ROOT logo
using namespace std;
#include <iostream>
#include <iomanip>
#include "hmdclistcells.h"
#include "hiterator.h"
#include "hcategory.h"
#include "hmdcdef.h"
#include "hmdccal1sim.h"
#include "hmdctimecut.h"
#include "hmdcgetcontainers.h"
#include "hmdclistgroupcells.h"
#include "hmdccellgroup.h"


//*-- Author : V. Pechenov
//*-- Modified : 25/06/2004 by V.Pechenov
//*-- Modified : 22/12/2006 by V.Pechenov

//_HADES_CLASS_DESCRIPTION 
///////////////////////////////////////////////////////////////////////
//  HMdcLayListCells - list of fired wires in one layer.
//                     Can keep also drift times 
//                     and geant track numbers.
//
//  HMdcModListCells - list of fired wires in one MDC 
//                     (6 HMdcLayListCells objects)
//
//  HMdcSecListCells - list of fired wires in one sector 
//                     (4 HMdcModListCells objects)
//
//  HMdcEvntListCells - list of fired wires in one sector 
//                      (6 HMdcSecListCells objects)
//
//  If you want to create an own object of HMdcEvntListCells class
//  use normal constructor.
// 
//  If you want to work with global object of HMdcEvntListCells class 
//  use static functions:
//    HMdcEvntListCells::getObject() - return pointer to the clobal 
//        object. If clobal object don't exist function will create it.
//
//    HMdcEvntListCells::getExObject() - return pointer to the existing 
//        clobal object. If clobal object don't exist - return 0.
//
//    HMdcEvntListCells::deleteCont() - deleting of global 
//        object. Can be colled any number times.
//
///////////////////////////////////////////////////////////////////////

void HMdcLayListCells::init(void) {
  arrEnd=arr+arrSize-1;
  drTime1     = NULL;
  drTime2     = NULL;
  tof1        = NULL;
  tof2        = NULL;
  nClust      = NULL;
  nRClust     = NULL;
  nFitted     = NULL;
  nRFitted    = NULL;
  gnTrackNum1 = NULL;
  gnTrackNum2 = NULL;
  clear();
}

HMdcLayListCells::~HMdcLayListCells(void) {
  if(drTime1     != NULL) {delete [] drTime1;     drTime1     = NULL;}
  if(drTime2     != NULL) {delete [] drTime2;     drTime2     = NULL;}
  if(tof1        != NULL) {delete [] tof1;        tof1        = NULL;}
  if(tof2        != NULL) {delete [] tof2;        tof2        = NULL;}
  if(nClust      != NULL) {delete [] nClust;      nClust      = NULL;}
  if(nRClust     != NULL) {delete [] nRClust;     nRClust     = NULL;}
  if(nFitted     != NULL) {delete [] nFitted;     nFitted     = NULL;}
  if(nRFitted    != NULL) {delete [] nRFitted;    nRFitted    = NULL;}
  if(gnTrackNum1 != NULL) {delete [] gnTrackNum1; gnTrackNum1 = NULL;}
  if(gnTrackNum2 != NULL) {delete [] gnTrackNum2; gnTrackNum2 = NULL;}
}

void HMdcLayListCells::copyListOfCells(HMdcLayListCells& lst) {
  // Copy data from "lst" to "this".
  memcpy(arr,lst.arr,arrSize);
  if(lst.drTime1     != NULL && drTime1     == NULL) drTime1     = new Float_t [maxCells];
  if(lst.drTime2     != NULL && drTime2     == NULL) drTime2     = new Float_t [maxCells];
  if(lst.tof1        != NULL && tof1        == NULL) tof1        = new Float_t [maxCells];
  if(lst.tof2        != NULL && tof2        == NULL) tof2        = new Float_t [maxCells];
  if(lst.nClust      != NULL && nClust      == NULL) nClust      = new UChar_t [maxCells];
  if(lst.nRClust     != NULL && nRClust     == NULL) nRClust     = new UChar_t [maxCells];
  if(lst.nFitted     != NULL && nFitted     == NULL) nFitted     = new UChar_t [maxCells];
  if(lst.nRFitted    != NULL && nRFitted    == NULL) nRFitted    = new UChar_t [maxCells];
  if(lst.gnTrackNum1 != NULL && gnTrackNum1 == NULL) gnTrackNum1 = new Int_t   [maxCells];
  if(lst.gnTrackNum2 != NULL && gnTrackNum2 == NULL) gnTrackNum2 = new Int_t   [maxCells];
  if(drTime1     != NULL) memcpy(drTime1,     lst.drTime1,     maxCells*4); //Float_t
  if(drTime2     != NULL) memcpy(drTime2,     lst.drTime2,     maxCells*4); //Float_t
  if(tof1        != NULL) memcpy(tof1,        lst.tof1,        maxCells*4); //Float_t
  if(tof2        != NULL) memcpy(tof2,        lst.tof2,        maxCells*4); //Float_t
  if(nClust      != NULL) memcpy(nClust,      lst.nClust,      maxCells);   //UChar_t
  if(nRClust     != NULL) memcpy(nRClust,     lst.nRClust,     maxCells);   //UChar_t
  if(nFitted     != NULL) memcpy(nFitted,     lst.nFitted,     maxCells);   //UChar_t 
  if(nRFitted    != NULL) memcpy(nRFitted,    lst.nRFitted,    maxCells);   //UChar_t  
  if(gnTrackNum1 != NULL) memcpy(gnTrackNum1, lst.gnTrackNum1, maxCells*4); //Int_t
  if(gnTrackNum2 != NULL) memcpy(gnTrackNum2, lst.gnTrackNum2, maxCells*4); //Int_t
  nFittedTot = lst.nFittedTot;
}

void HMdcLayListCells::clear(void) {
  memset(arr,0,arrSize);
  clearClustCounter();
  clearFitWiresCounter();
}

void HMdcLayListCells::clearFitWiresCounter(void) {
  if(nFitted  != NULL) memset(nFitted,0,maxCells);
  if(nRFitted != NULL) memset(nRFitted,0,maxCells);
  nFittedTot = 0;
}

void HMdcLayListCells::clearClustCounter(void) {
  if(nClust  != NULL)  memset(nClust,0,maxCells);
  if(nRClust != NULL)  memset(nRClust,0,maxCells);
}

Bool_t HMdcLayListCells::addCell(Int_t c,UChar_t tm,Float_t dt1,Float_t dt2) {
  // tm = 1  - in HMdcCal1 object time1 valid only
  // tm = 2  - in HMdcCal1 object time2 valid only
  // tm = 3  - in HMdcCal1 object time1 and time2 valid
  if(!boundsOk(c) || tm==0 || tm>3) return kFALSE;
  HMdcTBArray::set(arr,c,tm);
  if(tm&1) {
    if(drTime1 == NULL) drTime1 = new Float_t [maxCells];
    drTime1[c] = dt1;
  }
  if(tm&2) {
    if(drTime2 == NULL) drTime2 = new Float_t [maxCells];
    drTime2[c] = dt2;
  }
  return kTRUE;
}

Bool_t HMdcLayListCells::addCellSim(Int_t c,UChar_t tm,Float_t dt1,Float_t dt2,
        Int_t tr1,Int_t tr2,Float_t tf1,Float_t tf2) {
  // tm = 1  - in HMdcCal1 object time1 valid only
  // tm = 2  - in HMdcCal1 object time2 valid only
  // tm = 3  - in HMdcCal1 object time1 and time2 valid
  if(!boundsOk(c) || tm==0 || tm>3) return kFALSE;
  HMdcTBArray::set(arr,c,tm);
  if(tm&1) {
    if(drTime1 == NULL)     drTime1     = new Float_t [maxCells];
    if(gnTrackNum1 == NULL) gnTrackNum1 = new Int_t [maxCells];
    if(tof1 == NULL)        tof1        = new Float_t [maxCells];
    drTime1[c]     = dt1;
    gnTrackNum1[c] = tr1;
    tof1[c]        = tf1;
  }
  if(tm&2) {
    if(drTime2     == NULL) drTime2     = new Float_t [maxCells];
    if(gnTrackNum2 == NULL) gnTrackNum2 = new Int_t [maxCells];
    if(tof2        == NULL) tof2        = new Float_t [maxCells];
    drTime2[c]     = dt2;
    gnTrackNum2[c] = tr2;
    tof2[c]        = tf2;
  }
  return kTRUE;
}

UChar_t HMdcLayListCells::nextCell(Int_t& c,Float_t& dt1,Float_t& dt2) const {
  UChar_t tm=HMdcTBArray::next2Bits(arr,arrEnd,c);
  dt1 = (tm&1 && drTime1) ? drTime1[c]:-999.F;
  dt2 = (tm&2 && drTime2) ? drTime2[c]:-999.F;
  return tm;
}

UChar_t HMdcLayListCells::nextCellSim(Int_t& c,Float_t& dt1,Float_t& dt2,
    Int_t& tr1,Int_t& tr2,Float_t& tf1,Float_t& tf2) const {
  UChar_t tm=HMdcTBArray::next2Bits(arr,arrEnd,c);
  if(tm&1) {
    dt1 = drTime1     ? drTime1[c]     : -999.F;
    tr1 = gnTrackNum1 ? gnTrackNum1[c] : 0;
    tf1 = tof1        ? tof1[c]        : -99.F;
  } else {
    dt1 = -999.F;
    tr1 = 0;
    tf1 = -99.F;
  }
  if(tm&2) {
    dt2 = drTime2     ? drTime2[c]     : -999.F;
    tr2 = gnTrackNum2 ? gnTrackNum2[c] : 0;
    tf2 = tof2        ? tof2[c]        : -99.F;
  } else {
    dt2 = -999.F;
    tr2 = 0;
    tf2 = -99.F;
  }
  return tm;
}

UChar_t HMdcLayListCells::nextCellSim(Int_t& c,Int_t& tr1,Int_t& tr2,Float_t& tf1,Float_t& tf2) const {
  UChar_t tm = HMdcTBArray::next2Bits(arr,arrEnd,c);
  if(tm&1) {
    tr1 = gnTrackNum1!=NULL ? gnTrackNum1[c] : 0;
    tf1 = tof1!=NULL        ? tof1[c]        : -99.F;
  } else {
    tr1 = 0;
    tf1 = -99.F;
  }
  if(tm&2) {
    tr2 = gnTrackNum2!=NULL ? gnTrackNum2[c] : 0;
    tf2 = tof2!=NULL        ? tof2[c]        : -99.F;
  } else {
    tr2 = 0;
    tf2 = -99.F;
  }
  return tm;
}
      
void HMdcLayListCells::print(void) const {
  printf("%i cells:",getNCells());
  Int_t cell = -1;
  while((cell=next(cell)) >= 0) {
    if(drTime1 == NULL) printf(" %i(%i)",cell+1,getTime(cell));
    else                printf(" %i/%.1f",cell+1,drTime1[cell]);
  }
  printf("\n");
}

void HMdcLayListCells::printCellInfo(Int_t cell) const {
  UChar_t timeInd = getTime(cell);
  if(timeInd==0) return;
  printf(" %i(%i",cell+1,timeInd);
  if     (timeInd != 2 && gnTrackNum1 != NULL) printf(",G%i",gnTrackNum1[cell]);
  else if(timeInd != 1 && gnTrackNum2 != NULL) printf(",G%i",gnTrackNum2[cell]);
  if(nClust  != NULL)  printf(",NC%i",nClust[cell]);
  if(nRClust != NULL)  printf(":%i",nRClust[cell]);
  printf(")");
}

Bool_t HMdcLayListCells::increaseClusCount(Int_t cell) {
  if(!boundsOk(cell)) return kFALSE;
  if(nClust == NULL) {
    nClust = new UChar_t [maxCells];
    memset(nClust,0,maxCells);
  } else if(nClust[cell]==255) {
    Warning("increaseClusCount","Clusters counter for cell %i overflowed\n",cell);
    return kFALSE;
  }
  nClust[cell]++;
  return kTRUE;
}

Bool_t HMdcLayListCells::increaseRClusCount(Int_t cell) {
  if(!boundsOk(cell)) return kFALSE;
  if(nRClust == NULL) {
    nRClust = new UChar_t [maxCells];
    memset(nRClust,0,maxCells);
  } else if(nRClust[cell]==255) {
    Warning("increaseRClusCount","Clusters counter for cell %i overflowed\n",cell);
    return kFALSE;
  }
  nRClust[cell]++;
  return kTRUE;
}

Bool_t HMdcLayListCells::increaseFittedCount(Int_t cell) {
  if(!boundsOk(cell)) return kFALSE;
  if(nFitted == NULL) {
    nFitted = new UChar_t [maxCells];
    memset(nFitted,0,maxCells);
  } else if(nFitted[cell]==255) {
    Warning("increaseFittedCount","Fitted wire counter for cell %i overflowed\n",cell);
    return kFALSE;
  }
  if(nFitted[cell]==0) nFittedTot++;
  nFitted[cell]++;
  return kTRUE;
}

Bool_t HMdcLayListCells::increaseRFittedCount(Int_t cell) {
  if(!boundsOk(cell)) return kFALSE;
  if(nRFitted == NULL) {
    nRFitted = new UChar_t [maxCells];
    memset(nRFitted,0,maxCells);
  } else if(nRFitted[cell]==255) {
    Warning("increaseRFittedCount","Fitted wire counter for cell %i overflowed\n",cell);
    return kFALSE;
  }
  nRFitted[cell]++;
  return kTRUE;
}

Bool_t HMdcLayListCells::increaseFittedAndRealCount(Int_t cell) {
  if(!boundsOk(cell)) return kFALSE;
  if(nFitted == NULL) {
    nFitted = new UChar_t [maxCells];
    memset(nFitted,0,maxCells);
  }
  if(nRFitted == NULL) {
    nRFitted = new UChar_t [maxCells];
    memset(nRFitted,0,maxCells);
  }
  if(nFitted[cell]==255 || nRFitted[cell]==255) {
    Warning("increaseFittedAndRealCount","Wire counter for cell %i overflowed\n",cell);
    return kFALSE;
  }

  if(nFitted[cell]==0) nFittedTot++;
  nFitted[cell]++;
  nRFitted[cell]++;
  return kTRUE;
}

Bool_t HMdcLayListCells::decreaseClusCount(Int_t cell) {
  if(!boundsOk(cell) || nClust==0) return kFALSE;
  if(nClust[cell]==0) {
    Warning("decreaseClusCount","Clusters counter for cell %i =0\n",cell);
    return kFALSE;
  }
  nClust[cell]--;
  return kTRUE;
}

Bool_t HMdcLayListCells::decreaseRClusCount(Int_t cell) {
  if(!boundsOk(cell) || nRClust==NULL) return kFALSE;
  if(nRClust[cell]==0) {
    Warning("decreaseRClusCount","Clusters counter for cell %i =0\n",cell);
    return kFALSE;
  }
  nRClust[cell]--;
  return kTRUE;
}

Bool_t HMdcLayListCells::decreaseFittedCount(Int_t cell) {
  if(!boundsOk(cell) || nFitted==NULL) return kFALSE;
  if(nFitted[cell]==0) {
    Warning("decreaseFittedCount","Fitted counter for cell %i =0\n",cell);
    return kFALSE;
  }
  nFitted[cell]--;
  if(nFitted[cell] == 0) nFittedTot--;
  return kTRUE;
}

Bool_t HMdcLayListCells::decreaseFittedAndRealCount(Int_t cell) {
  if(!boundsOk(cell) || nFitted==NULL || nRFitted==NULL) return kFALSE;
  if(nFitted[cell]==0 || nRFitted[cell]==0) {
    Warning("decreaseFittedAndRealCount","Counter for cell %i =0\n",cell);
    return kFALSE;
  }
  nFitted[cell]--;
  if(nFitted[cell] == 0) nFittedTot--;
  nRFitted[cell]--;
  return kTRUE;
}

Bool_t HMdcLayListCells::decreaseRFittedCount(Int_t cell) {
  if(!boundsOk(cell) || nRFitted==NULL) return kFALSE;
  if(nRFitted[cell]==0) {
    Warning("decreaseRFittedCount","N.Fitted counter for cell %i =0\n",cell);
    return kFALSE;
  }
  nRFitted[cell]--;
  return kTRUE;
}

Bool_t HMdcLayListCells::nextNonFittedCell(Int_t& cell) const {
  if(nFitted == NULL) return nextCell(cell);
  while(nextCell(cell)) if(nFitted[cell] == 0) return kTRUE;
  return kFALSE;
}

Bool_t HMdcLayListCells::previousNonFittedCell(Int_t& cell) const {
  if(nFitted == NULL) return previousCell(cell);
  while(previousCell(cell)) if(nFitted[cell] == 0) return kTRUE;
  return kFALSE;
}

Int_t HMdcLayListCells::getNumNotFitted(void) const {
  return getNCells()-nFittedTot;
}

//---------------------------------------------------------------

Int_t HMdcModListCells::genNumNotFittedLayers(void) const {
  Int_t nlays = 0;
  for(Int_t l=0;l<6;l++) if(list[l].getNumNotFitted() > 0) nlays++;
  return nlays;
}

Int_t HMdcModListCells::genNumNotFittedLayers(Int_t &nNFCells) const {
  Int_t nlays = 0;
  nNFCells    = 0;
  for(Int_t l=0;l<6;l++) {
    Int_t nc = list[l].getNumNotFitted();
    nNFCells += nc;
    if(nc > 0) nlays++;
  }
  return nlays;
}

void HMdcModListCells::print(void) const {
  for(Int_t l=0;l<6;l++) {
    if(list[l].getFirstCell()<0) continue;
    printf(" %i layer:",l+1);
    list[l].print();
  }
}

UChar_t HMdcModListCells::nextCell(Int_t& l,Int_t& c,
    Float_t& dt1,Float_t& dt2) const {
  if(l<0) {
    l =  0;
    c = -1;
  }
  for(;l<6;l++) {
    UChar_t tm = list[l].nextCell(c,dt1,dt2);
    if(tm) return tm;
  }
  l = -1;
  return 0;
}

UChar_t HMdcModListCells::nextCellSim(Int_t& l,Int_t& c,
    Float_t& dt1,Float_t& dt2,
    Int_t& tr1,Int_t& tr2,Float_t& tf1,Float_t& tf2) const {
  if(l<0) {
    l=0;
    c=-1;
  }
  for(;l<6;l++) {
    UChar_t tm=list[l].nextCellSim(c,dt1,dt2,tr1,tr2,tf1,tf2);
    if(tm) return tm;
  }
  l=-1; 
  return 0;
}

UChar_t HMdcModListCells::nextCellSim(Int_t& l,Int_t& c,
    Int_t& tr1,Int_t& tr2,Float_t& tf1,Float_t& tf2) const {
  if(l<0) {
    l=0;
    c=-1;
  }
  for(;l<6;l++) {
    UChar_t tm=list[l].nextCellSim(c,tr1,tr2,tf1,tf2);
    if(tm) return tm;
  }
  l=-1; 
  return 0;
}

//---------------------------------------------------------------
    
void HMdcSecListCells::print(void) const {
  for(Int_t m=0;m<4;m++) {
    printf(" ---- %imod.:  %i cells in %i layers\n",m+1,list[m].getNCells(),list[m].getNLayers());
    list[m].print();
  }
}

UChar_t HMdcSecListCells::nextCell(Int_t& m, Int_t& l, Int_t& c,
    Float_t& dt1,Float_t& dt2) const {
  if(m<0) {
    m=l=0;
    c=-1;
  }
  for(;m<4;m++) {
    UChar_t tm=list[m].nextCell(l,c,dt1,dt2);
    if(tm) return tm;
  }
  m=-1;
  return 0;
}

UChar_t HMdcSecListCells::nextCellSim(Int_t& m,Int_t& l,Int_t& c,
    Float_t& dt1,Float_t& dt2,
    Int_t& tr1,Int_t& tr2,Float_t& tf1,Float_t& tf2) const {
  if(m<0) {
    m=l=0;
    c=-1;
  }
  for(;m<4;m++) {
    UChar_t tm=list[m].nextCellSim(l,c,dt1,dt2,tr1,tr2,tf1,tf2);
    if(tm) return tm;
  }
  m=-1;
  return 0;
}

UChar_t HMdcSecListCells::nextCellSim(Int_t& m,Int_t& l,Int_t& c,
    Int_t& tr1,Int_t& tr2,Float_t& tf1,Float_t& tf2) const {
  if(m<0) {
    m=l=0;
    c=-1;
  }
  for(;m<4;m++) {
    UChar_t tm=list[m].nextCellSim(l,c,tr1,tr2,tf1,tf2);
    if(tm) return tm;
  }
  m=-1;
  return 0;
}

void HMdcSecListCells::clearClustCounter(Int_t seg) {
  if(seg<0 || seg>1) return;
  Int_t m  = seg*2;
  Int_t ml = m+2;
  for(;m<ml;m++) list[m].clearClustCounter();
}

void HMdcSecListCells::clearFitWiresCounter(Int_t seg) {
  if(seg<0 || seg>1) return;
  Int_t m  = seg*2;
  Int_t ml = m+2;
  for(;m<ml;m++) list[m].clearFitWiresCounter();
}

Bool_t HMdcSecListCells::addToClusCounters(Int_t seg, HMdcList12GroupCells& listCells) {
  Int_t layInd    = -1;
  Int_t cell      = -1;
  Bool_t exitFlag = kTRUE;
  while(listCells.getNextCell(layInd,cell)) {
    Int_t mod = layInd/6+seg*2;
    if(!list[mod].increaseClusCount(layInd%6,cell)) exitFlag = kFALSE;
  }
  return exitFlag;
}

Bool_t HMdcSecListCells::addToRClusCounters(Int_t seg, HMdcList12GroupCells& listCells) {
  Int_t layInd    = -1;
  Int_t cell      = -1;
  Bool_t exitFlag = kTRUE;
  while(listCells.getNextCell(layInd,cell)) {
    Int_t mod = layInd/6+seg*2;
    if(!list[mod].increaseRClusCount(layInd%6,cell)) exitFlag = kFALSE;
  }
  return exitFlag;
}

Bool_t HMdcSecListCells::subFrClusCounters(Int_t seg, HMdcList12GroupCells& listCells) {
  Int_t layInd    = -1;
  Int_t cell      = -1;
  Bool_t exitFlag = kTRUE;
  while(listCells.getNextCell(layInd,cell)) {
    Int_t mod = layInd/6+seg*2;
    if(!list[mod].decreaseClusCount(layInd%6,cell)) exitFlag = kFALSE;
  }
  return exitFlag;
}

Bool_t HMdcSecListCells::subFrRClusCounters(Int_t seg,HMdcList12GroupCells& listCells) {
  Int_t layInd    = -1;
  Int_t cell      = -1;
  Bool_t exitFlag = kTRUE;
  while(listCells.getNextCell(layInd,cell)) {
    Int_t mod = layInd/6+seg*2;
    if(!list[mod].decreaseRClusCount(layInd%6,cell)) exitFlag = kFALSE;
  }
  return exitFlag;
}

Bool_t HMdcSecListCells::subFittedCounters(Int_t seg, HMdcCellGroup12 *listCells) {
  Int_t lc[4];
  Int_t mod = seg << 1;
  for(Int_t layInd=0;layInd<12;layInd++) {
    if(layInd == 6) mod++;
    Int_t nCells = listCells->getLayerListCells(layInd,lc);
    Int_t layer  = layInd%6;
    if(nCells > 0) for(Int_t i=0;i<nCells;i++) list[mod].decreaseFittedCount(layer,lc[i]);
  }
  return kTRUE;
}

Bool_t HMdcSecListCells::subFittedAndRealCounters(Int_t seg, HMdcCellGroup12 *listCells) {
  Int_t lc[4];
  Int_t mod = seg << 1;
  for(Int_t layInd=0;layInd<12;layInd++) {
    if(layInd == 6) mod++;
    Int_t nCells = listCells->getLayerListCells(layInd,lc);
    Int_t layer  = layInd%6;
    if(nCells > 0) for(Int_t i=0;i<nCells;i++) list[mod].decreaseFittedAndRealCount(layer,lc[i]);
  }
  return kTRUE;
}

Bool_t HMdcSecListCells::subRFittedCounters(Int_t seg, HMdcCellGroup12 *listCells) {
  Int_t lc[4];
  Int_t mod = seg << 1;
  for(Int_t layInd=0;layInd<12;layInd++) {
    if(layInd == 6) mod++;
    Int_t nCells = listCells->getLayerListCells(layInd,lc);
    Int_t layer  = layInd%6;
    if(nCells > 0) for(Int_t i=0;i<nCells;i++) list[mod].decreaseRFittedCount(layer,lc[i]);
  }
  return kTRUE;
}

Int_t HMdcSecListCells::getNUniqueWires(Int_t seg,HMdcList12GroupCells& listCells) const {
  // call it if "listCells" was added to the wire counters of HMdcSecListCells already
  Int_t layInd    = -1;
  Int_t cell      = -1;
  Int_t nUnWires  = 0;
  while(listCells.getNextCell(layInd,cell)) {
    Int_t mod = layInd/6+seg*2;
    UChar_t nCls = list[mod].getNClusters(layInd%6,cell);
    if(nCls==0) Warning("getNUniqueWires","Num.clusters == 0!");
    if(nCls==1) nUnWires++;
  }
  return nUnWires;
}

Int_t HMdcSecListCells::getNUniqueAndRWires(Int_t seg,
     HMdcList12GroupCells& listCells,Int_t& nWInReal) const {
  // call it if "listCells" was added to the wire counters of HMdcSecListCells  already
  Int_t layInd    = -1;
  Int_t cell      = -1;
  Int_t nUnWires  = 0;
  nWInReal        = 0;
  while(listCells.getNextCell(layInd,cell)) {
    Int_t mod = layInd/6+seg*2;
    UChar_t nCls = list[mod].getNClusters(layInd%6,cell);
    if(nCls==0) Warning("getNUniqueWires","Num.clusters == 0!");
    else if(nCls==1) nUnWires++;
    else if(list[mod].getNRClusters(layInd%6,cell) > 0) nWInReal++; // nCls>1 !
  }
  return nUnWires;
}

Int_t HMdcSecListCells::getNUniqueAndRWires2(Int_t seg,
     HMdcList12GroupCells& listCells,Int_t& nWInReal) const {
  // call it if "listCells" was NOT added to the wire counters of HMdcSecListCells yet
  Int_t layInd    = -1;
  Int_t cell      = -1;
  Int_t nUnWires  = 0;
  nWInReal        = 0;
  while(listCells.getNextCell(layInd,cell)) {
    Int_t mod = layInd/6+seg*2;
    UChar_t nCls = list[mod].getNClusters(layInd%6,cell);
    if(nCls==0) nUnWires++;
    else if(list[mod].getNRClusters(layInd%6,cell) > 0) nWInReal++; // nCls>1 !
  }
  return nUnWires;
}

Int_t HMdcSecListCells::getNUniqueWires2(Int_t seg,HMdcList12GroupCells& listCells) const {
  // call it if "listCells" was NOT added to the wire counters of HMdcSecListCells yet
  Int_t layInd    = -1;
  Int_t cell      = -1;
  Int_t nUnWires  = 0;
  while(listCells.getNextCell(layInd,cell)) {
    Int_t mod = layInd/6+seg*2;
    UChar_t nCls = list[mod].getNClusters(layInd%6,cell);
    if(nCls==0) nUnWires++;
  }
  return nUnWires;
}

Int_t HMdcSecListCells::getNUniqueWires(Int_t seg,
     HMdcList12GroupCells& listCells, Int_t& nLays) const {
  // call it if "listCells" was added to the wire counters of HMdcSecListCells already
  Int_t   layInd     = -1;
  Int_t   cell       = -1;
  Int_t   nUnWires   = 0;
  UChar_t layList[2] = {0,0};
  while(listCells.getNextCell(layInd,cell)) {
    Int_t modInd = layInd/6;
    Int_t layer  = layInd%6;
    Int_t mod    = modInd+seg*2;
    UChar_t nCls = list[mod].getNClusters(layer,cell);
    if(nCls==0) Warning("getNUniqueWires","Num.clusters == 0!");
    if(nCls==1) {
      nUnWires++;
      layList[modInd] |= 1<<layer;
    }
  }
  nLays = HMdcBArray::getNLayOrientation(layList[0] | layList[1]);
  return nUnWires;
}

Int_t HMdcSecListCells::getNUniqueWires2(Int_t seg,
     HMdcList12GroupCells& listCells, Int_t& nLays) const {
  // call it if "listCells" was NOT added to the wire counters of HMdcSecListCells yet
  Int_t   layInd     = -1;
  Int_t   cell       = -1;
  Int_t   nUnWires   = 0;
  UChar_t layList[2] = {0,0};
  while(listCells.getNextCell(layInd,cell)) {
    Int_t modInd = layInd/6;
    Int_t layer  = layInd%6;
    Int_t mod    = modInd+seg*2;
    UChar_t nCls = list[mod].getNClusters(layer,cell);
    if(nCls==0) {
      nUnWires++;
      layList[modInd] |= 1<<layer;
    }
  }
  nLays = HMdcBArray::getNLayOrientation(layList[0] | layList[1]);
  return nUnWires;
}

Int_t HMdcSecListCells::getNFittedUnWires(Int_t seg,HMdcCellGroup12 *listCells,UChar_t ns) const {
  Int_t nUnWires  = 0;
  Int_t cells[4];
  for(Int_t layInd=0;layInd<12;layInd++) {
    Int_t nCells = listCells->getLayerListCells(layInd,cells);
    const HMdcLayListCells &layList = (list[layInd/6+seg*2])[layInd%6];
    for(Int_t i=0;i<nCells;i++) if(layList.getNFitted(cells[i]) == ns) nUnWires++;
  }
  return nUnWires;
}

Int_t HMdcSecListCells::getNFittedUnLayers(Int_t seg,HMdcCellGroup12 *listCells,UChar_t ns) const {
  Int_t nUnLayers  = 0;
  Int_t cells[4];
  for(Int_t layInd=0;layInd<12;layInd++) {
    Int_t nCells = listCells->getLayerListCells(layInd,cells);
    const HMdcLayListCells &layList = (list[layInd/6+seg*2])[layInd%6];
    for(Int_t i=0;i<nCells;i++) if(layList.getNFitted(cells[i]) == ns) {
      nUnLayers++;
      break;
    }
  }
  return nUnLayers;
}

Bool_t HMdcSecListCells::addToNFittedCounters(Int_t seg,HMdcCellGroup12 *listCells) {
  Bool_t exitFlag = kTRUE;
  Int_t cells[4];
  for(Int_t layInd=0;layInd<12;layInd++) {
    Int_t nCells = listCells->getLayerListCells(layInd,cells);
    HMdcLayListCells &layList = list[layInd/6+seg*2][layInd%6];
    for(Int_t i=0;i<nCells;i++) if(!layList.increaseFittedCount(cells[i])) exitFlag = kFALSE;
  }
  return exitFlag;
}

Bool_t HMdcSecListCells::addToNRFittedCounters(Int_t seg,HMdcCellGroup12 *listCells) {
  Bool_t exitFlag = kTRUE;
  Int_t cells[4];
  for(Int_t layInd=0;layInd<12;layInd++) {
    Int_t nCells = listCells->getLayerListCells(layInd,cells);
    HMdcLayListCells &layList = list[layInd/6+seg*2][layInd%6];
    for(Int_t i=0;i<nCells;i++) if(!layList.increaseRFittedCount(cells[i])) exitFlag = kFALSE;
  }
  return exitFlag;
}

Bool_t HMdcSecListCells::addToFittedAndRealCounters(Int_t seg,HMdcCellGroup12 *listCells) {
  Bool_t exitFlag = kTRUE;
  Int_t cells[4];
  for(Int_t layInd=0;layInd<12;layInd++) {
    Int_t nCells = listCells->getLayerListCells(layInd,cells);
    HMdcLayListCells &layList = list[layInd/6+seg*2][layInd%6];
    for(Int_t i=0;i<nCells;i++) if(!layList.increaseFittedAndRealCount(cells[i])) exitFlag = kFALSE;
  }
  return exitFlag;
}

Int_t HMdcSecListCells::getNFittedUnAndRWires(Int_t seg,HMdcCellGroup12 *listCells,
                                                  Int_t& nWInReal,UChar_t ns) const {
  Int_t nUnWires  = 0;
  nWInReal        = 0;
  Int_t cells[4];
  for(Int_t layInd=0;layInd<12;layInd++) {
    Int_t nCells = listCells->getLayerListCells(layInd,cells);
    const HMdcLayListCells &layList = list[layInd/6+seg*2][layInd%6];
    for(Int_t i=0;i<nCells;i++) {
      if     (layList.getNFitted(cells[i]) == ns) nUnWires++;
      else if(layList.getNRFitted(cells[i]) > 0)  nWInReal++; // nSegs>1 !
    }
  }
  return nUnWires;
}

Float_t HMdcSecListCells::getSegmentWeight(Int_t seg,HMdcCellGroup12 *listCells,
                                                  Int_t& nWInReal,Bool_t isAdded) const {
//  Int_t nUnWires  = 0;
  nWInReal        = 0;
  Int_t cells[4];
  
  Int_t nWrTot = 0;
  Int_t nWrShr = 0;
  for(Int_t layInd=0;layInd<12;layInd++) {
    Int_t nCells = listCells->getLayerListCells(layInd,cells);
    const HMdcLayListCells &layList = list[layInd/6+seg*2][layInd%6];
    for(Int_t i=0;i<nCells;i++) {
      nWrTot++;
      nWrShr += layList.getNFitted(cells[i]);
      if( !isAdded ) nWrShr++;
//      if     (layList.getNFitted(cells[i]) == ns) nUnWires++; 
      if(layList.getNRFitted(cells[i]) > 0)  nWInReal++; // nSegs>1 !
    }
  }
  return Float_t(nWrTot)/Float_t(nWrShr);
}

//---------------------------------------------------------------

HMdcEvntListCells* HMdcEvntListCells::pGlobalLCells=0;

HMdcEvntListCells* HMdcEvntListCells::getObject(Bool_t& isCreated) {
  // Return isCreated = kTRUE if new object was created
  if(pGlobalLCells==0) {
    pGlobalLCells = new HMdcEvntListCells();
    isCreated     = kTRUE;
  } else isCreated = kFALSE;
  return pGlobalLCells;
}

void HMdcEvntListCells::deleteCont(void) {
  if(pGlobalLCells) delete pGlobalLCells;
  pGlobalLCells = 0;
}

HMdcEvntListCells::HMdcEvntListCells(void) {
  clear();
  pMdcCal1Cat = 0;
  iterMdcCal1 = 0;
}

HMdcEvntListCells::~HMdcEvntListCells(void) {
  if(iterMdcCal1) delete iterMdcCal1;
  iterMdcCal1=0;
  if(this==pGlobalLCells) pGlobalLCells=0;
}
    
void HMdcEvntListCells::print(void) const {
  printf("==== Event: %i cells ===============================\n",getNCells());
  for(Int_t s=0;s<6;s++) {
    printf("%i sector:  %i cells in %i layers \n",s+1,list[s].getNCells(),list[s].getNLayers());
    if(list[s].getNCells()) list[s].print();
  }
}

UChar_t HMdcEvntListCells::nextCell(Int_t& s,Int_t& m,Int_t& l,Int_t& c,
        Float_t& dt1,Float_t& dt2) const {
  if(s<0) {
    s=m=l=0;
    c=-1;
  }
  for(;s<6;s++) {
    UChar_t tm=list[s].nextCell(m,l,c,dt1,dt2);
    if(tm) return tm;
  }
  return 0;
}

UChar_t HMdcEvntListCells::nextCellSim(Int_t& s,Int_t& m,Int_t& l,Int_t& c,
    Float_t& dt1,Float_t& dt2,
    Int_t& tr1,Int_t& tr2,Float_t& tf1,Float_t& tf2) const {
  if(s<0) {
    s=m=l=0;
    c=-1;
  }
  for(;s<6;s++) {
    UChar_t tm=list[s].nextCellSim(m,l,c,dt1,dt2,tr1,tr2,tf1,tf2);
    if(tm) return tm;
  }
  return 0;
}

UChar_t HMdcEvntListCells::nextCellSim(Int_t& s,Int_t& m,Int_t& l,Int_t& c,
    Int_t& tr1,Int_t& tr2,Float_t& tf1,Float_t& tf2) const {
  if(s<0) {
    s=m=l=0;
    c=-1;
  }
  for(;s<6;s++) {
    UChar_t tm=list[s].nextCellSim(m,l,c,tr1,tr2,tf1,tf2);
    if(tm) return tm;
  }
  return 0;
}

Bool_t HMdcEvntListCells::setMdcCal1Cat(void) {
  // use this function when you read tree without creating Hades object
  HCategory* cat = HMdcGetContainers::getObject()->getCatMdcCal1();
  if(pMdcCal1Cat && pMdcCal1Cat==cat) return kTRUE;
  pMdcCal1Cat=cat;
  if(pMdcCal1Cat==0) {
    Error("setMdcCal1Cat","Can't get catMdcCal1 category!");
    return kFALSE;
  }
  if(iterMdcCal1) delete iterMdcCal1;
  isGeant = pMdcCal1Cat->getClass()==HMdcCal1Sim::Class();
  iterMdcCal1 = (HIterator*)pMdcCal1Cat->MakeIterator("native");
  pDrTimeCut=HMdcTimeCut::getExObject();
  if(pDrTimeCut && pDrTimeCut->getIsUsed()) pDrTimeCut=0;
  return kTRUE;
}

Int_t HMdcEvntListCells::collectWires(Int_t sec) {
  //if sec >=0 && sec<6 - collect wires from one sector only
  if(sec>5) sec=-1;
  if(!setMdcCal1Cat()) return 0;
  clear();
  Int_t nwires=0;
  iterMdcCal1->Reset();
  if(isGeant) {
    HMdcCal1Sim* pMdcCal1;
    while((pMdcCal1=(HMdcCal1Sim*)iterMdcCal1->Next())) {
      Int_t nHits   = pMdcCal1->getNHits();
      if(nHits > 2 || nHits==0) continue;
      UChar_t times = (nHits==-2) ? 3:1;
      if((times&1) && pMdcCal1->getStatus1()<0) times &= 2;
      if((times&2) && pMdcCal1->getStatus2()<0) times &= 1;
      if(times==0) continue;
      Int_t s,m,l,c;
      pMdcCal1->getAddress(s,m,l,c);
      if(sec>=0 && sec!=s) continue;
      Float_t t1  = pMdcCal1->getTime1();
      Float_t t2  = pMdcCal1->getTime2();
      Int_t   tr1 = pMdcCal1->getNTrack1();
      Int_t   tr2 = pMdcCal1->getNTrack2();
      Float_t tf1 = pMdcCal1->getTof1();
      Float_t tf2 = pMdcCal1->getTof2();
      addCellSim(s,m,l,c,times,t1,t2,tr1,tr2,tf1,tf2);
      nwires++;
    }
  } else {
    HMdcCal1 * pMdcCal1;
    while((pMdcCal1=(HMdcCal1*)iterMdcCal1->Next())) {
      if(pDrTimeCut && !pDrTimeCut->cut(pMdcCal1)) continue;
      Int_t nHits   = pMdcCal1->getNHits();
      if(nHits==0 || nHits > 2) continue;      // >2 - skip calibr. event
      UChar_t times = (nHits==-2) ? 3:1;       
      Int_t s,m,l,c;
      pMdcCal1->getAddress(s,m,l,c);
      if(sec>=0 && sec!=s) continue;
      Float_t t1 = pMdcCal1->getTime1();
      Float_t t2 = pMdcCal1->getTime2();
      addCell(s,m,l,c,times,t1,t2);
      nwires++;
    }
  }
  return nwires;
}

void HMdcEvntListCells::clearClustCounter(Int_t seg) {
  if(seg<0 || seg>1) return;
  for(Int_t s=0;s<6;s++) list[s].clearClustCounter(seg);
}

void HMdcEvntListCells::clearFitWiresCounter(Int_t seg) {
  if(seg<0 || seg>1) return;
  for(Int_t s=0;s<6;s++) list[s].clearFitWiresCounter(seg);
}

ClassImp(HMdcLayListCells)
ClassImp(HMdcModListCells)
ClassImp(HMdcSecListCells)
ClassImp(HMdcEvntListCells)
 hmdclistcells.cc:1
 hmdclistcells.cc:2
 hmdclistcells.cc:3
 hmdclistcells.cc:4
 hmdclistcells.cc:5
 hmdclistcells.cc:6
 hmdclistcells.cc:7
 hmdclistcells.cc:8
 hmdclistcells.cc:9
 hmdclistcells.cc:10
 hmdclistcells.cc:11
 hmdclistcells.cc:12
 hmdclistcells.cc:13
 hmdclistcells.cc:14
 hmdclistcells.cc:15
 hmdclistcells.cc:16
 hmdclistcells.cc:17
 hmdclistcells.cc:18
 hmdclistcells.cc:19
 hmdclistcells.cc:20
 hmdclistcells.cc:21
 hmdclistcells.cc:22
 hmdclistcells.cc:23
 hmdclistcells.cc:24
 hmdclistcells.cc:25
 hmdclistcells.cc:26
 hmdclistcells.cc:27
 hmdclistcells.cc:28
 hmdclistcells.cc:29
 hmdclistcells.cc:30
 hmdclistcells.cc:31
 hmdclistcells.cc:32
 hmdclistcells.cc:33
 hmdclistcells.cc:34
 hmdclistcells.cc:35
 hmdclistcells.cc:36
 hmdclistcells.cc:37
 hmdclistcells.cc:38
 hmdclistcells.cc:39
 hmdclistcells.cc:40
 hmdclistcells.cc:41
 hmdclistcells.cc:42
 hmdclistcells.cc:43
 hmdclistcells.cc:44
 hmdclistcells.cc:45
 hmdclistcells.cc:46
 hmdclistcells.cc:47
 hmdclistcells.cc:48
 hmdclistcells.cc:49
 hmdclistcells.cc:50
 hmdclistcells.cc:51
 hmdclistcells.cc:52
 hmdclistcells.cc:53
 hmdclistcells.cc:54
 hmdclistcells.cc:55
 hmdclistcells.cc:56
 hmdclistcells.cc:57
 hmdclistcells.cc:58
 hmdclistcells.cc:59
 hmdclistcells.cc:60
 hmdclistcells.cc:61
 hmdclistcells.cc:62
 hmdclistcells.cc:63
 hmdclistcells.cc:64
 hmdclistcells.cc:65
 hmdclistcells.cc:66
 hmdclistcells.cc:67
 hmdclistcells.cc:68
 hmdclistcells.cc:69
 hmdclistcells.cc:70
 hmdclistcells.cc:71
 hmdclistcells.cc:72
 hmdclistcells.cc:73
 hmdclistcells.cc:74
 hmdclistcells.cc:75
 hmdclistcells.cc:76
 hmdclistcells.cc:77
 hmdclistcells.cc:78
 hmdclistcells.cc:79
 hmdclistcells.cc:80
 hmdclistcells.cc:81
 hmdclistcells.cc:82
 hmdclistcells.cc:83
 hmdclistcells.cc:84
 hmdclistcells.cc:85
 hmdclistcells.cc:86
 hmdclistcells.cc:87
 hmdclistcells.cc:88
 hmdclistcells.cc:89
 hmdclistcells.cc:90
 hmdclistcells.cc:91
 hmdclistcells.cc:92
 hmdclistcells.cc:93
 hmdclistcells.cc:94
 hmdclistcells.cc:95
 hmdclistcells.cc:96
 hmdclistcells.cc:97
 hmdclistcells.cc:98
 hmdclistcells.cc:99
 hmdclistcells.cc:100
 hmdclistcells.cc:101
 hmdclistcells.cc:102
 hmdclistcells.cc:103
 hmdclistcells.cc:104
 hmdclistcells.cc:105
 hmdclistcells.cc:106
 hmdclistcells.cc:107
 hmdclistcells.cc:108
 hmdclistcells.cc:109
 hmdclistcells.cc:110
 hmdclistcells.cc:111
 hmdclistcells.cc:112
 hmdclistcells.cc:113
 hmdclistcells.cc:114
 hmdclistcells.cc:115
 hmdclistcells.cc:116
 hmdclistcells.cc:117
 hmdclistcells.cc:118
 hmdclistcells.cc:119
 hmdclistcells.cc:120
 hmdclistcells.cc:121
 hmdclistcells.cc:122
 hmdclistcells.cc:123
 hmdclistcells.cc:124
 hmdclistcells.cc:125
 hmdclistcells.cc:126
 hmdclistcells.cc:127
 hmdclistcells.cc:128
 hmdclistcells.cc:129
 hmdclistcells.cc:130
 hmdclistcells.cc:131
 hmdclistcells.cc:132
 hmdclistcells.cc:133
 hmdclistcells.cc:134
 hmdclistcells.cc:135
 hmdclistcells.cc:136
 hmdclistcells.cc:137
 hmdclistcells.cc:138
 hmdclistcells.cc:139
 hmdclistcells.cc:140
 hmdclistcells.cc:141
 hmdclistcells.cc:142
 hmdclistcells.cc:143
 hmdclistcells.cc:144
 hmdclistcells.cc:145
 hmdclistcells.cc:146
 hmdclistcells.cc:147
 hmdclistcells.cc:148
 hmdclistcells.cc:149
 hmdclistcells.cc:150
 hmdclistcells.cc:151
 hmdclistcells.cc:152
 hmdclistcells.cc:153
 hmdclistcells.cc:154
 hmdclistcells.cc:155
 hmdclistcells.cc:156
 hmdclistcells.cc:157
 hmdclistcells.cc:158
 hmdclistcells.cc:159
 hmdclistcells.cc:160
 hmdclistcells.cc:161
 hmdclistcells.cc:162
 hmdclistcells.cc:163
 hmdclistcells.cc:164
 hmdclistcells.cc:165
 hmdclistcells.cc:166
 hmdclistcells.cc:167
 hmdclistcells.cc:168
 hmdclistcells.cc:169
 hmdclistcells.cc:170
 hmdclistcells.cc:171
 hmdclistcells.cc:172
 hmdclistcells.cc:173
 hmdclistcells.cc:174
 hmdclistcells.cc:175
 hmdclistcells.cc:176
 hmdclistcells.cc:177
 hmdclistcells.cc:178
 hmdclistcells.cc:179
 hmdclistcells.cc:180
 hmdclistcells.cc:181
 hmdclistcells.cc:182
 hmdclistcells.cc:183
 hmdclistcells.cc:184
 hmdclistcells.cc:185
 hmdclistcells.cc:186
 hmdclistcells.cc:187
 hmdclistcells.cc:188
 hmdclistcells.cc:189
 hmdclistcells.cc:190
 hmdclistcells.cc:191
 hmdclistcells.cc:192
 hmdclistcells.cc:193
 hmdclistcells.cc:194
 hmdclistcells.cc:195
 hmdclistcells.cc:196
 hmdclistcells.cc:197
 hmdclistcells.cc:198
 hmdclistcells.cc:199
 hmdclistcells.cc:200
 hmdclistcells.cc:201
 hmdclistcells.cc:202
 hmdclistcells.cc:203
 hmdclistcells.cc:204
 hmdclistcells.cc:205
 hmdclistcells.cc:206
 hmdclistcells.cc:207
 hmdclistcells.cc:208
 hmdclistcells.cc:209
 hmdclistcells.cc:210
 hmdclistcells.cc:211
 hmdclistcells.cc:212
 hmdclistcells.cc:213
 hmdclistcells.cc:214
 hmdclistcells.cc:215
 hmdclistcells.cc:216
 hmdclistcells.cc:217
 hmdclistcells.cc:218
 hmdclistcells.cc:219
 hmdclistcells.cc:220
 hmdclistcells.cc:221
 hmdclistcells.cc:222
 hmdclistcells.cc:223
 hmdclistcells.cc:224
 hmdclistcells.cc:225
 hmdclistcells.cc:226
 hmdclistcells.cc:227
 hmdclistcells.cc:228
 hmdclistcells.cc:229
 hmdclistcells.cc:230
 hmdclistcells.cc:231
 hmdclistcells.cc:232
 hmdclistcells.cc:233
 hmdclistcells.cc:234
 hmdclistcells.cc:235
 hmdclistcells.cc:236
 hmdclistcells.cc:237
 hmdclistcells.cc:238
 hmdclistcells.cc:239
 hmdclistcells.cc:240
 hmdclistcells.cc:241
 hmdclistcells.cc:242
 hmdclistcells.cc:243
 hmdclistcells.cc:244
 hmdclistcells.cc:245
 hmdclistcells.cc:246
 hmdclistcells.cc:247
 hmdclistcells.cc:248
 hmdclistcells.cc:249
 hmdclistcells.cc:250
 hmdclistcells.cc:251
 hmdclistcells.cc:252
 hmdclistcells.cc:253
 hmdclistcells.cc:254
 hmdclistcells.cc:255
 hmdclistcells.cc:256
 hmdclistcells.cc:257
 hmdclistcells.cc:258
 hmdclistcells.cc:259
 hmdclistcells.cc:260
 hmdclistcells.cc:261
 hmdclistcells.cc:262
 hmdclistcells.cc:263
 hmdclistcells.cc:264
 hmdclistcells.cc:265
 hmdclistcells.cc:266
 hmdclistcells.cc:267
 hmdclistcells.cc:268
 hmdclistcells.cc:269
 hmdclistcells.cc:270
 hmdclistcells.cc:271
 hmdclistcells.cc:272
 hmdclistcells.cc:273
 hmdclistcells.cc:274
 hmdclistcells.cc:275
 hmdclistcells.cc:276
 hmdclistcells.cc:277
 hmdclistcells.cc:278
 hmdclistcells.cc:279
 hmdclistcells.cc:280
 hmdclistcells.cc:281
 hmdclistcells.cc:282
 hmdclistcells.cc:283
 hmdclistcells.cc:284
 hmdclistcells.cc:285
 hmdclistcells.cc:286
 hmdclistcells.cc:287
 hmdclistcells.cc:288
 hmdclistcells.cc:289
 hmdclistcells.cc:290
 hmdclistcells.cc:291
 hmdclistcells.cc:292
 hmdclistcells.cc:293
 hmdclistcells.cc:294
 hmdclistcells.cc:295
 hmdclistcells.cc:296
 hmdclistcells.cc:297
 hmdclistcells.cc:298
 hmdclistcells.cc:299
 hmdclistcells.cc:300
 hmdclistcells.cc:301
 hmdclistcells.cc:302
 hmdclistcells.cc:303
 hmdclistcells.cc:304
 hmdclistcells.cc:305
 hmdclistcells.cc:306
 hmdclistcells.cc:307
 hmdclistcells.cc:308
 hmdclistcells.cc:309
 hmdclistcells.cc:310
 hmdclistcells.cc:311
 hmdclistcells.cc:312
 hmdclistcells.cc:313
 hmdclistcells.cc:314
 hmdclistcells.cc:315
 hmdclistcells.cc:316
 hmdclistcells.cc:317
 hmdclistcells.cc:318
 hmdclistcells.cc:319
 hmdclistcells.cc:320
 hmdclistcells.cc:321
 hmdclistcells.cc:322
 hmdclistcells.cc:323
 hmdclistcells.cc:324
 hmdclistcells.cc:325
 hmdclistcells.cc:326
 hmdclistcells.cc:327
 hmdclistcells.cc:328
 hmdclistcells.cc:329
 hmdclistcells.cc:330
 hmdclistcells.cc:331
 hmdclistcells.cc:332
 hmdclistcells.cc:333
 hmdclistcells.cc:334
 hmdclistcells.cc:335
 hmdclistcells.cc:336
 hmdclistcells.cc:337
 hmdclistcells.cc:338
 hmdclistcells.cc:339
 hmdclistcells.cc:340
 hmdclistcells.cc:341
 hmdclistcells.cc:342
 hmdclistcells.cc:343
 hmdclistcells.cc:344
 hmdclistcells.cc:345
 hmdclistcells.cc:346
 hmdclistcells.cc:347
 hmdclistcells.cc:348
 hmdclistcells.cc:349
 hmdclistcells.cc:350
 hmdclistcells.cc:351
 hmdclistcells.cc:352
 hmdclistcells.cc:353
 hmdclistcells.cc:354
 hmdclistcells.cc:355
 hmdclistcells.cc:356
 hmdclistcells.cc:357
 hmdclistcells.cc:358
 hmdclistcells.cc:359
 hmdclistcells.cc:360
 hmdclistcells.cc:361
 hmdclistcells.cc:362
 hmdclistcells.cc:363
 hmdclistcells.cc:364
 hmdclistcells.cc:365
 hmdclistcells.cc:366
 hmdclistcells.cc:367
 hmdclistcells.cc:368
 hmdclistcells.cc:369
 hmdclistcells.cc:370
 hmdclistcells.cc:371
 hmdclistcells.cc:372
 hmdclistcells.cc:373
 hmdclistcells.cc:374
 hmdclistcells.cc:375
 hmdclistcells.cc:376
 hmdclistcells.cc:377
 hmdclistcells.cc:378
 hmdclistcells.cc:379
 hmdclistcells.cc:380
 hmdclistcells.cc:381
 hmdclistcells.cc:382
 hmdclistcells.cc:383
 hmdclistcells.cc:384
 hmdclistcells.cc:385
 hmdclistcells.cc:386
 hmdclistcells.cc:387
 hmdclistcells.cc:388
 hmdclistcells.cc:389
 hmdclistcells.cc:390
 hmdclistcells.cc:391
 hmdclistcells.cc:392
 hmdclistcells.cc:393
 hmdclistcells.cc:394
 hmdclistcells.cc:395
 hmdclistcells.cc:396
 hmdclistcells.cc:397
 hmdclistcells.cc:398
 hmdclistcells.cc:399
 hmdclistcells.cc:400
 hmdclistcells.cc:401
 hmdclistcells.cc:402
 hmdclistcells.cc:403
 hmdclistcells.cc:404
 hmdclistcells.cc:405
 hmdclistcells.cc:406
 hmdclistcells.cc:407
 hmdclistcells.cc:408
 hmdclistcells.cc:409
 hmdclistcells.cc:410
 hmdclistcells.cc:411
 hmdclistcells.cc:412
 hmdclistcells.cc:413
 hmdclistcells.cc:414
 hmdclistcells.cc:415
 hmdclistcells.cc:416
 hmdclistcells.cc:417
 hmdclistcells.cc:418
 hmdclistcells.cc:419
 hmdclistcells.cc:420
 hmdclistcells.cc:421
 hmdclistcells.cc:422
 hmdclistcells.cc:423
 hmdclistcells.cc:424
 hmdclistcells.cc:425
 hmdclistcells.cc:426
 hmdclistcells.cc:427
 hmdclistcells.cc:428
 hmdclistcells.cc:429
 hmdclistcells.cc:430
 hmdclistcells.cc:431
 hmdclistcells.cc:432
 hmdclistcells.cc:433
 hmdclistcells.cc:434
 hmdclistcells.cc:435
 hmdclistcells.cc:436
 hmdclistcells.cc:437
 hmdclistcells.cc:438
 hmdclistcells.cc:439
 hmdclistcells.cc:440
 hmdclistcells.cc:441
 hmdclistcells.cc:442
 hmdclistcells.cc:443
 hmdclistcells.cc:444
 hmdclistcells.cc:445
 hmdclistcells.cc:446
 hmdclistcells.cc:447
 hmdclistcells.cc:448
 hmdclistcells.cc:449
 hmdclistcells.cc:450
 hmdclistcells.cc:451
 hmdclistcells.cc:452
 hmdclistcells.cc:453
 hmdclistcells.cc:454
 hmdclistcells.cc:455
 hmdclistcells.cc:456
 hmdclistcells.cc:457
 hmdclistcells.cc:458
 hmdclistcells.cc:459
 hmdclistcells.cc:460
 hmdclistcells.cc:461
 hmdclistcells.cc:462
 hmdclistcells.cc:463
 hmdclistcells.cc:464
 hmdclistcells.cc:465
 hmdclistcells.cc:466
 hmdclistcells.cc:467
 hmdclistcells.cc:468
 hmdclistcells.cc:469
 hmdclistcells.cc:470
 hmdclistcells.cc:471
 hmdclistcells.cc:472
 hmdclistcells.cc:473
 hmdclistcells.cc:474
 hmdclistcells.cc:475
 hmdclistcells.cc:476
 hmdclistcells.cc:477
 hmdclistcells.cc:478
 hmdclistcells.cc:479
 hmdclistcells.cc:480
 hmdclistcells.cc:481
 hmdclistcells.cc:482
 hmdclistcells.cc:483
 hmdclistcells.cc:484
 hmdclistcells.cc:485
 hmdclistcells.cc:486
 hmdclistcells.cc:487
 hmdclistcells.cc:488
 hmdclistcells.cc:489
 hmdclistcells.cc:490
 hmdclistcells.cc:491
 hmdclistcells.cc:492
 hmdclistcells.cc:493
 hmdclistcells.cc:494
 hmdclistcells.cc:495
 hmdclistcells.cc:496
 hmdclistcells.cc:497
 hmdclistcells.cc:498
 hmdclistcells.cc:499
 hmdclistcells.cc:500
 hmdclistcells.cc:501
 hmdclistcells.cc:502
 hmdclistcells.cc:503
 hmdclistcells.cc:504
 hmdclistcells.cc:505
 hmdclistcells.cc:506
 hmdclistcells.cc:507
 hmdclistcells.cc:508
 hmdclistcells.cc:509
 hmdclistcells.cc:510
 hmdclistcells.cc:511
 hmdclistcells.cc:512
 hmdclistcells.cc:513
 hmdclistcells.cc:514
 hmdclistcells.cc:515
 hmdclistcells.cc:516
 hmdclistcells.cc:517
 hmdclistcells.cc:518
 hmdclistcells.cc:519
 hmdclistcells.cc:520
 hmdclistcells.cc:521
 hmdclistcells.cc:522
 hmdclistcells.cc:523
 hmdclistcells.cc:524
 hmdclistcells.cc:525
 hmdclistcells.cc:526
 hmdclistcells.cc:527
 hmdclistcells.cc:528
 hmdclistcells.cc:529
 hmdclistcells.cc:530
 hmdclistcells.cc:531
 hmdclistcells.cc:532
 hmdclistcells.cc:533
 hmdclistcells.cc:534
 hmdclistcells.cc:535
 hmdclistcells.cc:536
 hmdclistcells.cc:537
 hmdclistcells.cc:538
 hmdclistcells.cc:539
 hmdclistcells.cc:540
 hmdclistcells.cc:541
 hmdclistcells.cc:542
 hmdclistcells.cc:543
 hmdclistcells.cc:544
 hmdclistcells.cc:545
 hmdclistcells.cc:546
 hmdclistcells.cc:547
 hmdclistcells.cc:548
 hmdclistcells.cc:549
 hmdclistcells.cc:550
 hmdclistcells.cc:551
 hmdclistcells.cc:552
 hmdclistcells.cc:553
 hmdclistcells.cc:554
 hmdclistcells.cc:555
 hmdclistcells.cc:556
 hmdclistcells.cc:557
 hmdclistcells.cc:558
 hmdclistcells.cc:559
 hmdclistcells.cc:560
 hmdclistcells.cc:561
 hmdclistcells.cc:562
 hmdclistcells.cc:563
 hmdclistcells.cc:564
 hmdclistcells.cc:565
 hmdclistcells.cc:566
 hmdclistcells.cc:567
 hmdclistcells.cc:568
 hmdclistcells.cc:569
 hmdclistcells.cc:570
 hmdclistcells.cc:571
 hmdclistcells.cc:572
 hmdclistcells.cc:573
 hmdclistcells.cc:574
 hmdclistcells.cc:575
 hmdclistcells.cc:576
 hmdclistcells.cc:577
 hmdclistcells.cc:578
 hmdclistcells.cc:579
 hmdclistcells.cc:580
 hmdclistcells.cc:581
 hmdclistcells.cc:582
 hmdclistcells.cc:583
 hmdclistcells.cc:584
 hmdclistcells.cc:585
 hmdclistcells.cc:586
 hmdclistcells.cc:587
 hmdclistcells.cc:588
 hmdclistcells.cc:589
 hmdclistcells.cc:590
 hmdclistcells.cc:591
 hmdclistcells.cc:592
 hmdclistcells.cc:593
 hmdclistcells.cc:594
 hmdclistcells.cc:595
 hmdclistcells.cc:596
 hmdclistcells.cc:597
 hmdclistcells.cc:598
 hmdclistcells.cc:599
 hmdclistcells.cc:600
 hmdclistcells.cc:601
 hmdclistcells.cc:602
 hmdclistcells.cc:603
 hmdclistcells.cc:604
 hmdclistcells.cc:605
 hmdclistcells.cc:606
 hmdclistcells.cc:607
 hmdclistcells.cc:608
 hmdclistcells.cc:609
 hmdclistcells.cc:610
 hmdclistcells.cc:611
 hmdclistcells.cc:612
 hmdclistcells.cc:613
 hmdclistcells.cc:614
 hmdclistcells.cc:615
 hmdclistcells.cc:616
 hmdclistcells.cc:617
 hmdclistcells.cc:618
 hmdclistcells.cc:619
 hmdclistcells.cc:620
 hmdclistcells.cc:621
 hmdclistcells.cc:622
 hmdclistcells.cc:623
 hmdclistcells.cc:624
 hmdclistcells.cc:625
 hmdclistcells.cc:626
 hmdclistcells.cc:627
 hmdclistcells.cc:628
 hmdclistcells.cc:629
 hmdclistcells.cc:630
 hmdclistcells.cc:631
 hmdclistcells.cc:632
 hmdclistcells.cc:633
 hmdclistcells.cc:634
 hmdclistcells.cc:635
 hmdclistcells.cc:636
 hmdclistcells.cc:637
 hmdclistcells.cc:638
 hmdclistcells.cc:639
 hmdclistcells.cc:640
 hmdclistcells.cc:641
 hmdclistcells.cc:642
 hmdclistcells.cc:643
 hmdclistcells.cc:644
 hmdclistcells.cc:645
 hmdclistcells.cc:646
 hmdclistcells.cc:647
 hmdclistcells.cc:648
 hmdclistcells.cc:649
 hmdclistcells.cc:650
 hmdclistcells.cc:651
 hmdclistcells.cc:652
 hmdclistcells.cc:653
 hmdclistcells.cc:654
 hmdclistcells.cc:655
 hmdclistcells.cc:656
 hmdclistcells.cc:657
 hmdclistcells.cc:658
 hmdclistcells.cc:659
 hmdclistcells.cc:660
 hmdclistcells.cc:661
 hmdclistcells.cc:662
 hmdclistcells.cc:663
 hmdclistcells.cc:664
 hmdclistcells.cc:665
 hmdclistcells.cc:666
 hmdclistcells.cc:667
 hmdclistcells.cc:668
 hmdclistcells.cc:669
 hmdclistcells.cc:670
 hmdclistcells.cc:671
 hmdclistcells.cc:672
 hmdclistcells.cc:673
 hmdclistcells.cc:674
 hmdclistcells.cc:675
 hmdclistcells.cc:676
 hmdclistcells.cc:677
 hmdclistcells.cc:678
 hmdclistcells.cc:679
 hmdclistcells.cc:680
 hmdclistcells.cc:681
 hmdclistcells.cc:682
 hmdclistcells.cc:683
 hmdclistcells.cc:684
 hmdclistcells.cc:685
 hmdclistcells.cc:686
 hmdclistcells.cc:687
 hmdclistcells.cc:688
 hmdclistcells.cc:689
 hmdclistcells.cc:690
 hmdclistcells.cc:691
 hmdclistcells.cc:692
 hmdclistcells.cc:693
 hmdclistcells.cc:694
 hmdclistcells.cc:695
 hmdclistcells.cc:696
 hmdclistcells.cc:697
 hmdclistcells.cc:698
 hmdclistcells.cc:699
 hmdclistcells.cc:700
 hmdclistcells.cc:701
 hmdclistcells.cc:702
 hmdclistcells.cc:703
 hmdclistcells.cc:704
 hmdclistcells.cc:705
 hmdclistcells.cc:706
 hmdclistcells.cc:707
 hmdclistcells.cc:708
 hmdclistcells.cc:709
 hmdclistcells.cc:710
 hmdclistcells.cc:711
 hmdclistcells.cc:712
 hmdclistcells.cc:713
 hmdclistcells.cc:714
 hmdclistcells.cc:715
 hmdclistcells.cc:716
 hmdclistcells.cc:717
 hmdclistcells.cc:718
 hmdclistcells.cc:719
 hmdclistcells.cc:720
 hmdclistcells.cc:721
 hmdclistcells.cc:722
 hmdclistcells.cc:723
 hmdclistcells.cc:724
 hmdclistcells.cc:725
 hmdclistcells.cc:726
 hmdclistcells.cc:727
 hmdclistcells.cc:728
 hmdclistcells.cc:729
 hmdclistcells.cc:730
 hmdclistcells.cc:731
 hmdclistcells.cc:732
 hmdclistcells.cc:733
 hmdclistcells.cc:734
 hmdclistcells.cc:735
 hmdclistcells.cc:736
 hmdclistcells.cc:737
 hmdclistcells.cc:738
 hmdclistcells.cc:739
 hmdclistcells.cc:740
 hmdclistcells.cc:741
 hmdclistcells.cc:742
 hmdclistcells.cc:743
 hmdclistcells.cc:744
 hmdclistcells.cc:745
 hmdclistcells.cc:746
 hmdclistcells.cc:747
 hmdclistcells.cc:748
 hmdclistcells.cc:749
 hmdclistcells.cc:750
 hmdclistcells.cc:751
 hmdclistcells.cc:752
 hmdclistcells.cc:753
 hmdclistcells.cc:754
 hmdclistcells.cc:755
 hmdclistcells.cc:756
 hmdclistcells.cc:757
 hmdclistcells.cc:758
 hmdclistcells.cc:759
 hmdclistcells.cc:760
 hmdclistcells.cc:761
 hmdclistcells.cc:762
 hmdclistcells.cc:763
 hmdclistcells.cc:764
 hmdclistcells.cc:765
 hmdclistcells.cc:766
 hmdclistcells.cc:767
 hmdclistcells.cc:768
 hmdclistcells.cc:769
 hmdclistcells.cc:770
 hmdclistcells.cc:771
 hmdclistcells.cc:772
 hmdclistcells.cc:773
 hmdclistcells.cc:774
 hmdclistcells.cc:775
 hmdclistcells.cc:776
 hmdclistcells.cc:777
 hmdclistcells.cc:778
 hmdclistcells.cc:779
 hmdclistcells.cc:780
 hmdclistcells.cc:781
 hmdclistcells.cc:782
 hmdclistcells.cc:783
 hmdclistcells.cc:784
 hmdclistcells.cc:785
 hmdclistcells.cc:786
 hmdclistcells.cc:787
 hmdclistcells.cc:788
 hmdclistcells.cc:789
 hmdclistcells.cc:790
 hmdclistcells.cc:791
 hmdclistcells.cc:792
 hmdclistcells.cc:793
 hmdclistcells.cc:794
 hmdclistcells.cc:795
 hmdclistcells.cc:796
 hmdclistcells.cc:797
 hmdclistcells.cc:798
 hmdclistcells.cc:799
 hmdclistcells.cc:800
 hmdclistcells.cc:801
 hmdclistcells.cc:802
 hmdclistcells.cc:803
 hmdclistcells.cc:804
 hmdclistcells.cc:805
 hmdclistcells.cc:806
 hmdclistcells.cc:807
 hmdclistcells.cc:808
 hmdclistcells.cc:809
 hmdclistcells.cc:810
 hmdclistcells.cc:811
 hmdclistcells.cc:812
 hmdclistcells.cc:813
 hmdclistcells.cc:814
 hmdclistcells.cc:815
 hmdclistcells.cc:816
 hmdclistcells.cc:817
 hmdclistcells.cc:818
 hmdclistcells.cc:819
 hmdclistcells.cc:820
 hmdclistcells.cc:821
 hmdclistcells.cc:822
 hmdclistcells.cc:823
 hmdclistcells.cc:824
 hmdclistcells.cc:825
 hmdclistcells.cc:826
 hmdclistcells.cc:827
 hmdclistcells.cc:828
 hmdclistcells.cc:829
 hmdclistcells.cc:830
 hmdclistcells.cc:831
 hmdclistcells.cc:832
 hmdclistcells.cc:833
 hmdclistcells.cc:834
 hmdclistcells.cc:835
 hmdclistcells.cc:836
 hmdclistcells.cc:837
 hmdclistcells.cc:838
 hmdclistcells.cc:839
 hmdclistcells.cc:840
 hmdclistcells.cc:841
 hmdclistcells.cc:842
 hmdclistcells.cc:843
 hmdclistcells.cc:844
 hmdclistcells.cc:845
 hmdclistcells.cc:846
 hmdclistcells.cc:847
 hmdclistcells.cc:848
 hmdclistcells.cc:849
 hmdclistcells.cc:850
 hmdclistcells.cc:851
 hmdclistcells.cc:852
 hmdclistcells.cc:853
 hmdclistcells.cc:854
 hmdclistcells.cc:855
 hmdclistcells.cc:856
 hmdclistcells.cc:857
 hmdclistcells.cc:858
 hmdclistcells.cc:859
 hmdclistcells.cc:860
 hmdclistcells.cc:861
 hmdclistcells.cc:862
 hmdclistcells.cc:863
 hmdclistcells.cc:864
 hmdclistcells.cc:865
 hmdclistcells.cc:866
 hmdclistcells.cc:867
 hmdclistcells.cc:868
 hmdclistcells.cc:869
 hmdclistcells.cc:870
 hmdclistcells.cc:871
 hmdclistcells.cc:872
 hmdclistcells.cc:873
 hmdclistcells.cc:874
 hmdclistcells.cc:875
 hmdclistcells.cc:876
 hmdclistcells.cc:877
 hmdclistcells.cc:878
 hmdclistcells.cc:879
 hmdclistcells.cc:880
 hmdclistcells.cc:881
 hmdclistcells.cc:882
 hmdclistcells.cc:883
 hmdclistcells.cc:884
 hmdclistcells.cc:885
 hmdclistcells.cc:886
 hmdclistcells.cc:887
 hmdclistcells.cc:888
 hmdclistcells.cc:889
 hmdclistcells.cc:890
 hmdclistcells.cc:891
 hmdclistcells.cc:892
 hmdclistcells.cc:893
 hmdclistcells.cc:894
 hmdclistcells.cc:895
 hmdclistcells.cc:896
 hmdclistcells.cc:897
 hmdclistcells.cc:898
 hmdclistcells.cc:899
 hmdclistcells.cc:900
 hmdclistcells.cc:901
 hmdclistcells.cc:902
 hmdclistcells.cc:903
 hmdclistcells.cc:904
 hmdclistcells.cc:905
 hmdclistcells.cc:906
 hmdclistcells.cc:907
 hmdclistcells.cc:908
 hmdclistcells.cc:909
 hmdclistcells.cc:910
 hmdclistcells.cc:911
 hmdclistcells.cc:912
 hmdclistcells.cc:913
 hmdclistcells.cc:914
 hmdclistcells.cc:915
 hmdclistcells.cc:916
 hmdclistcells.cc:917
 hmdclistcells.cc:918
 hmdclistcells.cc:919
 hmdclistcells.cc:920
 hmdclistcells.cc:921
 hmdclistcells.cc:922
 hmdclistcells.cc:923
 hmdclistcells.cc:924
 hmdclistcells.cc:925
 hmdclistcells.cc:926
 hmdclistcells.cc:927
 hmdclistcells.cc:928
 hmdclistcells.cc:929
 hmdclistcells.cc:930
 hmdclistcells.cc:931
 hmdclistcells.cc:932
 hmdclistcells.cc:933
 hmdclistcells.cc:934
 hmdclistcells.cc:935
 hmdclistcells.cc:936
 hmdclistcells.cc:937
 hmdclistcells.cc:938
 hmdclistcells.cc:939
 hmdclistcells.cc:940
 hmdclistcells.cc:941
 hmdclistcells.cc:942
 hmdclistcells.cc:943
 hmdclistcells.cc:944
 hmdclistcells.cc:945
 hmdclistcells.cc:946
 hmdclistcells.cc:947
 hmdclistcells.cc:948