[u/mrichter/AliRoot.git] / TPC / AliTPCMonitorAltro.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  2007/10/12 13:36:27  cvetan
Coding convention fixes from Stefan

Revision 1.1  2007/09/17 10:23:31  cvetan
New TPC monitoring package from Stefan Kniege. The monitoring package can be started by running TPCMonitor.C macro located in macros folder.

*/ 

////////////////////////////////////////////////////////////////////////
////
//// AliTPCMonitorAltro class
////
//// Class for decoding raw TPC data in the ALTRO format.
//// Data are transformed from 32 bit words to 10 bit or 40 bit respectively.
//// The whole payload is transformed at once and written to an array. 
//// The single channels are decoded starting from the trailer word which is
//// decoded by DecodeTrailer(Int_t pos)
////
//// Authors: Roland Bramm, 
////          Stefan Kniege, IKF, Frankfurt
////       
/////////////////////////////////////////////////////////////////////////


#include "AliTPCMonitorAltro.h"
#include "AliLog.h" 
#include <Riostream.h>
using namespace std;
ClassImp(AliTPCMonitorAltro)  

//_____________________________________________________________________________________________
AliTPCMonitorAltro::AliTPCMonitorAltro(UInt_t* memory, Int_t size, Int_t fformat) :
  fverb(0),
  fmemory(memory),
  fsize(size),
  f40BitArray(0),
  f10BitArray(0),
  fdecoderPos(0),
  fallocate40BitArray(false),
  fallocate10BitArray(false),
  foffset(0),  
  fwrite10bit(0),
  fTrailerNWords(0), 
  fTrailerHwAddress(0),
  fTrailerDataPos(0),
  fTrailerBlockPos(0),
  fTrailerPos(0),
  fNextPos(0),
  ffilename(new Char_t[256])
{
  // Constructor: Set different CDH offsets for ROOT (0) and date format
  // Data offset can be changed via SetDataOffset(Int_t val)

  if(     fformat==0) foffset=7; // old CHD Format
  else if(fformat==1) foffset=8; // memory pointer from DATE (start CDH)
  else if(fformat==2) foffset=0; // memory pointer from ROOT (after CDH)
} 


//_____________________________________________________________________________________________
AliTPCMonitorAltro::AliTPCMonitorAltro(const AliTPCMonitorAltro &altro) :
  TNamed(altro),
  fverb(altro.fverb),
  fmemory(altro.fmemory),
  fsize(altro.fsize),
  f40BitArray(altro.f40BitArray),
  f10BitArray(altro.f10BitArray),
  fdecoderPos(altro.fdecoderPos),
  fallocate40BitArray(altro.fallocate40BitArray),
  fallocate10BitArray(altro.fallocate10BitArray),
  foffset(altro.foffset),
  fwrite10bit(altro.fwrite10bit),
  fTrailerNWords(altro.fTrailerNWords),
  fTrailerHwAddress(altro.fTrailerHwAddress),
  fTrailerDataPos(altro.fTrailerDataPos),
  fTrailerBlockPos(altro.fTrailerBlockPos),
  fTrailerPos(altro.fTrailerPos),
  fNextPos(altro.fNextPos),
  ffilename(new Char_t[strlen(altro.ffilename)+1])
{
  // copy constructor
  strcpy(ffilename,altro.ffilename);

}

//_____________________________________________________________________________________________
AliTPCMonitorAltro &AliTPCMonitorAltro::operator =(const AliTPCMonitorAltro& altro)
{
  // assignement operator 
  
  if(this!=&altro){ 
    ((TNamed *)this)->operator=(altro);
    fverb=altro.fverb;
    fmemory=altro.fmemory;
    fsize=altro.fsize;
    f40BitArray=altro.f40BitArray;
    f10BitArray=altro.f10BitArray;
    fdecoderPos=altro.fdecoderPos;
    fallocate40BitArray=altro.fallocate40BitArray;
    fallocate10BitArray=altro.fallocate10BitArray;
    foffset=altro.foffset;
    fwrite10bit=altro.fwrite10bit;
    fTrailerNWords=altro.fTrailerNWords;
    fTrailerHwAddress=altro.fTrailerHwAddress;
    fTrailerDataPos=altro.fTrailerDataPos;
    fTrailerBlockPos=altro.fTrailerBlockPos;
    fTrailerPos=altro.fTrailerPos; 
    fNextPos=altro.fNextPos;
    ffilename = new Char_t[strlen(altro.ffilename)+1]; 
    strcpy(ffilename,altro.ffilename);
  }
  return *this;
}


//_____________________________________________________________________________________________
AliTPCMonitorAltro::~AliTPCMonitorAltro() {
  // Destructor
  if(fallocate40BitArray == true) delete[] f40BitArray;
  if(fallocate10BitArray == true) delete[] f10BitArray;
  delete[] ffilename;
 }

//_____________________________________________________________________________________________
void AliTPCMonitorAltro::Allocate40BitArray() 
{
  // create array for 40 bit decoded data
  fallocate40BitArray = true;
  f40BitArray = new long long[Get40BitArraySize()];
}

//_____________________________________________________________________________________________
void AliTPCMonitorAltro::Allocate10BitArray() 
{
  // Create array for 10 bit decoded data
  fallocate10BitArray = true;
  f10BitArray = new Short_t[Get10BitArraySize()];
} 

//_____________________________________________________________________________________________
long long *AliTPCMonitorAltro::Get40BitArray() 
{
  // Return pointer to array for 40 bit decoded data 
  return f40BitArray;
}

//_____________________________________________________________________________________________
Short_t *AliTPCMonitorAltro::Get10BitArray() 
{
  // Return pointer to array for 10 bit decoded data 
  return f10BitArray;
}

// //_____________________________________________________________________________________________
// Int_t AliTPCMonitorAltro::Get40BitArraySize() 
// {
//   // Return number of 40 bit words in payload 
//   return fmemory[fsize-1];
// }

// //_____________________________________________________________________________________________
// Int_t AliTPCMonitorAltro::Get10BitArraySize() 
// { 
//   // Return number of 10 bit words in payload 
//   return fmemory[fsize-1]*4;
// }

//_____________________________________________________________________________________________
void AliTPCMonitorAltro::Decodeto40Bit() 
{
  // Decode 32 bit words in fmemory to 40 bit words
  Long64_t blackbox = 0;
  Int_t rest;
  
  for(Int_t i = 0; i < Get40BitArraySize(); i++) 
    {
      rest = i%4;
      switch(rest) {
      case 0:
	blackbox = (fmemory[foffset])     + (((Long64_t)(fmemory[foffset+1]&fgk08BitOn))<<32);
	foffset +=1;
	break;
      case 1:
	blackbox = (fmemory[foffset]>>8 ) + (((Long64_t)(fmemory[foffset+1]&fgk16BitOn))<<24);
	foffset +=1;
	break;
      case 2:
	blackbox = (fmemory[foffset]>>16) + (((Long64_t)(fmemory[foffset+1]&fgk24BitOn))<<16);
	foffset +=1;
	break;
      case 3:
	blackbox = (fmemory[foffset]>>24) + (((Long64_t)(fmemory[foffset+1]         ))<< 8);
	foffset +=2;
	break;
      default:
	blackbox = 0;
	break;
      }
      f40BitArray[i] = blackbox;
    }
}

//_____________________________________________________________________________________________
void AliTPCMonitorAltro::Decodeto10Bit(Int_t equipment) 
{
  // Decode 32 bit words in fmemory to 10 bit words.
  // Write words to file if fwrite10bit ("Write 10 bit" in Monitor.C Gui ) is set

  Long64_t blackbox = 0;
  Int_t    rest     = 0;
  
  ofstream datout;
  if(fwrite10bit)
  {
    Char_t nameout[256] ; sprintf(nameout,"%s_PayloadEquipmentId_%03i.txt",ffilename,equipment);
    datout.open(nameout);
    AliInfo(Form("AliTPCMonitorAltro::decodeto10Bit :  Write Data to %s",nameout));
    if(foffset==0) datout <<  "Payload without CDH in 10bit words " << endl;
    else           datout  << "CDH in 32 bit hex words words (" << foffset << " lines )  followed by payload in 10 bit words " << endl;
    for(Int_t ih = 0; ih< foffset ; ih++)
    {
      datout << hex << fmemory[ih] << endl;
    }
  }
  
  for(Int_t ind = 0; ind < Get40BitArraySize(); ind++)
  {
    rest = ind%4;
    switch(rest)
    {
    case 0:
      blackbox = (fmemory[foffset])     + (((Long64_t)(fmemory[foffset+1]&fgk08BitOn))<<32);
      foffset +=1;
      break;
    case 1:
      blackbox = (fmemory[foffset]>>8 ) + (((Long64_t)(fmemory[foffset+1]&fgk16BitOn))<<24);
      foffset +=1;
      break;
    case 2:
      blackbox = (fmemory[foffset]>>16) + (((Long64_t)(fmemory[foffset+1]&fgk24BitOn))<<16);
      foffset +=1;
      break;
    case 3:
      blackbox = (fmemory[foffset]>>24) + (((Long64_t)(fmemory[foffset+1]         ))<< 8);
      foffset +=2;
      break;
    default:
      blackbox = 0;
      break;
    }
    f10BitArray[ind*4+0] = (Short_t)( blackbox & fgkmask10 )    ;
    f10BitArray[ind*4+1] = (Short_t)((blackbox & fgkmask20)>>10);
    f10BitArray[ind*4+2] = (Short_t)((blackbox & fgkmask30)>>20);
    f10BitArray[ind*4+3] = (Short_t)((blackbox & fgkmask40)>>30);
  }
  if(fwrite10bit)
  {
    for(Int_t ind = 0; ind < Get40BitArraySize(); ind++)
    {
      datout << dec <<  f10BitArray[ind*4+0] << "\n";
      datout << dec <<  f10BitArray[ind*4+1] << "\n";
      datout << dec <<  f10BitArray[ind*4+2] << "\n";
      datout << dec <<  f10BitArray[ind*4+3] << "\n";
    }
  }
  
  if(fwrite10bit) datout.close();
}

//_____________________________________________________________________________________________
Int_t AliTPCMonitorAltro::DecodeTrailer(Int_t pos)
{
  // Decode the trailer word starting at position pos in fmemory
  // Check if information leads to proper next trailer position
  if (GetAltroVersion()==0xaabb) return DecodeTrailerVbb(pos);
  fTrailerPos = pos;
  if(pos<=4) return 0;
  
  Long64_t  words         = 0;
  Long64_t  tail          = 0;
  Long64_t  trailer       = 0;
  Long64_t  carry         = 0;
  Long64_t  rest          = 0 ;
    
  for(Long64_t  iter = 0 ; iter<4;iter++)
    {
      carry =  f10BitArray[pos-iter] ; 
      carry = ( carry << (30- ((iter)*10)));
      trailer += carry ;
    }
  
  fTrailerHwAddress = (trailer & ((Long64_t )fgkTrailerMaskHardw)  );
  words             = (Long64_t )( (trailer & ((Long64_t )fgkTrailerMaskNWords))>>16);
  tail           = (Long64_t )( (trailer & ((Long64_t )fgkTrailerMaskTail   ))>>26 );
  
  if(words%4!=0) rest =  4-(words%4);
  fTrailerNWords      = words+rest ;
  fTrailerDataPos     = pos -4 -rest ;
  fTrailerBlockPos    = pos -4 ;
  fNextPos            = (pos -fTrailerNWords -4);
  
  if(       tail!=fgkTrailerTail        ) { AliError(Form("Could not read Trailer. \"Write 10bit\" for this event. Last Trailer line (2AA): %i. Supp.next Trailer line (2AA): %i ",pos,fNextPos));    return -1;      }
  else if(     fNextPos==-1           ) { /* was last channel  */   	                                                                                                                            return  0;      }
  else if(     fNextPos <0            ) { AliError("Next Trailer position < 0 ");                                                                                                                   return -1;      }
  else if((f10BitArray[fNextPos]!=682)) { AliError(Form("Could not find tail (2AA) at next supposed position %i",fNextPos));                                                                        return -1;      }
  else                                  {                                                                                                                                                           return fNextPos;}
  
}

//_____________________________________________________________________________________________
Int_t AliTPCMonitorAltro::DecodeTrailerVbb(Int_t pos)
{
  // Decode the trailer word starting at position pos in fmemory
  // Check if information leads to proper next trailer position
    fTrailerPos = pos;
  if(pos>Get10BitArraySize()-4) return 0;
  
  Long64_t  words         = 0;
  Long64_t  tail          = 0;
  Long64_t  trailer       = 0;
  Long64_t  carry         = 0;
  Long64_t  rest          = 0 ;
  
  for(Long64_t  iter = 0 ; iter<4;iter++)
  {
    carry =  f10BitArray[pos-iter] ;
    carry = ( carry << (30- ((iter)*10)));
    trailer += carry ;
  }
  
  fTrailerHwAddress = (trailer & ((Long64_t )fgkTrailerMaskHardw)  );
  words             = (Long64_t )( (trailer & ((Long64_t )fgkTrailerMaskNWords))>>16);
  tail           = (Long64_t )( (trailer & ((Long64_t )fgkTrailerMaskTail   ))>>26 );

    //Decide on read direction (sign) from the RCU trailer information
  Int_t sign=-1;
  if (GetAltroVersion()==0xaabb) sign=1;
  
  if(words%4!=0) rest =  4-(words%4);
  fTrailerNWords      = words+rest ;
  fTrailerDataPos     = pos +sign*(4+rest) ;
  fTrailerBlockPos    = pos +sign*4 ;
  fNextPos            = (pos +sign*(fTrailerNWords+4));
  
  if(       tail==fgkTrailerTailErr        ) {
    AliError(Form("Found Altro header with error marker (2AEE)[%0llx]: %i. Supp.next Trailer line (2AA)[%0x]: %i ",
                  tail,pos,f10BitArray[fNextPos],fNextPos));
    return -fNextPos;
  } else if ( tail!=fgkTrailerTail        ) {
    AliError(Form("Could not read Trailer. \"Write 10bit\" for this event. Last Trailer line (2AA)[%0llx]: %i. Supp.next Trailer line (2AA)[%0x]: %i ",
                  tail,pos,f10BitArray[fNextPos],fNextPos));    return -1;
  } else if(     fNextPos==Get10BitArraySize()+3           ) { /* was last channel  */
    return  0;
  }  else if(     fNextPos >=Get10BitArraySize()            ) {
    AliError(Form("Next Trailer position < 0 %i", fNextPos));
    return -1;
  } else if((f10BitArray[fNextPos]!=682)&&(f10BitArray[fNextPos]!=686)) {
    AliError(Form("Could not find tail (2AA) at next supposed position %i",fNextPos));
    return -1;
  } else {
    return fNextPos;
  }
  
}
Commit	Line	Data
48265b32	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$
fb3305d1	18	Revision 1.2 2007/10/12 13:36:27 cvetan
	19	Coding convention fixes from Stefan
	20
ca7b8371	21	Revision 1.1 2007/09/17 10:23:31 cvetan
	22	New TPC monitoring package from Stefan Kniege. The monitoring package can be started by running TPCMonitor.C macro located in macros folder.
	23
48265b32	24	*/
48265b32	25
ca7b8371	26	////////////////////////////////////////////////////////////////////////
	27	////
	28	//// AliTPCMonitorAltro class
	29	////
	30	//// Class for decoding raw TPC data in the ALTRO format.
	31	//// Data are transformed from 32 bit words to 10 bit or 40 bit respectively.
	32	//// The whole payload is transformed at once and written to an array.
	33	//// The single channels are decoded starting from the trailer word which is
	34	//// decoded by DecodeTrailer(Int_t pos)
	35	////
	36	//// Authors: Roland Bramm,
	37	//// Stefan Kniege, IKF, Frankfurt
	38	////
	39	/////////////////////////////////////////////////////////////////////////
	40
48265b32	41
48265b32	42	#include "AliTPCMonitorAltro.h"
ca7b8371	43	#include "AliLog.h"
ca7b8371	44	#include <Riostream.h>
fb3305d1	45	using namespace std;
ca7b8371	46	ClassImp(AliTPCMonitorAltro)
48265b32	47
48265b32	48	//_____________________________________________________________________________________________
ca7b8371	49	AliTPCMonitorAltro::AliTPCMonitorAltro(UInt_t* memory, Int_t size, Int_t fformat) :
	50	fverb(0),
	51	fmemory(memory),
	52	fsize(size),
	53	f40BitArray(0),
	54	f10BitArray(0),
	55	fdecoderPos(0),
	56	fallocate40BitArray(false),
	57	fallocate10BitArray(false),
	58	foffset(0),
	59	fwrite10bit(0),
	60	fTrailerNWords(0),
	61	fTrailerHwAddress(0),
	62	fTrailerDataPos(0),
	63	fTrailerBlockPos(0),
	64	fTrailerPos(0),
	65	fNextPos(0),
	66	ffilename(new Char_t[256])
48265b32	67	{
ca7b8371	68	// Constructor: Set different CDH offsets for ROOT (0) and date format
	69	// Data offset can be changed via SetDataOffset(Int_t val)
	70
48265b32	71	if( fformat==0) foffset=7; // old CHD Format
ca7b8371	72	else if(fformat==1) foffset=8; // memory pointer from DATE (start CDH)
ca7b8371	73	else if(fformat==2) foffset=0; // memory pointer from ROOT (after CDH)
48265b32	74	}
48265b32	75
ca7b8371	76
	77	//_____________________________________________________________________________________________
	78	AliTPCMonitorAltro::AliTPCMonitorAltro(const AliTPCMonitorAltro &altro) :
	79	TNamed(altro),
	80	fverb(altro.fverb),
	81	fmemory(altro.fmemory),
	82	fsize(altro.fsize),
	83	f40BitArray(altro.f40BitArray),
	84	f10BitArray(altro.f10BitArray),
	85	fdecoderPos(altro.fdecoderPos),
	86	fallocate40BitArray(altro.fallocate40BitArray),
	87	fallocate10BitArray(altro.fallocate10BitArray),
	88	foffset(altro.foffset),
	89	fwrite10bit(altro.fwrite10bit),
	90	fTrailerNWords(altro.fTrailerNWords),
	91	fTrailerHwAddress(altro.fTrailerHwAddress),
	92	fTrailerDataPos(altro.fTrailerDataPos),
	93	fTrailerBlockPos(altro.fTrailerBlockPos),
	94	fTrailerPos(altro.fTrailerPos),
	95	fNextPos(altro.fNextPos),
	96	ffilename(new Char_t[strlen(altro.ffilename)+1])
	97	{
	98	// copy constructor
	99	strcpy(ffilename,altro.ffilename);
	100
	101	}
	102
	103	//_____________________________________________________________________________________________
	104	AliTPCMonitorAltro &AliTPCMonitorAltro::operator =(const AliTPCMonitorAltro& altro)
	105	{
	106	// assignement operator
	107
	108	if(this!=&altro){
	109	((TNamed *)this)->operator=(altro);
	110	fverb=altro.fverb;
	111	fmemory=altro.fmemory;
	112	fsize=altro.fsize;
	113	f40BitArray=altro.f40BitArray;
	114	f10BitArray=altro.f10BitArray;
	115	fdecoderPos=altro.fdecoderPos;
	116	fallocate40BitArray=altro.fallocate40BitArray;
	117	fallocate10BitArray=altro.fallocate10BitArray;
	118	foffset=altro.foffset;
	119	fwrite10bit=altro.fwrite10bit;
	120	fTrailerNWords=altro.fTrailerNWords;
	121	fTrailerHwAddress=altro.fTrailerHwAddress;
	122	fTrailerDataPos=altro.fTrailerDataPos;
	123	fTrailerBlockPos=altro.fTrailerBlockPos;
	124	fTrailerPos=altro.fTrailerPos;
	125	fNextPos=altro.fNextPos;
	126	ffilename = new Char_t[strlen(altro.ffilename)+1];
	127	strcpy(ffilename,altro.ffilename);
	128	}
	129	return *this;
	130	}
	131
	132
48265b32	133	//_____________________________________________________________________________________________
	134	AliTPCMonitorAltro::~AliTPCMonitorAltro() {
	135	// Destructor
	136	if(fallocate40BitArray == true) delete[] f40BitArray;
	137	if(fallocate10BitArray == true) delete[] f10BitArray;
	138	delete[] ffilename;
	139	}
	140
	141	//_____________________________________________________________________________________________
	142	void AliTPCMonitorAltro::Allocate40BitArray()
	143	{
	144	// create array for 40 bit decoded data
	145	fallocate40BitArray = true;
	146	f40BitArray = new long long[Get40BitArraySize()];
	147	}
	148
	149	//_____________________________________________________________________________________________
	150	void AliTPCMonitorAltro::Allocate10BitArray()
	151	{
	152	// Create array for 10 bit decoded data
	153	fallocate10BitArray = true;
	154	f10BitArray = new Short_t[Get10BitArraySize()];
fb3305d1	155	}
48265b32	156
	157	//_____________________________________________________________________________________________
	158	long long *AliTPCMonitorAltro::Get40BitArray()
	159	{
	160	// Return pointer to array for 40 bit decoded data
	161	return f40BitArray;
	162	}
	163
	164	//_____________________________________________________________________________________________
	165	Short_t *AliTPCMonitorAltro::Get10BitArray()
	166	{
	167	// Return pointer to array for 10 bit decoded data
	168	return f10BitArray;
	169	}
	170
fb3305d1	171	// //_____________________________________________________________________________________________
	172	// Int_t AliTPCMonitorAltro::Get40BitArraySize()
	173	// {
	174	// // Return number of 40 bit words in payload
	175	// return fmemory[fsize-1];
	176	// }
	177
	178	// //_____________________________________________________________________________________________
	179	// Int_t AliTPCMonitorAltro::Get10BitArraySize()
	180	// {
	181	// // Return number of 10 bit words in payload
	182	// return fmemory[fsize-1]*4;
	183	// }
48265b32	184
	185	//_____________________________________________________________________________________________
	186	void AliTPCMonitorAltro::Decodeto40Bit()
	187	{
	188	// Decode 32 bit words in fmemory to 40 bit words
	189	Long64_t blackbox = 0;
	190	Int_t rest;
	191
	192	for(Int_t i = 0; i < Get40BitArraySize(); i++)
	193	{
	194	rest = i%4;
	195	switch(rest) {
	196	case 0:
ca7b8371	197	blackbox = (fmemory[foffset]) + (((Long64_t)(fmemory[foffset+1]&fgk08BitOn))<<32);
48265b32	198	foffset +=1;
	199	break;
	200	case 1:
ca7b8371	201	blackbox = (fmemory[foffset]>>8 ) + (((Long64_t)(fmemory[foffset+1]&fgk16BitOn))<<24);
48265b32	202	foffset +=1;
	203	break;
	204	case 2:
ca7b8371	205	blackbox = (fmemory[foffset]>>16) + (((Long64_t)(fmemory[foffset+1]&fgk24BitOn))<<16);
48265b32	206	foffset +=1;
	207	break;
	208	case 3:
	209	blackbox = (fmemory[foffset]>>24) + (((Long64_t)(fmemory[foffset+1] ))<< 8);
	210	foffset +=2;
	211	break;
	212	default:
	213	blackbox = 0;
	214	break;
	215	}
	216	f40BitArray[i] = blackbox;
	217	}
	218	}
	219
	220	//_____________________________________________________________________________________________
	221	void AliTPCMonitorAltro::Decodeto10Bit(Int_t equipment)
	222	{
	223	// Decode 32 bit words in fmemory to 10 bit words.
	224	// Write words to file if fwrite10bit ("Write 10 bit" in Monitor.C Gui ) is set
	225
	226	Long64_t blackbox = 0;
	227	Int_t rest = 0;
	228
	229	ofstream datout;
	230	if(fwrite10bit)
5312f439	231	{
	232	Char_t nameout[256] ; sprintf(nameout,"%s_PayloadEquipmentId_%03i.txt",ffilename,equipment);
	233	datout.open(nameout);
	234	AliInfo(Form("AliTPCMonitorAltro::decodeto10Bit : Write Data to %s",nameout));
	235	if(foffset==0) datout << "Payload without CDH in 10bit words " << endl;
	236	else datout << "CDH in 32 bit hex words words (" << foffset << " lines ) followed by payload in 10 bit words " << endl;
	237	for(Int_t ih = 0; ih< foffset ; ih++)
48265b32	238	{
5312f439	239	datout << hex << fmemory[ih] << endl;
48265b32	240	}
5312f439	241	}
48265b32	242
5312f439	243	for(Int_t ind = 0; ind < Get40BitArraySize(); ind++)
	244	{
	245	rest = ind%4;
	246	switch(rest)
48265b32	247	{
5312f439	248	case 0:
	249	blackbox = (fmemory[foffset]) + (((Long64_t)(fmemory[foffset+1]&fgk08BitOn))<<32);
	250	foffset +=1;
	251	break;
	252	case 1:
	253	blackbox = (fmemory[foffset]>>8 ) + (((Long64_t)(fmemory[foffset+1]&fgk16BitOn))<<24);
	254	foffset +=1;
	255	break;
	256	case 2:
	257	blackbox = (fmemory[foffset]>>16) + (((Long64_t)(fmemory[foffset+1]&fgk24BitOn))<<16);
	258	foffset +=1;
	259	break;
	260	case 3:
	261	blackbox = (fmemory[foffset]>>24) + (((Long64_t)(fmemory[foffset+1] ))<< 8);
	262	foffset +=2;
	263	break;
	264	default:
	265	blackbox = 0;
	266	break;
48265b32	267	}
5312f439	268	f10BitArray[ind*4+0] = (Short_t)( blackbox & fgkmask10 ) ;
	269	f10BitArray[ind*4+1] = (Short_t)((blackbox & fgkmask20)>>10);
	270	f10BitArray[ind*4+2] = (Short_t)((blackbox & fgkmask30)>>20);
	271	f10BitArray[ind*4+3] = (Short_t)((blackbox & fgkmask40)>>30);
	272	}
48265b32	273	if(fwrite10bit)
5312f439	274	{
5312f439	275	for(Int_t ind = 0; ind < Get40BitArraySize(); ind++)
48265b32	276	{
5312f439	277	datout << dec << f10BitArray[ind*4+0] << "\n";
	278	datout << dec << f10BitArray[ind*4+1] << "\n";
	279	datout << dec << f10BitArray[ind*4+2] << "\n";
	280	datout << dec << f10BitArray[ind*4+3] << "\n";
48265b32	281	}
5312f439	282	}
48265b32	283
	284	if(fwrite10bit) datout.close();
	285	}
	286
	287	//_____________________________________________________________________________________________
	288	Int_t AliTPCMonitorAltro::DecodeTrailer(Int_t pos)
	289	{
	290	// Decode the trailer word starting at position pos in fmemory
	291	// Check if information leads to proper next trailer position
5312f439	292	if (GetAltroVersion()==0xaabb) return DecodeTrailerVbb(pos);
48265b32	293	fTrailerPos = pos;
	294	if(pos<=4) return 0;
	295
	296	Long64_t words = 0;
	297	Long64_t tail = 0;
	298	Long64_t trailer = 0;
	299	Long64_t carry = 0;
	300	Long64_t rest = 0 ;
	301
	302	for(Long64_t iter = 0 ; iter<4;iter++)
	303	{
	304	carry = f10BitArray[pos-iter] ;
	305	carry = ( carry << (30- ((iter)*10)));
	306	trailer += carry ;
	307	}
	308
ca7b8371	309	fTrailerHwAddress = (trailer & ((Long64_t )fgkTrailerMaskHardw) );
	310	words = (Long64_t )( (trailer & ((Long64_t )fgkTrailerMaskNWords))>>16);
	311	tail = (Long64_t )( (trailer & ((Long64_t )fgkTrailerMaskTail ))>>26 );
48265b32	312
	313	if(words%4!=0) rest = 4-(words%4);
	314	fTrailerNWords = words+rest ;
	315	fTrailerDataPos = pos -4 -rest ;
	316	fTrailerBlockPos = pos -4 ;
	317	fNextPos = (pos -fTrailerNWords -4);
	318
ca7b8371	319	if( tail!=fgkTrailerTail ) { AliError(Form("Could not read Trailer. \"Write 10bit\" for this event. Last Trailer line (2AA): %i. Supp.next Trailer line (2AA): %i ",pos,fNextPos)); return -1; }
48265b32	320	else if( fNextPos==-1 ) { /* was last channel */ return 0; }
	321	else if( fNextPos <0 ) { AliError("Next Trailer position < 0 "); return -1; }
	322	else if((f10BitArray[fNextPos]!=682)) { AliError(Form("Could not find tail (2AA) at next supposed position %i",fNextPos)); return -1; }
	323	else { return fNextPos;}
	324
	325	}
	326
5312f439	327	//_____________________________________________________________________________________________
	328	Int_t AliTPCMonitorAltro::DecodeTrailerVbb(Int_t pos)
	329	{
	330	// Decode the trailer word starting at position pos in fmemory
	331	// Check if information leads to proper next trailer position
	332	fTrailerPos = pos;
	333	if(pos>Get10BitArraySize()-4) return 0;
	334
	335	Long64_t words = 0;
	336	Long64_t tail = 0;
	337	Long64_t trailer = 0;
	338	Long64_t carry = 0;
	339	Long64_t rest = 0 ;
	340
	341	for(Long64_t iter = 0 ; iter<4;iter++)
	342	{
	343	carry = f10BitArray[pos-iter] ;
	344	carry = ( carry << (30- ((iter)*10)));
	345	trailer += carry ;
	346	}
	347
	348	fTrailerHwAddress = (trailer & ((Long64_t )fgkTrailerMaskHardw) );
	349	words = (Long64_t )( (trailer & ((Long64_t )fgkTrailerMaskNWords))>>16);
	350	tail = (Long64_t )( (trailer & ((Long64_t )fgkTrailerMaskTail ))>>26 );
	351
	352	//Decide on read direction (sign) from the RCU trailer information
	353	Int_t sign=-1;
	354	if (GetAltroVersion()==0xaabb) sign=1;
	355
	356	if(words%4!=0) rest = 4-(words%4);
	357	fTrailerNWords = words+rest ;
	358	fTrailerDataPos = pos +sign*(4+rest) ;
	359	fTrailerBlockPos = pos +sign*4 ;
	360	fNextPos = (pos +sign*(fTrailerNWords+4));
	361
	362	if( tail==fgkTrailerTailErr ) {
7d85e147	363	AliError(Form("Found Altro header with error marker (2AEE)[%0llx]: %i. Supp.next Trailer line (2AA)[%0x]: %i ",
5312f439	364	tail,pos,f10BitArray[fNextPos],fNextPos));
	365	return -fNextPos;
	366	} else if ( tail!=fgkTrailerTail ) {
7d85e147	367	AliError(Form("Could not read Trailer. \"Write 10bit\" for this event. Last Trailer line (2AA)[%0llx]: %i. Supp.next Trailer line (2AA)[%0x]: %i ",
5312f439	368	tail,pos,f10BitArray[fNextPos],fNextPos)); return -1;
	369	} else if( fNextPos==Get10BitArraySize()+3 ) { /* was last channel */
	370	return 0;
	371	} else if( fNextPos >=Get10BitArraySize() ) {
	372	AliError(Form("Next Trailer position < 0 %i", fNextPos));
	373	return -1;
	374	} else if((f10BitArray[fNextPos]!=682)&&(f10BitArray[fNextPos]!=686)) {
	375	AliError(Form("Could not find tail (2AA) at next supposed position %i",fNextPos));
	376	return -1;
	377	} else {
	378	return fNextPos;
	379	}
	380
	381	}
48265b32	382
48265b32	383