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

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

  const int debug = 1;

  // cuts on channel level: should be same as in checklog.pl
  const float kMinPed = 20;
  const float kMaxPed = 130;
  const float kMinRms = 0.2;
  const float kMaxRms = 3.0;
  const float kMinGain20mV = 18.9;
  const float kMaxGain20mV = 20.6;

  // 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();

  const int kNSta = 2;
  const int kNErrBits = 14; // check for 14 different errors
  const char *kBitStr[] = { "FileCount", "VRef", "ACurr", "Sync", // 0x1, 0x2, 0x4, 0x8
			    "PedAna", "RmsAna", "Gain", "RiseTime", // 0x10, 0x20, 0x40, 0x80
			    "Xtalk", "RingOsc", "i2c", "Jtag", // 0x100, 0x200, 0x400, 0x800
			    "Mem", "DFT" // 0x1000, 0x2000
  }; 

  int nTests[kNSta] = {0};
  int nFail[kNSta] = {0};
  int nFailBit[kNSta][kNErrBits] = {0};
  int nFailChan[kNSta][kNChan] = {0};

  int ista = 0;
  int ibit = 0;
  int ichan = 0;
  for (ista=0; ista<kNSta; ista++) {
    nTests[ista] = 0;
    nFail[ista] = 0;
    for (ibit=0; ibit<kNErrBits; ibit++) {
      nFailBit[ista][ibit] = 0;
    }  
    for (ichan=0; ichan<kNChan; ichan++) {
      nFailChan[ista][ichan] = 0;
    }  
  }


  int nbytes = 0;
  for (Long64_t i=0; i<nentries;i++) {
    nbytes += tree->GetEntry(i);
    if (debug>1) cout << " entry i " << i << " iSta " << iSta << endl;
    ista = iSta - 1;
    if (ista<0 || ista>1) {
      cout << " bad entry i " << i << " ista " << ista << endl;
    }

    nTests[ista]++;
    if (iErrCode > 0) {
      nFail[ista]++;

      for (ibit=0; ibit<kNErrBits; ibit++) {
	if ( (iErrCode & (1<<ibit)) > 0 ) {
	  nFailBit[ista][ibit]++;
	}
      }

      if ( (iErrCode & 0x00f0)>0 ) { // some channel issue: check pedestal, gain and rms values
	for (ichan=0; ichan<kNChan; ichan++) {
	  if ( (fPedAna20mV[ichan]<kMinPed) || (fPedAna20mV[ichan]>kMaxPed) ||
	       (fRmsAna20mV[ichan]<kMinRms) || (fRmsAna20mV[ichan]>kMaxRms) ||
	       (fGain20mV[ichan]<kMinGain20mV) || (fGain20mV[ichan]>kMaxGain20mV) ) {
	    nFailChan[ista][ichan]++;
	  }
	}
      }

    } // some error
  } // entries
  
  const int kNChanLines = 4;
  int chanPerLine = kNChan / kNChanLines;
  int iline = 0;

  // report
  for (ista=0; ista<kNSta; ista++) {
    if (nTests[ista] > 0) {
      int nOK = nTests[ista] - nFail[ista];
      float percPass = (100.0 * nOK) / nTests[ista];

      printf("\nStation %d nTests %d nFail %d -- pass rate %5.2f %% \n", ista+1, nTests[ista], nFail[ista], percPass);
      for (ibit=0; ibit<kNErrBits; ibit++) {
	printf("nFail %3d : %s\n", nFailBit[ista][ibit], kBitStr[ibit]);
      }  


      printf("Channel failure rates \n");
      for (iline=0; iline<kNChanLines; iline++) {
	int minChan = iline*chanPerLine; 
	int maxChan = (iline+1)*chanPerLine - 1;
	printf("ch %2d - %2d : ", minChan, maxChan);

	for (ichan=minChan; ichan<= maxChan; ichan++) {
	  printf("%2d", nFailChan[ista][ichan]);
	}  
	printf("\n");
      }
    }
  }

}