/*
 * PndMvdReadInTBData.cxx
 *
 *  Created on: 23.10.2014
 *      Author: Stockmanns
 */

#include <PndMvdReadInTBData.h>

#include "mrfdata_8b.h"
#include "mrftools.h"
#include "boost/archive/binary_oarchive.hpp"
#include "boost/archive/binary_iarchive.hpp"
#include "boost/serialization/binary_object.hpp"
#include <boost/archive/archive_exception.hpp>

PndMvdReadInTBData::PndMvdReadInTBData() : fDigiArray(0), fClockFrequency(0), fSuperFrameCount(0),
					   fOldFrameCount(0), fOldAllHeaderCount(0), fFirstHeader(kTRUE), fFE(-1),
					   fNonSequentialFC(0), fHammingLossFrameCount(0), fCRCLossFrameCount(0),
					   fTotalHitCount(0),fPreFrameLossHitCount(0), fHammingLossHitCount(0), fCRCLossHitCount(0), fCorrectHitCount(0),
					   fHeaderPresent(kFALSE), fTrailerPresent(kFALSE), fDoubleHeader(0), fDoubleTrailer(0), fVerbose(0),
					   fOrder(16), fPolynom(0x8005), fCRCXor(0x0000), fRefIn(0), fRefOut(0), fCRCInit_direct(0), fDataCount(0),
					   fFileCounter(0), fTotalFrameCount(0), fTotalHeaderCount(0), fTotalTrailerCount(0) {
	// TODO Auto-generated constructor stub
  	fCRCMask = ((((unsigned long)1<<(fOrder-1))-1)<<1)|1;
	fCRCHighBit = (unsigned long)1<<(fOrder-1);

	GenerateCRCTable();
}

PndMvdReadInTBData::~PndMvdReadInTBData() {
  fFileHandle->close();
  delete(fFileHandle);
}

void PndMvdReadInTBData::GenerateCRCTable() {
  // make CRC lookup table used by table algorithms
	ULong64_t bit, crc;
	for (int i=0; i<256; i++) {
		crc=(ULong64_t)i;
		if (fRefIn) 
		  {
		    crc=ReflectBitsStream(crc, 8);
		  }
		crc<<= fOrder-8;

		for (int j=0; j<8; j++) 
		  {
			bit = crc & fCRCHighBit;
			crc<<= 1;
			if (bit) 
			  {
			    crc^= fPolynom;
			  }
		  }				
		if (fRefIn) 
		  {
		    crc = ReflectBitsStream(crc, fOrder);
		  }
		crc&= fCRCMask;
		fCRCTab[i]= crc;
	}
}

UShort_t PndMvdReadInTBData::CheckHammingCode(ULong64_t dataword, int dataword_length)
{
	// This function expects a standard hamming encoded dataword (including hamming bits at 2^i positions) and returns the hamming bits
	// If the dataword is correct, the hamming bits are 0
	// If an error occured, the hamming bits are !=0
	// If a 1-bit error occured, the hamming bits give the possions of the wrong bit 

	ULong64_t shift=1;
	ULong64_t hamming_code=0;

	if(dataword_length > 63)
	{
		std::cout << "Error: maximum length of datastream is 63" << std::endl;
		return 0xffff;
	}

	// loop over all hamming bits
	for (int i = 0; pow(2,i) < dataword_length; ++i)
	{
		int start=pow(2,i);
		int stepwidth=2*start;
		int parity_bit=0;
		for (int j = start; j < dataword_length+1; j+=stepwidth)
		{
			for (int k = j; k < j+stepwidth/2 && k < dataword_length+1; ++k)
			{
				parity_bit ^= ((dataword & (shift <<(k-1)))>> (k-1));
			}
		}
		hamming_code += (parity_bit << i);
	}
	return hamming_code;
}

ULong64_t PndMvdReadInTBData::ConvertToPix4HammingToStandardHamming(ULong64_t topixhamming)
{
 	// The ToPix header and trailer data word consists of 34 data bits and 6 hamming bits.
	//								       bit no:	39    38   37   36   35         9    8    7    6    5    4    3    2    1    0 
	// In a ToPix4 dataword the hamming bits are at the end of the word:           (d34)(d33)(d32)(d31)(d30) ... (d04)(d03)(d02)(d01)(H 6)(H 5)(H 4)(H 3)(H 2)(H 1)
	// At the standard hamming encoding the hamming bits are at the 2^i positions  (d34)(d33)(d32)(d31)(d30) ... (d07)(d06)(d05)(d04)(H 3)(d03)(d02)(d01)(H 2)(H 1)
        // This function expects a ToPix4 encoded dataword and moves the hamming bits at the end to the defined positions. 

  ULong64_t standard_hamming = 0;

	standard_hamming  = ( topixhamming & 0xff00000000);
	standard_hamming += ((topixhamming & 0x00fffe0000) >>  1 );
	standard_hamming += ((topixhamming & 0x000001fc00) >>  2 );
	standard_hamming += ((topixhamming & 0x0000000380) >>  3 );
	standard_hamming += ((topixhamming & 0x0000000040) >>  4 );

	standard_hamming += ((topixhamming & 0x0000000020) << 26 );
	standard_hamming += ((topixhamming & 0x0000000010) << 11 );
	standard_hamming += ((topixhamming & 0x0000000008) <<  4 );
	standard_hamming += ((topixhamming & 0x0000000004) <<  1 );
	standard_hamming += ( topixhamming & 0x0000000002);
	standard_hamming += ( topixhamming & 0x0000000001);

	return standard_hamming; 
}

void PndMvdReadInTBData::Init(){
	//std::cout << "PndMvdReadInTBData::Init called" << std::endl;
//	for (int i = 0; i < fFileName.size(); i++){
	 std::ifstream* ifs = new std::ifstream(fFileNames[fFileCounter], std::ios::binary);
	 std::cout << "File: " << fFileNames[fFileCounter] << " is good: " << ifs->good() << std::endl;
	 fFileCounter++;
	 fFileHandle=ifs;
//	}
}

Bool_t PndMvdReadInTBData::ReadInData(TClonesArray* sdsDigiContainer, TClonesArray* headerContainer, TClonesArray* allheaderContainer){
	TMrfData_8b* tempdata;
	tempdata = new TMrfData_8b;
	ULong_t dataword=0;
	Bool_t endOfFile = kFALSE;

	fOutputArray = sdsDigiContainer;
	fOutputArrayHeader = headerContainer;
	fOutputArrayAllHeader = allheaderContainer;
	std::vector<ULong64_t> rawArray;
	endOfFile |= ReadInRawData(fFileHandle, rawArray);
	AnalyzeData(rawArray, fClockFrequency);
	return endOfFile;
}

Bool_t PndMvdReadInTBData::ReadInRawData(std::ifstream* fileHandle, std::vector<ULong64_t>& rawData){
	TMrfData_8b* tempdata;
	tempdata = new TMrfData_8b;
	ULong_t dataword=0;
	Bool_t endOfFile = kFALSE;
	if(fileHandle->good())
	  {
	    if (fVerbose > 2) 
	      {
	      std::cout << std::endl;
	      std::cout << "PndMvdReadInTBData::ReadInRawData reading file " << std::endl;
	    }
		try
		  {
		    boost::archive::binary_iarchive iar(*fileHandle); 	//this line causes an "Invalid Signature Error" at the end of the file but the file is still good
		    iar >> tempdata;
		  }
		catch (boost::archive::archive_exception& exception){
		  if (fVerbose > 1)
		    {
		      std::cout << "PndMvdReadInTBData::ReadInRawData: Error found in reading file " << " : " << fileHandle->good() << " " << fileHandle->eof() << " Exception: " << exception.code << std::endl;
		    }
		  if (fVerbose > 1)
		    {
		      std::cout << exception.what() << std::endl;
		    }
		  if (exception.code == 3)
		  {
		      if(fFileCounter < fFileNames.size())
			{
			  std::cout <<fFE <<  " open new file " << fFileNames[fFileCounter] << std::endl; 
			  fileHandle->close();
			  delete(fFileHandle);
			  std::ifstream* ifs = new std::ifstream(fFileNames[fFileCounter], std::ios::binary);
			  fFileCounter++;
			  return endOfFile;
			}
		      else
			{			  
			  std::cout <<fFE <<  " All files read! Finishing FE " <<  std::endl; 
			  endOfFile = kTRUE;
			  return endOfFile;
			}
		  }
		}
		if (fVerbose > 2) std::cout << fFE << " PndMvdReadInTBData::ReadInRawData: NWords: " << tempdata->getNumWords() << std::endl;
		for (UInt_t i=0;i < tempdata->getNumWords();i+=5)
		{
			dataword=0;
			for(uint j=0; j< 5 ; j++)
			{
				dataword = dataword << 8;
				dataword += tempdata->getWord(i+j);
			}
			rawData.push_back(dataword);
			ULong_t frameCount = dataword & 0x3FC0000;
			frameCount = frameCount >> 18;
			if (fVerbose > 2)  std::cout << std::dec << "dataword No "<< i/5<< "/"<< tempdata->getNumWords()/5 << ": "<<std::hex << dataword << " " << std::dec << frameCount << std::endl;
		
		}
	  } 
	else
	  {
	    std::cout << fFE << " An error occured " << std::endl;
	    std::cout << fFE << " fileHandle->good() " << fileHandle->good() << std::endl;
	    std::cout << fFE << " fileHandle->eof()  " << fileHandle->eof() << std::endl;
	    std::cout << fFE << " fileHandle->fail() " << fileHandle->fail() << std::endl;
	    std::cout << fFE << " fileHandle->bad()  " << fileHandle->bad() << std::endl;

	    endOfFile = kFALSE;
	    return endOfFile;
	  }
	return endOfFile;
}

ULong64_t PndMvdReadInTBData::CalculateCRCTableFast(std::vector<char> p, ULong64_t len) {

	// fast lookup table algorithm without augmented zero bytes, e.g. used in pkzip.
	// only usable with polynom orders of 8, 16, 24 or 32.

	ULong64_t crc = fCRCInit_direct;

	std::vector<char>::iterator it=p.begin(); 

	if (fRefIn) 
	  {
	    crc = ReflectBitsStream(crc, fOrder);
	  }

	if (!fRefIn)
	  {
	    while (len--) 
		      {
			crc = (crc << 8) ^ fCRCTab[ ((crc >> (fOrder-8)) & 0xff) ^ (*it & 0xff)];
			it++;
		      }
	  }
	else 
	  {
	    while (len--) 
	      {
		crc = (crc >> 8) ^ fCRCTab[ (crc & 0xff) ^ (*it & 0xff)];
		it++;
	      }
	  }
	if (fRefOut^fRefIn)
	  {
	    crc = ReflectBitsStream(crc, fOrder);
	  }
	crc^= fCRCXor;
	crc&= fCRCMask;

	return(crc);
}

ULong64_t PndMvdReadInTBData::ReflectBitsStream(ULong64_t crc, int bitnum) {

	// reflects the lower 'bitnum' bits of 'crc'

	ULong64_t i, j=1, crcout=0;

	for (i=(ULong64_t)1<<(bitnum-1); i; i>>=1) 
	  {
		if (crc & i)
		  {
		    crcout|=j;
		  }
		j<<= 1;
	  }
	return (crcout);
}

void PndMvdReadInTBData::AnalyzeToPixFrame(Double_t clockFrequency)
{
  if (fVerbose > 2)  
    {
      std::cout << fFE << " PndMvdReadInTBData::AnalyzeToPixFrame: fToPixFrame size: " << std::dec << fToPixFrame.size() << " header " << std::hex << fToPixFrame[0] <<  std::endl;
    }	


  ULong_t hammingcheck = CheckHammingCode(ConvertToPix4HammingToStandardHamming(fToPixFrame[0]),40);
  if(hammingcheck!=0)
    {
      if (fVerbose > 1)  
	{
	  std::cout << "Wrong Hamming Code found! (Header) : " << std::hex<< fToPixFrame[0] << " Parity bits "<< hammingcheck << std::endl;
	}
      fHammingLossFrameCount++;
      fHammingLossHitCount+= fToPixFrame.size()-2;
      return;
    }
  
  hammingcheck = CheckHammingCode(ConvertToPix4HammingToStandardHamming(fToPixFrame[fToPixFrame.size()-1]),40);
  if(hammingcheck!=0)
    {
      if (fVerbose > 1)  
	{
	  std::cout << "Wrong Hamming Code found! (Trailer): " << std::hex<< fToPixFrame[0] << " Parity bits "<< hammingcheck << std::endl;
	}
      fHammingLossFrameCount++;
      fHammingLossHitCount+= fToPixFrame.size()-2;
      return;
    }
  
  PndSdsDigiTopix4 recentPixel;

  std::vector<char> topix_data; // vector necessary to do crc check

  for(int i=1; i< fToPixFrame.size()-1;i++)
    {
      for(int j=0; j<8 ;j++)
	{
	  if(j==0 or j==1 or j==2)
	    {
	      topix_data.push_back(0x00);
	    }
	  else 
	    {
	      topix_data.push_back((fToPixFrame[i] >> (7-j)*2*4) & 0xff);
	    }
	}
    }
  
  ULong64_t crc_calculated = CalculateCRCTableFast(topix_data,topix_data.size());
  
  if(crc_calculated != ((fToPixFrame.back()>>6) & 0xffff))
    {
      fCRCLossFrameCount++;
      fCRCLossHitCount += fToPixFrame.size()-2;
      if(fVerbose == -1)
	{
	  std::cout << fFE << " CRC WRONG! Frame will be deleted. Calculated CRC: " <<std::hex <<  crc_calculated << " topix CRC: "<< ((fToPixFrame.back()>>6) & 0xffff) <<  std::endl;
      
	  for(int y=0; y< fToPixFrame.size(); y++)
	    {
	      if(y==0)
		{
		  std::cout <<fFE << " " << std::hex << fToPixFrame[y] << " - FCount " <<  fRecentFrameHeader.fFrameCount <<  std::endl;
		}
	      else
		{
		  std::cout <<fFE << " " << std::hex << fToPixFrame[y] << std::endl;
		}
	    }
	  std::cout << std::endl;
	} 
      fToPixFrame.clear(); // delete topix frame due to negative CRC check. 
      return;
    }

  for (int i=0; i < fToPixFrame.size(); i++)
    { 
      ULong64_t header = (fToPixFrame[i] & 0xC000000000) >> 38;

      switch (header) {
      case 1 :
	{
	  fRecentFrameHeader = BitAnalyzeHeader(fToPixFrame[i]);
	  
	  if (fVerbose > 2)   std::cout << fFE << " FrameHeader: rawData: " << std::hex << fToPixFrame[i]  << " chip " << std::dec << fRecentFrameHeader.fChipAddress << " framecount " << fRecentFrameHeader.fFrameCount << std::endl;
	  
	  if (fOldFrameCount + 1 != fRecentFrameHeader.fFrameCount){
	    if (!(fOldFrameCount == 255 & fRecentFrameHeader.fFrameCount == 0)){
	      if (fVerbose > 1) std::cout << fFE << "-E- non sequential FC: " << fOldFrameCount << " " << fRecentFrameHeader.fFrameCount << std::endl;
	      fNonSequentialFC++;
	    }
	  }
	  
	  if (fOldFrameCount > fRecentFrameHeader.fFrameCount){
	    fSuperFrameCount++;
	    if (fVerbose > 1) std::cout << fFE << " SuperFrameCount increased: " << std::dec<<  fSuperFrameCount << " oldFC " << fOldFrameCount << " recent FC " << fRecentFrameHeader.fFrameCount << std::endl;
	  }
	  //fOldFrameCount = fRecentFrameHeader.fFrameCount;
	  Int_t deltaFrameCount = ((int)(fRecentFrameHeader.fFrameCount - fOldFrameCount)<0 ?((fRecentFrameHeader.fFrameCount - fOldFrameCount)+256) : (fRecentFrameHeader.fFrameCount - fOldFrameCount));
	//  new ((*fOutputArrayHeader)[fOutputArrayHeader->GetEntriesFast()]) PndSdsDigiTopix4Header(fRecentFrameHeader.fFrameCount, fFE, fRecentFrameHeader.fChipAddress, fRecentFrameHeader.fECC, fTotalFrameCount,deltaFrameCount, 0, fToPixFrame.size()-2 );
	  new ((*fOutputArrayHeader)[fOutputArrayHeader->GetEntriesFast()]) PndSdsDigiTopix4Header(fRecentFrameHeader.fFrameCount, 0, fFE, fRecentFrameHeader.fECC, fTotalFrameCount,deltaFrameCount, 0, fToPixFrame.size()-2 );
	  if (deltaFrameCount > 1) std::cout << "-W- OutputArrayHeader deltaFrameCount > 1 " << deltaFrameCount << std::endl;
	  fOldFrameCount = fRecentFrameHeader.fFrameCount;
	}
	break;

      case 2 : 
	{
	  fRecentFrameTrailer = BitAnalyzeTrailer(fToPixFrame[i]);
	  if (fRecentFrameTrailer.fFrameCRC !=0 && (fToPixFrame.size() < 20))
	    {
	      // std::cout << fFE << " Frame counter " << fRecentFrameHeader.fFrameCount << std::endl;
	      if(fVerbose ==-1)
		{
		  for(int y=0; y< fToPixFrame.size(); y++)
		    {
		      if(y==0)
			{
			  std::cout <<fFE << " " << std::hex << fToPixFrame[y] << " - FCount " <<  fRecentFrameHeader.fFrameCount <<  std::endl;
			}
		      else
			{
			  std::cout <<fFE << " " << std::hex << fToPixFrame[y] << std::endl;
			}
		    }
		  std::cout << std::endl;
		}
	    }
	  if (fVerbose > 2) std::cout <<  fFE <<" FrameTrailer: nEvents " << fRecentFrameTrailer.fNEvents << " frame CRC: " << fRecentFrameTrailer.fFrameCRC << std::endl;
	  
	  PndSdsDigiTopix4Header * header_trailer =(PndSdsDigiTopix4Header*)(fOutputArrayHeader->Last());
	  header_trailer->SetNumberOfEvents(fRecentFrameTrailer.fNEvents);
	}
	break;

      case 3 : recentPixel = ProcessData(fToPixFrame[i], fRecentFrameHeader, clockFrequency);
		if (fVerbose > 2) std::cout << fFE << " Pixel: " << recentPixel << std::endl;
	new ((*fOutputArray)[fOutputArray->GetEntriesFast()]) PndSdsDigiTopix4(recentPixel);
	fCorrectHitCount++;
	break;
      }
    } 
}

void PndMvdReadInTBData::AnalyzeData(std::vector<ULong64_t>& rawData, Double_t clockFrequency)
{
	if (fVerbose > 2) std::cout << "PndMvdReadInTBData::AnalyzeData rawData.size(): " << rawData.size() << std::endl;
	for (int i = 0; i < rawData.size(); i++){
		ULong_t header = rawData[i] & 0xC000000000;
		header = header >> 38;
		if (fFirstHeader) {
			if (header == 1){
				fFirstHeader = kFALSE;
			} else {
				continue;
			}
		}
		
		if (header == 1) // header word found 
		  {
		    fTotalHeaderCount++;

		    fRecentAllFrameHeader = BitAnalyzeHeader(rawData.at(i));

		    Int_t deltaAllFrameCount = ((int)(fRecentAllFrameHeader.fFrameCount - fOldAllHeaderCount)<0 ?((fRecentAllFrameHeader.fFrameCount - fOldAllHeaderCount)+256) : (fRecentAllFrameHeader.fFrameCount - fOldAllHeaderCount));
		    new ((*fOutputArrayAllHeader)[fOutputArrayAllHeader->GetEntriesFast()]) PndSdsDigiTopix4Header(fRecentAllFrameHeader.fFrameCount, fFE, fRecentAllFrameHeader.fChipAddress, fRecentAllFrameHeader.fECC, fTotalHeaderCount, deltaAllFrameCount, 0, 0 );
		    if (deltaAllFrameCount > 1) std::cout << "-W- deltaAllFrameCount > 1: " << deltaAllFrameCount << std::endl;
		    fOldAllHeaderCount= fRecentAllFrameHeader.fFrameCount;

		    if(fHeaderPresent==kTRUE)
		      {
			// double header found, cant check previous data without trailer, clear vector
			fDoubleHeader++;
			
			if (fVerbose > 1)  
			  {
			    std::cout << "Double Header Found! count: " << fDoubleHeader << "| FE: " << fFE << std::hex << " last ToPixFrame element: "<< fToPixFrame.back()<< " new frame header " << rawData[i] << std::endl;
			  }
			fPreFrameLossHitCount += fToPixFrame.size() -1;
			fToPixFrame.clear();
			// load new header into vector
			fToPixFrame.push_back(rawData[i]);
		      }
		    else
		      {
			// header found, start recording topix frame 
			fTrailerPresent=kFALSE;
			fHeaderPresent=kTRUE;
			fToPixFrame.push_back(rawData[i]);
		      }
		  }
		
		else if(header == 2) // trailer word found 
		  {
		    fTotalTrailerCount++;
		    if(fTrailerPresent==kTRUE)
		      {
			// double trailer found, cant give the hits a valid timestamp without the header, clear vector
			
			fToPixFrame.clear();
			fDoubleTrailer++;
			if (fVerbose > 1)  
			  {
			    std::cout << "Double Trailer Found! Double header counter: " << fDoubleTrailer << std::endl;
			  }
		      }
		    else
		      {
			if(fHeaderPresent==kTRUE)
			  {
			    // one topix frame found! Go and analyze the vector...
			    fHeaderPresent=kFALSE;
			    fTrailerPresent=kTRUE;
			    fToPixFrame.push_back(rawData[i]);
			    //  if (fVerbose > 1)  
			    //  {
			    //	std::cout << "ToPix Frame found! Go and analyze this amont of data: " << fToPixFrame.size() << std::endl;
			    //}
			  
			    fTotalFrameCount++;
			    AnalyzeToPixFrame(clockFrequency);
			    fToPixFrame.clear();
			  }
			else
			  {
			    if (fVerbose > 1)  
			      {
				std::cout << "Trailer without header found! Double header counter: " << fDoubleHeader << std::endl;
			      }
			    // trailer without header, can happen at the beginning of the file or the header was not detected correctly
			    // this case is in principle impossible to enter
			    fPreFrameLossHitCount += fToPixFrame.size()-1 ;
			    fDoubleTrailer++;
			    fToPixFrame.clear();
			    continue;
			  }
		      }
		  }
		else if(header==3) // data word found 
		  {
		    fTotalHitCount++;
		    if(fHeaderPresent==kTRUE)
		      {
			// found data while a active header is present, go and save the data
			fToPixFrame.push_back(rawData[i]);
		     
		      }
		    else
		      {
			// found data without a valid header, may happen at the beginning of the file or the header was detected
			fPreFrameLossHitCount++;
			continue;
		      }
		  }
		else
		  {
		    // not interessting 
		  }
	}
}

frameHeader PndMvdReadInTBData::BitAnalyzeHeader(ULong64_t& header)
{
	frameHeader tempHeader;
	ULong_t temp = header;
	tempHeader.fECC = temp & 0x3F;
	temp = temp >> 18;
	tempHeader.fFrameCount = temp & 0xFF;

	temp = temp >> 8;
	tempHeader.fChipAddress = temp & 0xFFF;

	return tempHeader;
}

frameTrailer PndMvdReadInTBData::BitAnalyzeTrailer(ULong64_t& trailer)
{
	frameTrailer tempTrailer;
	ULong_t temp = trailer;
	tempTrailer.fECC = temp & 0x3F;

	temp = temp >> 6;
	tempTrailer.fFrameCRC = temp & 0xFFFF;

	temp = temp >> 16;
	tempTrailer.fNEvents = temp & 0xFFFF;

	return tempTrailer;

}

pixel PndMvdReadInTBData::BitAnalyzePixelData(ULong64_t& data)
{
	//le_dataword = ((dataword & 0x0000000000fff000)>>12);¬
	//te_dataword = (dataword & 0x0000000000000fff);¬
	//pixeladdress = ((dataword & 0x0000003fff000000)>>24);¬

	pixel tempPixel;
	ULong_t temp = data;
	tempPixel.fTrailingEdge = mrftools::grayToBin(temp & 0X0000000000000FFF);

	temp = temp >> 12;
	tempPixel.fLeadingEdge = mrftools::grayToBin(temp & 0X0000000000000FFF);

	temp = temp >> 12;
	tempPixel.fPixelAddress = temp & 0X00000000000003FFF;

//	if (fVerbose > 1) std::cout << "BitAnalyzePixelData: " << std::hex << data << " pixel " << std::dec << tempPixel.fPixelAddress << " " << tempPixel.fLeadingEdge << " " << tempPixel.fTrailingEdge << std::endl;

	return tempPixel;

}

PndSdsDigiTopix4 PndMvdReadInTBData::ProcessData(ULong64_t& data, frameHeader& header, Double_t& clockFrequency)
{
	if (fVerbose > 1) std::cout  << "PndMvdReadInTBData::ProcessData raw Data: " << data << std::endl;
	pixel pixelData = BitAnalyzePixelData(data);
	std::pair<UInt_t, UInt_t> pixelAddress = PixeladdressToMatrixAddress(pixelData.fPixelAddress);
	Double_t timestamp = ((Double_t)fSuperFrameCount * 256. * 4096. + (Double_t)header.fFrameCount * 4096. + (Double_t)pixelData.fLeadingEdge)/clockFrequency * 1000.;
	Double_t timestamp_independent = ((Double_t) fTotalHeaderCount * 4096. + (Double_t)pixelData.fLeadingEdge)/clockFrequency * 1000.;

	std::vector<Int_t> indices; // just for compatibility with PndSdsDigiPixel
//	return PndSdsDigiTopix4(indices, 0, 0, fFE, pixelAddress.first, pixelAddress.second, pixelData.fLeadingEdge, pixelData.fTrailingEdge, header.fFrameCount, timestamp, fCorrectHitCount,fTotalHitCount, timestamp_independent);
	return PndSdsDigiTopix4(indices, 0, fFE - 1, 0, pixelAddress.first, pixelAddress.second, pixelData.fLeadingEdge, pixelData.fTrailingEdge, header.fFrameCount, timestamp, fCorrectHitCount,fTotalHitCount, timestamp_independent);

}

std::pair<UInt_t, UInt_t> PndMvdReadInTBData::PixeladdressToMatrixAddress(UInt_t pixelglobaladdress)
{
    // Matrix: 32 columns x 20 rows

    UInt_t double_column_address =0;
    UInt_t double_column_side=0;
    UInt_t pixel_address=0;

    UInt_t matrix_column, matrix_row;

    UInt_t temp = pixelglobaladdress;

    pixel_address= temp & 0x7f; //todo check if this conversion is correct!
    temp = temp >> 7;
    double_column_side= temp & 0x1;
    temp = temp >> 1;
    double_column_address= temp & 0x3f;
     temp = temp >> 6;

  //   if (pixel_address > 127) {
  //   	std::cout << "-E- PndMvdReadInTBData::PixeladdressToMatrixAddress PixelAddress > 128 " << pixel_address << std::endl;
  //   }



 //   temp = temp >> 6;



 //   if (fVerbose > 1) std::cout << "PixeladdressToMatrix rawData " << pixelglobaladdress << " dc " << double_column_address << " dcs " << double_column_side << " pixel " << pixel_address << std::endl;

    UInt_t sel = (double_column_address<<1) | (double_column_side);

    if(sel == 0)
    {
        matrix_row = pixel_address;
        matrix_column = 1;
    }
    else if(sel ==1)
    {
        matrix_row = pixel_address;
        matrix_column = 0;
    }
    else if(sel == 6)
    {
        matrix_row = pixel_address;
        matrix_column = 19;
    }
    else if(sel == 7)
    {
        matrix_row = pixel_address;
        matrix_column = 18;
    }
    else if (sel==2)
    {
        if (pixel_address <32)
        {
            matrix_row = pixel_address;
            matrix_column = 3;
        }
        else if (pixel_address < 64)
        {
            matrix_row = 31 - (pixel_address-32);
            matrix_column = 4;
        }
        else if (pixel_address < 96)
        {
            matrix_row = (pixel_address-64);
            matrix_column = 7;
        }
        else if (pixel_address < 128)
        {
            matrix_row = 31 - (pixel_address-96);
            matrix_column = 8;
        }
    }
    else if (sel==3)
    {
        if (pixel_address <32)
        {
            matrix_row = pixel_address;
            matrix_column = 2;
        }
        else if (pixel_address < 64)
        {
            matrix_row = 31 - (pixel_address-32);
            matrix_column = 5;
        }
        else if (pixel_address < 96)
        {
            matrix_row = (pixel_address-64);
            matrix_column = 6;
        }
        else if (pixel_address < 128)
        {
            matrix_row = 31 - (pixel_address-96);
            matrix_column = 9;
        }
    }
    else if (sel==4)
    {
        if (pixel_address < 32)
        {
            matrix_row = pixel_address;
            matrix_column = 10;
        }
        else if (pixel_address < 64)
        {
            matrix_row = 31 - (pixel_address-32);
            matrix_column = 13;
        }
        else if (pixel_address < 96)
        {
            matrix_row = (pixel_address-64);
            matrix_column = 14;
        }
        else if (pixel_address < 128)
        {
            matrix_row = 31 - (pixel_address-96);
            matrix_column = 17;
        }
    }
    else if (sel==5)
    {
        if (pixel_address < 32)
        {
            matrix_row = pixel_address;
            matrix_column = 11;
        }
        else if (pixel_address < 64)
        {
            matrix_row = 31 - (pixel_address-32);
            matrix_column = 12;
        }
        else if (pixel_address < 96)
        {
            matrix_row = (pixel_address-64);
            matrix_column = 15;
        }
        else if (pixel_address < 128)
        {
            matrix_row = 31 - (pixel_address-96);
            matrix_column = 16;
        }
    }

    return std::pair<UInt_t, UInt_t>(matrix_column, matrix_row);
}