[u/mrichter/AliRoot.git] / HLT / src / AliL3RawDataFileHandler.cxx

// @(#) $Id$

// Author: C. Loizides <loizides@ikf.uni-frankfurt.de>
//*-- Copyright &copy ALICE HLT Group

#include "AliL3StandardIncludes.h"

#include "AliL3RootTypes.h"
#include "AliL3Logging.h"
#include "AliL3Transform.h"
#include "AliL3MemHandler.h"
#include "AliL3DigitData.h"

#include "AliL3RawDataFileHandler.h"

#if GCCVERSION == 3
using namespace std;
#endif

/** \class AliL3RawDataFileHandler 
<pre>
//_____________________________________________________________
// AliL3RawDataFileHandler
//
</pre>
*/

ClassImp(AliL3RawDataFileHandler)

AliL3RawDataFileHandler::AliL3RawDataFileHandler()
{
  FreeAll();

  if((sizeof(Int_t) != 4) || (sizeof(Short_t) != 2)){
    LOG(AliL3Log::kError,"AliL3RawDataFileHandler::AliL3RawDataFileHandler","Constructor")
      <<"Check architecture to run the conversion on! Int_t should be 32 and Short_t should be 16 bit."<<ENDLOG;
  }
}

AliL3RawDataFileHandler::~AliL3RawDataFileHandler()
{
  FreeAll();
}

void AliL3RawDataFileHandler::FreeAll()
{
  if(fInRaw) CloseRawInput();
  if(fInRawPed) CloseRawPedestalsInput();
  if(fMapping) CloseMappingFile();
  if(fNChannels){
    delete[] fRow;
    delete[] fPad;
    delete[] fRowPad;
  }
  if(fPedestals) delete[] fPedestals;
  if(fOutRaw) CloseRawOutput();

  fConvert=kTRUE;
  fInRaw = 0;
  fInRawPed = 0;
  fOutRaw = 0;
  fMapping = 0;
  fNChannels=0;
  fRow=0;
  fPad=0;
  fRowPad=0;
  fRowMinUsed=AliL3Transform::GetNRows();
  fRowMaxUsed=0;
  fPadMinUsed=255;
  fPadMaxUsed=0;
  fNTimeBins=0;
  for(Int_t i=0;i<AliL3Transform::GetNRows();i++) fNPads[i]=0;
  fPedVal=0;
  fPedestals=0;
}

Bool_t AliL3RawDataFileHandler::SetRawInput(Char_t *name)
{
  if(fInRaw){
    LOG(AliL3Log::kError,"AliL3RawDataFileHandler::SetRawInput","File Open")
      <<"File ptr is already in use, close file first"<<ENDLOG;
    return kFALSE;
  }

  //Open the raw data file with name.
  fInRaw = new ifstream();
  fInRaw->open(name,fstream::binary);

  if(!fInRaw->is_open()){
    LOG(AliL3Log::kError,"AliL3RawDataFileHandler::SetRawInput","File Open")
      <<"Pointer to ifstream = 0x0"<<ENDLOG;
    return kFALSE;
  }
  
  return kTRUE;
}

Bool_t AliL3RawDataFileHandler::SetRawInput(ifstream *file)
{
  if(fInRaw){
    LOG(AliL3Log::kError,"AliL3RawDataFileHandler::SetRawInput","File Open")
      <<"File ptr is already in use, close file first"<<ENDLOG;
    return kFALSE;
  }

  //Open the raw data file with given file.
  fInRaw = file;

  if(!fInRaw->is_open()){
    LOG(AliL3Log::kError,"AliL3RawDataFileHandler::SetRawInput","File Open")
      <<"Pointer to ifstream = 0x0"<<ENDLOG;
    return kFALSE;
  }
  
  return kTRUE;
}

void AliL3RawDataFileHandler::CloseRawInput()
{
  if(!fInRaw){
    LOG(AliL3Log::kWarning,"AliL3RawDataFileHandler::CloseRawInput","File Close")
      <<"Nothing to Close"<<ENDLOG;
    return;
  }
  if(fInRaw->is_open()) fInRaw->close();
  delete fInRaw;
  fInRaw = 0;
}

Bool_t AliL3RawDataFileHandler::SetRawOutput(Char_t *name)
{
  if(fOutRaw){
    LOG(AliL3Log::kError,"AliL3RawDataFileHandler::SetRawOutput","File Open")
      <<"File ptr is already in use, close file first"<<ENDLOG;
    return kFALSE;
  }

  fOutRaw = new ofstream();
  fOutRaw->open(name,fstream::binary);

  if(!fOutRaw->is_open()){
    LOG(AliL3Log::kError,"AliL3RawDataFileHandler::SetRawOutput","File Open")
      <<"Pointer to ofstream = 0x0"<<ENDLOG;
    return kFALSE;
  }
  
  return kTRUE;
}

Bool_t AliL3RawDataFileHandler::SetRawOutput(ofstream *file)
{
  if(fOutRaw){
    LOG(AliL3Log::kError,"AliL3RawDataFileHandler::SetRawOutput","File Open")
      <<"File ptr is already in use, close file first"<<ENDLOG;
    return kFALSE;
  }

  //Open the raw data file with given file.
  fOutRaw = file;

  if(!fOutRaw->is_open()){
    LOG(AliL3Log::kError,"AliL3RawDataFileHandler::SetRawOutput","File Open")
      <<"Pointer to ofstream = 0x0"<<ENDLOG;
    return kFALSE;
  }
  
  return kTRUE;
}

void AliL3RawDataFileHandler::CloseRawOutput()
{
  if(!fOutRaw){
    LOG(AliL3Log::kWarning,"AliL3RawDataFileHandler::CloseRawOutput","File Close")
      <<"Nothing to Close"<<ENDLOG;
    return;
  }
  if(fOutRaw->is_open()) fOutRaw->close();
  delete fOutRaw;
  fOutRaw = 0;
}


Bool_t AliL3RawDataFileHandler::SetRawPedestalsInput(Char_t *name)
{
  if(fInRawPed){
    LOG(AliL3Log::kError,"AliL3RawDataFileHandler::SetRawPedestalsInput","File Open")
      <<"File ptr is already in use, close file first"<<ENDLOG;
    return kFALSE;
  }

  //Open the raw data file with name.
  fInRawPed = new ifstream();
  fInRawPed->open(name,fstream::binary);

  if(!fInRawPed->is_open()){
    LOG(AliL3Log::kError,"AliL3RawDataFileHandler::SetRawPedestalsInput","File Open")
      <<"Pointer to ifstream = 0x0"<<ENDLOG;
    return kFALSE;
  }
  
  return kTRUE;
}

Bool_t AliL3RawDataFileHandler::SetRawPedestalsInput(ifstream *file)
{
  if(fInRawPed){
    LOG(AliL3Log::kError,"AliL3RawDataFileHandler::SetRawPedestalsInput","File Open")
      <<"File ptr is already in use, close file first"<<ENDLOG;
    return kFALSE;
  }

  //Open the raw data file with given file.
  fInRawPed = file;

  if(!fInRawPed->is_open()){
    LOG(AliL3Log::kError,"AliL3RawDataFileHandler::SetRawPedestalsInput","File Open")
      <<"Pointer to ifstream = 0x0"<<ENDLOG;
    return kFALSE;
  }
  
  return kTRUE;
}

void AliL3RawDataFileHandler::CloseRawPedestalsInput()
{
  if(!fInRawPed){
    LOG(AliL3Log::kWarning,"AliL3RawDataFileHandler::CloseRawPedestalsInput","File Close")
      <<"Nothing to Close"<<ENDLOG;
    return;
  }
  if(fInRawPed->is_open()) fInRawPed->close();
  delete fInRawPed;
  fInRaw = 0;
}

Bool_t AliL3RawDataFileHandler::SetMappingFile(Char_t *name)
{
  if(fMapping){
    LOG(AliL3Log::kError,"AliL3RawDataFileHandler::SetMapping","File Open")
      <<"File ptr is already in use, close file first"<<ENDLOG;
    return kFALSE;
  }

  fMapping = fopen(name,"r");
  if(!fMapping){
    LOG(AliL3Log::kWarning,"AliL3RawDataFileHandler::SetMappingFile","File Open")
      <<"Pointer to file = 0x0"<<ENDLOG;
    return kFALSE;
  }
  
  return kTRUE;
}

Bool_t AliL3RawDataFileHandler::SetMappingFile(FILE *file)
{
  if(fMapping){
    LOG(AliL3Log::kError,"AliL3RawDataFileHandler::SetMapping","File Open")
      <<"File ptr is already in use, close file first"<<ENDLOG;
    return kFALSE;
  }

  fMapping = file;
  if(!fMapping){
    LOG(AliL3Log::kWarning,"AliL3RawDataFileHandler::SetMappingFile","File Open")
      <<"Pointer to file = 0x0"<<ENDLOG;
    return kFALSE;
  }
  
  return kTRUE;
}

void AliL3RawDataFileHandler::CloseMappingFile()
{
  if(!fMapping){
    LOG(AliL3Log::kWarning,"AliL3RawDataFileHandler::CloseMappingFile","File Close")
      <<"Nothing to Close"<<ENDLOG;
    return;
  }
  fclose(fMapping);
  fMapping = 0;
}

Int_t AliL3RawDataFileHandler::ReadMappingFile()
{
  if(!fMapping){
    LOG(AliL3Log::kError,"AliL3RawDataFileHandler::ReadMappingFile","File Open")
      <<"Pointer to file = 0x0"<<ENDLOG;
    return -1;
  }

  Char_t dummy[100];
  fgets(dummy,80,fMapping);

  Int_t nboard,nadc;
  fscanf(fMapping,"%s %d %s %d",dummy,&nboard,dummy,&nadc); 

  fNChannels=nboard*nadc;
  if(fNChannels<=0){
    LOG(AliL3Log::kWarning,"AliL3RawDataFileHandler::ReadMappingFile","Data Inconsistency")
      <<"fNChannels must be greater than 0"<<ENDLOG;
    return -1;
  }

  fRow=new Byte_t[fNChannels];
  fPad=new Byte_t[fNChannels];
  fRowPad=new Short_t*[AliL3Transform::GetNRows()];
  for(Int_t i=0; i < AliL3Transform::GetNRows(); i++){
    fRowPad[i]=new Short_t[AliL3Transform::GetNPads(i)];
    for(Int_t j=0; j < AliL3Transform::GetNPads(i); j++) fRowPad[i][j]=-1;
  }

  for(UInt_t i=0;i<fNChannels;i++){
    Int_t board,adc,row,pad;
    if(fscanf(fMapping,"%d %d %d %d",&board,&adc,&row,&pad)!=4) break; 
    //store the mapping
    fRow[i]=(Byte_t)row;
    fPad[i]=(Byte_t)pad;
    fRowPad[row][pad]=i;
    if(row>fRowMaxUsed) fRowMaxUsed=row;
    if(row<fRowMinUsed) fRowMinUsed=row;
    if(pad>fPadMaxUsed) fPadMaxUsed=pad;
    if(pad<fPadMinUsed) fPadMinUsed=pad;

    fNPads[row]++;
    //cout << i << " " << row << " " << pad << endl;
  }

  return fNChannels;
}

inline Int_t AliL3RawDataFileHandler::Convert4(Int_t i)
{ //BigEndian i0i1i2i3 -> LittleEndian i3i2i1i0
  if(!fConvert) return i;
  Char_t *p=(Char_t*)&i;
  Char_t temp[4];
  temp[0]=p[3];
  temp[1]=p[2];
  temp[2]=p[1];
  temp[3]=p[0];
  return (*(Int_t*)temp);
}

inline Short_t AliL3RawDataFileHandler::Convert2(Short_t s)
{ //BigEndian i0i1 -> LittleEndian i1i0
  if(!fConvert) return s;
  Char_t *p=(Char_t*)&s;
  Char_t temp[2];
  temp[0]=p[1];
  temp[1]=p[0];
  return (*(Short_t*)temp);
}

Int_t AliL3RawDataFileHandler::ReadRawInput()
{
  //Read data from cosmics file into memory

  if(!fInRaw){
    LOG(AliL3Log::kError,"AliL3RawDataFileHandler::ReadRawInput","File Open")
      <<"No Input avalible: no object ifstream"<<ENDLOG;
    return 0; 
  }

  if(!fInRaw->is_open()){
    LOG(AliL3Log::kError,"AliL3RawDataFileHandler::ReadRawInput","File Open")
      <<"No Input avalible: ifstream not opened"<<ENDLOG;
    return 0;
  }

  Int_t dummy4;
  Short_t dummy2;
  fInRaw->read((Char_t*)&dummy4,sizeof(dummy4));
  if(dummy4==(Int_t)fNChannels) fConvert=kFALSE;
  else {
    Int_t knumofChannels = Convert4(dummy4);    
    if(knumofChannels!=(Int_t)fNChannels){
      LOG(AliL3Log::kError,"AliL3RawDataFileHandler::ReadRawInput","Data Inconsistency")
	<<"Number of Channels should be equal to fNChannels "<<knumofChannels<<" "<<fNChannels<<ENDLOG;
      return 0;
    }
  }
  
  //read used altrochannels (for the moment
  //this information is not really needed as
  //all channels per FEC are used
  for(UInt_t i = 0 ; i < fNChannels ; i++){
    fInRaw->read((Char_t*)&dummy2,sizeof(dummy2));
    UShort_t channel = Convert2(dummy2);
    if(channel>fNChannels){
    LOG(AliL3Log::kWarning,"AliL3RawDataFileHandler::ReadRawInput","Data Inconsistency")
      <<AliL3Log::kDec<<"Channel number must be smaller then fNChannels "<<channel<<" "<<fNChannels<<ENDLOG;
    return 0;
    }
  }

  fInRaw->read((Char_t*)&dummy4,sizeof(dummy4));
  Int_t numofChannelsTest = Convert4(dummy4);

  if (numofChannelsTest != (Int_t)fNChannels){
    LOG(AliL3Log::kWarning,"AliL3RawDataFileHandler::ReadRawInput","Data Inconsistency")
      <<AliL3Log::kDec<<"Number of test channels should be equal to fNChannels "<<numofChannelsTest<<" "<<fNChannels<<ENDLOG;
    return 0;
  }

  //Timebins
  fInRaw->read((Char_t*)&dummy4,sizeof(dummy4));
  fNTimeBins=Convert4(dummy4);

  if(fNTimeBins!=AliL3Transform::GetNTimeBins()){
    LOG(AliL3Log::kError,"AliL3RawDataFileHandler::ReadRawInput","Data Inconsistency")
      <<AliL3Log::kDec<<"fNTimeBins does not match AliL3Transformer, check AliL3Transform::Init() "<<fNTimeBins<<" "<<AliL3Transform::GetNTimeBins()<<ENDLOG;
  }

  return fNChannels;
}

Short_t** AliL3RawDataFileHandler::GetRawData(Int_t &channels, Int_t &timebins)
{
  Short_t **charges=0;
  channels=0;
  timebins=0;

  if(fNTimeBins==0){
    LOG(AliL3Log::kWarning,"AliL3RawDataFileHandler::GetRawData","Data Inconsistency")
      <<"Call AliL3RawDataFileHandler::RawReadInput() first"<<ENDLOG;
    if(!ReadRawInput()){
      LOG(AliL3Log::kError,"AliL3RawDataFileHandler::GetRawData","Data Inconsistency")
	<<"Something went wrong reading data header"<<ENDLOG;
      return 0;
    }
  }

  charges=new Short_t*[fNChannels];
  for(UInt_t c=0;c<fNChannels;c++) charges[c]=new Short_t[fNTimeBins];

  for(UInt_t channel = 0; channel < fNChannels; channel++){
    for(Int_t timebin = 0 ; timebin < fNTimeBins ; timebin++){
      Short_t dummy2;
      fInRaw->read((Char_t*)&dummy2,sizeof(dummy2));
      Short_t charge = Convert2(dummy2);
      charges[channel][timebin]=charge;
    }
  }

  channels=fNChannels;
  timebins=fNTimeBins;

  return charges;
}

Int_t AliL3RawDataFileHandler::StoreRawData(Short_t **charges)
{
  //store charges in the raw data format

  if(!fOutRaw){
    LOG(AliL3Log::kError,"AliL3RawDataFileHandler::StoreRawData","File Open")
      <<"No Output avalible: no object ofstream"<<ENDLOG;
    return 0; 
  }

  if(!fOutRaw->is_open()){
    LOG(AliL3Log::kError,"AliL3RawDataFileHandler::StoreRawData","File Open")
      <<"No Output avalible: ofstream not opened"<<ENDLOG;
    return 0;
  }

  Int_t dummy4;
  Short_t dummy2;

  dummy4=Convert4(fNChannels);

  fOutRaw->write((Char_t*)&dummy4,sizeof(dummy4));
  for(UInt_t i = 0 ; i < fNChannels ; i++){
    dummy2 = Convert2(Short_t(i));
    fOutRaw->write((Char_t*)&dummy2,sizeof(dummy2));
  }

  dummy4=Convert4(fNChannels);
  fOutRaw->write((Char_t*)&dummy4,sizeof(dummy4));

  //Timebins
  dummy4=Convert4(fNTimeBins);
  fOutRaw->write((Char_t*)&dummy4,sizeof(dummy4));

  for(UInt_t channel = 0; channel < fNChannels; channel++){
    for(Int_t timebin = 0 ; timebin < fNTimeBins ; timebin++){
      Short_t charge=charges[channel][timebin];
      dummy2 = Convert2(charge);
      fOutRaw->write((Char_t*)&dummy2,sizeof(dummy2));
    }
  }

  return fNChannels;
}

Int_t AliL3RawDataFileHandler::ReadRawPedestalsInput()
{
  if(!fInRawPed){
    LOG(AliL3Log::kError,"AliL3RawDataFileHandler::ReadRawPedestalsInput","File Open")
      <<"No Input avalible: no object ifstream"<<ENDLOG;
    return 0; 
  }

  if(!fInRawPed->is_open()){
    LOG(AliL3Log::kError,"AliL3RawDataFileHandler::ReadRawPedestalsInput","File Open")
      <<"No Input avalible: ifstream not opened"<<ENDLOG;
    return 0;
  }

  Int_t dummy4;
  Short_t dummy2;
  fInRawPed->read((Char_t*)&dummy4,sizeof(dummy4));
  if(dummy4==(Int_t)fNChannels) fConvert=kFALSE;
  else {
    Int_t knumofChannels = Convert4(dummy4);    
    if(knumofChannels!=(Int_t)fNChannels){
      LOG(AliL3Log::kError,"AliL3RawDataFileHandler::ReadRawPedestalsInput","Data Inconsistency")
	<<AliL3Log::kDec<<"Number of Channels should be equal to fNChannels "<<knumofChannels<<" "<<fNChannels<<ENDLOG;
      return 0;
    }
  }
  
  //read used altrochannels (for the moment
  for(UInt_t i = 0 ; i < fNChannels ; i++){
    fInRawPed->read((Char_t*)&dummy2,sizeof(dummy2));
    //UShort_t channel = Convert2(dummy2);
  }

  fInRawPed->read((Char_t*)&dummy4,sizeof(dummy4));
  //Int_t numofChannelsTest = Convert4(dummy4);

  //Timebins
  fInRawPed->read((Char_t*)&dummy4,sizeof(dummy4));
  fNTimeBins=Convert4(dummy4);

  if(fNTimeBins!=AliL3Transform::GetNTimeBins()){
    LOG(AliL3Log::kError,"AliL3RawDataFileHandler::ReadRawPedestalsInput","Data Inconsistency")
      <<AliL3Log::kDec<<"fNTimeBins does not match AliL3Transformer, check AliL3Transform::Init() "<<fNTimeBins<<" "<<AliL3Transform::GetNTimeBins()<<ENDLOG;
  }

  //Read the data
  fPedestals=new Short_t*[fNChannels];
  for(UInt_t c=0;c<fNChannels;c++) fPedestals[c]=new Short_t[fNTimeBins];

  for(UInt_t channel = 0; channel < fNChannels; channel++){
    for(Int_t timebin = 0 ; timebin < fNTimeBins ; timebin++){
      Short_t dummy2;
      fInRawPed->read((Char_t*)&dummy2,sizeof(dummy2));
      Short_t charge = Convert2(dummy2);
      fPedestals[channel][timebin]=charge;
    }
  }

  return fNChannels;
}

AliL3DigitRowData * AliL3RawDataFileHandler::RawData2Memory(UInt_t &nrow,Int_t event)
{                                           //event is not used
  AliL3DigitRowData *data = 0;
  nrow=0;

  if(fNTimeBins==0){
    LOG(AliL3Log::kWarning,"AliL3RawDataFileHandler::RawData2Memory","Data Inconsistency")
      <<"Call AliL3RawDataFileHandler::RawReadInput() first"<<ENDLOG;
    if(!ReadRawInput()){
      LOG(AliL3Log::kError,"AliL3RawDataFileHandler::RawData2Memory","Data Inconsistency")
	<<"Something went wrong reading data header"<<ENDLOG;
      return 0;
    }
  }
  
  //Read the data
  Short_t charges[fNChannels][fNTimeBins];
  for(UInt_t channel = 0; channel < fNChannels; channel++){
    for(Int_t timebin = 0 ; timebin < fNTimeBins ; timebin++){
      Short_t dummy2;
      fInRaw->read((Char_t*)&dummy2,sizeof(dummy2));
      Short_t charge = Convert2(dummy2);

      //Pedestal substraction
      if(fPedestals) charge-=fPedestals[channel][timebin];
      else charge-=fPedVal;
      if(charge<0) charge=0;

      charges[channel][timebin]=charge;
    }
  }

  //get data size
  Int_t nrows=0;
  Int_t ndigitcount=0;
  Int_t ndigits[AliL3Transform::GetNRows()];
  for(Int_t i=0;i<AliL3Transform::GetNRows();i++) ndigits[i]=0;

  //no need to search for slice/sector given by init
  //but check for row/patch boundaries
  //assume slice 0
  for(Int_t slrow=0;slrow<AliL3Transform::GetNRows();slrow++){
    
    if(slrow<fRowMin) continue;
    if(slrow>fRowMax) break;

    for(Int_t pad=0;pad<AliL3Transform::GetNPads(slrow);pad++){
      Short_t channel=fRowPad[slrow][pad];
      if(channel==-1) continue; //no data on that channel;

      for(Int_t timebin = 0 ; timebin < fNTimeBins ; timebin++){
	Int_t dig=charges[channel][timebin];
	
	if(dig <= AliL3Transform::GetZeroSup()) continue;
	if(dig >= AliL3Transform::GetADCSat())
	  dig = AliL3Transform::GetADCSat();

	ndigits[slrow]++; //for this row only
	ndigitcount++;  //total number of digits to be published
      }
    }
    
    //count number of rows
    nrows++;
  }

  //test data consistency
  Int_t ndigitcounttest=0;
  for(Int_t slrow=0;slrow<AliL3Transform::GetNRows();slrow++)
    ndigitcounttest+=ndigits[slrow];
  if(ndigitcount!=ndigitcounttest)
    LOG(AliL3Log::kError,"AliL3RawDataFileHandler::RawData2Memory","Digits")
    <<AliL3Log::kDec<<"Found Inconsistency "<<ndigitcount<<" != "<<ndigitcounttest<<ENDLOG;
    
  Int_t size = sizeof(AliL3DigitData)*ndigitcount
    + nrows*sizeof(AliL3DigitRowData);
  LOG(AliL3Log::kDebug,"AliL3RawDataFileHandler::RawData2Memory","Digits")
    <<AliL3Log::kDec<<"Found "<<ndigitcount<<" Digits on "<<nrows<<" rows"<<ENDLOG;

  //now copy data
  data=(AliL3DigitRowData*) Allocate(size);
  nrow = (UInt_t)nrows;
  //memset(data,1,size); //for debugging

  Int_t ndigitcounttest2=0;
  AliL3DigitRowData *tempPt = data;
  for(Int_t slrow=0;slrow<AliL3Transform::GetNRows();slrow++){
    
    if(slrow<fRowMin) continue;
    if(slrow>fRowMax) break;
    
    tempPt->fRow = slrow;
    tempPt->fNDigit = ndigits[slrow];

    Int_t localcount=0;
    for(Int_t pad=0;pad<AliL3Transform::GetNPads(slrow);pad++){
      Short_t channel=fRowPad[slrow][pad];
      if(channel==-1) continue; //no data on that channel;

      for(Int_t timebin = 0 ; timebin < fNTimeBins ; timebin++){
	Int_t dig=charges[channel][timebin];
	
	if(dig <= AliL3Transform::GetZeroSup()) continue;
	if(dig >= AliL3Transform::GetADCSat())
	  dig = AliL3Transform::GetADCSat();

	//Exclude data outside cone:
	//AliL3Transform::Raw2Local(xyz,sector,row,pad,time);
	//if(fParam->GetPadRowRadii(sector,row)<230./250.*fabs(xyz[2])) continue;

        tempPt->fDigitData[localcount].fCharge=(UShort_t)dig;
        tempPt->fDigitData[localcount].fPad=(UChar_t)pad;
        tempPt->fDigitData[localcount].fTime=(UShort_t)timebin;
#ifdef do_mc
	tempPt->fDigitData[localcount].fTrackID[0] = 0;
	tempPt->fDigitData[localcount].fTrackID[1] = 0;
	tempPt->fDigitData[localcount].fTrackID[2] = 0;
#endif
        localcount++;
	ndigitcounttest2++;
      } //time
    } //pad 

    if(localcount != ndigits[slrow])
      LOG(AliL3Log::kFatal,"AliL3RawDataFileHandler::RawData2Memory","Memory")
	<<AliL3Log::kDec<<"Mismatch: localcount "<<localcount<<" ndigits "
	<<ndigits[slrow]<<ENDLOG;

    Byte_t *tmp = (Byte_t*)tempPt;
    Int_t size = sizeof(AliL3DigitRowData)
                                      + ndigits[slrow]*sizeof(AliL3DigitData);
    tmp += size;
    tempPt = (AliL3DigitRowData*)tmp;
  }//row

  if(ndigitcount!=ndigitcounttest2)
    LOG(AliL3Log::kError,"AliL3RawDataFileHandler::RawData2Memory","Digits")
    <<AliL3Log::kDec<<"Found Inconsistency "<<ndigitcount<<" != "<<ndigitcounttest2<<ENDLOG;

  return data;
}

Bool_t AliL3RawDataFileHandler::RawData2CompBinary(Int_t event)
{
  Bool_t out = kTRUE;
  UInt_t ndigits=0;
  AliL3DigitRowData *digits=0;
  digits = RawData2Memory(ndigits,event);
  out = Memory2CompBinary(ndigits,digits);
  Free();
  return out;
}
Commit	Line	Data
3e87ef69	1	// @(#) $Id$
	2
	3	// Author: C. Loizides <loizides@ikf.uni-frankfurt.de>
	4	//*-- Copyright &copy ALICE HLT Group
	5
	6	#include "AliL3StandardIncludes.h"
	7
	8	#include "AliL3RootTypes.h"
	9	#include "AliL3Logging.h"
	10	#include "AliL3Transform.h"
	11	#include "AliL3MemHandler.h"
	12	#include "AliL3DigitData.h"
	13
	14	#include "AliL3RawDataFileHandler.h"
	15
	16	#if GCCVERSION == 3
	17	using namespace std;
	18	#endif
	19
	20	/** \class AliL3RawDataFileHandler
	21	<pre>
	22	//_____________________________________________________________
	23	// AliL3RawDataFileHandler
	24	//
	25	</pre>
	26	*/
	27
	28	ClassImp(AliL3RawDataFileHandler)
	29
	30	AliL3RawDataFileHandler::AliL3RawDataFileHandler()
	31	{
	32	FreeAll();
	33
	34	if((sizeof(Int_t) != 4) \|\| (sizeof(Short_t) != 2)){
	35	LOG(AliL3Log::kError,"AliL3RawDataFileHandler::AliL3RawDataFileHandler","Constructor")
	36	<<"Check architecture to run the conversion on! Int_t should be 32 and Short_t should be 16 bit."<<ENDLOG;
	37	}
	38	}
	39
	40	AliL3RawDataFileHandler::~AliL3RawDataFileHandler()
	41	{
	42	FreeAll();
	43	}
	44
	45	void AliL3RawDataFileHandler::FreeAll()
	46	{
	47	if(fInRaw) CloseRawInput();
	48	if(fInRawPed) CloseRawPedestalsInput();
	49	if(fMapping) CloseMappingFile();
	50	if(fNChannels){
	51	delete[] fRow;
	52	delete[] fPad;
	53	delete[] fRowPad;
	54	}
	55	if(fPedestals) delete[] fPedestals;
	56	if(fOutRaw) CloseRawOutput();
	57
	58	fConvert=kTRUE;
	59	fInRaw = 0;
	60	fInRawPed = 0;
	61	fOutRaw = 0;
	62	fMapping = 0;
	63	fNChannels=0;
	64	fRow=0;
65	fPad=0;
66	fRowPad=0;
67	fRowMinUsed=AliL3Transform::GetNRows();
68	fRowMaxUsed=0;
69	fPadMinUsed=255;
70	fPadMaxUsed=0;
71	fNTimeBins=0;
72	for(Int_t i=0;i<AliL3Transform::GetNRows();i++) fNPads[i]=0;
73	fPedVal=0;
74	fPedestals=0;
75	}
76
77	Bool_t AliL3RawDataFileHandler::SetRawInput(Char_t *name)
78	{
79	if(fInRaw){
80	LOG(AliL3Log::kError,"AliL3RawDataFileHandler::SetRawInput","File Open")
81	<<"File ptr is already in use, close file first"<<ENDLOG;
82	return kFALSE;
83	}
84
85	//Open the raw data file with name.
86	fInRaw = new ifstream();
87	fInRaw->open(name,fstream::binary);
88
89	if(!fInRaw->is_open()){
90	LOG(AliL3Log::kError,"AliL3RawDataFileHandler::SetRawInput","File Open")
91	<<"Pointer to ifstream = 0x0"<<ENDLOG;
92	return kFALSE;
93	}
94
95	return kTRUE;
96	}
97
98	Bool_t AliL3RawDataFileHandler::SetRawInput(ifstream *file)
99	{
100	if(fInRaw){
101	LOG(AliL3Log::kError,"AliL3RawDataFileHandler::SetRawInput","File Open")
102	<<"File ptr is already in use, close file first"<<ENDLOG;
103	return kFALSE;
104	}
105
106	//Open the raw data file with given file.
107	fInRaw = file;
108
109	if(!fInRaw->is_open()){
110	LOG(AliL3Log::kError,"AliL3RawDataFileHandler::SetRawInput","File Open")
111	<<"Pointer to ifstream = 0x0"<<ENDLOG;
112	return kFALSE;
113	}
114
115	return kTRUE;
116	}
117
118	void AliL3RawDataFileHandler::CloseRawInput()
119	{
120	if(!fInRaw){
121	LOG(AliL3Log::kWarning,"AliL3RawDataFileHandler::CloseRawInput","File Close")
122	<<"Nothing to Close"<<ENDLOG;
123	return;
124	}
125	if(fInRaw->is_open()) fInRaw->close();
126	delete fInRaw;
127	fInRaw = 0;
128	}
129
130	Bool_t AliL3RawDataFileHandler::SetRawOutput(Char_t *name)
131	{
132	if(fOutRaw){
133	LOG(AliL3Log::kError,"AliL3RawDataFileHandler::SetRawOutput","File Open")
134	<<"File ptr is already in use, close file first"<<ENDLOG;
135	return kFALSE;
136	}
137
138	fOutRaw = new ofstream();
139	fOutRaw->open(name,fstream::binary);
140
141	if(!fOutRaw->is_open()){
142	LOG(AliL3Log::kError,"AliL3RawDataFileHandler::SetRawOutput","File Open")
143	<<"Pointer to ofstream = 0x0"<<ENDLOG;
144	return kFALSE;
145	}
146
147	return kTRUE;
148	}
149
150	Bool_t AliL3RawDataFileHandler::SetRawOutput(ofstream *file)
151	{
152	if(fOutRaw){
153	LOG(AliL3Log::kError,"AliL3RawDataFileHandler::SetRawOutput","File Open")
154	<<"File ptr is already in use, close file first"<<ENDLOG;
155	return kFALSE;
156	}
157
158	//Open the raw data file with given file.
159	fOutRaw = file;
160
161	if(!fOutRaw->is_open()){
162	LOG(AliL3Log::kError,"AliL3RawDataFileHandler::SetRawOutput","File Open")
163	<<"Pointer to ofstream = 0x0"<<ENDLOG;
164	return kFALSE;
165	}
166
167	return kTRUE;
168	}
169
170	void AliL3RawDataFileHandler::CloseRawOutput()
171	{
172	if(!fOutRaw){
173	LOG(AliL3Log::kWarning,"AliL3RawDataFileHandler::CloseRawOutput","File Close")
174	<<"Nothing to Close"<<ENDLOG;
175	return;
176	}
177	if(fOutRaw->is_open()) fOutRaw->close();
178	delete fOutRaw;
179	fOutRaw = 0;
180	}
181
182
183	Bool_t AliL3RawDataFileHandler::SetRawPedestalsInput(Char_t *name)
184	{
185	if(fInRawPed){
186	LOG(AliL3Log::kError,"AliL3RawDataFileHandler::SetRawPedestalsInput","File Open")
187	<<"File ptr is already in use, close file first"<<ENDLOG;
188	return kFALSE;
189	}
190
191	//Open the raw data file with name.
192	fInRawPed = new ifstream();
193	fInRawPed->open(name,fstream::binary);
194
195	if(!fInRawPed->is_open()){
196	LOG(AliL3Log::kError,"AliL3RawDataFileHandler::SetRawPedestalsInput","File Open")
197	<<"Pointer to ifstream = 0x0"<<ENDLOG;
198	return kFALSE;
199	}
200
201	return kTRUE;
202	}
203
204	Bool_t AliL3RawDataFileHandler::SetRawPedestalsInput(ifstream *file)
205	{
206	if(fInRawPed){
207	LOG(AliL3Log::kError,"AliL3RawDataFileHandler::SetRawPedestalsInput","File Open")
208	<<"File ptr is already in use, close file first"<<ENDLOG;
209	return kFALSE;
210	}
211
212	//Open the raw data file with given file.
213	fInRawPed = file;
214
215	if(!fInRawPed->is_open()){
216	LOG(AliL3Log::kError,"AliL3RawDataFileHandler::SetRawPedestalsInput","File Open")
217	<<"Pointer to ifstream = 0x0"<<ENDLOG;
218	return kFALSE;
219	}
220
221	return kTRUE;
222	}
223
224	void AliL3RawDataFileHandler::CloseRawPedestalsInput()
225	{
02f030e3	226	if(!fInRawPed){
3e87ef69	227	LOG(AliL3Log::kWarning,"AliL3RawDataFileHandler::CloseRawPedestalsInput","File Close")
	228	<<"Nothing to Close"<<ENDLOG;
	229	return;
	230	}
02f030e3	231	if(fInRawPed->is_open()) fInRawPed->close();
02f030e3	232	delete fInRawPed;
3e87ef69	233	fInRaw = 0;
	234	}
	235
	236	Bool_t AliL3RawDataFileHandler::SetMappingFile(Char_t *name)
	237	{
	238	if(fMapping){
	239	LOG(AliL3Log::kError,"AliL3RawDataFileHandler::SetMapping","File Open")
	240	<<"File ptr is already in use, close file first"<<ENDLOG;
	241	return kFALSE;
	242	}
	243
	244	fMapping = fopen(name,"r");
	245	if(!fMapping){
	246	LOG(AliL3Log::kWarning,"AliL3RawDataFileHandler::SetMappingFile","File Open")
	247	<<"Pointer to file = 0x0"<<ENDLOG;
	248	return kFALSE;
	249	}
	250
	251	return kTRUE;
	252	}
	253
	254	Bool_t AliL3RawDataFileHandler::SetMappingFile(FILE *file)
	255	{
	256	if(fMapping){
	257	LOG(AliL3Log::kError,"AliL3RawDataFileHandler::SetMapping","File Open")
	258	<<"File ptr is already in use, close file first"<<ENDLOG;
	259	return kFALSE;
	260	}
	261
	262	fMapping = file;
	263	if(!fMapping){
	264	LOG(AliL3Log::kWarning,"AliL3RawDataFileHandler::SetMappingFile","File Open")
	265	<<"Pointer to file = 0x0"<<ENDLOG;
	266	return kFALSE;
	267	}
	268
	269	return kTRUE;
	270	}
	271
	272	void AliL3RawDataFileHandler::CloseMappingFile()
	273	{
	274	if(!fMapping){
	275	LOG(AliL3Log::kWarning,"AliL3RawDataFileHandler::CloseMappingFile","File Close")
	276	<<"Nothing to Close"<<ENDLOG;
	277	return;
	278	}
	279	fclose(fMapping);
	280	fMapping = 0;
	281	}
	282
	283	Int_t AliL3RawDataFileHandler::ReadMappingFile()
	284	{
	285	if(!fMapping){
	286	LOG(AliL3Log::kError,"AliL3RawDataFileHandler::ReadMappingFile","File Open")
	287	<<"Pointer to file = 0x0"<<ENDLOG;
	288	return -1;
	289	}
	290
	291	Char_t dummy[100];
	292	fgets(dummy,80,fMapping);
	293
	294	Int_t nboard,nadc;
	295	fscanf(fMapping,"%s %d %s %d",dummy,&nboard,dummy,&nadc);
	296
297	fNChannels=nboard*nadc;
298	if(fNChannels<=0){
299	LOG(AliL3Log::kWarning,"AliL3RawDataFileHandler::ReadMappingFile","Data Inconsistency")
300	<<"fNChannels must be greater than 0"<<ENDLOG;
301	return -1;
302	}
303
304	fRow=new Byte_t[fNChannels];
305	fPad=new Byte_t[fNChannels];
306	fRowPad=new Short_t*[AliL3Transform::GetNRows()];
307	for(Int_t i=0; i < AliL3Transform::GetNRows(); i++){
308	fRowPad[i]=new Short_t[AliL3Transform::GetNPads(i)];
309	for(Int_t j=0; j < AliL3Transform::GetNPads(i); j++) fRowPad[i][j]=-1;
310	}
311
312	for(UInt_t i=0;i<fNChannels;i++){
313	Int_t board,adc,row,pad;
314	if(fscanf(fMapping,"%d %d %d %d",&board,&adc,&row,&pad)!=4) break;
315	//store the mapping
316	fRow[i]=(Byte_t)row;
317	fPad[i]=(Byte_t)pad;
318	fRowPad[row][pad]=i;
319	if(row>fRowMaxUsed) fRowMaxUsed=row;
320	if(row<fRowMinUsed) fRowMinUsed=row;
321	if(pad>fPadMaxUsed) fPadMaxUsed=pad;
322	if(pad<fPadMinUsed) fPadMinUsed=pad;
323
324	fNPads[row]++;
325	//cout << i << " " << row << " " << pad << endl;
326	}
327
328	return fNChannels;
329	}
330
331	inline Int_t AliL3RawDataFileHandler::Convert4(Int_t i)
332	{ //BigEndian i0i1i2i3 -> LittleEndian i3i2i1i0
333	if(!fConvert) return i;
334	Char_t p=(Char_t)&i;
335	Char_t temp[4];
336	temp[0]=p[3];
337	temp[1]=p[2];
338	temp[2]=p[1];
339	temp[3]=p[0];
340	return ((Int_t)temp);
341	}
342
343	inline Short_t AliL3RawDataFileHandler::Convert2(Short_t s)
344	{ //BigEndian i0i1 -> LittleEndian i1i0
345	if(!fConvert) return s;
346	Char_t p=(Char_t)&s;
347	Char_t temp[2];
348	temp[0]=p[1];
349	temp[1]=p[0];
350	return ((Short_t)temp);
351	}
352
353	Int_t AliL3RawDataFileHandler::ReadRawInput()
354	{
355	//Read data from cosmics file into memory
356
357	if(!fInRaw){
358	LOG(AliL3Log::kError,"AliL3RawDataFileHandler::ReadRawInput","File Open")
359	<<"No Input avalible: no object ifstream"<<ENDLOG;
360	return 0;
361	}
362
363	if(!fInRaw->is_open()){
364	LOG(AliL3Log::kError,"AliL3RawDataFileHandler::ReadRawInput","File Open")
365	<<"No Input avalible: ifstream not opened"<<ENDLOG;
366	return 0;
367	}
368
369	Int_t dummy4;
370	Short_t dummy2;
371	fInRaw->read((Char_t*)&dummy4,sizeof(dummy4));
372	if(dummy4==(Int_t)fNChannels) fConvert=kFALSE;
373	else {
374	Int_t knumofChannels = Convert4(dummy4);
375	if(knumofChannels!=(Int_t)fNChannels){
376	LOG(AliL3Log::kError,"AliL3RawDataFileHandler::ReadRawInput","Data Inconsistency")
377	<<"Number of Channels should be equal to fNChannels "<<knumofChannels<<" "<<fNChannels<<ENDLOG;
378	return 0;
379	}
380	}
381
382	//read used altrochannels (for the moment
383	//this information is not really needed as
384	//all channels per FEC are used
385	for(UInt_t i = 0 ; i < fNChannels ; i++){
386	fInRaw->read((Char_t*)&dummy2,sizeof(dummy2));
387	UShort_t channel = Convert2(dummy2);
388	if(channel>fNChannels){
389	LOG(AliL3Log::kWarning,"AliL3RawDataFileHandler::ReadRawInput","Data Inconsistency")
390	<<AliL3Log::kDec<<"Channel number must be smaller then fNChannels "<<channel<<" "<<fNChannels<<ENDLOG;
391	return 0;
392	}
393	}
394
395	fInRaw->read((Char_t*)&dummy4,sizeof(dummy4));
396	Int_t numofChannelsTest = Convert4(dummy4);
397
398	if (numofChannelsTest != (Int_t)fNChannels){
399	LOG(AliL3Log::kWarning,"AliL3RawDataFileHandler::ReadRawInput","Data Inconsistency")
400	<<AliL3Log::kDec<<"Number of test channels should be equal to fNChannels "<<numofChannelsTest<<" "<<fNChannels<<ENDLOG;
401	return 0;
402	}
403
404	//Timebins
405	fInRaw->read((Char_t*)&dummy4,sizeof(dummy4));
406	fNTimeBins=Convert4(dummy4);
407
408	if(fNTimeBins!=AliL3Transform::GetNTimeBins()){
409	LOG(AliL3Log::kError,"AliL3RawDataFileHandler::ReadRawInput","Data Inconsistency")
410	<<AliL3Log::kDec<<"fNTimeBins does not match AliL3Transformer, check AliL3Transform::Init() "<<fNTimeBins<<" "<<AliL3Transform::GetNTimeBins()<<ENDLOG;
411	}
412
413	return fNChannels;
414	}
415
416	Short_t** AliL3RawDataFileHandler::GetRawData(Int_t &channels, Int_t &timebins)
417	{
418	Short_t **charges=0;
419	channels=0;
420	timebins=0;
421
422	if(fNTimeBins==0){
423	LOG(AliL3Log::kWarning,"AliL3RawDataFileHandler::GetRawData","Data Inconsistency")
424	<<"Call AliL3RawDataFileHandler::RawReadInput() first"<<ENDLOG;
425	if(!ReadRawInput()){
426	LOG(AliL3Log::kError,"AliL3RawDataFileHandler::GetRawData","Data Inconsistency")
427	<<"Something went wrong reading data header"<<ENDLOG;
428	return 0;
429	}
430	}
431
432	charges=new Short_t*[fNChannels];
433	for(UInt_t c=0;c<fNChannels;c++) charges[c]=new Short_t[fNTimeBins];
434
435	for(UInt_t channel = 0; channel < fNChannels; channel++){
436	for(Int_t timebin = 0 ; timebin < fNTimeBins ; timebin++){
437	Short_t dummy2;
438	fInRaw->read((Char_t*)&dummy2,sizeof(dummy2));
439	Short_t charge = Convert2(dummy2);
440	charges[channel][timebin]=charge;
441	}
442	}
443
444	channels=fNChannels;
445	timebins=fNTimeBins;
446
447	return charges;
448	}
449
450	Int_t AliL3RawDataFileHandler::StoreRawData(Short_t **charges)
451	{
452	//store charges in the raw data format
453
454	if(!fOutRaw){
455	LOG(AliL3Log::kError,"AliL3RawDataFileHandler::StoreRawData","File Open")
456	<<"No Output avalible: no object ofstream"<<ENDLOG;
457	return 0;
458	}
459
460	if(!fOutRaw->is_open()){
461	LOG(AliL3Log::kError,"AliL3RawDataFileHandler::StoreRawData","File Open")
462	<<"No Output avalible: ofstream not opened"<<ENDLOG;
463	return 0;
464	}
465
466	Int_t dummy4;
467	Short_t dummy2;
468
469	dummy4=Convert4(fNChannels);
470
471	fOutRaw->write((Char_t*)&dummy4,sizeof(dummy4));
472	for(UInt_t i = 0 ; i < fNChannels ; i++){
473	dummy2 = Convert2(Short_t(i));
474	fOutRaw->write((Char_t*)&dummy2,sizeof(dummy2));
475	}
476
477	dummy4=Convert4(fNChannels);
478	fOutRaw->write((Char_t*)&dummy4,sizeof(dummy4));
479
480	//Timebins
481	dummy4=Convert4(fNTimeBins);
482	fOutRaw->write((Char_t*)&dummy4,sizeof(dummy4));
483
484	for(UInt_t channel = 0; channel < fNChannels; channel++){
485	for(Int_t timebin = 0 ; timebin < fNTimeBins ; timebin++){
486	Short_t charge=charges[channel][timebin];
487	dummy2 = Convert2(charge);
488	fOutRaw->write((Char_t*)&dummy2,sizeof(dummy2));
489	}
490	}
491
492	return fNChannels;
493	}
494
495	Int_t AliL3RawDataFileHandler::ReadRawPedestalsInput()
496	{
497	if(!fInRawPed){
498	LOG(AliL3Log::kError,"AliL3RawDataFileHandler::ReadRawPedestalsInput","File Open")
499	<<"No Input avalible: no object ifstream"<<ENDLOG;
500	return 0;
501	}
502
503	if(!fInRawPed->is_open()){
504	LOG(AliL3Log::kError,"AliL3RawDataFileHandler::ReadRawPedestalsInput","File Open")
505	<<"No Input avalible: ifstream not opened"<<ENDLOG;
506	return 0;
507	}
508
509	Int_t dummy4;
510	Short_t dummy2;
511	fInRawPed->read((Char_t*)&dummy4,sizeof(dummy4));
512	if(dummy4==(Int_t)fNChannels) fConvert=kFALSE;
513	else {
514	Int_t knumofChannels = Convert4(dummy4);
515	if(knumofChannels!=(Int_t)fNChannels){
516	LOG(AliL3Log::kError,"AliL3RawDataFileHandler::ReadRawPedestalsInput","Data Inconsistency")
517	<<AliL3Log::kDec<<"Number of Channels should be equal to fNChannels "<<knumofChannels<<" "<<fNChannels<<ENDLOG;
518	return 0;
519	}
520	}
521
522	//read used altrochannels (for the moment
523	for(UInt_t i = 0 ; i < fNChannels ; i++){
524	fInRawPed->read((Char_t*)&dummy2,sizeof(dummy2));
525	//UShort_t channel = Convert2(dummy2);
526	}
527
528	fInRawPed->read((Char_t*)&dummy4,sizeof(dummy4));
529	//Int_t numofChannelsTest = Convert4(dummy4);
530
531	//Timebins
532	fInRawPed->read((Char_t*)&dummy4,sizeof(dummy4));
533	fNTimeBins=Convert4(dummy4);
534
535	if(fNTimeBins!=AliL3Transform::GetNTimeBins()){
536	LOG(AliL3Log::kError,"AliL3RawDataFileHandler::ReadRawPedestalsInput","Data Inconsistency")
537	<<AliL3Log::kDec<<"fNTimeBins does not match AliL3Transformer, check AliL3Transform::Init() "<<fNTimeBins<<" "<<AliL3Transform::GetNTimeBins()<<ENDLOG;
538	}
539
540	//Read the data
541	fPedestals=new Short_t*[fNChannels];
542	for(UInt_t c=0;c<fNChannels;c++) fPedestals[c]=new Short_t[fNTimeBins];
543
544	for(UInt_t channel = 0; channel < fNChannels; channel++){
545	for(Int_t timebin = 0 ; timebin < fNTimeBins ; timebin++){
546	Short_t dummy2;
547	fInRawPed->read((Char_t*)&dummy2,sizeof(dummy2));
548	Short_t charge = Convert2(dummy2);
549	fPedestals[channel][timebin]=charge;
550	}
551	}
552
553	return fNChannels;
554	}
555
556	AliL3DigitRowData * AliL3RawDataFileHandler::RawData2Memory(UInt_t &nrow,Int_t event)
557	{ //event is not used
558	AliL3DigitRowData *data = 0;
559	nrow=0;
560
561	if(fNTimeBins==0){
562	LOG(AliL3Log::kWarning,"AliL3RawDataFileHandler::RawData2Memory","Data Inconsistency")
563	<<"Call AliL3RawDataFileHandler::RawReadInput() first"<<ENDLOG;
564	if(!ReadRawInput()){
565	LOG(AliL3Log::kError,"AliL3RawDataFileHandler::RawData2Memory","Data Inconsistency")
566	<<"Something went wrong reading data header"<<ENDLOG;
567	return 0;
568	}
569	}
570
571	//Read the data
572	Short_t charges[fNChannels][fNTimeBins];
573	for(UInt_t channel = 0; channel < fNChannels; channel++){
574	for(Int_t timebin = 0 ; timebin < fNTimeBins ; timebin++){
575	Short_t dummy2;
576	fInRaw->read((Char_t*)&dummy2,sizeof(dummy2));
577	Short_t charge = Convert2(dummy2);
578
579	//Pedestal substraction
580	if(fPedestals) charge-=fPedestals[channel][timebin];
581	else charge-=fPedVal;
582	if(charge<0) charge=0;
583
584	charges[channel][timebin]=charge;
585	}
586	}
587
588	//get data size
589	Int_t nrows=0;
590	Int_t ndigitcount=0;
591	Int_t ndigits[AliL3Transform::GetNRows()];
592	for(Int_t i=0;i<AliL3Transform::GetNRows();i++) ndigits[i]=0;
593
594	//no need to search for slice/sector given by init
595	//but check for row/patch boundaries
596	//assume slice 0
597	for(Int_t slrow=0;slrow<AliL3Transform::GetNRows();slrow++){
598
599	if(slrow<fRowMin) continue;
600	if(slrow>fRowMax) break;
601
602	for(Int_t pad=0;pad<AliL3Transform::GetNPads(slrow);pad++){
603	Short_t channel=fRowPad[slrow][pad];
604	if(channel==-1) continue; //no data on that channel;
605
606	for(Int_t timebin = 0 ; timebin < fNTimeBins ; timebin++){
607	Int_t dig=charges[channel][timebin];
608
609	if(dig <= AliL3Transform::GetZeroSup()) continue;
610	if(dig >= AliL3Transform::GetADCSat())
611	dig = AliL3Transform::GetADCSat();
612
613	ndigits[slrow]++; //for this row only
614	ndigitcount++; //total number of digits to be published
615	}
616	}
617
618	//count number of rows
619	nrows++;
620	}
621
622	//test data consistency
623	Int_t ndigitcounttest=0;
624	for(Int_t slrow=0;slrow<AliL3Transform::GetNRows();slrow++)
625	ndigitcounttest+=ndigits[slrow];
626	if(ndigitcount!=ndigitcounttest)
627	LOG(AliL3Log::kError,"AliL3RawDataFileHandler::RawData2Memory","Digits")
628	<<AliL3Log::kDec<<"Found Inconsistency "<<ndigitcount<<" != "<<ndigitcounttest<<ENDLOG;
629
630	Int_t size = sizeof(AliL3DigitData)*ndigitcount
631	+ nrows*sizeof(AliL3DigitRowData);
632	LOG(AliL3Log::kDebug,"AliL3RawDataFileHandler::RawData2Memory","Digits")
633	<<AliL3Log::kDec<<"Found "<<ndigitcount<<" Digits on "<<nrows<<" rows"<<ENDLOG;
634
635	//now copy data
636	data=(AliL3DigitRowData*) Allocate(size);
637	nrow = (UInt_t)nrows;
638	//memset(data,1,size); //for debugging
639
640	Int_t ndigitcounttest2=0;
641	AliL3DigitRowData *tempPt = data;
642	for(Int_t slrow=0;slrow<AliL3Transform::GetNRows();slrow++){
643
644	if(slrow<fRowMin) continue;
645	if(slrow>fRowMax) break;
646
647	tempPt->fRow = slrow;
648	tempPt->fNDigit = ndigits[slrow];
649
650	Int_t localcount=0;
651	for(Int_t pad=0;pad<AliL3Transform::GetNPads(slrow);pad++){
652	Short_t channel=fRowPad[slrow][pad];
653	if(channel==-1) continue; //no data on that channel;
654
655	for(Int_t timebin = 0 ; timebin < fNTimeBins ; timebin++){
656	Int_t dig=charges[channel][timebin];
657
658	if(dig <= AliL3Transform::GetZeroSup()) continue;
659	if(dig >= AliL3Transform::GetADCSat())
660	dig = AliL3Transform::GetADCSat();
661
662	//Exclude data outside cone:
663	//AliL3Transform::Raw2Local(xyz,sector,row,pad,time);
664	//if(fParam->GetPadRowRadii(sector,row)<230./250.*fabs(xyz[2])) continue;
665
666	tempPt->fDigitData[localcount].fCharge=(UShort_t)dig;
667	tempPt->fDigitData[localcount].fPad=(UChar_t)pad;
668	tempPt->fDigitData[localcount].fTime=(UShort_t)timebin;
669	#ifdef do_mc
670	tempPt->fDigitData[localcount].fTrackID[0] = 0;
671	tempPt->fDigitData[localcount].fTrackID[1] = 0;
672	tempPt->fDigitData[localcount].fTrackID[2] = 0;
673	#endif
674	localcount++;
675	ndigitcounttest2++;
676	} //time
677	} //pad
678
679	if(localcount != ndigits[slrow])
680	LOG(AliL3Log::kFatal,"AliL3RawDataFileHandler::RawData2Memory","Memory")
681	<<AliL3Log::kDec<<"Mismatch: localcount "<<localcount<<" ndigits "
682	<<ndigits[slrow]<<ENDLOG;
683
684	Byte_t tmp = (Byte_t)tempPt;
685	Int_t size = sizeof(AliL3DigitRowData)
686	+ ndigits[slrow]*sizeof(AliL3DigitData);
687	tmp += size;
688	tempPt = (AliL3DigitRowData*)tmp;
689	}//row
690
691	if(ndigitcount!=ndigitcounttest2)
692	LOG(AliL3Log::kError,"AliL3RawDataFileHandler::RawData2Memory","Digits")
693	<<AliL3Log::kDec<<"Found Inconsistency "<<ndigitcount<<" != "<<ndigitcounttest2<<ENDLOG;
694
695	return data;
696	}
240d63be	697
	698	Bool_t AliL3RawDataFileHandler::RawData2CompBinary(Int_t event)
	699	{
	700	Bool_t out = kTRUE;
	701	UInt_t ndigits=0;
	702	AliL3DigitRowData *digits=0;
	703	digits = RawData2Memory(ndigits,event);
	704	out = Memory2CompBinary(ndigits,digits);
	705	Free();
	706	return out;
	707	}