[u/mrichter/AliRoot.git] / HLT / misc / AliL3AltroMemHandler.cxx

/* $Id$
Author: Constantin Loizides <mailto: loizides@ikf.physik.uni-frankfurt.de>
*/

#include <iostream.h>
#include <stdio.h>
#include <string.h>
#include "AliL3AltroMemHandler.h"
#include "AliL3Logging.h"

/** \class AliL3AltroMemHandler
//<pre>
//--------------------------------------------------------------------
// AliL3AltroMemHandler
//
// Converts digits in memory into a backlinked ALTRO like data format.
// Its output file is used as input to the various VHDL testbenches.
// The file misc/read.cxx shows how to use this class.
//</pre>
*/

ClassImp(AliL3AltroMemHandler)

AliL3AltroMemHandler::AliL3AltroMemHandler(){
  Clear();
  ClearRead();
};

void AliL3AltroMemHandler::Clear(){
  memset(altromem,0,ALTRO_SIZE);
  memset(times_per_pad,0,1024);
  memset(charges_per_pad,0,1024);
  counter=ALTRO_SIZE;
  tcounter=0;
  lpad=0;
  lrow=0;
  flag=kFALSE;
};

void AliL3AltroMemHandler::ClearRead(){
  rcounter=0;
  scounter=0;
  rpad=0;
  rrow=0;
  rtime=0;
}

void AliL3AltroMemHandler::Write(UShort_t row, UChar_t pad, UShort_t time, UShort_t charge)
{
  if(tcounter==0){
    lrow=row;
    lpad=pad;
  } else if((lrow!=row) || (lpad!=pad)){
    MakeAltroPackets(); //make packets
    Write();            //write packets
    Clear();            //clear up for next pad

    lrow=row;
    lpad=pad;
  }

  Add(charge,time);
}

void AliL3AltroMemHandler::Add(UShort_t charge, UShort_t time)
{
  times_per_pad[tcounter]=time;
  charges_per_pad[tcounter]=charge;
  tcounter++;
}

void AliL3AltroMemHandler::MakeAltroPackets()
{
  UShort_t i=0,j=0;
  UShort_t t=0,seqlength;
  UShort_t htime,ltime;

  while(t<tcounter){
    pcounter=0;
    altromem[--counter]=0xFFFF; //mark return

    //make packets
    while((pcounter<ALTRO_SIZE) && (t<tcounter)){

      //find sequence
      i=t;
      ltime=times_per_pad[t];
      j=0;
      while((i+1<tcounter)&&(times_per_pad[i+1]==ltime+j+1)){
	i++;
	j++;
      }
      seqlength=j+1; //number of consecutive times   
      htime=times_per_pad[i]; //abs. time for sequence

/*
  cout << " counter " << counter << endl;
  if(htime!=ltime+j){
  cerr << "Error: " << ltime << " - " << htime << endl;
  exit(1);
  }
*/
      //don't store sequence if it doesn't fit into packet
      if(pcounter+seqlength>=ALTRO_SIZE) break;

      //store charges of sequence
      for(UShort_t k=0;k<seqlength;k++){
	altromem[--counter]=charges_per_pad[t];
	pcounter++;
	t++;
      }

      altromem[--counter]=htime;       //store abs. time of sequence
      pcounter++;
      altromem[--counter]=seqlength+2; //store length of sequence
      pcounter++;
    }

    AddTrailer();
  }
}

void AliL3AltroMemHandler::AddTrailer()
{
  UShort_t savepcounter=pcounter;

  while(pcounter%4!=0){
    altromem[--counter]=0x2AA;
    pcounter++;
  } 
  altromem[--counter]=0x2AA;
  altromem[--counter]=savepcounter;
  altromem[--counter]=lpad;
  altromem[--counter]=lrow;
}

void AliL3AltroMemHandler::Write()
{
  if(counter==ALTRO_SIZE) return;

  //save packets (reversed) to file
  UShort_t *ptr=altromem+counter;
  for (int i=counter;i<ALTRO_SIZE;i++) {

    if(flag==kTRUE){
      if (*ptr==0xFFFF) continue; //no return for end of packet
      fwrite(ptr,sizeof(UShort_t),1,fOutBinary);
    } else {
      if (*ptr==0xFFFF) fprintf(fOutBinary,"\n");
      else fprintf(fOutBinary,"%X ",*ptr);
    }

    ptr++;
  }
}

void AliL3AltroMemHandler::WriteFinal()
{
  if(tcounter>0){
    MakeAltroPackets();
    Write();
  }
}

Bool_t AliL3AltroMemHandler::Read(UShort_t &row, UChar_t &pad, UShort_t &time, UShort_t &charge)
{
  if(flag==kTRUE) {
    LOG(AliL3Log::kWarning,"AliL3AltroMemHandler::Read","File Open")<<"Binary not supported!"<<ENDLOG;
    return kFALSE;
  }
  
  if(feof(fInBinary)){
    LOG(AliL3Log::kDebug,"AliL3AltroMemHandler::Read","File Open")<<"End of File!"<<ENDLOG;
    return kFALSE;
  }

  unsigned int dummy,dummy1;

  if(rcounter==0){
    fscanf(fInBinary,"%x",&dummy);
    rrow=(UShort_t)dummy;
    fscanf(fInBinary,"%x",&dummy);
    rpad=(UShort_t)dummy;
    fscanf(fInBinary,"%x",&dummy);
    rcounter=(UShort_t)dummy;
    fscanf(fInBinary,"%x",&dummy);
    if(dummy!=682){
      if(feof(fInBinary)){
	ClearRead();
	return kFALSE;
      } else {
	LOG(AliL3Log::kError,"AliL3AltroMemHandler::Read","Trailer not found!")<<ENDLOG;
	return kFALSE;
      }
    }
    dummy1 = rcounter;
    while(dummy1 % 4 != 0) {
      fscanf(fInBinary,"%x",&dummy);
      dummy1++;
    } 
  } 
  if(scounter==0){
    fscanf(fInBinary,"%x",&dummy);
    scounter=(UShort_t)dummy-2;
    fscanf(fInBinary,"%x",&dummy);
    rtime=(UShort_t)dummy;
    rcounter-=2;
  }
  fscanf(fInBinary,"%x",&dummy);

  row=rrow;
  pad=rpad;
  time=rtime;
  charge=(UShort_t)dummy;

  scounter--;
  rcounter--;
  rtime--;
  return kTRUE;
}

Bool_t AliL3AltroMemHandler::ReadSequence(UShort_t &row, UChar_t &pad, UShort_t &time, UChar_t &n, UShort_t **charges)
{
  if(flag==kTRUE) {
    LOG(AliL3Log::kWarning,"AliL3AltroMemHandler::ReadSequence","File Open")<<"Binary not supported!"<<ENDLOG;
    return kFALSE;
  }
  
  if(feof(fInBinary)){
    LOG(AliL3Log::kDebug,"AliL3AltroMemHandler::ReadSequence","File Open")<<"End of File!"<<ENDLOG;
    return kFALSE;
  }

  unsigned int dummy,dummy1,dummy2;

  if(rcounter==0){
    fscanf(fInBinary,"%x",&dummy);
    rrow=(UShort_t)dummy;
    fscanf(fInBinary,"%x",&dummy);
    rpad=(UShort_t)dummy;
    fscanf(fInBinary,"%x",&dummy);
    rcounter=(UShort_t)dummy;
    fscanf(fInBinary,"%x",&dummy);
    if(dummy!=682){
      if(feof(fInBinary)){
	ClearRead();
	return kFALSE;
      } else {
	LOG(AliL3Log::kError,"AliL3AltroMemHandler::ReadSequence","Format") <<"Trailer not found!"<<ENDLOG;
	return kFALSE;
      }
    }
    dummy1 = rcounter;
    while(dummy1 % 4 != 0) {
      fscanf(fInBinary,"%x",&dummy);
      dummy1++;
    } 
  } 

  fscanf(fInBinary,"%x",&dummy);
  scounter=(UShort_t)dummy-2;
  fscanf(fInBinary,"%x",&dummy);
  rtime=(UShort_t)dummy;
  rcounter-=2;

  if(n<scounter){
    if(*charges) delete[] *charges;
    *charges=new UShort_t[scounter];
  }

  dummy2=0;
  while(dummy2<scounter){
    fscanf(fInBinary,"%x",&dummy);
    (*charges)[dummy2]=(UShort_t)dummy;
    dummy2++;
    rcounter--;
  }

  row=rrow;
  pad=rpad;
  time=rtime;
  n=scounter;
  return kTRUE;
}

Bool_t AliL3AltroMemHandler::SetBinaryInput(FILE *file)
{
  fInBinary = file;
  if(!fInBinary){
    LOG(AliL3Log::kWarning,"AliL3AltroMemHandler::SetBinaryInput","File Open")<<"Pointer to File = 0x0 "<<ENDLOG;
    return kFALSE;
  }
  ClearRead();
  flag=kTRUE;
  return kTRUE;
}

Bool_t AliL3AltroMemHandler::SetASCIIInput(FILE *file)
{
  fInBinary = file;
  if(!fInBinary){
    LOG(AliL3Log::kWarning,"AliL3AltroMemHandler::SetASCIIInput","File Open")<<"Pointer to File = 0x0 "<<ENDLOG;
    return kFALSE;
  }
  ClearRead();
  flag=kFALSE;
  return kTRUE;
}

Bool_t AliL3AltroMemHandler::SetBinaryOutput(FILE *file){
  fOutBinary = file;
  if(!fOutBinary){
    LOG(AliL3Log::kWarning,"AliL3AltroMemHandler::SetBinaryOutput","File Open") <<"Pointer to File = 0x0 "<<ENDLOG;
    return kFALSE;
  }
  Clear();
  flag=kTRUE;
  return kTRUE;
}

Bool_t AliL3AltroMemHandler::SetASCIIOutput(FILE *file){
  fOutBinary = file;
  if(!fOutBinary){
    LOG(AliL3Log::kWarning,"AliL3AltroMemHandler::SetASCIIOutput","File Open") <<"Pointer to File = 0x0 "<<ENDLOG;
    return kFALSE;
  }
  Clear();
  flag=kFALSE;
  return kTRUE;
}
Commit	Line	Data
acf814d1	1	/* $Id$
	2	Author: Constantin Loizides <mailto: loizides@ikf.physik.uni-frankfurt.de>
	3	*/
	4
	5	#include <iostream.h>
	6	#include <stdio.h>
	7	#include <string.h>
	8	#include "AliL3AltroMemHandler.h"
1d4de105	9	#include "AliL3Logging.h"
acf814d1	10
9c50e540	11	/** \class AliL3AltroMemHandler
a36f659c	12	//<pre>
	13	//--------------------------------------------------------------------
	14	// AliL3AltroMemHandler
	15	//
9c50e540	16	// Converts digits in memory into a backlinked ALTRO like data format.
faebf2f5	17	// Its output file is used as input to the various VHDL testbenches.
9c50e540	18	// The file misc/read.cxx shows how to use this class.
1d4de105	19	//</pre>
9c50e540	20	*/
	21
	22	ClassImp(AliL3AltroMemHandler)
	23
acf814d1	24	AliL3AltroMemHandler::AliL3AltroMemHandler(){
acf814d1	25	Clear();
a36f659c	26	ClearRead();
acf814d1	27	};
acf814d1	28
acf814d1	29	void AliL3AltroMemHandler::Clear(){
acf814d1	30	memset(altromem,0,ALTRO_SIZE);
faebf2f5	31	memset(times_per_pad,0,1024);
	32	memset(charges_per_pad,0,1024);
	33	counter=ALTRO_SIZE;
acf814d1	34	tcounter=0;
acf814d1	35	lpad=0;
acf814d1	36	lrow=0;
	37	flag=kFALSE;
	38	};
	39
a36f659c	40	void AliL3AltroMemHandler::ClearRead(){
	41	rcounter=0;
	42	scounter=0;
	43	rpad=0;
	44	rrow=0;
	45	rtime=0;
	46	}
	47
	48	void AliL3AltroMemHandler::Write(UShort_t row, UChar_t pad, UShort_t time, UShort_t charge)
faebf2f5	49	{
	50	if(tcounter==0){
	51	lrow=row;
	52	lpad=pad;
	53	} else if((lrow!=row) \|\| (lpad!=pad)){
	54	MakeAltroPackets(); //make packets
a36f659c	55	Write(); //write packets
faebf2f5	56	Clear(); //clear up for next pad
	57
	58	lrow=row;
	59	lpad=pad;
	60	}
	61
	62	Add(charge,time);
	63	}
	64
	65	void AliL3AltroMemHandler::Add(UShort_t charge, UShort_t time)
	66	{
	67	times_per_pad[tcounter]=time;
	68	charges_per_pad[tcounter]=charge;
	69	tcounter++;
	70	}
	71
	72	void AliL3AltroMemHandler::MakeAltroPackets()
	73	{
	74	UShort_t i=0,j=0;
	75	UShort_t t=0,seqlength;
	76	UShort_t htime,ltime;
a36f659c	77
faebf2f5	78	while(t<tcounter){
	79	pcounter=0;
	80	altromem[--counter]=0xFFFF; //mark return
	81
	82	//make packets
	83	while((pcounter<ALTRO_SIZE) && (t<tcounter)){
	84
	85	//find sequence
	86	i=t;
	87	ltime=times_per_pad[t];
	88	j=0;
	89	while((i+1<tcounter)&&(times_per_pad[i+1]==ltime+j+1)){
	90	i++;
	91	j++;
	92	}
	93	seqlength=j+1; //number of consecutive times
	94	htime=times_per_pad[i]; //abs. time for sequence
a36f659c	95
faebf2f5	96	/*
	97	cout << " counter " << counter << endl;
	98	if(htime!=ltime+j){
	99	cerr << "Error: " << ltime << " - " << htime << endl;
	100	exit(1);
	101	}
	102	*/
a36f659c	103	//don't store sequence if it doesn't fit into packet
	104	if(pcounter+seqlength>=ALTRO_SIZE) break;
	105
faebf2f5	106	//store charges of sequence
	107	for(UShort_t k=0;k<seqlength;k++){
	108	altromem[--counter]=charges_per_pad[t];
	109	pcounter++;
	110	t++;
	111	}
	112
	113	altromem[--counter]=htime; //store abs. time of sequence
	114	pcounter++;
	115	altromem[--counter]=seqlength+2; //store length of sequence
	116	pcounter++;
	117	}
	118
	119	AddTrailer();
	120	}
acf814d1	121	}
acf814d1	122
faebf2f5	123	void AliL3AltroMemHandler::AddTrailer()
	124	{
	125	UShort_t savepcounter=pcounter;
acf814d1	126
faebf2f5	127	while(pcounter%4!=0){
	128	altromem[--counter]=0x2AA;
	129	pcounter++;
acf814d1	130	}
faebf2f5	131	altromem[--counter]=0x2AA;
	132	altromem[--counter]=savepcounter;
	133	altromem[--counter]=lpad;
	134	altromem[--counter]=lrow;
	135	}
acf814d1	136
faebf2f5	137	void AliL3AltroMemHandler::Write()
	138	{
	139	if(counter==ALTRO_SIZE) return;
	140
	141	//save packets (reversed) to file
acf814d1	142	UShort_t *ptr=altromem+counter;
faebf2f5	143	for (int i=counter;i<ALTRO_SIZE;i++) {
	144
	145	if(flag==kTRUE){
	146	if (*ptr==0xFFFF) continue; //no return for end of packet
	147	fwrite(ptr,sizeof(UShort_t),1,fOutBinary);
	148	} else {
	149	if (*ptr==0xFFFF) fprintf(fOutBinary,"\n");
	150	else fprintf(fOutBinary,"%X ",*ptr);
	151	}
	152
	153	ptr++;
acf814d1	154	}
faebf2f5	155	}
acf814d1	156
faebf2f5	157	void AliL3AltroMemHandler::WriteFinal()
	158	{
	159	if(tcounter>0){
	160	MakeAltroPackets();
	161	Write();
	162	}
acf814d1	163	}
acf814d1	164
a36f659c	165	Bool_t AliL3AltroMemHandler::Read(UShort_t &row, UChar_t &pad, UShort_t &time, UShort_t &charge)
	166	{
	167	if(flag==kTRUE) {
	168	LOG(AliL3Log::kWarning,"AliL3AltroMemHandler::Read","File Open")<<"Binary not supported!"<<ENDLOG;
	169	return kFALSE;
	170	}
	171
	172	if(feof(fInBinary)){
	173	LOG(AliL3Log::kDebug,"AliL3AltroMemHandler::Read","File Open")<<"End of File!"<<ENDLOG;
	174	return kFALSE;
	175	}
	176
	177	unsigned int dummy,dummy1;
	178
	179	if(rcounter==0){
	180	fscanf(fInBinary,"%x",&dummy);
	181	rrow=(UShort_t)dummy;
	182	fscanf(fInBinary,"%x",&dummy);
	183	rpad=(UShort_t)dummy;
	184	fscanf(fInBinary,"%x",&dummy);
	185	rcounter=(UShort_t)dummy;
	186	fscanf(fInBinary,"%x",&dummy);
	187	if(dummy!=682){
	188	if(feof(fInBinary)){
	189	ClearRead();
	190	return kFALSE;
	191	} else {
	192	LOG(AliL3Log::kError,"AliL3AltroMemHandler::Read","Trailer not found!")<<ENDLOG;
	193	return kFALSE;
	194	}
	195	}
	196	dummy1 = rcounter;
	197	while(dummy1 % 4 != 0) {
	198	fscanf(fInBinary,"%x",&dummy);
	199	dummy1++;
	200	}
	201	}
	202	if(scounter==0){
	203	fscanf(fInBinary,"%x",&dummy);
	204	scounter=(UShort_t)dummy-2;
	205	fscanf(fInBinary,"%x",&dummy);
	206	rtime=(UShort_t)dummy;
	207	rcounter-=2;
	208	}
	209	fscanf(fInBinary,"%x",&dummy);
	210
	211	row=rrow;
	212	pad=rpad;
	213	time=rtime;
	214	charge=(UShort_t)dummy;
	215
	216	scounter--;
	217	rcounter--;
	218	rtime--;
	219	return kTRUE;
	220	}
	221
	222	Bool_t AliL3AltroMemHandler::ReadSequence(UShort_t &row, UChar_t &pad, UShort_t &time, UChar_t &n, UShort_t **charges)
	223	{
	224	if(flag==kTRUE) {
	225	LOG(AliL3Log::kWarning,"AliL3AltroMemHandler::ReadSequence","File Open")<<"Binary not supported!"<<ENDLOG;
	226	return kFALSE;
	227	}
	228
229	if(feof(fInBinary)){
230	LOG(AliL3Log::kDebug,"AliL3AltroMemHandler::ReadSequence","File Open")<<"End of File!"<<ENDLOG;
231	return kFALSE;
232	}
233
234	unsigned int dummy,dummy1,dummy2;
235
236	if(rcounter==0){
237	fscanf(fInBinary,"%x",&dummy);
238	rrow=(UShort_t)dummy;
239	fscanf(fInBinary,"%x",&dummy);
240	rpad=(UShort_t)dummy;
241	fscanf(fInBinary,"%x",&dummy);
242	rcounter=(UShort_t)dummy;
243	fscanf(fInBinary,"%x",&dummy);
244	if(dummy!=682){
245	if(feof(fInBinary)){
246	ClearRead();
247	return kFALSE;
248	} else {
249	LOG(AliL3Log::kError,"AliL3AltroMemHandler::ReadSequence","Format") <<"Trailer not found!"<<ENDLOG;
250	return kFALSE;
251	}
252	}
253	dummy1 = rcounter;
254	while(dummy1 % 4 != 0) {
255	fscanf(fInBinary,"%x",&dummy);
256	dummy1++;
257	}
258	}
259
260	fscanf(fInBinary,"%x",&dummy);
261	scounter=(UShort_t)dummy-2;
262	fscanf(fInBinary,"%x",&dummy);
263	rtime=(UShort_t)dummy;
264	rcounter-=2;
265
266	if(n<scounter){
267	if(charges) delete[] charges;
268	*charges=new UShort_t[scounter];
269	}
270
271	dummy2=0;
272	while(dummy2<scounter){
273	fscanf(fInBinary,"%x",&dummy);
274	(*charges)[dummy2]=(UShort_t)dummy;
275	dummy2++;
276	rcounter--;
277	}
278
279	row=rrow;
280	pad=rpad;
281	time=rtime;
282	n=scounter;
283	return kTRUE;
284	}
285
286	Bool_t AliL3AltroMemHandler::SetBinaryInput(FILE *file)
287	{
acf814d1	288	fInBinary = file;
acf814d1	289	if(!fInBinary){
a36f659c	290	LOG(AliL3Log::kWarning,"AliL3AltroMemHandler::SetBinaryInput","File Open")<<"Pointer to File = 0x0 "<<ENDLOG;
acf814d1	291	return kFALSE;
acf814d1	292	}
a36f659c	293	ClearRead();
	294	flag=kTRUE;
	295	return kTRUE;
	296	}
	297
	298	Bool_t AliL3AltroMemHandler::SetASCIIInput(FILE *file)
	299	{
	300	fInBinary = file;
	301	if(!fInBinary){
	302	LOG(AliL3Log::kWarning,"AliL3AltroMemHandler::SetASCIIInput","File Open")<<"Pointer to File = 0x0 "<<ENDLOG;
	303	return kFALSE;
	304	}
	305	ClearRead();
	306	flag=kFALSE;
acf814d1	307	return kTRUE;
acf814d1	308	}
acf814d1	309
	310	Bool_t AliL3AltroMemHandler::SetBinaryOutput(FILE *file){
	311	fOutBinary = file;
	312	if(!fOutBinary){
	313	LOG(AliL3Log::kWarning,"AliL3AltroMemHandler::SetBinaryOutput","File Open") <<"Pointer to File = 0x0 "<<ENDLOG;
	314	return kFALSE;
	315	}
a36f659c	316	Clear();
faebf2f5	317	flag=kTRUE;
	318	return kTRUE;
	319	}
	320
	321	Bool_t AliL3AltroMemHandler::SetASCIIOutput(FILE *file){
	322	fOutBinary = file;
	323	if(!fOutBinary){
	324	LOG(AliL3Log::kWarning,"AliL3AltroMemHandler::SetASCIIOutput","File Open") <<"Pointer to File = 0x0 "<<ENDLOG;
	325	return kFALSE;
	326	}
a36f659c	327	Clear();
faebf2f5	328	flag=kFALSE;
acf814d1	329	return kTRUE;
acf814d1	330	}
a36f659c	331