[u/mrichter/AliRoot.git] / ITS / UPGRADE / AliITSUSuze02.cxx

#include <Riostream.h>
#include "TMath.h"
#include "AliITSUSuze02.h"

//*******************************************************************
//
//  Simulation of the SUZE02 readout
//  Origin: Serhiy.Senuykov@cern.ch
//  
//*******************************************************************

using std::cout;
using std::endl;

ClassImp(AliITSUSuze02)

AliITSUSuze02::AliITSUSuze02(Int_t Nrows, Int_t Ncols):
  fNRowsChip(Nrows),
  fNColsChip(Ncols),
  fChip(new TMatrixF(Nrows,Ncols)), 
  fTestColumnSize(2),
  fTestRowSize(2),
  fNWindowsPer32colsMax(0),
  fNWindowsPerHalfFSBBMax(0),
  fNWindowsPerFSBBMax(0),
  fNDigitsEncoded(0), 
  fNEncodedWindows(0),
  fNDigitsLost(0),
  fNLostWindows(0),
  fDataSizePerChip(0),
  fNWindowsPer32colsMin(0),
  fNWindowsPerHalfFSBBMin(0),
  fNWindowsPerFSBBMin(0)
{
  if (Ncols%(kNumberOfFSBB*kNumberOfHalfFSBB) != 0) {
    printf("Number of columns should be multiple of %d. SUZE matrix wasn't created\n",kNumberOfFSBB*kNumberOfHalfFSBB);
  }
}  
  
AliITSUSuze02::AliITSUSuze02(const AliITSUSuze02& suze): 
  fNRowsChip(suze.fNRowsChip),
  fNColsChip(suze.fNColsChip),
  fChip(new TMatrixF(*suze.fChip)), 
  fTestColumnSize(suze.fTestColumnSize),
  fTestRowSize(suze.fTestRowSize),
  fNWindowsPer32colsMax(suze.fNWindowsPer32colsMax),
  fNWindowsPerHalfFSBBMax(suze.fNWindowsPerHalfFSBBMax),
  fNWindowsPerFSBBMax(suze.fNWindowsPerFSBBMax),
  fNDigitsEncoded(suze.fNDigitsEncoded), 
  fNEncodedWindows(suze.fNEncodedWindows),
  fNDigitsLost(suze.fNDigitsLost),
  fNLostWindows(suze.fNLostWindows),
  fDataSizePerChip(suze.fDataSizePerChip),
  fNWindowsPer32colsMin(suze.fNWindowsPer32colsMin),
  fNWindowsPerHalfFSBBMin(suze.fNWindowsPerHalfFSBBMin),
  fNWindowsPerFSBBMin(suze.fNWindowsPerFSBBMin)
{
}

AliITSUSuze02 &AliITSUSuze02::operator=(const AliITSUSuze02& suze) {
  if (&suze == this) return *this;

  fNRowsChip = suze.fNRowsChip;
  fNColsChip = suze.fNColsChip;
  fChip = new TMatrixF(*suze.fChip);  
  fTestColumnSize = suze.fTestColumnSize;
  fTestRowSize = suze.fTestRowSize;
  fNWindowsPer32colsMax = suze.fNWindowsPer32colsMax;
  fNWindowsPerHalfFSBBMax = suze.fNWindowsPerHalfFSBBMax;
  fNWindowsPerFSBBMax = suze.fNWindowsPerFSBBMax;
  fNDigitsEncoded = suze.fNDigitsEncoded;
  fNEncodedWindows = suze.fNEncodedWindows;
  fNDigitsLost = suze.fNDigitsLost;
  fNLostWindows = suze.fNLostWindows;
  fDataSizePerChip = suze.fDataSizePerChip;
  fNWindowsPer32colsMin = suze.fNWindowsPer32colsMin;
  fNWindowsPerHalfFSBBMin = suze.fNWindowsPerHalfFSBBMin;
  fNWindowsPerFSBBMin = suze.fNWindowsPerFSBBMin;

  return *this;
}

AliITSUSuze02::~AliITSUSuze02() {
  if(fChip) delete fChip;
}

void AliITSUSuze02::SetEncodingWindowSize(Int_t Wrows, Int_t Wcols){
  fTestColumnSize=Wrows;
  fTestRowSize=Wcols;
}

void AliITSUSuze02::SetQuotas(Int_t q32, Int_t qHalfFSBB, Int_t qFSBB){
  fNWindowsPer32colsMax=q32;
  fNWindowsPerHalfFSBBMax=qHalfFSBB;
  fNWindowsPerFSBBMax=qFSBB;
}

void AliITSUSuze02::AddDigit(Int_t row, Int_t col){
  (*fChip)(row,col)++;
}

//void AliITSUSuze02::Process(Bool_t Verbose){  
void AliITSUSuze02::Process(TH1F* OverflowCodes, TH1F* NDigitsPerEncodingWindowDist, Bool_t Verbose) {

  //cout<<"Processing"<<endl;
  //fChip->Print(); 
  
  Int_t NRowsFSBB=fNRowsChip;
  Int_t NColsFSBB=fNColsChip/kNumberOfFSBB;
  TMatrixF FSBB(NRowsFSBB,NColsFSBB);
  
  Int_t NRowsSuperLine=fTestColumnSize;
  Int_t NColsSuperLine=NColsFSBB;   
  TMatrixF SuperLineUp(NRowsSuperLine,NColsSuperLine);
  TMatrixF SuperLineDown(NRowsSuperLine,NColsSuperLine);
  
  Int_t NRowsSuperLineX2=NRowsSuperLine*2; 
  Int_t NColsSuperLineX2=NColsSuperLine; //SuperLineX2 and SuperLine size in columns is equal to FSBB.
  TMatrixF SuperLineX2(NRowsSuperLineX2,NColsSuperLineX2); 
  
  TMatrixF TestRow(1,fTestRowSize);
  TMatrixF TestColumn(fTestColumnSize,1);      
  Int_t TestRowSum=0;
  TMatrixF EncodingWindow(fTestColumnSize,fTestRowSize);
  
  Int_t EncodingWindowStartRow=0;
  Int_t EncodingWindowStopRow=0;
  Int_t EncodingWindowStartCol=0;
  Int_t EncodingWindowStopCol=0;
  
  Int_t nMasks=fTestRowSize-1;
  Int_t MaskSize=NRowsSuperLineX2-1;
  TMatrixF Masks(MaskSize,nMasks);

   //parameters for internal data size calculation
  Int_t DataSizePerWindowInRow=8+fTestColumnSize*fTestRowSize+TMath::Ceil(TMath::Log2(fTestColumnSize));
  Int_t DataSizePerSuperLineX2Header=30;   
  
  Int_t DataSizePerSuperLineX2=0;
  
  Bool_t Overflow32=kFALSE;
  Bool_t OverflowHalfFSBB=kFALSE;
  Bool_t OverflowFSBB=kFALSE;
  
  Int_t nWindowsPer32cols=fNWindowsPer32colsMax;
  Int_t nWindowsPerHalfFSBB=fNWindowsPerHalfFSBBMax;
  Int_t nWindowsPerFSBB=fNWindowsPerFSBBMax; 
  
  fNWindowsPer32colsMin=fNWindowsPer32colsMax;
  fNWindowsPerHalfFSBBMin=fNWindowsPerHalfFSBBMax;
  fNWindowsPerFSBBMin=fNWindowsPerFSBBMax;  
  
  fNEncodedWindows=0;
  fNDigitsEncoded=0;
  fNLostWindows=0;
  fNDigitsLost=0;
  fDataSizePerChip=0;    
  
  for(Int_t FSBBindex=0; FSBBindex<kNumberOfFSBB; FSBBindex++){
    FSBB=fChip->GetSub(0,NRowsFSBB-1,FSBBindex*NColsFSBB,(FSBBindex+1)*NColsFSBB-1);
    SuperLineDown=FSBB.GetSub(0,NRowsSuperLine-1,0,NColsSuperLine-1);
    for(Int_t SuperLineX2StartRow=0; SuperLineX2StartRow<NRowsFSBB; SuperLineX2StartRow+=NRowsSuperLine){
      if(nWindowsPerFSBB<fNWindowsPerFSBBMin) {fNWindowsPerFSBBMin=nWindowsPerFSBB;} //saving the lowest number of remaining windows
      nWindowsPerFSBB=fNWindowsPerFSBBMax; //Reset number of available encoding windows for the new double SuperLine
      OverflowFSBB=kFALSE;
      SuperLineUp=SuperLineDown;
      if(SuperLineX2StartRow+NRowsSuperLineX2<=NRowsFSBB){
        SuperLineDown=FSBB.GetSub(SuperLineX2StartRow+NRowsSuperLine,SuperLineX2StartRow+NRowsSuperLineX2-1,0,NColsSuperLine-1);
      }
      else if(SuperLineX2StartRow+NRowsSuperLine<NRowsFSBB){
        SuperLineDown.Zero();
        SuperLineDown.SetSub(0,0,FSBB.GetSub(SuperLineX2StartRow+NRowsSuperLine,NRowsFSBB-1,0,NColsSuperLine-1));
      } 
      else{
        SuperLineDown.Zero();
      }
      if(SuperLineUp.Sum()>0){
        DataSizePerSuperLineX2=0; 
        SuperLineX2.SetSub(0,0,SuperLineUp);
        SuperLineX2.SetSub(NRowsSuperLine,0,SuperLineDown);
        for(Int_t HalfFSBBindex=0; HalfFSBBindex<kNumberOfHalfFSBB; HalfFSBBindex++){
          if(nWindowsPerHalfFSBB<fNWindowsPerHalfFSBBMin) {fNWindowsPerHalfFSBBMin=nWindowsPerHalfFSBB;}  
          nWindowsPerHalfFSBB=fNWindowsPerHalfFSBBMax; //reset counter per HalfFSBB
          OverflowHalfFSBB=kFALSE;
          for(Int_t i=0; i<MaskSize; i++){ //reset masks to 1111111
            for(Int_t j=0; j<nMasks; j++){
              Masks(i,j)=1;
            }
          }
          
          for(Int_t TestRowStartCol=HalfFSBBindex*NColsSuperLineX2/kNumberOfHalfFSBB; TestRowStartCol<(HalfFSBBindex+1)*NColsSuperLineX2/kNumberOfHalfFSBB; TestRowStartCol++){
            if(TestRowStartCol%32==0){
	            if(nWindowsPer32cols<fNWindowsPer32colsMin) fNWindowsPer32colsMin=nWindowsPer32cols;
              nWindowsPer32cols=fNWindowsPer32colsMax; //reset nWindowsPer32cols counter every 32 columns
              Overflow32=kFALSE;
            }
            //apply masks
            for(Int_t RowIndex=0; RowIndex<MaskSize; RowIndex++){
              for(Int_t MaskIndex=0; MaskIndex<nMasks; MaskIndex++){
                if(Masks(RowIndex,MaskIndex)==0){
                  // cout<<"Mask has zero bit at pos:"<<RowIndex<<":"<<MaskIndex<<endl;
                  // cout<<"will clean the pixels at row:"<<RowIndex<<" from pos.:"<<TestRowStartCol<<" till "<< TestRowStartCol+(nMasks-MaskIndex)<<endl;
                  for(Int_t ColIndex=TestRowStartCol; ColIndex<TestRowStartCol+(nMasks-MaskIndex); ColIndex++){
                    if(ColIndex<(HalfFSBBindex+1)*NColsSuperLineX2/kNumberOfHalfFSBB){
                      SuperLineX2(RowIndex,ColIndex)=0;
                      // cout<<"Mask has zero bit. Cleaning at pos:"<<RowIndex<<":"<<ColIndex<<endl;
                      if(RowIndex>=fTestColumnSize){
                        SuperLineDown(RowIndex-fTestColumnSize,ColIndex)=0;
                      }
                    }
                  }
                  break;
                }
              }
            }
            //shift masks
            for(Int_t RowIndex=0; RowIndex<MaskSize; RowIndex++){
              for(Int_t MaskIndex=nMasks-1; MaskIndex>0; MaskIndex--){
                Masks(RowIndex,MaskIndex)=Masks(RowIndex,MaskIndex-1);
              }
              Masks(RowIndex,0)=1;
            }  
            
            for(Int_t TestRowStartRow=0; TestRowStartRow<fTestColumnSize; TestRowStartRow++){
              TestRowSum=0;
              for(Int_t TestRowIndex=0; TestRowIndex<fTestRowSize; TestRowIndex++){
                if(TestRowStartCol+TestRowIndex<(HalfFSBBindex+1)*NColsSuperLineX2/kNumberOfHalfFSBB){
                  TestRowSum+=SuperLineX2(TestRowStartRow,TestRowStartCol+TestRowIndex);
                }
                if(TestRowSum>0){
                  //cout<<"TestR at col n."<<TestRowStartCol<<" and row n."<<TestRowStartRow<<" has a hit"<<endl;
                  break;
                }
              }
              if(TestRowSum>0){
                TestColumn=SuperLineX2.GetSub(TestRowStartRow,TestRowStartRow+fTestColumnSize-1,TestRowStartCol,TestRowStartCol);   
                if(TestColumn.Sum()>0){
                  EncodingWindowStartRow=TestRowStartRow;
                  EncodingWindowStopRow=EncodingWindowStartRow+fTestColumnSize-1;
                  EncodingWindowStartCol=TestRowStartCol; 
                  
                  if(TestRowStartCol+fTestRowSize>(HalfFSBBindex+1)*NColsSuperLineX2/kNumberOfHalfFSBB){
                    EncodingWindowStopCol=((HalfFSBBindex+1)*NColsSuperLineX2/kNumberOfHalfFSBB)-1;
                  }
                  else{
                    EncodingWindowStopCol=EncodingWindowStartCol+fTestRowSize-1;
                  }

                  EncodingWindow.Zero();
                  EncodingWindow.SetSub(0,0,SuperLineX2.GetSub(EncodingWindowStartRow,EncodingWindowStopRow,EncodingWindowStartCol,EncodingWindowStopCol));
                  
                  if(nWindowsPer32cols && nWindowsPerHalfFSBB && nWindowsPerFSBB){
                    //cout<<"Will encode window starting at "<<TestRowStartRow<<":"<<TestRowStartCol<<endl;
                    fNDigitsEncoded+=EncodingWindow.Sum();
                    fNEncodedWindows++;
                    OverflowCodes->Fill(0);
		                NDigitsPerEncodingWindowDist->Fill(EncodingWindow.Sum());
                    nWindowsPerFSBB--;
                    nWindowsPerHalfFSBB--;
                    nWindowsPer32cols--;
                    DataSizePerSuperLineX2+=DataSizePerWindowInRow;
                    //cout<<"Windows left:"<<nWindowsPerFSBB<<":"<<nWindowsPerHalfFSBB<<":"<<nWindowsPer32cols<<endl;
                  }
                  else{
                    fNDigitsLost+=EncodingWindow.Sum();
                    fNLostWindows++;
                    //cout<<"------ No encoding at col.:"<<TestRowStartCol<<" at SuperLineX2 that starts at row:"<<SuperLineX2StartRow<<endl;
                    if(!nWindowsPer32cols) Overflow32=kTRUE;
                    if(!nWindowsPerHalfFSBB) OverflowHalfFSBB=kTRUE;
                    if(!nWindowsPerFSBB) OverflowFSBB=kTRUE;
                    OverflowCodes->Fill(Overflow32+2*OverflowHalfFSBB+4*OverflowFSBB);
                  } 
                  for(Int_t k=TestRowStartRow;k<TestRowStartRow+fTestColumnSize; k++){
                    Masks(k,0)=0;
                    //cout<<"Setting Mask to 0 at "<<k<<endl;
                    //Setting to 0 the first column of the encoding window. This part if probably present in the real SUZE.
                    SuperLineX2(k,TestRowStartCol)=0;
                    if(k>=fTestColumnSize){
                      SuperLineDown(k-fTestColumnSize,TestRowStartCol)=0;
                    }
                  }
                }  
                break;
              }
            }
          }
        }
        fDataSizePerChip+=(DataSizePerSuperLineX2+DataSizePerSuperLineX2Header);
      }
    }
  }
  if(Verbose){
    cout<<fNDigitsEncoded<<" digits encoded in "<<fNEncodedWindows<<" windows"<<endl;
    cout<<fNDigitsLost<<" digits lost in "<<fNLostWindows<<" windows"<<endl;
  }
}

void AliITSUSuze02::GetResults(){
  
}
/*
void AliITSUSuze02::InitHistos(){
  fOverflowCodes = new TH1F("OverflowCodes","Overflow codes",8,0,8);
  if(fNRowsChip*fNColsChip){
    fNDigitsPerEncodingWindowDist = new TH1F("nDigitsPerEncodingWindowPerChip","nDigitsPerEncodingWindowPerChip",fTestColumnSize*fTestRowSize,1,fTestColumnSize*fTestRowSize+1);
  }
  else{
    printf("Run AliITSUSuze02::SetEncodingWindowSize first\n");
  }
}
*/
void AliITSUSuze02::ResetChip(){
  fChip->Zero();
}
Commit	Line	Data
5e2539d9	1	#include <Riostream.h>
e417d616 IB	2	#include "TMath.h"
	3	#include "AliITSUSuze02.h"
	4
	5	//*******************************************************************
	6	//
	7	// Simulation of the SUZE02 readout
	8	// Origin: Serhiy.Senuykov@cern.ch
	9	//
	10	//*******************************************************************
	11
5e2539d9	12	using std::cout;
	13	using std::endl;
	14
e417d616 IB	15	ClassImp(AliITSUSuze02)
e417d616 IB	16
64c3da7b	17	AliITSUSuze02::AliITSUSuze02(Int_t Nrows, Int_t Ncols):
852af72e	18	fNRowsChip(Nrows),
	19	fNColsChip(Ncols),
	20	fChip(new TMatrixF(Nrows,Ncols)),
64c3da7b	21	fTestColumnSize(2),
	22	fTestRowSize(2),
	23	fNWindowsPer32colsMax(0),
	24	fNWindowsPerHalfFSBBMax(0),
	25	fNWindowsPerFSBBMax(0),
	26	fNDigitsEncoded(0),
	27	fNEncodedWindows(0),
	28	fNDigitsLost(0),
	29	fNLostWindows(0),
852af72e	30	fDataSizePerChip(0),
64c3da7b	31	fNWindowsPer32colsMin(0),
	32	fNWindowsPerHalfFSBBMin(0),
	33	fNWindowsPerFSBBMin(0)
	34	{
	35	if (Ncols%(kNumberOfFSBB*kNumberOfHalfFSBB) != 0) {
e417d616 IB	36	printf("Number of columns should be multiple of %d. SUZE matrix wasn't created\n",kNumberOfFSBB*kNumberOfHalfFSBB);
	37	}
	38	}
	39
64c3da7b	40	AliITSUSuze02::AliITSUSuze02(const AliITSUSuze02& suze):
852af72e	41	fNRowsChip(suze.fNRowsChip),
	42	fNColsChip(suze.fNColsChip),
	43	fChip(new TMatrixF(*suze.fChip)),
64c3da7b	44	fTestColumnSize(suze.fTestColumnSize),
	45	fTestRowSize(suze.fTestRowSize),
	46	fNWindowsPer32colsMax(suze.fNWindowsPer32colsMax),
	47	fNWindowsPerHalfFSBBMax(suze.fNWindowsPerHalfFSBBMax),
	48	fNWindowsPerFSBBMax(suze.fNWindowsPerFSBBMax),
	49	fNDigitsEncoded(suze.fNDigitsEncoded),
	50	fNEncodedWindows(suze.fNEncodedWindows),
	51	fNDigitsLost(suze.fNDigitsLost),
	52	fNLostWindows(suze.fNLostWindows),
852af72e	53	fDataSizePerChip(suze.fDataSizePerChip),
64c3da7b	54	fNWindowsPer32colsMin(suze.fNWindowsPer32colsMin),
	55	fNWindowsPerHalfFSBBMin(suze.fNWindowsPerHalfFSBBMin),
	56	fNWindowsPerFSBBMin(suze.fNWindowsPerFSBBMin)
	57	{
	58	}
	59
	60	AliITSUSuze02 &AliITSUSuze02::operator=(const AliITSUSuze02& suze) {
	61	if (&suze == this) return *this;
	62
852af72e	63	fNRowsChip = suze.fNRowsChip;
	64	fNColsChip = suze.fNColsChip;
	65	fChip = new TMatrixF(*suze.fChip);
64c3da7b	66	fTestColumnSize = suze.fTestColumnSize;
	67	fTestRowSize = suze.fTestRowSize;
	68	fNWindowsPer32colsMax = suze.fNWindowsPer32colsMax;
	69	fNWindowsPerHalfFSBBMax = suze.fNWindowsPerHalfFSBBMax;
	70	fNWindowsPerFSBBMax = suze.fNWindowsPerFSBBMax;
	71	fNDigitsEncoded = suze.fNDigitsEncoded;
	72	fNEncodedWindows = suze.fNEncodedWindows;
	73	fNDigitsLost = suze.fNDigitsLost;
	74	fNLostWindows = suze.fNLostWindows;
852af72e	75	fDataSizePerChip = suze.fDataSizePerChip;
64c3da7b	76	fNWindowsPer32colsMin = suze.fNWindowsPer32colsMin;
	77	fNWindowsPerHalfFSBBMin = suze.fNWindowsPerHalfFSBBMin;
	78	fNWindowsPerFSBBMin = suze.fNWindowsPerFSBBMin;
	79
	80	return *this;
	81	}
	82
e417d616	83	AliITSUSuze02::~AliITSUSuze02() {
852af72e	84	if(fChip) delete fChip;
e417d616 IB	85	}
	86
	87	void AliITSUSuze02::SetEncodingWindowSize(Int_t Wrows, Int_t Wcols){
	88	fTestColumnSize=Wrows;
	89	fTestRowSize=Wcols;
	90	}
	91
	92	void AliITSUSuze02::SetQuotas(Int_t q32, Int_t qHalfFSBB, Int_t qFSBB){
	93	fNWindowsPer32colsMax=q32;
	94	fNWindowsPerHalfFSBBMax=qHalfFSBB;
	95	fNWindowsPerFSBBMax=qFSBB;
	96	}
	97
	98	void AliITSUSuze02::AddDigit(Int_t row, Int_t col){
852af72e	99	(*fChip)(row,col)++;
e417d616 IB	100	}
	101
	102	//void AliITSUSuze02::Process(Bool_t Verbose){
	103	void AliITSUSuze02::Process(TH1F* OverflowCodes, TH1F* NDigitsPerEncodingWindowDist, Bool_t Verbose) {
	104
	105	//cout<<"Processing"<<endl;
852af72e	106	//fChip->Print();
e417d616	107
852af72e	108	Int_t NRowsFSBB=fNRowsChip;
852af72e	109	Int_t NColsFSBB=fNColsChip/kNumberOfFSBB;
e417d616 IB	110	TMatrixF FSBB(NRowsFSBB,NColsFSBB);
	111
	112	Int_t NRowsSuperLine=fTestColumnSize;
	113	Int_t NColsSuperLine=NColsFSBB;
	114	TMatrixF SuperLineUp(NRowsSuperLine,NColsSuperLine);
	115	TMatrixF SuperLineDown(NRowsSuperLine,NColsSuperLine);
	116
	117	Int_t NRowsSuperLineX2=NRowsSuperLine*2;
	118	Int_t NColsSuperLineX2=NColsSuperLine; //SuperLineX2 and SuperLine size in columns is equal to FSBB.
	119	TMatrixF SuperLineX2(NRowsSuperLineX2,NColsSuperLineX2);
	120
	121	TMatrixF TestRow(1,fTestRowSize);
	122	TMatrixF TestColumn(fTestColumnSize,1);
	123	Int_t TestRowSum=0;
	124	TMatrixF EncodingWindow(fTestColumnSize,fTestRowSize);
	125
	126	Int_t EncodingWindowStartRow=0;
	127	Int_t EncodingWindowStopRow=0;
	128	Int_t EncodingWindowStartCol=0;
	129	Int_t EncodingWindowStopCol=0;
	130
	131	Int_t nMasks=fTestRowSize-1;
	132	Int_t MaskSize=NRowsSuperLineX2-1;
	133	TMatrixF Masks(MaskSize,nMasks);
	134
	135	//parameters for internal data size calculation
	136	Int_t DataSizePerWindowInRow=8+fTestColumnSize*fTestRowSize+TMath::Ceil(TMath::Log2(fTestColumnSize));
	137	Int_t DataSizePerSuperLineX2Header=30;
	138
	139	Int_t DataSizePerSuperLineX2=0;
	140
	141	Bool_t Overflow32=kFALSE;
	142	Bool_t OverflowHalfFSBB=kFALSE;
	143	Bool_t OverflowFSBB=kFALSE;
	144
	145	Int_t nWindowsPer32cols=fNWindowsPer32colsMax;
	146	Int_t nWindowsPerHalfFSBB=fNWindowsPerHalfFSBBMax;
	147	Int_t nWindowsPerFSBB=fNWindowsPerFSBBMax;
	148
	149	fNWindowsPer32colsMin=fNWindowsPer32colsMax;
	150	fNWindowsPerHalfFSBBMin=fNWindowsPerHalfFSBBMax;
	151	fNWindowsPerFSBBMin=fNWindowsPerFSBBMax;
	152
	153	fNEncodedWindows=0;
	154	fNDigitsEncoded=0;
	155	fNLostWindows=0;
	156	fNDigitsLost=0;
852af72e	157	fDataSizePerChip=0;
e417d616 IB	158
e417d616 IB	159	for(Int_t FSBBindex=0; FSBBindex<kNumberOfFSBB; FSBBindex++){
852af72e	160	FSBB=fChip->GetSub(0,NRowsFSBB-1,FSBBindexNColsFSBB,(FSBBindex+1)NColsFSBB-1);
e417d616 IB	161	SuperLineDown=FSBB.GetSub(0,NRowsSuperLine-1,0,NColsSuperLine-1);
	162	for(Int_t SuperLineX2StartRow=0; SuperLineX2StartRow<NRowsFSBB; SuperLineX2StartRow+=NRowsSuperLine){
	163	if(nWindowsPerFSBB<fNWindowsPerFSBBMin) {fNWindowsPerFSBBMin=nWindowsPerFSBB;} //saving the lowest number of remaining windows
	164	nWindowsPerFSBB=fNWindowsPerFSBBMax; //Reset number of available encoding windows for the new double SuperLine
	165	OverflowFSBB=kFALSE;
	166	SuperLineUp=SuperLineDown;
	167	if(SuperLineX2StartRow+NRowsSuperLineX2<=NRowsFSBB){
	168	SuperLineDown=FSBB.GetSub(SuperLineX2StartRow+NRowsSuperLine,SuperLineX2StartRow+NRowsSuperLineX2-1,0,NColsSuperLine-1);
	169	}
	170	else if(SuperLineX2StartRow+NRowsSuperLine<NRowsFSBB){
	171	SuperLineDown.Zero();
	172	SuperLineDown.SetSub(0,0,FSBB.GetSub(SuperLineX2StartRow+NRowsSuperLine,NRowsFSBB-1,0,NColsSuperLine-1));
	173	}
	174	else{
	175	SuperLineDown.Zero();
	176	}
	177	if(SuperLineUp.Sum()>0){
	178	DataSizePerSuperLineX2=0;
	179	SuperLineX2.SetSub(0,0,SuperLineUp);
	180	SuperLineX2.SetSub(NRowsSuperLine,0,SuperLineDown);
	181	for(Int_t HalfFSBBindex=0; HalfFSBBindex<kNumberOfHalfFSBB; HalfFSBBindex++){
	182	if(nWindowsPerHalfFSBB<fNWindowsPerHalfFSBBMin) {fNWindowsPerHalfFSBBMin=nWindowsPerHalfFSBB;}
	183	nWindowsPerHalfFSBB=fNWindowsPerHalfFSBBMax; //reset counter per HalfFSBB
	184	OverflowHalfFSBB=kFALSE;
	185	for(Int_t i=0; i<MaskSize; i++){ //reset masks to 1111111
	186	for(Int_t j=0; j<nMasks; j++){
	187	Masks(i,j)=1;
	188	}
	189	}
	190
	191	for(Int_t TestRowStartCol=HalfFSBBindexNColsSuperLineX2/kNumberOfHalfFSBB; TestRowStartCol<(HalfFSBBindex+1)NColsSuperLineX2/kNumberOfHalfFSBB; TestRowStartCol++){
	192	if(TestRowStartCol%32==0){
	193	if(nWindowsPer32cols<fNWindowsPer32colsMin) fNWindowsPer32colsMin=nWindowsPer32cols;
	194	nWindowsPer32cols=fNWindowsPer32colsMax; //reset nWindowsPer32cols counter every 32 columns
	195	Overflow32=kFALSE;
	196	}
	197	//apply masks
	198	for(Int_t RowIndex=0; RowIndex<MaskSize; RowIndex++){
	199	for(Int_t MaskIndex=0; MaskIndex<nMasks; MaskIndex++){
	200	if(Masks(RowIndex,MaskIndex)==0){
	201	// cout<<"Mask has zero bit at pos:"<<RowIndex<<":"<<MaskIndex<<endl;
	202	// cout<<"will clean the pixels at row:"<<RowIndex<<" from pos.:"<<TestRowStartCol<<" till "<< TestRowStartCol+(nMasks-MaskIndex)<<endl;
	203	for(Int_t ColIndex=TestRowStartCol; ColIndex<TestRowStartCol+(nMasks-MaskIndex); ColIndex++){
	204	if(ColIndex<(HalfFSBBindex+1)*NColsSuperLineX2/kNumberOfHalfFSBB){
	205	SuperLineX2(RowIndex,ColIndex)=0;
	206	// cout<<"Mask has zero bit. Cleaning at pos:"<<RowIndex<<":"<<ColIndex<<endl;
	207	if(RowIndex>=fTestColumnSize){
	208	SuperLineDown(RowIndex-fTestColumnSize,ColIndex)=0;
	209	}
	210	}
	211	}
	212	break;
	213	}
	214	}
	215	}
	216	//shift masks
	217	for(Int_t RowIndex=0; RowIndex<MaskSize; RowIndex++){
	218	for(Int_t MaskIndex=nMasks-1; MaskIndex>0; MaskIndex--){
	219	Masks(RowIndex,MaskIndex)=Masks(RowIndex,MaskIndex-1);
	220	}
	221	Masks(RowIndex,0)=1;
	222	}
	223
	224	for(Int_t TestRowStartRow=0; TestRowStartRow<fTestColumnSize; TestRowStartRow++){
225	TestRowSum=0;
226	for(Int_t TestRowIndex=0; TestRowIndex<fTestRowSize; TestRowIndex++){
227	if(TestRowStartCol+TestRowIndex<(HalfFSBBindex+1)*NColsSuperLineX2/kNumberOfHalfFSBB){
228	TestRowSum+=SuperLineX2(TestRowStartRow,TestRowStartCol+TestRowIndex);
229	}
230	if(TestRowSum>0){
231	//cout<<"TestR at col n."<<TestRowStartCol<<" and row n."<<TestRowStartRow<<" has a hit"<<endl;
232	break;
233	}
234	}
235	if(TestRowSum>0){
236	TestColumn=SuperLineX2.GetSub(TestRowStartRow,TestRowStartRow+fTestColumnSize-1,TestRowStartCol,TestRowStartCol);
237	if(TestColumn.Sum()>0){
238	EncodingWindowStartRow=TestRowStartRow;
239	EncodingWindowStopRow=EncodingWindowStartRow+fTestColumnSize-1;
240	EncodingWindowStartCol=TestRowStartCol;
241
242	if(TestRowStartCol+fTestRowSize>(HalfFSBBindex+1)*NColsSuperLineX2/kNumberOfHalfFSBB){
243	EncodingWindowStopCol=((HalfFSBBindex+1)*NColsSuperLineX2/kNumberOfHalfFSBB)-1;
244	}
245	else{
246	EncodingWindowStopCol=EncodingWindowStartCol+fTestRowSize-1;
247	}
248
249	EncodingWindow.Zero();
250	EncodingWindow.SetSub(0,0,SuperLineX2.GetSub(EncodingWindowStartRow,EncodingWindowStopRow,EncodingWindowStartCol,EncodingWindowStopCol));
251
252	if(nWindowsPer32cols && nWindowsPerHalfFSBB && nWindowsPerFSBB){
253	//cout<<"Will encode window starting at "<<TestRowStartRow<<":"<<TestRowStartCol<<endl;
254	fNDigitsEncoded+=EncodingWindow.Sum();
255	fNEncodedWindows++;
256	OverflowCodes->Fill(0);
257	NDigitsPerEncodingWindowDist->Fill(EncodingWindow.Sum());
258	nWindowsPerFSBB--;
259	nWindowsPerHalfFSBB--;
260	nWindowsPer32cols--;
261	DataSizePerSuperLineX2+=DataSizePerWindowInRow;
262	//cout<<"Windows left:"<<nWindowsPerFSBB<<":"<<nWindowsPerHalfFSBB<<":"<<nWindowsPer32cols<<endl;
263	}
264	else{
265	fNDigitsLost+=EncodingWindow.Sum();
266	fNLostWindows++;
267	//cout<<"------ No encoding at col.:"<<TestRowStartCol<<" at SuperLineX2 that starts at row:"<<SuperLineX2StartRow<<endl;
268	if(!nWindowsPer32cols) Overflow32=kTRUE;
269	if(!nWindowsPerHalfFSBB) OverflowHalfFSBB=kTRUE;
270	if(!nWindowsPerFSBB) OverflowFSBB=kTRUE;
271	OverflowCodes->Fill(Overflow32+2OverflowHalfFSBB+4OverflowFSBB);
272	}
273	for(Int_t k=TestRowStartRow;k<TestRowStartRow+fTestColumnSize; k++){
274	Masks(k,0)=0;
275	//cout<<"Setting Mask to 0 at "<<k<<endl;
276	//Setting to 0 the first column of the encoding window. This part if probably present in the real SUZE.
277	SuperLineX2(k,TestRowStartCol)=0;
278	if(k>=fTestColumnSize){
279	SuperLineDown(k-fTestColumnSize,TestRowStartCol)=0;
280	}
281	}
282	}
283	break;
284	}
285	}
286	}
287	}
852af72e	288	fDataSizePerChip+=(DataSizePerSuperLineX2+DataSizePerSuperLineX2Header);
e417d616 IB	289	}
	290	}
	291	}
	292	if(Verbose){
	293	cout<<fNDigitsEncoded<<" digits encoded in "<<fNEncodedWindows<<" windows"<<endl;
	294	cout<<fNDigitsLost<<" digits lost in "<<fNLostWindows<<" windows"<<endl;
	295	}
	296	}
	297
	298	void AliITSUSuze02::GetResults(){
	299
	300	}
	301	/*
	302	void AliITSUSuze02::InitHistos(){
	303	fOverflowCodes = new TH1F("OverflowCodes","Overflow codes",8,0,8);
852af72e	304	if(fNRowsChip*fNColsChip){
852af72e	305	fNDigitsPerEncodingWindowDist = new TH1F("nDigitsPerEncodingWindowPerChip","nDigitsPerEncodingWindowPerChip",fTestColumnSizefTestRowSize,1,fTestColumnSizefTestRowSize+1);
e417d616 IB	306	}
	307	else{
	308	printf("Run AliITSUSuze02::SetEncodingWindowSize first\n");
	309	}
	310	}
	311	*/
852af72e	312	void AliITSUSuze02::ResetChip(){
852af72e	313	fChip->Zero();
e417d616	314	}