#include <stdlib.h>
#include <iostream>
#include <iomanip>
//
#include <TString.h>
#include <TH1F.h>
#include <TH2F.h>
#include <TMatrixD.h>
#include <TMatrixF.h>
#include <TArrayF.h>
#include <TArrayI.h>
//
#include <PamLevel2.h>
#include <CaloFranzini.h>
//
using namespace std;
//
extern Bool_t MATRIX;
extern Bool_t FULL;
extern Bool_t SIMU;
extern Bool_t CRIG;
extern Bool_t SRIG;
CaloFranzini *cf;
Int_t nbin;
Float_t rig[18];
Float_t rmean[17];
Int_t ntot[17];
Int_t MDIM = 8213;
//Int_t MDIM = 4128;
//Float_t qqplane[17][43];
//Int_t nnqplane[17][43];

TArrayF *qplane[17];
TArrayI *nqplane[17];
TMatrixD *matrix[17];
TMatrixD *nmat[17];

//TMatrixD *fqplane;
//TMatrixD *fnqplane;
TMatrixD *fqplane[17];
TMatrixD *fnqplane[17];
TMatrixD *fmatrix[17];
//TMatrixF *fnmat[17];
//TMatrixD *fmatrix;
//TMatrixD *fnmat;
//TMatrixF *fmatrix;
//TMatrixF *fnmat;
TMatrixF *fnmat[17];
//Int_t finmat[43][191];

//===============================================================================
bool Select( PamLevel2* event ){

  //---------------------------------------------------------
  // single track
  //---------------------------------------------------------
  if( event->GetTrkLevel2()->GetNTracks()!=1 ) return false; 
  PamTrack *track = event->GetTrack(0);
  if(!track)return false;

  //------------------------------------------------------------------
  // tracker pre-selection
  //------------------------------------------------------------------
  TrkTrack *trk = track->GetTrkTrack();
  float rigidity = trk->GetRigidity();
  if ( CRIG ) rigidity = event->GetCaloLevel2()->qtot/260.;
  if ( SRIG ) rigidity = event->GetGPamela()->P0;
  bool TRACK__OK = false;
  if( 
     trk->chi2 >0     &&
     trk->GetNX()>=4  &&
     trk->GetNY()>=3  &&
     trk->GetLeverArmX()>=5 &&
     true ) TRACK__OK = true;

  if( !TRACK__OK )return false;

  //------------------------------------------------------------------
  // TOF pre-selection
  //------------------------------------------------------------------
  bool TOF__OK = false;
  if(
     event->GetToFLevel2()->GetNHitPaddles(0) == 1 &&
     event->GetToFLevel2()->GetNHitPaddles(1) == 1 &&
     event->GetToFLevel2()->GetNHitPaddles(2) == 1 &&
     event->GetToFLevel2()->GetNHitPaddles(3) == 1 &&
     event->GetToFLevel2()->GetNHitPaddles(4) >= 1 &&
     event->GetToFLevel2()->GetNHitPaddles(5) >= 1 &&
     event->GetToFLevel2()->npmt() <= 18           &&
     !event->GetAcLevel2()->CARDhit() &&
     !event->GetAcLevel2()->CAThit() &&
     true ) TOF__OK = true;
  if( !TOF__OK && !SIMU)return false;
  //------------------------------------------------------
  // no albedo
  //------------------------------------------------------
  if(  	 !SIMU && (track->GetToFTrack()->beta[12]<=0.2 ||
		   track->GetToFTrack()->beta[12] >= 1.5) ) return false;

  //------------------------------------------------------
  bool CUT1 = false;
  if( 
     trk->nstep<100   &&
     rigidity<400.   &&
     rigidity>0.1   &&
     trk->resx[0]<0.001 && 
     trk->resx[5]<0.001 && 
     track->IsSolved() &&
     trk->IsInsideCavity() &&
     true ) CUT1 = true;
  //------------------------------------------------------
  if( !CUT1 )return false;
  if ( trk->GetDeflection()>0. && !SIMU ) return false;

  //
  //  ELENA'S CUT
  //
  //
  // lever-arm 6
  //====================================================
  bool LX6=false;
  if(
     track->GetTrkTrack()->GetLeverArmX()==6 &&
     !track->GetTrkTrack()->IsBad(0,0) &&
     !track->GetTrkTrack()->IsBad(5,0) &&
     track->GetTrkTrack()->resx[0]<0.001 &&
     track->GetTrkTrack()->resx[5]<0.001 &&
     track->GetTrkTrack()->IsInsideCavity() &&
     true ) LX6 = true;
  
  //====================================================
  // lever-arm 5
  //====================================================
  bool LX5=false;
  if(
     track->GetTrkTrack()->GetLeverArmX()==5 &&
     true ){
    if(
       track->GetTrkTrack()->XGood(0) && track->GetTrkTrack()->XGood(4)
       ){
      
      if(
	 !track->GetTrkTrack()->IsBad(0,0) &&
	 !track->GetTrkTrack()->IsBad(4,0) &&
	 track->GetTrkTrack()->resx[0]<0.001 &&
	 track->GetTrkTrack()->resx[4]<0.001 &&
	 track->GetTrkTrack()->IsInsideCavity() &&
	 true) LX5 = true;	  
    }else if (
	      track->GetTrkTrack()->XGood(1) && track->GetTrkTrack()->XGood(5)
	      ){
      
      if(
	 !track->GetTrkTrack()->IsBad(1,0) &&
	 !track->GetTrkTrack()->IsBad(5,0) &&
	 track->GetTrkTrack()->resx[1]<0.001 &&
	 track->GetTrkTrack()->resx[5]<0.001 &&
	 track->GetTrkTrack()->IsInsideCavity() &&
	 true) LX5 = true;
    }
  }
  if ( !LX5 && !LX6 ) return false;
  Float_t defl = trk->GetDeflection();
  float p0 = 1.111588e+00;
  float p1 = 1.707656e+00;
  float p2 = 1.489693e-01;
  float chi2m025 = p0 + fabs(defl)*p1 + defl*defl*p2;
  
  float def_0      = 0.07;
  float chi2m025_0 = p0 + fabs(def_0)*p1 + def_0*def_0*p2;
  
  //  int   nchi2cut=5;
  float chi2cut=3.;
  float chi2m = pow( chi2m025-chi2m025_0+pow(chi2cut,0.25), 4.);
  bool CUT2 = false;
  if(
     track->GetTrkTrack()->chi2 < chi2m &&
     true ) CUT2 = true;  
  if ( !CUT2 ) return false;
  float dedxtrk    = trk->GetDEDX();
  //  float zcutn =  9.   + 20./(rigidity*rigidity);
  float zcut2 =  3.   + 4.3/(rigidity*rigidity);
  float zcut1 =  0.52 + 0.455/(rigidity*rigidity);
  Bool_t Z1 = false;
  if(dedxtrk > zcut1 && dedxtrk < zcut2){
    Z1=true;
  }
  if ( !Z1 && !SIMU ) return false;
  //------------------------------------------------------
  //
  // energy momentum match
  //
  Float_t qtotimp = event->GetCaloLevel2()->qtot / trk->GetRigidity();
  Float_t qcut2 = (-0.5 * trk->GetRigidity() + 150.) * 1.1;
  if ( qcut2 < 55. ) qcut2 = 55.;
  if ( qtotimp <= qcut2 ) return false;
  //
  for (Int_t i=0; i < 22; i++){
    if ( track->GetCaloTrack()->tibar[i][1] < 0 || track->GetCaloTrack()->tibar[i][0] < 0 ){
      return false;
    };
  };
  //
  if ( event->GetCaloLevel2()->qtot == 0. ) return false;
  if ( rigidity>5. && track->GetCaloTrack()->qtrack/event->GetCaloLevel2()->qtot < 0.4 ) return false;
  if ( rigidity<1. && track->GetToFTrack()->beta[12] < 0.8 ) return false;
  if ( rigidity>50. ){
    if ( trk->GetNX()<5  &&
	 trk->GetNY()<4 ) return false;
    //
    Bool_t sphit = false;
    for ( Int_t plane = 0; plane < 6; plane++){
      if ( !trk->XGood(plane) ){
	for (Int_t sing = 0; sing < event->GetTrkLevel2()->nclsx(); sing++){
	  TClonesArray &t = *(event->GetTrkLevel2()->SingletX);
	  TrkSinglet *singlet = (TrkSinglet*)t[sing];
	  if ( (singlet->plane-1) == plane ){
	    Float_t x = (singlet->coord[0]+singlet->coord[1])/2.;
	    if ( fabs(track->GetTrkTrack()->xv[plane] - x) < 1. ) sphit = true;
	  };
	};
      };
      if ( !trk->YGood(plane) ){
	for (Int_t sing = 0; sing < event->GetTrkLevel2()->nclsy(); sing++){
	  TClonesArray &t = *(event->GetTrkLevel2()->SingletY);
	  TrkSinglet *singlet = (TrkSinglet*)t[sing];
	  if ( (singlet->plane-1) == plane ){
	    Float_t x1 = (singlet->coord[0]);
	    Float_t x2 = (singlet->coord[1]);
	    if ( fabs(track->GetTrkTrack()->yv[plane] - x1) < 1. ) sphit = true;
	    if ( fabs(track->GetTrkTrack()->yv[plane] - x2) < 1. ) sphit = true;
	  };
	};
      };
    };
    if ( sphit ) return false; // spurious hit along the track
  };
  //
  Int_t ti0 = track->GetCaloTrack()->tibar[0][1]-1;
  
  Int_t view = 0;
  Int_t plane = 0;
  Int_t strip = 0;
  Float_t mip = 0.;
  //
  for ( Int_t i=0; i<event->GetCaloLevel1()->istrip; i++ ){
    //
    mip = event->GetCaloLevel1()->DecodeEstrip(i,view,plane,strip);
    if ( view == 1 && plane == 0 && strip == ti0 && mip > 4.) return false;
    if ( view == 1 && (plane >0 || strip > ti0) ) break;
  };
  //  if ( event->GetCaloLevel1()->qtotpl(0) > 7. ) return false;

  //  if ( rigidity > 2.2 || rigidity < 1.5 ) return false;
  //  printf(" rig %f CRIG %i SRIG %i \n",rigidity,CRIG,SRIG);
  //
  return true;
}
//===============================================================
// Create histograms
//
//
//
//
//
//===============================================================
void CreateHistos( PamLevel2* event , TString file){

  cf = new CaloFranzini(event);
  //
  if ( MATRIX ){
    cf->UpdateMatrixFile(file.Data());
    cf->LoadBin();
    if ( !FULL ){
      cf->LoadLong();
    } else {
      cf->LoadFull(); 
    };
  } else {
    cf->CreateMatrixFile(file.Data());
  };
  //
  //
  nbin = 18;
  rig[0] = 0.1;
  rig[1] = 0.5;
  rig[2] = 1.;
  rig[3] = 1.5;
  rig[4] = 2.2;
  rig[5] = 3.;
  rig[6] = 4.;
  rig[7] = 5.;
  rig[8] = 6.;
  rig[9] = 8.;
  rig[10] = 10.;
  rig[11] = 15.;
  rig[12] = 25.;
  rig[13] = 35.;
  rig[14] = 50.;
  rig[15] = 100.;
  rig[16] = 200.;
  rig[17] = 400.;
  //
  memset(rmean, 0, 17*sizeof(Float_t));
  memset(ntot, 0, 17*sizeof(Int_t));
  //  memset(finmat, 0, 43*191*sizeof(Int_t));  
//  Double_t tol = 1E-20;
  //
  for (Int_t i=0; i < 17 ; i++){
    //  for (Int_t i=3; i < 4 ; i++){
    if ( !FULL ){
      matrix[i] = new TMatrixD(43,43);
      qplane[i] = new TArrayF(43);
      nqplane[i] = new TArrayI(43);
      nmat[i] = new TMatrixD(43,43);
    } else {
      if ( MATRIX ){
	//	fmatrix = new TMatrixF(4128,4128);
	//	fnmat = new TMatrixF(4128,4128);
	//	fmatrix = new TMatrixF(8213,8213);
	//	fnmat = new TMatrixF(8213,8213);
	//	fmatrix = new TMatrixF(MDIM,MDIM);
	//	fnmat = new TMatrixF(MDIM,MDIM);
	//	fmatrix[i] = new TMatrixF(1849,1849);
	//	fnmat[i] = new TMatrixF(43,43);
	fmatrix[i] = new TMatrixD(1333,1333);
//	fmatrix[i]->SetTol(tol);
	fnmat[i] = new TMatrixF(43,31);
	//	cf->WriteFullMatrix(fmatrix, i);
	//	cf->WriteFullNMatrix(fnmat, i);
	//	delete fmatrix;
	//	delete fnmat;
	//fnmat[i] = new TMatrixI(8213,8213);
      } else {
	//	fqplane = new TMatrixD(43,191); // 43 planes x 191 strip (= 1 + 95 x 2, one strip is the one transversed by the track that could be on the extreme right or left) 
	//	fnqplane = new TMatrixD(43,191);//
	//	fqplane[i] = new TMatrixD(43,43); // 43 planes x 43 "strip", where 43 = 50 + 14 + 5 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + [1] + ...
	//	fnqplane[i] = new TMatrixD(43,43);//                                     0    1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20   21
	//
	fqplane[i] = new TMatrixD(43,31); // 43 planes x 43 "strip", where 43 = 50 + 14 + 6 + 5 + 3 + 3 + 3 + 2 + 2 + 2 + 1 + 1 + 1 + 1 + 1 + [1] + 1 + 1 + 1 + 1 + ...
	fnqplane[i] = new TMatrixD(43,31);//                                     0    1   2   3   4   5   6   7   8   9  10  11  12  13  14    15  16  17  18  19  ...
	//
	//	cf->WriteFullMean(fqplane, i);
	//	cf->WriteFullNMean(fnqplane, i);
	//	delete fqplane;
	//	delete fnqplane;
	//
      };
    };
  };
  //
}

//=============================================================== 
void FindAverage( PamLevel2* L2, int iev ){
  //
  Float_t erig = L2->GetTrack(0)->GetTrkTrack()->GetRigidity();
  if ( SRIG ) erig = L2->GetGPamela()->P0;
  if ( CRIG ) erig = L2->GetCaloLevel2()->qtot/260.;
  //
  Int_t rbi = 0;
  for (Int_t i = 0; i<nbin-1; i++){ 
    if ( erig>=rig[i] && erig < rig[i+1] ){
      rbi = i;
      break;
    };
  };
  //
  if ( erig < rig[0] ) return;
  if ( erig >= rig[nbin-1] ) return;
  //
  rmean[rbi] += erig;
  ntot[rbi]++;
  //
  if (!FULL ){
    Int_t dgf = 43;
    //
    for (Int_t i=0; i<dgf; i++){
      (*nqplane[rbi])[i]++;
    };
    //
    // Fill the estrip matrix
    //
    Int_t nplane = 0;
    Int_t view = 0;
    Int_t plane = 0;
    Int_t strip = 0;
    Float_t mip = 0.;
    //
    for ( Int_t i=0; i<L2->GetCaloLevel1()->istrip; i++ ){
      //
      mip = L2->GetCaloLevel1()->DecodeEstrip(i,view,plane,strip);
      //
      nplane = 1 - view + 2 * plane;
      if ( erig > 4. && nplane == 0 && mip > 15. ) printf(" IEV %i erig %f OBT %u pkt %u file %s \n",iev,erig,L2->GetOrbitalInfo()->OBT,L2->GetOrbitalInfo()->pkt_num,L2->GetPamTree()->GetFile()->GetName());
      //printf(" IEV %i OBT %u pkt %u file %s \n",iev,L2->GetOrbitalInfo()->OBT,L2->GetOrbitalInfo()->pkt_num,L2->GetPamTree()->GetFile()->GetName());
      if ( nplane > 37 ) nplane--; 
      if ( nplane < dgf ){
	(*qplane[rbi])[nplane] += mip;
      };
      //
    };
  } else {
    //
    // FULL CALORIMETER
    //
    //    fqplane = cf->LoadFullAverage(rbi);
    //    fnqplane = cf->LoadFullNAverage(rbi);
    CaloTrkVar *ct = L2->GetTrack(0)->GetCaloTrack();
    //
    Int_t nplane = 0;
    Int_t view = 0;
    Int_t plane = 0;
    Int_t strip = 0;
    Float_t mip = 0.;
    //
    Int_t cs = 0;
    Int_t cd = 0;
    Int_t mstrip = 0;
    //
    for (Int_t j=0; j<2; j++){
      for (Int_t i=0; i<22; i++){
	nplane = 1 - j + 2*i;
	if ( nplane > 37 ) nplane--;
	//
	cs = ct->tibar[i][j] - 1;
	//
	cd = 95 - cs;	
	//
	Int_t oldstr = -1;
	for (Int_t k=0; k<191; k++){
	  mstrip = cd + k;
	  //	  if ( mstrip < (191-cs) ) (*fnqplane[rbi])[nplane][mstrip] += 1.;
	  //	  if ( mstrip < (191-cs) ) (*fnqplane)[nplane][mstrip] += 1.;
	  Int_t lstr = cf->ConvertStrip(mstrip);
	  if ( oldstr != lstr ){
	    (*fnqplane[rbi])[nplane][lstr] += 1.;
	    oldstr = lstr;
	  };	
	};
      };
    };
    //
    //
    for ( Int_t i=0; i<L2->GetCaloLevel1()->istrip; i++ ){
      //
      mip = L2->GetCaloLevel1()->DecodeEstrip(i,view,plane,strip);
      //
      nplane = 1 - view + 2 * plane;
      if ( nplane > 37 ) nplane--; 
      //
      cs = ct->tibar[plane][view] - 1;
      //
      cd = 95 - cs;
      //
      mstrip = cd + strip;
      //
      Int_t lstr = cf->ConvertStrip(mstrip);
      //      (*fqplane[rbi])[nplane][mstrip] += mip;
      //      (*fqplane)[nplane][mstrip] += mip;
      (*fqplane[rbi])[nplane][lstr] += mip;
      //
    };
    //
    //    cf->WriteFullMean(fqplane, rbi);
    //    cf->WriteFullNMean(fnqplane, rbi);
    //    cf->UnLoadFullAverage(rbi);
    //    cf->UnLoadFullNAverage(rbi);
    //    delete fqplane;
    //    delete fnqplane;
    //
  };
}

void CalculateAverage(){
  //  
  if ( !FULL ){
    for (Int_t i=0; i<nbin-1; i++){
      if ( (*nqplane[i])[0] > 0 ) rmean[i] /= (Float_t)(*nqplane[i])[0];
      for (Int_t j=0; j<43 ; j++){
	if ( (*nqplane[i])[j] > 0 ){  
	  (*qplane[i])[j] /= (Float_t)(*nqplane[i])[j];
	} else {
	  (*qplane[i])[j] = 0.;
	};
	printf(" BIN %i plane %i average energy %f qplane %f nqplane %i \n",i,j,rmean[i],(*qplane[i])[j],(*nqplane[i])[j]);
      };
    };
    for (Int_t i=0; i<nbin-1; i++){
      //
      cf->WriteLongMean(qplane[i], i);
      //
    };
  } else {
    //
    for (Int_t i=0; i<nbin-1; i++){
      //      fqplane = cf->LoadFullAverage(i);
      //      fnqplane = cf->LoadFullNAverage(i);
      if ( ntot[i] > 0 ) rmean[i] /= (Float_t)(ntot[i]);
      //
      for (Int_t j=0; j<43 ; j++){
	//	for (Int_t k=0; k<191; k++){
	//	for (Int_t k=0; k<43; k++){
	for (Int_t k=0; k<31; k++){
	  // 	  if ( (*fnqplane[i])[j][k] > 0 ){  
	  // 	    (*fqplane[i])[j][k] /= (Float_t)(*fnqplane[i])[j][k];
	  // 	  } else {
	  // 	    (*fqplane[i])[j][k] = 0.;
	  // 	  };
	  // 	  printf(" BIN %i plane %i strip %i average energy %f qplane %f nqplane %f \n",i,j,k,rmean[i],(*fqplane[i])[j][k],(*fnqplane[i])[j][k]);
	  if ( (*fnqplane[i])[j][k] > 0 ){  
	    if ( (*fqplane[i])[j][k] == 0. ) (*fqplane[i])[j][k] = 0.7;
	    (*fqplane[i])[j][k] /= (Float_t)(*fnqplane[i])[j][k];
	  } else {
	    (*fqplane[i])[j][k] = 0.;
	  };
	  //	  printf(" BIN %i plane %i strip %i average energy %f qplane %f nqplane %f \n",i,j,k,rmean[i],(*fqplane)[j][k],(*fnqplane)[j][k]);
	};
      };
      cf->WriteFullMean(fqplane[i], i);
      cf->WriteFullNMean(fnqplane[i], i);
      //      cf->UnLoadFullAverage(i);
      //      cf->UnLoadFullNAverage(i);
      //      delete fqplane;
      //      delete fnqplane;
    };
    //
    //     for (Int_t i=0; i<nbin-1; i++){
    //       //
    //       cf->WriteFullMean(fqplane[i], i);
    //       //
    //     };
  };
  //  
  cf->WriteNumBin(nbin);
  //
  TArrayF *rigbin = new TArrayF(18, rig);
  cf->WriteRigBin(rigbin);
  //
  TArrayF *rmeanbin = new TArrayF(17, rmean);
  TFile *file =  cf->GetFile();
  file->cd();
  file->WriteObject(&(*rmeanbin), "binrigmean");
  //
  //
}

//=============================================================== 
void FindMatrix( PamLevel2* L2, int iev ){
  //
  Float_t erig = L2->GetTrack(0)->GetTrkTrack()->GetRigidity();
  if ( SRIG ) erig = L2->GetGPamela()->P0;
  if ( CRIG ) erig = L2->GetCaloLevel2()->qtot/260.;
  //
  Int_t rbi = 0;
  for (Int_t i = 0; i<nbin-1; i++){
    if ( erig>=rig[i] && erig < rig[i+1] ){
      rbi = i;
      break;
    };
  };
  //
  if ( erig < rig[0] ) return;
  if ( erig >= rig[nbin-1] ) return;
  //
  if ( !FULL ){
    Int_t dgf = 43;
    //
    for (Int_t i=0; i<dgf; i++){
      for (Int_t j=0; j<dgf; j++){
	(*nmat[rbi])[i][j] += 1.;
      };
    };
    //
    // Fill the estrip matrix
    //
    Int_t nplane = 0;
    Int_t view = 0;
    Int_t plane = 0;
    Int_t strip = 0;
    Float_t mip = 0.;
    Float_t hpl[43];
    memset(hpl,0,43*sizeof(Float_t));
    for ( Int_t i=0; i<L2->GetCaloLevel1()->istrip; i++ ){
      //
      mip = L2->GetCaloLevel1()->DecodeEstrip(i,view,plane,strip);
      //
      nplane = 1 - view + 2 * plane;
      if ( nplane > 37 ) nplane--; 
      if ( nplane < dgf ){
	hpl[nplane] += mip;
      };
      //
    };
    //
    for (Int_t i=0; i<dgf; i++){
      for (Int_t j=0; j<dgf; j++){
	(*matrix[rbi])[i][j] += (hpl[i] - cf->GetAverageAt(i,erig)) * (hpl[j] - cf->GetAverageAt(j,erig));
      };
    };
  } else {
    //
    // FULL CALORIMETER
    //
    //    if ( rbi != 3 ) return;
    printf(" matrix %i IEV %i \n",rbi,iev);
    //    fmatrix = cf->LoadFullMatrix(rbi);
    //    cf->LoadFullMatrix(rbi,fmatrix);
    //    fnmat = cf->LoadFullNMatrix(rbi);
    //    printf(" done \n");
    //    printf(" start loop \n");
    //
    CaloTrkVar *ct = L2->GetTrack(0)->GetCaloTrack();
    //
    Int_t nplane = 0;
    Int_t view = 0;
    Int_t plane = 0;
    Int_t strip = 0;
    Float_t mip = 0.;
    //
    //    Int_t mindgf = 48;
    //    Int_t dgf = 143;
    //       Int_t mindgf = 0; //tutto
    //        Int_t dgf = 191; //tutto
    //    Int_t mindgf = 94;
    //    Int_t dgf = 96;
    //    Int_t mindgf = 84;
    //    Int_t dgf = 106;
    Int_t mindgf = 0;
    Int_t dgf = 43;
    Int_t cs = 0;
    Int_t cd = 0;
    Int_t mstrip = 0;
    //
    //    Float_t mipv[43][43];
    //    memset(mipv,0,43*43*sizeof(Float_t));
    Float_t mipv[43][31];
    memset(mipv,0,43*31*sizeof(Float_t));
    //
    for ( Int_t i=0; i<L2->GetCaloLevel1()->istrip; i++ ){
      //
      mip = L2->GetCaloLevel1()->DecodeEstrip(i,view,plane,strip);
      //
      nplane = 1 - view + 2 * plane;
      if ( nplane > 37 ) nplane--; 
      //
      cs = ct->tibar[plane][view] - 1;
      //
      cd = 95 - cs;
      //
      mstrip = cd + strip;
      //
      Int_t lstr = cf->ConvertStrip(mstrip);
      mipv[nplane][lstr] += mip;
      //
    };
    //
    Float_t mip1 = 1.;
    Int_t cs1;
    Int_t cd1;
    Float_t mip2 = 1.;
    Int_t cs2;
    Int_t cd2;
    Int_t mi = -1;
    Int_t mj = -1;
    Int_t nn1 = 0;
    Int_t pl1 = 0;
    Int_t vi1 = 0;
    Int_t nn2 = 0;
    Int_t pl2 = 0;
    Int_t vi2 = 0;
    Int_t mstrip1min = 0;
    Int_t mstrip1max = 0;
    Int_t mstrip2min = 0;
    Int_t mstrip2max = 0;
    //
    Int_t toto = 0;
    //
    for (Int_t nplane1=0; nplane1<43; nplane1++){
      if ( nplane1 >= 37 ) nn1 = nplane1 + 1;
      vi1 = 1;
      if ( nn1%2 ) vi1 = 0;
      pl1 = (nn1 - 1 + vi1)/2;
      //
      cs1 = ct->tibar[pl1][vi1] - 1; // convertire nplane in pl1 e vi1
      //
      cd1 = 95 - cs1;
      //
      Int_t at1 = TMath::Max(0,(cd1+0));
      Int_t at2 = TMath::Min(190,(cd1+95));
      mstrip1min = cf->ConvertStrip(at1);
      mstrip1max = cf->ConvertStrip(at2) + 1;
      //      mstrip1min = cf->ConvertStrip(TMath::Max(mindgf,(cd1+0)));
      //      mstrip1max = cf->ConvertStrip(TMath::Min(dgf,(cd1+95))) + 1;
      //
      if ( nplane1 == 0 || nplane1 == 42 ) printf(" pl %i mstrip1min %i mstrip1max %i mindgf %i dgf %i cd1 %i\n",nplane1,mstrip1min,mstrip1max,mindgf,dgf,cd1);
      //
      for (Int_t mstrip1=mstrip1min; mstrip1<mstrip1max; mstrip1++){
	//	printf(".\n");
	//
	mj = -1;
	//
	mip1 = mipv[nplane1][mstrip1] - cf->GetFullAverageAt(nplane1,mstrip1,erig,rbi);
	//
	//	mi = (nplane1 * 191) + mstrip1;
	//	mi = (nplane1 * 43) + mstrip1;
	mi = (nplane1 * 31) + mstrip1;
	//
	//	if ( mstrip1 > mstrip1min ) break;
	//	if ( mstrip1 > dgf ) break;
	//	if ( mstrip1 >= mindgf && mstrip1 <= dgf && mstrip1 >= mstrip1min && mstrip1 <= mstrip1max ){
	//
	//	finmat[nplane1][mstrip1]++;
	(*fnmat[rbi])[nplane1][mstrip1] += 1.;
	//
	if ( mip1 != 0. ){
	  //
	  for (Int_t nplane2=0; nplane2<43; nplane2++){
	    //
	    if ( nplane2 >= 37 ) nn2 = nplane2 + 1;
	    vi2 = 1;
	    if ( nn2%2 ) vi2 = 0;
	    pl1 = (nn2 - 1 + vi2)/2;
	    //
	    cs2 = ct->tibar[pl2][vi2] - 1;
	    //
	    cd2 = 95 - cs2;
	    //
	    //	  mstrip2min = cd2 + 0;
	    //	  mstrip2max = cd2 + 95;
	    Int_t t1 = TMath::Max(0,(cd2+0));
	    Int_t t2 = TMath::Min(190,(cd2+95));
	    mstrip2min = cf->ConvertStrip(t1);
	    mstrip2max = cf->ConvertStrip(t2) + 1;
	    //
	    if ( nplane1 == 0 && nplane2 == 0 && mstrip1==mstrip1min ) printf(" mstrip2min %i mstrip2max %i \n",mstrip2min,mstrip2max);
	    //
	    for (Int_t mstrip2=mstrip2min; mstrip2<mstrip2max; mstrip2++){
	      //	      
	      mip2 = mipv[nplane2][mstrip2] - cf->GetFullAverageAt(nplane2,mstrip2,erig,rbi);
	      //
	      if ( mip2 != 0. ){
		//
		//		mj = (nplane2 * 191) + mstrip2;
		//		mj = (nplane2 * 43) + mstrip2;
//		mj = (nplane2 * 31) + mstrip2;
		Int_t sh = -15 + nplane1;
		if ( sh > 15 ) sh -= 31*nplane1;
		//
		mj = (nplane2 * 31) + mstrip2 + sh;
		//
		if ( mj < 0 ) mj += 1333;
		if ( mj >= 1333 ) mj -= 1333;
//		printf(" mi %i mj %i sh %i \n",mi,mj,sh);
	        //
		//	      mj++;
		//
		//	      if ( mstrip2 > mstrip2min ) break;
		//	      if ( mstrip2 > dgf ) break;
		//	      if ( mstrip2 >= mindgf && mstrip2 <= dgf && mstrip2 >= mstrip2min && mstrip2 <= mstrip2max ){
		//		if ( mstrip1 >= mstrip1min && mstrip1 <= mstrip1max && mstrip2 >= mstrip2min && mstrip2 <= mstrip2max){
		//		(*fmatrix[rbi])[mi][mj] += (mipv[nplane1][mstrip1] - cf->GetFullAverageAt(nplane1,mstrip1,erig)) * (mipv[nplane2][mstrip2] - cf->GetFullAverageAt(nplane2,mstrip2,erig));
		//	    	  (*fnmat[rbi])[mi][mj] += 1.;
		(*fmatrix[rbi])[mi][mj] += (mip1 * mip2); // giusto
		//		(*fmatrix)[mi][mj] += (mip1 * mip2) * 1000000.;
		toto++;
		//	      (*fmatrix)[mi][mj] += 1.;
		//		cf->GetFullAverageAt(nplane1,mstrip1,erig,rbi);
		//		cf->GetFullAverageAt(nplane2,mstrip2,erig,rbi);
		//	    	  (*fnmat)[mi][mj] += 1.;
		//		};
	      };
	    };
	  };
	};
      };
    };
    //  
    printf(" toto = %i \n",toto);
    printf("\n done \n");
    //    printf(" write matrix \n");
    //    cf->WriteFullMatrix(fmatrix, rbi);
    //    cf->WriteFullNMatrix(fnmat, rbi);
    //    printf(" done \n");
    //    printf(" unload matrix \n");
    //   cf->UnLoadFullMatrix(rbi);
    //    cf->UnLoadFullNMatrix(rbi);
    //    printf(" done \n");
    //    printf(" delete matrix \n");
    //    delete fmatrix;
    //    delete fnmat;
    //    printf(" done \n");
  };
}

//===============================================================
// Save histograms
//
//
//
//
//
//===============================================================
void SaveHistos(){
  //
  if ( MATRIX ){
    //
    printf("Finished, calculating average and inverting matrices\n");
    //
    if ( !FULL ){
      for (Int_t i=0; i<nbin-1; i++){
	//
	// determine the average matrix
	//    
	for (Int_t ii=0; ii<43; ii++){
	  for (Int_t j=0; j<43; j++){
	    if ( (*nmat[i])[ii][j] > 0. ){
	      (*matrix[i])[ii][j] /= (*nmat[i])[ii][j];
	    } else {
	      (*matrix[i])[ii][j] = 0.;
	    };
	  };
	};
	//
	cf->WriteLongMatrix(matrix[i],i);
	//
	if ( matrix[i]->Determinant() == 0. ){
	  printf("\n");
	  for (Int_t ii=0; ii<43; ii++){
	    for (Int_t j=0; j<43; j++){
	      printf(" %.f",(*matrix[i])[ii][j]);	  
	    };
	    printf("\n");
	  };
	  printf("\n");
	  printf(" ERROR: the matrix at bin %i is singular, determinant = 0., it cannot be inverted! \n",i);
	} else {
	  Double_t det = 0.;
	  TMatrixD invmatrix = (TMatrixD)(matrix[i]->Invert(&det));
	  printf(" Bin %i determinant is %f \n",i,det);
	  cf->WriteInvertedLongMatrix((TMatrixD)invmatrix,i);
	};
      };
    } else {
      //
      // FULL
      //
      for (Int_t i=0; i<nbin-1; i++){
	//      for (Int_t i=3; i<5; i++){
	//      for (Int_t i=3; i<4; i++){
	//
	// determine the average matrix
	//    
	//	fmatrix = cf->LoadFullMatrix(i);
	//	fnmat = cf->LoadFullNMatrix(i);	
	//
	// 	for (Int_t ii=0; ii<MDIM; ii++){
	// 	  for (Int_t j=0; j<MDIM; j++){
	// // 	    if ( (*fnmat[i])[ii][j] > 0. ){
	// // 	      (*fmatrix[i])[ii][j] /= (*fnmat[i])[ii][j];
	// // 	    } else {
	// // 	      (*fmatrix[i])[ii][j] = 0.;
	// // 	    };
	// 	    if ( (*fnmat)[ii][j] > 0. ){
	// 	      (*fmatrix)[ii][j] /= (*fnmat)[ii][j];
	// 	    } else {
	// 	      (*fmatrix)[ii][j] = 0.;
	// 	    };
	// 	  };
	// 	};
	//
// 	TMatrixD *mymat3 = new TMatrixD(129,129);
// 	TMatrixD *mymat5 = new TMatrixD(215,215);
// 	TMatrixD *mymat7 = new TMatrixD(301,301);
// 	TMatrixD *mymat9 = new TMatrixD(387,387);
// 	TMatrixD *mymat11 = new TMatrixD(473,473);
// 	TMatrixD *mymat17 = new TMatrixD(731,731);
	//	TMatrixF *mymat = new TMatrixF(129,129);
	//	TMatrixF *mymat = new TMatrixF(989,989);
	Int_t i1 = -1;
	Int_t j1 = -1;
	//	int mi,mj;
	Int_t nonzero = 0;
	Int_t nonzero1 = 0;
	for (Int_t ii=0; ii<43; ii++){
	  //	  for (Int_t j=0; j<191; j++){
	  //	  for (Int_t j=0; j<43; j++){
	  for (Int_t j=0; j<31; j++){
	    // 	    if ( (*fnmat[i])[ii][j] > 0. ){
	    // 	      (*fmatrix[i])[ii][j] /= (*fnmat[i])[ii][j];
	    // 	    } else {
	    // 	      (*fmatrix[i])[ii][j] = 0.;
	    // 	    };
	    //	    i1 =  (ii * 191) + j;
	    //	    i1 =  (ii * 43) + j;
	    i1 =  (ii * 31) + j;
	    //	    j1 = -1;
	    for (Int_t iij=0; iij<43; iij++){
	      //	      for (Int_t jj=0; jj<191; jj++){
	      //	      for (Int_t jj=0; jj<43; jj++){
	      for (Int_t jj=0; jj<31; jj++){
		//
		//		j1 = (iij * 191) + jj;
		//		j1 = (iij * 43) + jj;
		Int_t sh = -15 + ii;
		if ( sh > 15 ) sh -= 31*ii;
		//
		j1 = (iij * 31) + jj + sh;
		//
		if ( j1 < 0 ) j1 += 1333;
		if ( j1 >= 1333 ) j1 -= 1333;

//		j1 = (iij * 31) + jj;
		//		j1++;
		//		if ( finmat[ii][j] > 0 ){
		//		  (*fmatrix)[i1][j1] /= finmat[ii][j];
		if ( (*fnmat[i])[ii][j] == 0. || (*fmatrix[i])[i1][j1] == 0. || !((*fmatrix[i])[i1][j1] == (*fmatrix[i])[i1][j1]) ){
		  (*fmatrix[i])[i1][j1] = 1.;
		} else {
		  (*fmatrix[i])[i1][j1] /= (*fnmat[i])[ii][j];
		  nonzero++;
		  if ( i1 == 0 ) nonzero1++;
		};
		//
// 		if ( j>=7 && j <=23 && jj >=7 && jj<=23 ){
// 		  Int_t mi17 = (ii*3) + j -7;
// 		  Int_t mj17 = (iij*3) + jj -7;
// 		  (*mymat17)[mi17][mj17] = (*fmatrix[i])[i1][j1];
// 		};
// 		if ( j>=10 && j <=20 && jj >=10 && jj<=20 ){
// 		  Int_t mi11 = (ii*3) + j -10;
// 		  Int_t mj11 = (iij*3) + jj -10;
// 		  (*mymat11)[mi11][mj11] = (*fmatrix[i])[i1][j1];
// 		};
// 		if ( j>=11 && j <=19 && jj >=11 && jj<=19 ){
// 		  Int_t mi9 = (ii*3) + j -11;
// 		  Int_t mj9 = (iij*3) + jj -11;
// 		  (*mymat9)[mi9][mj9] = (*fmatrix[i])[i1][j1];
// 		};
// 		if ( j>=12 && j <=18 && jj >=12 && jj<=18 ){
// 		  Int_t mi7 = (ii*3) + j -12;
// 		  Int_t mj7 = (iij*3) + jj -12;
// 		  (*mymat7)[mi7][mj7] = (*fmatrix[i])[i1][j1];
// 		};
// 		if ( j>=13 && j <=17 && jj >=13 && jj<=17 ){
// 		  Int_t mi5 = (ii*3) + j -13;
// 		  Int_t mj5 = (iij*3) + jj -13;
// 		  (*mymat5)[mi5][mj5] = (*fmatrix[i])[i1][j1];
// 		};
// 		if ( j>=14 && j <=16 && jj >=14 && jj<=16 ){
// 		  Int_t mi3 = (ii*3) + j -14;
// 		  Int_t mj3 = (iij*3) + jj -14;
// 		  (*mymat3)[mi3][mj3] = (*fmatrix[i])[i1][j1];
// 		};


		//		if ( j>=94 && j <=96 && jj >=94 && jj<=96 ){
		//			mi = (ii*3) + j -94;
		//			mj = (iij*3) + jj -94;
		//			(*mymat)[mi][mj] = (*fmatrix)[i1][j1];
		//		};


		//		if ( j>=84 && j <=106 && jj >=84 && jj<=106 ){
		//			mi = (ii*3) + j -84;
		//			mj = (iij*3) + jj -84;
		//			(*mymat)[mi][mj] = (*fmatrix)[i1][j1];
		//		};

	      };
	    };
	  };
	};
	//
	printf(" Matrix has %i non-zero elements \n",nonzero);	
	//	printf(" Matrix has %i non-zero elements on the first row\n",nonzero1);	
	//
	// 	Bool_t BAD = false;
	// 	for (Int_t ii=0; ii<43; ii++){
	// 	  for (Int_t j=0; j<191; j++){
	// 	    //
	// 	    i1 =  (ii * 191) + j;
	// 	    //
	// 	    for (Int_t iij=0; iij<43; iij++){
	// 	      for (Int_t jj=0; jj<191; jj++){
	// 		//
	// 		j1 = (iij * 191) + jj;
	// 		//
	// 		//		printf(" ROW %i COLUMN %i VALUE %f \n",i1,j1,(*fmatrix)[i1][j1]);
	// 		if ( (*fmatrix)[i1][j1] == 0. || !((*fmatrix)[i1][j1]==(*fmatrix)[i1][j1]) ){
	// 		  printf(" ROW %i COLUMN %i VALUE %f \n",i1,j1,(*fmatrix)[i1][j1]);
	// 		  printf(" che schifo! \n");
	// 		  BAD = true;
	// 		};
	// 		//
	// 	      };
	// 	    };
	// 	  };
	// 	};
	// 	//
	// 	if ( BAD ) printf(" questa matrice fa cagare \n");
	//
	//
	cf->WriteFullMatrix(fmatrix[i],i);
	//	cf->WriteFullMatrix(fmatrix, i);
	//	cf->WriteFullNMatrix(fnmat, i);
	cf->WriteFullNMatrix(fnmat[i], i);
	//
	//	TDecompSVD svd(*fmatrix[i]); 
	//	Bool_t ok = svd.Decompose(); 
	//
	Double_t zero = (Double_t)0.0;
	//
	if ( fmatrix[i]->Determinant() == zero ){
	  //if ( fmatrix->Determinant() == 0. ){
	  printf(" ERROR: the matrix at bin %i is singular, determinant = 0., it cannot be inverted! \n",i);
	} else {
	  //	};
	  //	if ( i == 3 ){
	  //	if ( ok ){
	  //	  Double_t tol = 1E-20;
	  //	  TDecompSVD svd((*fmatrix)[i],tol);
	  //	  svd.Decompose(); 
	  //	  TMatrixD svdInv = svd.Invert();
	  //	  svdInv.Print("svdInv"); 
	  //	  cout << "condition: " << svd.Condition() << endl; 
	  //	  cf->WriteInvertedFullMatrix((TMatrixD)svdInv,999);
	  
 	  Double_t det = 0.;
 	  TMatrixD invmatrix = (TMatrixD)(fmatrix[i]->Invert(&det));
 	  printf(" Bin %i determinant is %f \n",i,det);
          cf->WriteInvertedFullMatrix((TMatrixD)invmatrix,i);
	};

// 	if ( mymat3->Determinant() == 0. ){
// 	  printf(" ERROR: the matrix at bin %i is singular, determinant = 0., it cannot be inverted! \n",i);
// 	} else {
// 	  Double_t det = 0.;
// 	  TMatrixD invmatrix = (TMatrixD)(mymat3->Invert(&det));
// 	  printf(" Mymat3 determinant is %f \n",det);
// 	  cf->WriteInvertedFullMatrix((TMatrixD)invmatrix,1103);
// 	};
// 	cf->WriteFullMatrix(mymat3, 103);
// 	if ( mymat5->Determinant() == 0. ){
// 	  printf(" ERROR: the matrix at bin %i is singular, determinant = 0., it cannot be inverted! \n",i);
// 	} else {
// 	  Double_t det = 0.;
// 	  TMatrixD invmatrix = (TMatrixD)(mymat5->Invert(&det));
// 	  printf(" Mymat5 determinant is %f \n",det);
// 	  cf->WriteInvertedFullMatrix((TMatrixD)invmatrix,1105);
// 	};
// 	cf->WriteFullMatrix(mymat5, 105);
// 	if ( mymat7->Determinant() == 0. ){
// 	  printf(" ERROR: the matrix at bin %i is singular, determinant = 0., it cannot be inverted! \n",i);
// 	} else {
// 	  Double_t det = 0.;
// 	  TMatrixD invmatrix = (TMatrixD)(mymat7->Invert(&det));
// 	  printf(" Mymat7 determinant is %f \n",det);
// 	  cf->WriteInvertedFullMatrix((TMatrixD)invmatrix,1107);
// 	};
// 	cf->WriteFullMatrix(mymat7, 107);
// 	if ( mymat9->Determinant() == 0. ){
// 	  printf(" ERROR: the matrix at bin %i is singular, determinant = 0., it cannot be inverted! \n",i);
// 	} else {
// 	  Double_t det = 0.;
// 	  TMatrixD invmatrix = (TMatrixD)(mymat9->Invert(&det));
// 	  printf(" Mymat3 determinant is %f \n",det);
// 	  cf->WriteInvertedFullMatrix((TMatrixD)invmatrix,1109);
// 	};
// 	cf->WriteFullMatrix(mymat9, 109);
// 	if ( mymat11->Determinant() == 0. ){
// 	  printf(" ERROR: the matrix at bin %i is singular, determinant = 0., it cannot be inverted! \n",i);
// 	} else {
// 	  Double_t det = 0.;
// 	  TMatrixD invmatrix = (TMatrixD)(mymat11->Invert(&det));
// 	  printf(" Mymat11 determinant is %f \n",det);
// 	  cf->WriteInvertedFullMatrix((TMatrixD)invmatrix,1111);
// 	};
// 	cf->WriteFullMatrix(mymat11, 111);
// 	if ( mymat17->Determinant() == 0. ){
// 	  printf(" ERROR: the matrix at bin %i is singular, determinant = 0., it cannot be inverted! \n",i);
// 	} else {
// 	  Double_t det = 0.;
// 	  TMatrixD invmatrix = (TMatrixD)(mymat17->Invert(&det));
// 	  printf(" Mymat3 determinant is %f \n",det);
// 	  cf->WriteInvertedFullMatrix((TMatrixD)invmatrix,1117);
// 	};
// 	cf->WriteFullMatrix(mymat17, 117);


	//
	//	cf->UnLoadFullMatrix(i);
	//	cf->UnLoadFullNMatrix(i);
	//	delete fmatrix;
	//	delete fnmat;
	//
      };
    };
    //
    printf(" done, closing file and exiting\n");
    //
  };
  //
  cf->CloseMatrixFile();
  //
  cf->Delete();
  //
}