void cutCheck(const int istation=1, const char *desc="Aug15-16")
{
  char fname[100]; 
  sprintf(fname, "result%s.root", desc);

  TFile *inFile = TFile::Open(fname);

  const int debug = 1;

  const int kNCutLevels = 4;
  const char *kCutStr = {"Green", "Yellow", "Red", "Fail"};

  const int kNCutsGlob = 2 + 5 + 1; 
  const char *kCutGlobStr = {"VRef", "ACurr", 
			     "Sync", "Mem", "i2c", "Jtag", "DFT", 
			     "RingCnt" };

  const int kNCutsChan =  5; 
  const char *kCutGlobStr = { "Ped", "Gain", "Rms", "RiseTime", "Xtalk"

  const int kNChips = 100000; // max number of chips so far, for any station
  const int kChipOffset = 100000;

  // constants for arrays 
  const int kNChan = 32;
  const int kNQR = 26;
  const int kNVRef = 6;
  const int kNACurr = 5;
  const int kNSync = 8;

  TTree *tree = (TTree*) inFile->Get("tree");

  //Declaration of leaves types
  //Declaration of leaves types
  Char_t          filename[200];
  Char_t          datetime[100];
  Char_t          cQR[kNQR];
  Int_t           iChip;
  Int_t           iSta;
  Float_t         fVRef[kNVRef];
  Float_t         fVCurr[kNACurr];
  Float_t         fACurr[kNACurr];
  Float_t         fGain20mV[32];
  Float_t         fGain30mV[32];
  Float_t         fRT20mV[32];
  Float_t         fRT30mV[32];
  Float_t         fPed20mV[32];
  Float_t         fPed30mV[32];
  Float_t         fRms20mV[32];
  Float_t         fRms30mV[32];
  Float_t         fPedAna20mV[32];
  Float_t         fPedAna30mV[32];
  Float_t         fRmsAna20mV[32];
  Float_t         fRmsAna30mV[32];
  Float_t         fX20mVeven;
  Float_t         fX20mVodd;
  Float_t         fX30mVeven;
  Float_t         fX30mVodd;
  Int_t           iSync[kNSync];
  Int_t           iDFT;
  Int_t           iJtag;
  Int_t           iMem;
  Float_t         fRingOsc;
  Int_t           i2cErr;
  Int_t           iErrCode;
  Int_t           iRCode;
  
  // Set branch addresses.
  tree->SetBranchAddress("filename",filename);
  tree->SetBranchAddress("datetime",datetime);
  tree->SetBranchAddress("cQR",&cQR);
  tree->SetBranchAddress("iChip",&iChip);
  tree->SetBranchAddress("iSta",&iSta);
  tree->SetBranchAddress("fVRef",fVRef);
  tree->SetBranchAddress("fVCurr",fVCurr);
  tree->SetBranchAddress("fACurr",fACurr);
  tree->SetBranchAddress("fGain20mV",fGain20mV);
  tree->SetBranchAddress("fGain30mV",fGain30mV);
  tree->SetBranchAddress("fRT20mV",fRT20mV);
  tree->SetBranchAddress("fRT30mV",fRT30mV);
  tree->SetBranchAddress("fPed20mV",fPed20mV);
  tree->SetBranchAddress("fPed30mV",fPed30mV);
  tree->SetBranchAddress("fRms20mV",fRms20mV);
  tree->SetBranchAddress("fRms30mV",fRms30mV);
  tree->SetBranchAddress("fPedAna20mV",fPedAna20mV);
  tree->SetBranchAddress("fPedAna30mV",fPedAna30mV);
  tree->SetBranchAddress("fRmsAna20mV",fRmsAna20mV);
  tree->SetBranchAddress("fRmsAna30mV",fRmsAna30mV);
  tree->SetBranchAddress("fX20mVeven",&fX20mVeven);
  tree->SetBranchAddress("fX20mVodd",&fX20mVodd);
  tree->SetBranchAddress("fX30mVeven",&fX30mVeven);
  tree->SetBranchAddress("fX30mVodd",&fX30mVodd);
  tree->SetBranchAddress("iSync",iSync);
  tree->SetBranchAddress("iDFT",&iDFT);
  tree->SetBranchAddress("iJtag",&iJtag);
  tree->SetBranchAddress("iMem",&iMem);
  tree->SetBranchAddress("fRingOsc",&fRingOsc);
  tree->SetBranchAddress("i2cErr",&i2cErr);
  tree->SetBranchAddress("iErrCode",&iErrCode);
  tree->SetBranchAddress("iRCode",&iRCode);
  
  //     This is the loop skeleton
  //       To read only selected branches, Insert statements like:
  // tree->SetBranchStatus("*",0);  // disable all branches
  // TTreePlayer->SetBranchStatus("branchname",1);  // activate branchname
  Long64_t nentries = tree->GetEntries();


  int minChip = kNChips;
  int maxChip = 0;
  int iEntry[kNChips] = {-1};
  int locChip = 0;  

  // we do a loop over entries first, to get the latest entry for a chip, for this station
  Long64_t nbytes = 0;
  if (debug>1) cout << " nentries " << nentries << endl;
  for (Long64_t i=0; i<nentries;i++) {
    if (debug>1) cout << " get entry i " << i << endl;
    nbytes += tree->GetEntry(i);
    if (debug>1) cout << " entry i " << i << " iSta " << iSta << endl;

    if (iSta == istation) { // selected station
      if (debug>1) cout << " selected entry i " << i << " iSta " << iSta << endl;

      locChip = iChip - kChipOffset;  
      if ( (locChip>=0) && (locChip < kNChips) ) { // right range of chips

	if (minChip>locChip) minChip = locChip;
	if (maxChip<locChip) maxChip = locChip;    

	iEntry[locChip] = i; // keep track of latest entry for each chip
      }
    } // station
  } // entries
  
  // then we loop over the last entry per chip						 
  for (int ichip = minChip; ichip<=maxChip; ichip++) {
    if (iEntry[ichip] >= 0) {
      nbytes += tree->GetEntry(iEntry[ichip]);
      locChip = iChip - kChipOffset;  

      int nSyncFail = 0;
      int nSyncOK = 0;
      for (k=0; k<kNSync; k++) {
	if ( (200<iSync[k]) && (iSync[k]<300) ) { nSyncOK++; }
	else { nSyncFail++; }
      }
      if (debug>1) cout << " nSyncOK " << nSyncOK << endl;
      if ( nSyncOK == kNSync ) {
	if (debug>1) cout << " ok entry for station " << iSta << endl;

	
	for (k=0; k<kNHistChanMin; k++) chanMin[k] = max[k+kNHistGlob];
	for (k=0; k<kNHistChanMax; k++) chanMax[k] = min[k+kNHistGlob+kNHistChanMin];
      
	// find all the min and max values
	for (int ichan=0; ichan<32; ichan++) {
	  k = 0;
	  if (debug>1) cout << " ichan " << ichan << endl;
	  if (chanMin[k] > fGain20mV[ichan]) chanMin[k] = fGain20mV[ichan];
	  if (chanMax[k] < fGain20mV[ichan]) chanMax[k] = fGain20mV[ichan];
	  k++;
	  if (chanMin[k] > fGain30mV[ichan]) chanMin[k] = fGain30mV[ichan];
	  if (chanMax[k] < fGain30mV[ichan]) chanMax[k] = fGain30mV[ichan];
	  k++;
	  if (chanMin[k] > fRT20mV[ichan]) chanMin[k] = fRT20mV[ichan];
	  if (chanMax[k] < fRT20mV[ichan]) chanMax[k] = fRT20mV[ichan];
	  k++;
	  if (chanMin[k] > fRT30mV[ichan]) chanMin[k] = fRT30mV[ichan];
	  if (chanMax[k] < fRT30mV[ichan]) chanMax[k] = fRT30mV[ichan];
	  k++;
	  if (chanMin[k] > fPed20mV[ichan]) chanMin[k] = fPed20mV[ichan];
	  if (chanMax[k] < fPed20mV[ichan]) chanMax[k] = fPed20mV[ichan];
	  k++;
	  if (chanMin[k] > fPed30mV[ichan]) chanMin[k] = fPed30mV[ichan];
	  if (chanMax[k] < fPed30mV[ichan]) chanMax[k] = fPed30mV[ichan];
	  k++;
	  if (chanMin[k] > fRms20mV[ichan]) chanMin[k] = fRms20mV[ichan];
	  if (chanMax[k] < fRms20mV[ichan]) chanMax[k] = fRms20mV[ichan];
	  k++;
	  if (chanMin[k] > fRms30mV[ichan]) chanMin[k] = fRms30mV[ichan];
	  if (chanMax[k] < fRms30mV[ichan]) chanMax[k] = fRms30mV[ichan];
	  k++;
	  
	  if (chanMin[k] > fPedAna20mV[ichan]) chanMin[k] = fPedAna20mV[ichan];
	  if (chanMax[k] < fPedAna20mV[ichan]) chanMax[k] = fPedAna20mV[ichan];
	  k++;
	  if (chanMin[k] > fPedAna30mV[ichan]) chanMin[k] = fPedAna30mV[ichan];
	  if (chanMax[k] < fPedAna30mV[ichan]) chanMax[k] = fPedAna30mV[ichan];
	  k++;
	  if (chanMin[k] > fRmsAna20mV[ichan]) chanMin[k] = fRmsAna20mV[ichan];
	  if (chanMax[k] < fRmsAna20mV[ichan]) chanMax[k] = fRmsAna20mV[ichan];
	  k++;
	  if (chanMin[k] > fRmsAna30mV[ichan]) chanMin[k] = fRmsAna30mV[ichan];
	  if (chanMax[k] < fRmsAna30mV[ichan]) chanMax[k] = fRmsAna30mV[ichan];
	}

      // fill histos
      j = kNHistGlob;
      for (k=0; k<kNHistChanMin; k++) {
	if (debug>1) cout << " min-hist " << j+k << endl;
	h[j+k]->Fill(chanMin[k]);
      }
      j = kNHistGlob + kNHistChanMin;
      for (k=0; k<kNHistChanMax; k++) {
	if (debug>1) cout << " max-hist " << j+k << endl;
	h[j+k]->Fill(chanMax[k]);
      }

    } // ok entry
  } // chip

  // third: check cut info, and create plots
  if (debug>1) cout << " create canvas " << endl;
  TCanvas *c1 = new TCanvas("c1","c1");
  if (debug>1) cout << " canvas created " << endl;

  gStyle->SetOptStat(0);


}