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

#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):
  fNRowsModule(Nrows),
  fNColsModule(Ncols),
  fModule(new TMatrixF(Nrows,Ncols)), 
  fTestColumnSize(2),
  fTestRowSize(2),
  fNWindowsPer32colsMax(0),
  fNWindowsPerHalfFSBBMax(0),
  fNWindowsPerFSBBMax(0),
  fNDigitsEncoded(0), 
  fNEncodedWindows(0),
  fNDigitsLost(0),
  fNLostWindows(0),
  fDataSizePerModule(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): 
  fNRowsModule(suze.fNRowsModule),
  fNColsModule(suze.fNColsModule),
  fModule(new TMatrixF(*suze.fModule)), 
  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),
  fDataSizePerModule(suze.fDataSizePerModule),
  fNWindowsPer32colsMin(suze.fNWindowsPer32colsMin),
  fNWindowsPerHalfFSBBMin(suze.fNWindowsPerHalfFSBBMin),
  fNWindowsPerFSBBMin(suze.fNWindowsPerFSBBMin)
{
}

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

  fNRowsModule = suze.fNRowsModule;
  fNColsModule = suze.fNColsModule;
  fModule = new TMatrixF(*suze.fModule);  
  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;
  fDataSizePerModule = suze.fDataSizePerModule;
  fNWindowsPer32colsMin = suze.fNWindowsPer32colsMin;
  fNWindowsPerHalfFSBBMin = suze.fNWindowsPerHalfFSBBMin;
  fNWindowsPerFSBBMin = suze.fNWindowsPerFSBBMin;

  return *this;
}

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

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){
  (*fModule)(row,col)++;
}

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

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