DemuxFast.cxx

Go to the documentation of this file.

using namespace std;
#include "DemuxFast.h"
#include "MyDemuxPatternMaster.h"

#include <cstdio>
#include <vector>
// MINOS includes
#include "MessageService/MsgService.h"     // MSG text output
#include "MinosObjectMap/MomNavigator.h"   // Data access
#include "CandData/CandRecord.h"           // DigitList handling
#include "CandDigit/CandDigitListHandle.h" // "                "
#include "CandDigit/CandDigitHandle.h"     // "                "
#include "CandDigit/CandDeMuxDigitListHandle.h" // "                "
#include "CandDigit/CandDeMuxDigitHandle.h"     // "                "
#include "JobControl/JobCommand.h"         // JobCommand handling
#include "JobControl/JobCModuleRegistry.h" // JOBMODULE registration macro
#include "DataUtil/GetCandidate.h"
#include "Validity/VldContext.h"
#include "Plex/PlexPlaneId.h"
#include "RawData/RawRecord.h"
#include "RawData/RawDaqSnarlHeader.h"

// extra includes - SR modules
#include "CandStripSR/CandStripSRHandle.h"
#include "CandStripSR/CandStripSRListHandle.h"

// extra includes - getting truth
#include "MINF_Classes/MINFast.h"
#include "REROOT_Classes/REROOT_NeuKin.h"
#include "REROOT_Classes/REROOT_NeuVtx.h"
#include "REROOT_Classes/REROOT_FLSHit.h"

// other stuff
#include "TFile.h"
#include "TPolyMarker.h"

CVSID("$Id: DemuxFast.cxx,v 1.4 2004/03/11 17:07:12 rhatcher Exp $");

JOBMODULE(DemuxFast,"DemuxFast","MC Cheese Module/n");

ClassImp(DemuxFast);

DemuxFast::DemuxFast() 
  //:  fCanvas(" ","DemuxFast",800,800)
{
  pMaster = new MyDemuxPatternMaster();
 
  _vaChip0[0] = -1;
  _vaChip0[1] = -1;
  _vaChip0[2] = 14;
  _vaChip0[3] =  0;
  _vaChip0[4] = 15;
  _vaChip0[5] =  1;
  _vaChip0[6] = 10;
  _vaChip0[7] =  4;
  _vaChip0[8] = 11;
  _vaChip0[9] =  5;
  _vaChip0[10] =  6;
  _vaChip0[11] =  8;
  _vaChip0[12] =  7;
  _vaChip0[13] =  9;
  _vaChip0[14] =  2;
  _vaChip0[15] = 13;
  _vaChip0[16] =  3;
  _vaChip0[17] =  12;

  for(int i=0;i<500;i++){
    if(i<249)_UVmap[i] = (i%2)+1;
    if(i>249)_UVmap[i] = ((i+1)%2)+1;
    if(i==249)_UVmap[i] = 0;
  }


}

void DemuxFast::BeginJob()
{
}

JobCResult DemuxFast::Reco(MomNavigator *mom) 
{
  int ndigits=0;

  for(int i=0; i<500;i++){
    PlanesAltListsE[i].erase(PlanesAltListsE[i].begin(),PlanesAltListsE[i].end());
    PlanesAltListsW[i].erase(PlanesAltListsW[i].begin(),PlanesAltListsW[i].end());
    planehit[i] = 0;
    goldplanehit[i] = 0;
    _goldGuide[i] = 0;
    _qTotE[i] = 0;
    _qTotW[i] = 0;
    _qMaxE[i] = 0;
    _qMaxW[i] = 0;
  }


  PlexSEIdAltL altlist;
  PlexSEIdAltL* paltlist;

// Find PrimaryCandidateRecord fragment in MOM.
    CandRecord* candrecord = dynamic_cast<CandRecord*>(mom->GetFragment("CandRecord","PrimaryCandidateRecord"));

  if (candrecord == 0) {
    MSG("DemuxFast", Msg::kWarning) << "No PrimaryCandidateRecord in MOM."
                                                                << endl;
    return JobCResult::kError;
  }

  int run;
  int snarl;

  TObject* obj;
  for (int i=0; (obj=mom->At(i)); ++i) {
    const RawRecord* rr = dynamic_cast<RawRecord*>(obj);
    if (rr) {
      const RawDaqSnarlHeader* 
        rdsh = dynamic_cast<const RawDaqSnarlHeader*>(rr->GetRawHeader());
      if (rdsh) {
        run   = rdsh->GetRun();
        snarl = rdsh->GetSnarl();
      }
    }
  }
  
  MSG("DmxFast",Msg::kInfo) << " Run : " << run << " Snarl : " << snarl << endl;


  // Find PrimaryCandidateRecord fragment in MOM.
  const CandDigitListHandle *canddigit = 
      DataUtil::GetCandidate<CandDigitListHandle>(mom,
                                                  "CandDigitListHandle", 
                                                  "canddigitlist");
  MSG("DmxFast",Msg::kDebug) << " *** DemuxFast::Ana CandDigit*** " <<canddigit << endl; 
  
  if (canddigit == 0) {
    MSG("DemuxFast",Msg::kWarning) << "Failed to get CandDigitListHandle!\n";
    return JobCResult::kFailed;
  }


  CandDigitHandleItr cdhItr(canddigit->GetDaughterIterator());

  while ( CandDigitHandle *cdh = cdhItr() ) {
    // for each digit
    paltlist = const_cast<PlexSEIdAltL*>(&(cdh->GetPlexSEIdAltL()));
    int iplane = paltlist->GetPlane();
    if(paltlist->IsVetoShield())MSG("DmxFast",Msg::kInfo) << " IS VETO SHIELD " << iplane << endl;
    if(iplane>0&&iplane<500){
      int pixel =  _vaChip0[cdh->GetChannelId().GetVaChannel()];
      if(paltlist->GetEnd()==StripEnd::kEast){
        pixelE[iplane][cdh->GetChannelId().GetVaChip()][pixel] += cdh->GetCharge();
      }else{
        //PlanesAltListsW[iplane].push_back(paltlist);
        pixelW[iplane][cdh->GetChannelId().GetVaChip()][pixel] += cdh->GetCharge();
      }
      ndigits++;
    }
  }

  
  CandDigitHandleItr cdhIt(canddigit->GetDaughterIterator());
  while ( CandDigitHandle *cdh = cdhIt() ) {
    // for each digit
    paltlist = const_cast<PlexSEIdAltL*>(&(cdh->GetPlexSEIdAltL()));
    int iplane = paltlist->GetPlane();
    if(iplane>0&&iplane<500){
      float crossTalk;
      int pixel =  _vaChip0[cdh->GetChannelId().GetVaChannel()];
      int va    =  cdh->GetChannelId().GetVaChip();
      if(paltlist->GetEnd()==StripEnd::kEast){
        crossTalk = this->IsItXTalk(0,iplane,va,pixel);
        if(crossTalk<10.*cdh->GetCharge()){
          PlanesAltListsE[iplane].push_back(paltlist);
          paltlist->SetFirst();
          _qTotE[iplane] += paltlist->GetCurrentItem().GetPE();
          if(paltlist->GetCurrentItem().GetPE()>_qMaxE[iplane])_qMaxE[iplane]=
                 paltlist->GetCurrentItem().GetPE();
        }
      }else{
        crossTalk = this->IsItXTalk(1,iplane,va,pixel);
        if(crossTalk<10.*cdh->GetCharge()){
          PlanesAltListsW[iplane].push_back(paltlist);
          paltlist->SetFirst();
          _qTotW[iplane] += paltlist->GetCurrentItem().GetPE();
          if(paltlist->GetCurrentItem().GetPE()>_qMaxW[iplane])_qMaxW[iplane]=
                  paltlist->GetCurrentItem().GetPE();
        }
      }
      if(crossTalk>10.*cdh->GetCharge())MSG("DmxFast",Msg::kDebug) << "Plane : " << iplane << " : " << cdh->GetCharge() << " cf " <<  crossTalk << endl;
    }
  }
  

  for(int i=0; i<500; i++){
    if(PlanesAltListsE[i].size()>0){
      for(int j=0;j<16;j++){
        pixelE[i][0][j]=0;
        pixelE[i][1][j]=0;
        pixelE[i][2][j]=0;
      }
    }
    if(PlanesAltListsE[i].size()>0){
      for(int j=0;j<16;j++){
        pixelW[i][0][j]=0;
        pixelW[i][1][j]=0;
        pixelW[i][2][j]=0;
      }
    }
  }


  _cutRatioLow    = 0.2;
  _cutRatioHigh   = 5.0;
  _cutPEmin       = 2.0;
  _cutFractionMin = 0.05;
  _cutSigmaQ      = 0.0;
  _cutTrackTargetQ=20.0;


  _rangeWindow = 4;
  for(int i=0; i<500; i++){
    if(PlanesAltListsE[i].size()&&PlanesAltListsW[i].size()){
      MSG("DmxFast",Msg::kDebug) << i << " : " << PlanesAltListsE[i].size() << " : " << PlanesAltListsW[i].size() << endl;
      this->ResetMap(PlanesAltListsE[i].size(),PlanesAltListsW[i].size());
      this->MakeMap(i);
      //  this->PrintMap(ecount,wcount);
      this->GroupHits(ecount,wcount);
      this->SelectHits(true);
    }
  }
  this->MakeGoldGuide();



  MSG("DmxFast",Msg::kDebug) << "**************************************" << endl;
  MSG("DmxFast",Msg::kDebug) << "*                                    *" << endl;
  MSG("DmxFast",Msg::kDebug) << "*          Finished Loop 0           *" << endl;
  MSG("DmxFast",Msg::kDebug) << "*                                    *" << endl;
  MSG("DmxFast",Msg::kDebug) << "**************************************" << endl;



  NdemuxedHits=NdemuxedHitsU = NdemuxedHitsV = 0;
  demuxedHitPlane.clear();
  demuxedHitStrip.clear();

  _cutRatioLow    = 0.2;
  _cutRatioHigh   = 5.0;
  _cutPEmin       = 4.0;
  _cutFractionMin = 0.1;
  _cutSigmaQ      = 3.0;
  _rangeWindow = 4;


  for(int i=0; i<500; i++){
    if(PlanesAltListsE[i].size()&&PlanesAltListsW[i].size()){
      MSG("DmxFast",Msg::kDebug) << i << " : " << PlanesAltListsE[i].size() << " : " << PlanesAltListsW[i].size() << endl;
      this->ResetMap(PlanesAltListsE[i].size(),PlanesAltListsW[i].size());
      this->MakeMap(i);
      //  this->PrintMap(ecount,wcount);
      this->GroupHits(ecount,wcount);
      this->SelectHits(false,true);
    }
  }

  MSG("DmxFast",Msg::kDebug) << "**************************************" << endl;
  MSG("DmxFast",Msg::kDebug) << "*                                    *" << endl;
  MSG("DmxFast",Msg::kDebug) << "*          Finished Loop 1a           *" << endl;
  MSG("DmxFast",Msg::kDebug) << "*                                    *" << endl;
  MSG("DmxFast",Msg::kDebug) << "**************************************" << endl;

  MSG("DmxFast",Msg::kDebug) << " N : " << NdemuxedHits  << endl;

  _cutFractionMin = 0.25;

  if(NdemuxedHitsU==0){
    for(int i=0; i<500; i++){
      if(_UVmap[i]==1){
        if(PlanesAltListsE[i].size()&&PlanesAltListsW[i].size()){
          MSG("DmxFast",Msg::kDebug) << i << " : " << PlanesAltListsE[i].size() << " : " << PlanesAltListsW[i].size() << endl;
          this->ResetMap(PlanesAltListsE[i].size(),PlanesAltListsW[i].size());
          this->MakeMap(i);
          //  this->PrintMap(ecount,wcount);
          this->GroupHits(ecount,wcount);
          this->SelectHits(false,false);
        }
      }
    }
  }


  if(NdemuxedHitsV==0){
    for(int i=0; i<500; i++){
      if(_UVmap[i]==2){
        if(PlanesAltListsE[i].size()&&PlanesAltListsW[i].size()){
          MSG("DmxFast",Msg::kDebug) << i << " : " << PlanesAltListsE[i].size() << " : " << PlanesAltListsW[i].size() << endl;
          this->ResetMap(PlanesAltListsE[i].size(),PlanesAltListsW[i].size());
          this->MakeMap(i);
          //  this->PrintMap(ecount,wcount);
          this->GroupHits(ecount,wcount);
          this->SelectHits(false,false);
        }
      }
    }
  }

  
  MSG("DmxFast",Msg::kDebug) << "**************************************" << endl;
  MSG("DmxFast",Msg::kDebug) << "*                                    *" << endl;
  MSG("DmxFast",Msg::kDebug) << "*          Finished Loop 1b           *" << endl;
  MSG("DmxFast",Msg::kDebug) << "*                                    *" << endl;
  MSG("DmxFast",Msg::kDebug) << "**************************************" << endl;

  // Now use hitmap to fill in gaps.

  _cutRatioLow    = 0.1;
  _cutRatioHigh   =10.0;
  _cutPEmin       = 2.0;
  _cutFractionMin = 0.05;
  _cutSigmaQ      = 5.0;
  _rangeWindow    = 100;

  this->MakeSearchTactics();

  vector <DemuxSearchTactic>::iterator literS;
  vector <DemuxSearchTactic>::iterator literSE;

  for(unsigned int i=0; i<searchTactics.size(); i++){
    int plane = searchTactics[i].iplane;
    if(searchTactics[i].goodTactic){
      this->ResetMap(PlanesAltListsE[plane].size(),PlanesAltListsW[plane].size());
      this->MakeMap(searchTactics[i]);
      this->GroupHits(ecount,wcount);
      if(this->SelectHits(false)){
        MSG("DmxFast",Msg::kDebug) << " OK go and make a new tactic " << endl;
        this->NewTactic(searchTactics[i]);
      }
    }else{
      this->NewTactic(searchTactics[i]);
    }
    literS++;
  }

  literS  = searchTactics.begin();
  literSE = searchTactics.end();

  MSG("DmxFast",Msg::kDebug) << "**************************************" << endl;
  MSG("DmxFast",Msg::kDebug) << "*                                    *" << endl;
  MSG("DmxFast",Msg::kDebug) << "*          Finished Loop 2           *" << endl;
  MSG("DmxFast",Msg::kDebug) << "*                                    *" << endl;
  MSG("DmxFast",Msg::kDebug) << "**************************************" << endl;

  this->MakeSearchTacticsX();
  // MSG("DmxFast",Msg::kDebug) << " Number of Search Tactics : " << searchTactics.size() << endl;

  for(unsigned int i=0; i<searchTactics.size(); i++){
    int plane = searchTactics[i].iplane;
    if(searchTactics[i].goodTactic){
      this->ResetMap(PlanesAltListsE[plane].size(),PlanesAltListsW[plane].size());
      this->MakeMap(searchTactics[i]);
      // this->PrintMap(ecount,wcount);
      this->GroupHits(ecount,wcount);
      this->NewTactic( searchTactics[i] );
    }
    this->NewTactic( searchTactics[i] );
  }

  MSG("DmxFast",Msg::kDebug) << "**************************************" << endl;
  MSG("DmxFast",Msg::kDebug) << "*                                    *" << endl;
  MSG("DmxFast",Msg::kDebug) << "*          Finished Loop 3           *" << endl;
  MSG("DmxFast",Msg::kDebug) << "*                                    *" << endl;
  MSG("DmxFast",Msg::kDebug) << "**************************************" << endl;

  //this->PrintWhatRemains();
  // Time to mop up crap 

  this->MakeSearchTacticsY();
  // MSG("DmxFast",Msg::kDebug) << " Number of Singles Search Tactics : " << searchTactics.size() << endl;

  literS = searchTactics.begin();
  while(literS!=searchTactics.end()){
    if((*literS).goodTactic){
      this->DemuxSingles((*literS));
    }
    literS++;
  }

  MSG("DmxFast",Msg::kDebug) << "**************************************" << endl;
  MSG("DmxFast",Msg::kDebug) << "*                                    *" << endl;
  MSG("DmxFast",Msg::kDebug) << "*          Finished Loop 4           *" << endl;
  MSG("DmxFast",Msg::kDebug) << "*                                    *" << endl;
  MSG("DmxFast",Msg::kDebug) << "**************************************" << endl;

  JobCResult result = JobCResult::kAOK;

  // NJT
  // Attempt to save the data.
  // Get the DeMuxDigitList.

  // Actually, this code is redundant, now that I fixed the 
  // bug elsewhere.
  /*
  cout << "Getting DeMuxDigitListHandle.\n";
  
  // Find PrimaryCandidateRecord fragment in MOM.
  CandRecord *candrec = dynamic_cast<CandRecord *>
    (mom->GetFragment("CandRecord", "PrimaryCandidateRecord"));
  if (candrec == 0) {
    result.SetError().SetFailed();
    return result;
  }

  CandDigitListHandle *crdlh = dynamic_cast<CandDigitListHandle *>
    (candrec->FindCandHandle("CandDigitListHandle", "canddigitlist"));
  if (crdlh == 0) {
    result.SetError().SetFailed();
    MSG("DmxFast",Msg::kError) << "Couldn't get CandDigitListHandle.\n";
    return result;
  }
  cout << "Doing saving.\n";

  // Build a big map of the reults.
  typedef std::multimap<int,int> resMap_t;
  resMap_t resMap;

  for(int i=0;i<NdemuxedHits;i++){
    resMap.insert(pair<int,int>(demuxedHitPlane[i],demuxedHitStrip[i]));
  }
    
  CandDigitHandleItr cdhItr3(crdlh->GetDaughterIterator());
  while ( CandDigitHandle *cdh = cdhItr3() ) {
    // for each digit
    PlexSEIdAltL& altlist = (cdh->GetPlexSEIdAltLWritable());
    int iplane = altlist.GetPlane();
    // find the list of strips for this plane.
    pair<resMap_t::iterator,resMap_t::iterator> range = resMap.equal_range(iplane); 

    // Go through the altlist, assign values.
    altlist.ClearWeights();
    altlist.SetFirst();
    while(altlist.IsValid()) {
      for(resMap_t::iterator it=range.first; it!= range.second; it++) {
        int strip = it->second;
        cout << "Comparing (plane " << iplane << "): " << strip << "  " << altlist.GetCurrentSEId().GetStrip() << endl;
        if(altlist.GetCurrentSEId().GetStrip() == strip){
          altlist.SetCurrentWeight(99.0);
        }
      }
      altlist.Next();
    }
  }
  */
  return result;
}


JobCResult DemuxFast::Ana(const MomNavigator* )
{
  MSG("DmxFast",Msg::kDebug) <<  " *** DemuxFast::Ana *** " << endl;
  return JobCResult::kAOK;
}

void DemuxFast::PrintMap(int ne, int nw){
  

  MSG("DmxFast",Msg::kDebug) << "Print Map " << ne << " : " << nw << endl;
  for(int ie=0;ie<=ne;ie++){
    for(int iw=0;iw<=nw;iw++){
      MSG("DmxFast",Msg::kDebug) << _amap[ie][iw];
    }
    MSG("DmxFast",Msg::kDebug) << endl;
  }

  return;
} 



void DemuxFast::ResetMap(int ne, int nw){
  
  // MSG("DmxFast",Msg::kDebug) << "DemuxFast::ResetMap(" << ne << "," << nw << ")" << endl;
  for(int ie=0;ie<=ne;ie++){
    for(int iw=0;iw<=nw;iw++){
      _amap[ie][iw] = false;
    }
  }

  // MSG("DmxFast",Msg::kDebug) << "DemuxFast::ResetMap done" <<endl;
  return;
} 

void DemuxFast::NewTactic(DemuxSearchTactic oldTactic){
  
  MSG("DmxFast",Msg::kDebug) << "DemuxFast::NewTactic" <<endl;

  bool foundh;
  bool foundl;
  bool found;
  DemuxSearchTactic newTactic;

  switch(oldTactic.searchType){
  case SEARCH_GAP:

    break;
  case SEARCH_GAP_B:
    MSG("DmxFast",Msg::kDebug) << " SEARCH_GAP_B : do something" << endl;
    found = false;
    MSG("DmxFast",Msg::kDebug) << " Old : " << oldTactic.lowplane << ":"
           << oldTactic.iplane << ":" << oldTactic.highplane << endl;
    for(int i=oldTactic.highplane-2;i>=oldTactic.iplane+2&&found==false;i-=2){
      if(!_searched[i]&&PlanesAltListsE[i].size()&&PlanesAltListsW[i].size()){
        MSG("DmxFast",Msg::kDebug) << "Make New Tactic for Plane " << i << endl;
        found = true;
        newTactic.iplane = i;
        newTactic.goodTactic = true;
        newTactic.lowplane = oldTactic.lowplane;
        newTactic.highplane = oldTactic.iplane;
        newTactic.searchType = SEARCH_GAP_F;
      }
    }
    if(found){
      MSG("DmxFast",Msg::kDebug) <<"Inserting new tactic : " << newTactic.lowplane << ":"
           << newTactic.iplane << ":" << newTactic.highplane << endl;
      searchTactics.push_back(newTactic);
      _searched[newTactic.iplane] = true;
    }
    break;
  case SEARCH_GAP_F:
    MSG("DmxFast",Msg::kDebug) << " SEARCH_GAP_F : do something" << endl;
    found = false;
    for(int i=oldTactic.iplane+2;i<=oldTactic.highplane-2&&found==false;i+=2){
      if(!_searched[i]&&PlanesAltListsE[i].size()&&PlanesAltListsW[i].size()){
        MSG("DmxFast",Msg::kDebug) << "Make New Tactic for Plane " << i << endl;
        found = true;
        newTactic.iplane = i;
        newTactic.goodTactic = true;
        newTactic.lowplane = oldTactic.iplane;
        newTactic.highplane = oldTactic.highplane;
        newTactic.searchType = SEARCH_GAP_F;
      }
    }
    if(found){
      MSG("DmxFast",Msg::kDebug) <<"Inserting new tactic : " << newTactic.lowplane<<":"    << newTactic.iplane << ":" << newTactic.highplane << endl;
      searchTactics.push_back(newTactic);
      _searched[newTactic.iplane] = true;
    }
    break;
  case SEARCH_FORWARDS:
    foundh = false;
    foundl = false;
    if(oldTactic.goodTactic){
      MSG("DmxFast",Msg::kDebug) << "Continuing forwards search " << endl;
      for(int i=oldTactic.iplane+2;i<500&&foundh==false;i+=2){
        if(PlanesAltListsE[i].size()&&PlanesAltListsW[i].size()){
          MSG("DmxFast",Msg::kDebug) << "Make Tactic for Plane " << i << endl;
          foundh = true;
          newTactic.iplane = i;
          newTactic.goodTactic = true;
          newTactic.highplane = oldTactic.iplane;
          newTactic.lowplane = oldTactic.highplane;
          newTactic.searchType = SEARCH_FORWARDS;
        }
      }
    }else{
      MSG("DmxFast",Msg::kDebug) << "Starting forwards search " << endl;
      for(int i=oldTactic.iplane+2;i<500&&foundh==false;i+=2){
        if(PlanesAltListsE[i].size()&&PlanesAltListsW[i].size()){
          MSG("DmxFast",Msg::kDebug) << "Make Tactic for Plane " << i << endl;
          foundh = true;
          newTactic.highplane = oldTactic.iplane;
          newTactic.iplane = i; 
          newTactic.goodTactic = true;
          newTactic.lowplane = -100;
          newTactic.searchType = SEARCH_FORWARDS;
        }
      }
      for(int i=oldTactic.iplane-2;i>oldTactic.iplane-12&&foundl==false;i-=2){
        if(planehit[i]>0){
          foundl = true;
          newTactic.lowplane = i;
        }
      }
    }
    if(foundh){
      MSG("DmxFast",Msg::kDebug) <<"Inserting new tactic : " << newTactic.lowplane << ":"
           << newTactic.iplane << ":" << newTactic.highplane << endl;
      searchTactics.push_back(newTactic);
    }
    break;
  case SEARCH_BACKWARDS:
    foundh = false;
    foundl = false;
    if(oldTactic.goodTactic){
      MSG("DmxFast",Msg::kDebug) << "Continuing backwards search " << endl;
      for(int i=oldTactic.iplane-2;i>0&&foundl==false;i-=2){
        if(PlanesAltListsE[i].size()&&PlanesAltListsW[i].size()){
          MSG("DmxFast",Msg::kDebug) << "Make Tactic for Plane " << i << endl;
          foundl = true;
          newTactic.iplane = i;
          newTactic.lowplane = oldTactic.iplane;
          newTactic.goodTactic = true;
          newTactic.highplane = oldTactic.lowplane;
          newTactic.searchType = SEARCH_BACKWARDS;
        }
      }
    }else{
      MSG("DmxFast",Msg::kDebug) << "Starting backwards search " << endl;
      for(int i=oldTactic.iplane-2;i>0&&foundl==false;i-=2){
        if(PlanesAltListsE[i].size()&&PlanesAltListsW[i].size()){
          MSG("DmxFast",Msg::kDebug) << "Make Tactic for Plane " << i << endl;
          foundl = true;
          newTactic.lowplane = oldTactic.iplane;
          newTactic.iplane = i; 
          newTactic.goodTactic = true;
          newTactic.highplane = -100;
          newTactic.searchType = SEARCH_BACKWARDS;
        }
      }
      for(int i=oldTactic.iplane+2;i<oldTactic.iplane+12&&foundh==false;i+=2){
        if(planehit[i]>0){
          foundh = true;
          newTactic.highplane = i;
        }
      }
    }
    if(foundl){
      MSG("DmxFast",Msg::kDebug) <<"Inserting new tactic : " << newTactic.lowplane << ":"
           << newTactic.iplane << ":" << newTactic.highplane << endl;
      searchTactics.push_back(newTactic);
    }
    break;
  default:
    break;
  }
  
  return;
} 


void DemuxFast::MakeSearchTactics()
{

  bool ifirstU=false;
  bool ifirstV=false;
  int firstUplane=0;
  int firstVplane=0;
  int lastUplane=0;
  int lastVplane=0;
  int foundPlane=0;


  searchTactics.erase(searchTactics.begin(),searchTactics.end());

  for(int i=0; i<500; i++){
    _searched[i] = false;
    if(planehit[i]>0){
      MSG("DmxFast",Msg::kDebug) << "Found a hit plane " << i << endl;
      if(ifirstU==false){
        if( _UVmap[i]==1){
          ifirstU = true;
          firstUplane = i;
        }
      }
      if(ifirstV==false){
        if( _UVmap[i]==2){
          ifirstV = true;
          firstVplane = i;
        }
      }
      if(_UVmap[i]==1)lastUplane =i;
      if(_UVmap[i]==2)lastVplane =i;

      int inext = i+2;
      if(inext==249)inext=250;
      if(inext==250)inext=251;
      if(planehit[inext]==0){
        MSG("DmxFast",Msg::kDebug) << "Found an empty plane " << inext << endl;
        int j = inext+2;
        bool found = false;
        while(found==false&&j-inext <=24){
          j++;
          if(_UVmap[j]==_UVmap[i]&&planehit[j]>0)found=true;
        }
        if(found){
          MSG("DmxFast",Msg::kDebug) << "Looking in GAP " << i << ":" << j << endl;
          bool lfound = false;
          // Step forward in gap
          for(int k=i+2; k<=j-2; k++){
            if(_UVmap[k]==_UVmap[i]){
              if(!lfound && PlanesAltListsE[k].size()&&PlanesAltListsW[k].size()){
                lfound = true;
                DemuxSearchTactic tactic;
                foundPlane = k;
                tactic.iplane = k;
                tactic.searchType = SEARCH_GAP_F;
                tactic.lowplane  = i;
                tactic.highplane = j;
                tactic.goodTactic = true;
                searchTactics.push_back(tactic);
                _searched[k] = true;
                MSG("DmxFast",Msg::kDebug) << "Inserting F GAP search tactic : " << k<<"("<<i<<"," << j << ")" << endl; 
              }
            }
          }
          // Step backwards in gap
          if(lfound){
            MSG("DmxFast",Msg::kDebug) << " Loop : " << j-2 << ":" << foundPlane+2 << endl;
            bool found = false;
            for(int k=j-2; k>=foundPlane+2; k--){
              if(_UVmap[k]==_UVmap[i]){
                if(!found &&PlanesAltListsE[k].size()&&PlanesAltListsW[k].size()){
                  found = true;
                  DemuxSearchTactic tactic;
                  tactic.iplane = k;
                  tactic.searchType = SEARCH_GAP_B;
                  tactic.lowplane  = i;
                  tactic.highplane = j;
                  tactic.goodTactic = true;
                  searchTactics.push_back(tactic);
                  _searched[k] = true;
                  MSG("DmxFast",Msg::kDebug) << "Inserting B GAP search tactic : " << k<<"("<<i<<"," << j << ")" << endl; 
                }
              }
            }
          } 
        }       
      }
    }
  }
  if(ifirstU){
    DemuxSearchTactic tactic;
    tactic.iplane = firstUplane;
    tactic.lowplane = firstUplane;
    tactic.highplane = firstUplane;
    tactic.searchType = SEARCH_BACKWARDS;
    tactic.goodTactic = false;
    searchTactics.push_back(tactic);


    tactic.iplane = lastUplane;
    tactic.lowplane = lastUplane;
    tactic.highplane = lastUplane;
    tactic.searchType = SEARCH_FORWARDS;
    tactic.goodTactic = false;
    searchTactics.push_back(tactic);
  }

  if(ifirstV){
    DemuxSearchTactic tactic;
    tactic.iplane = firstVplane;
    tactic.lowplane = firstVplane;
    tactic.highplane = firstVplane;
    tactic.searchType = SEARCH_BACKWARDS;
    tactic.goodTactic = false;
    searchTactics.push_back(tactic);

    tactic.iplane = lastVplane;
    tactic.lowplane = lastVplane;
    tactic.highplane = lastVplane;
    tactic.searchType = SEARCH_FORWARDS;
    tactic.goodTactic = false;
    searchTactics.push_back(tactic);
  }
    
  return;
}


void DemuxFast::MakeSearchTacticsX()
{

  searchTactics.erase(searchTactics.begin(),searchTactics.end());
  bool found;

  for(int i=0; i<500; i++){
    if(planehit[i]>0){
      if(PlanesAltListsE[i].size()&&PlanesAltListsW[i].size()){
        int j = -100;
        int k = -100;
        int jj = i-2;
        if(jj==248 || jj==249)jj--;
        int kk = i+2;
        if(kk==249 || kk==250)kk++;
        found = false;
        while(found==false){
          if(planehit[jj]){
            j=jj;
            found = true;
          }
          jj-=2;
          if(jj==248 || jj==249)jj--;
          if(jj<0||jj<i-12)found =true;
        }
        found = false;
        while(found==false){
          if(planehit[kk]){
            k=kk;
            found = true;
          }
          kk+=2;
          if(kk==249 || kk==250)kk++;
          if(kk>499||kk>i+12)found =true;
        }
        DemuxSearchTactic tactic;
        tactic.iplane = i;
        tactic.searchType = SEARCH_GAP;
        tactic.lowplane  = j;
        tactic.highplane = k;
        tactic.goodTactic = true;
        searchTactics.push_back(tactic);
        // MSG("DmxFast",Msg::kDebug) << "Inserting a search tactic : " << k<<"("<<i<<"," << j << ")" << endl; 
      }
    }
  }    
  return;
}


void DemuxFast::MakeSearchTacticsY()
{

  searchTactics.erase(searchTactics.begin(),searchTactics.end());
  bool found;

  for(int i=0; i<500; i++){
    if(PlanesAltListsE[i].size()||PlanesAltListsW[i].size()){
      int j = -100;
      int k = -100;
      int jj = i-2;
      if(jj==248 || jj==249)jj--;
      int kk = i+2;
      if(kk==249 || kk==250)kk++;
      found = false;
      while(found==false){
        if(planehit[jj]){
          j=jj;
          found = true;
        }
        jj-=2;
        if(jj==248 || jj==249)jj--;
        if(jj<0||jj<i-12)found =true;
      }
      found = false;
      while(found==false){
        if(planehit[kk]){
          k=kk;
          found = true;
        }
        kk+=2;
        if(kk==249 || kk==250)kk++;
        if(kk>499||kk>i+12)found =true;
      }
      DemuxSearchTactic tactic;
      tactic.iplane = i;
      tactic.searchType = SEARCH_SINGLES;
      tactic.lowplane  = j;
      tactic.highplane = k;
      tactic.goodTactic = true;
      searchTactics.push_back(tactic);
      // MSG("DmxFast",Msg::kDebug) << "Inserting a search tactic : " << k<<"("<<i<<"," << j << ")" << endl; 
    }
  }    
  return;
}


void DemuxFast::GroupHits(int ecount, int wcount){

  // MSG("DmxFast",Msg::kDebug) << "DemuxFast::GroupHits" << endl;

  for(int iw=0;iw<=wcount; iw++){
    for(int iwp=0;iwp<=wcount; iwp++){
      _bmap[iw][iwp] = false;
    }
  }

  for(int ie =0; ie<=ecount; ie++){
    for(int iw=0;iw<=wcount; iw++){
      if(_amap[ie][iw]){
        for(int iwp =0;iwp<=wcount; iwp++){
          if(_amap[ie][iwp]){
            _bmap[iw][iwp] = true;
            _bmap[iwp][iw] = true;
          }
        }
      }
    }
  }

  // MSG("DmxFast",Msg::kDebug) << "Associator : " << endl;
  for(int iw=0;iw<=wcount; iw++){
    _bmap[iw][iw] = true;
    for(int iwp=0;iwp<=wcount; iwp++){
      if(_bmap[iw][iwp]==false){
        for(int k=0;k<=wcount; k++)_bmap[iw][iwp] |= _bmap[iw][k] && _bmap[k][iwp];
      }
      // MSG("DmxFast",Msg::kDebug) << _bmap[iw][iwp];
    }
    // MSG("DmxFast",Msg::kDebug) << endl;
  }


  ngroup = 0;
  for(int iw=0;iw<=wcount; iw++){wfound[iw]=false;}
  for(int ie=0;ie<=ecount; ie++){efound[ie]=false;}

  for(int iw=0;iw<=wcount; iw++){
    if(wfound[iw]==false){
      ngroup++;
      ningroupw[ngroup]=0;
      for(int iwp=0;iwp<=wcount; iwp++){
        if(_bmap[iw][iwp]){
          ningroupw[ngroup]++;
          wgroup[ngroup][ningroupw[ngroup]]=iwp;
          wfound[iwp]=true;
        }
      }
    }
  }
      
  if(ngroup>0){
    for(int ig=1;ig<=ngroup;ig++){
      ningroupe[ig]=0;
      for(int iw=1;iw<=ningroupw[ig];iw++){
        for(int ie=0;ie<=ecount;ie++){
          if(efound[ie]==false && _amap[ie][(wgroup[ig][iw])]){
            ningroupe[ig]++;
            egroup[ig][ningroupe[ig]]=ie;
            efound[ie] = true;
          }
        }
      }
    }
  }

  return;
}

void DemuxFast::MakeMap(int i, bool useTargets)
{

  vector <PlexSEIdAltL*>::iterator literE;
  vector <PlexSEIdAltL*>::iterator literW;
  float ratioQ;
  float ratioEW=0;
  float qE;
  float qW;
  float sigma;
  float r=0;
  float av;
  float ed;
  float ratio;
  int s;
 
  //MSG("DmxFast",Msg::kDebug) << "DemuxFast::MakeMap " << i << endl;
  if(_qTotW[i]>0)ratioEW =  _qTotE[i]/_qTotW[i];

  literE = PlanesAltListsE[i].begin();
  ecount = -1;
  kView = (*literE)->GetPlaneView();
  currentPlane = (*literE)->GetPlane();
  MSG("DmxFast",Msg::kDebug) << " current Plane : " << currentPlane << endl;
  while (literE != PlanesAltListsE[i].end()){
    ecount++;
    _pAmapE[ecount] = (*literE);
    literW = PlanesAltListsW[i].begin();
    wcount = -1;
    while ( literW != PlanesAltListsW[i].end()){
      wcount++;
      _pAmapW[wcount] = (*literW);
      //MSG("DmxFast",Msg::kDebug) << " Counts : " << ecount << " : " << wcount << endl; 
      (*literE)->SetFirst();
      while( (*literE)->IsValid() ){
        //      ushE = _pUgh->GetStripHandle((*literE)->GetCurrentSEId());
        qE = (*literE)->GetCurrentItem().GetPE()*CalDigitType::kPE;
        (*literW)->SetFirst();
        while( (*literW)->IsValid() ){
          qW = (*literW)->GetCurrentItem().GetPE()*CalDigitType::kPE;
          // In here we can check for a possibility
          if((*literE)->GetCurrentSEId().GetStrip()==(*literW)->GetCurrentSEId().GetStrip()){
            s = (*literE)->GetCurrentSEId().GetStrip();
            ratioQ =  qE/qW;
            // Define requirements for a good combination...
            bool goodComb = true;

            if(ratioQ<(ratioEW*_cutRatioLow))goodComb=false;
            if(ratioQ>(ratioEW*_cutRatioHigh))goodComb=false;
            if((*literE)->GetCurrentItem().GetPE()*CalDigitType::kPE < _cutPEmin)goodComb = false;
            if((*literW)->GetCurrentItem().GetPE()*CalDigitType::kPE < _cutPEmin)goodComb = false;
            if((*literE)->GetCurrentItem().GetPE()<_cutFractionMin*_qMaxE[i])goodComb=false;
            if((*literW)->GetCurrentItem().GetPE()<_cutFractionMin*_qMaxW[i])goodComb=false;
            
            av = _goldGuide[currentPlane];
            ed = 0.;
            if(av>0){
              ratio = (qE-qW)/(qE+qW);
              sigma = 4.0*sqrt( qE*qW*(qE+qW) )/(qE+qW)/(qE+qW);
              if(kView==PlaneView::kU)r = -0.55+1.1*(av/192.);
              if(kView==PlaneView::kV)r =  0.55-1.1*(av/192.);
              ed = (ratio-r)/sigma;
            }

            //float dt = (tW -tE)*1E9-(clearW-clearE)*6.0-(wlsW-wlsE)*4.6;

            MSG("DmxFast",Msg::kDebug) << "Poss : " << qE << " : " << qW << " : " << ed << " : " << (*literE)->GetCurrentSEId().GetStrip();
            if(goodComb){
              MSG("DmxFast",Msg::kDebug) << " *";
            }
            if( fabs(ed)-0.001 >= _cutSigmaQ )goodComb = false;

            if(goodComb&&useTargets){
              bool found = false;
              for(unsigned int t=0;t<targets.size()&&found==false;t++){
                if(abs(targets[t]-s)<12){
                  found = true;
                }
              } 
              goodComb = found;
            }

            if(goodComb){
              _amap[ecount][wcount] = true;
              MSG("DmxFast",Msg::kDebug) << "*";
            }

            MSG("DmxFast",Msg::kDebug) << endl;

            _smap[ecount][wcount] = s;
          }
          (*literW)->Next();
        }
        (*literE)->Next();
      }
      literW++;
    }
    literE++;
  }
  return;
}

void DemuxFast::MakeMap(DemuxSearchTactic tactic)
{

  int i = tactic.iplane;
  int j = tactic.lowplane;
  int k = tactic.highplane;
  int itarget;
  int it;

  targets.erase(targets.begin(),targets.end());

  if(planehit[i]>0){
    for(int ii=1;ii<=planehit[i];ii++){
      itarget = hitmap[i][ii];
      targets.push_back(itarget);
      MSG("DmxFast",Msg::kDebug) << " I target " << ii << " : " << hitmap[i][ii] << endl;
    }
  }
  if(j>0){
    for(int jj=1;jj<=planehit[j];jj++){
      
      itarget = hitmap[j][jj];
      targets.push_back(itarget);
      MSG("DmxFast",Msg::kDebug) << " J target " << jj << " : " << hitmap[j][jj] << endl;
    }
  }
  if(k>0){
    for(int kk=1;kk<=planehit[k];kk++){
      itarget = hitmap[k][kk];
      targets.push_back(itarget);
      MSG("DmxFast",Msg::kDebug) << " K target " << kk << " : " << hitmap[k][kk] << endl;
    }
  }

  if(j>0&&k>0){
    for(int jj=1;jj<=planehit[j];jj++){
      if(qhitmapE[j][jj]>_cutTrackTargetQ && qhitmapW[j][jj]>_cutTrackTargetQ){
        for(int kk=1;kk<=planehit[k];kk++){
          if(qhitmapE[k][kk]>_cutTrackTargetQ && qhitmapW[k][kk]>_cutTrackTargetQ){
            it =hitmap[j][jj] + (hitmap[k][kk]-hitmap[j][jj])*(i-j)/(k-j);
            MSG("DmxFast",Msg::kDebug) << "JK target " << jj<<kk << " : " << it << endl;
            targets.push_back(it);  
          }
        }
      }
    }
  }

  this->MakeMap(i,true);

  return;
}

void DemuxFast::DemuxSingles(DemuxSearchTactic tactic)
{

  vector <PlexSEIdAltL*>::iterator literE;
  vector <PlexSEIdAltL*>::iterator literW;

  int i = tactic.iplane;
  int j = tactic.lowplane;
  int k = tactic.highplane;
  int itarget;
  int it;
  int s;
  int sbest;
  int closeness;
  float q;

  targets.erase(targets.begin(),targets.end());

  MSG("DmxFast",Msg::kDebug) << "DemuxFast::DemuxSingles " << i << endl;

  if(planehit[i]>0){
    for(int ii=1;ii<=planehit[i];ii++){
      itarget = hitmap[i][ii];
      targets.push_back(itarget);
      MSG("DmxFast",Msg::kDebug) << " I target " << ii << " : " << hitmap[i][ii] << endl;
    }
  }
  if(j>0){
    for(int jj=1;jj<=planehit[j];jj++){
      itarget = hitmap[j][jj];
      targets.push_back(itarget);
      MSG("DmxFast",Msg::kDebug) << " J target " << jj << " : " << hitmap[j][jj] << endl;
    }
  }
  if(k>0){
    for(int kk=1;kk<=planehit[k];kk++){
      itarget = hitmap[k][kk];
      targets.push_back(itarget);
      MSG("DmxFast",Msg::kDebug) << " K target " << kk << " : " << hitmap[k][kk] << endl;
    }
  }
  if(j>0&&k>0){
    for(int jj=1;jj<=planehit[j];jj++){
      if(qhitmapE[j][jj]>_cutTrackTargetQ && qhitmapW[j][jj]>_cutTrackTargetQ){
        for(int kk=1;kk<=planehit[k];kk++){
          if(qhitmapE[k][kk]>_cutTrackTargetQ && qhitmapW[k][kk]>_cutTrackTargetQ){
            it =hitmap[j][jj] + (hitmap[k][kk]-hitmap[j][jj])*(i-j)/(k-j);
            if(j<249 && i>249)it =hitmap[j][jj] + (hitmap[k][kk]-hitmap[j][jj])*(i-j-15)/(k-j-15);
            if(i<249 && k>249)it =hitmap[j][jj] + (hitmap[k][kk]-hitmap[j][jj])*(i-j)/(k+15-j);
            MSG("DmxFast",Msg::kDebug) << "JK target " << jj<<kk << " : " << it << endl;
            targets.push_back(it);  
          }
        }
      }
    }
  }

  if(targets.size()<1)return;

  currentPlane = i;

  if(PlanesAltListsE[i].size()>0){
    literE = PlanesAltListsE[i].begin();
    kView = (*literE)->GetPlaneView();
    currentPlane = (*literE)->GetPlane();
    while (PlanesAltListsE[i].size()>0){
      sbest =0;
      closeness = 999;
      literE = PlanesAltListsE[i].begin();
      (*literE)->SetFirst();
      q = (*literE)->GetCurrentItem().GetPE()*CalDigitType::kPE;
      while( (*literE)->IsValid() ){
        s = (*literE)->GetCurrentSEId().GetStrip();
        bool found = false;
        for(unsigned int t=0;t<targets.size()&&found==false;t++){
          if(abs(targets[t]-s)<closeness){
            closeness = abs(targets[t]-s);
            sbest = s;                  
            if(closeness==0)found = true;
          }
        }
        (*literE)->Next();
      }
      MSG("DmxFast",Msg::kDebug) << "Closest Strip : " << closeness << " --> " << sbest << endl;
      
      demuxedHitPlane.push_back(currentPlane);
      demuxedHitStrip.push_back(sbest);
      demuxedHitQ.push_back(q);
      NdemuxedHits++;
      if(kView==PlaneView::kV) NdemuxedHitsV++;
      if(kView==PlaneView::kU) NdemuxedHitsU++;

      MSG("DmxFast",Msg::kDebug) << "Adding  U " << NdemuxedHitsU << " : " << currentPlane << " : " << sbest << endl;

      this->DemuxHitE(*literE, sbest);
    }
  }



  if(PlanesAltListsW[i].size()>0){
    literW = PlanesAltListsW[i].begin();
    kView = (*literW)->GetPlaneView();
    currentPlane = (*literW)->GetPlane();
    MSG("DmxFast",Msg::kDebug) << " current W Plane : " << currentPlane << endl;
    while (PlanesAltListsW[i].size()>0){
      literW = PlanesAltListsW[i].begin();
      sbest =0;
      closeness = 999;
      (*literW)->SetFirst();
      q = (*literW)->GetCurrentItem().GetPE();  
      while( (*literW)->IsValid() ){
        s = (*literW)->GetCurrentSEId().GetStrip();
        bool found = false;
        for(unsigned int t=0;t<targets.size()&&found==false;t++){
          if(abs(targets[t]-s)<closeness){
            closeness = abs(targets[t]-s);
            sbest = s;                  
            if(closeness==0)found = true;
          }
        }
        (*literW)->Next();
      }
      MSG("DmxFast",Msg::kDebug) << "Closest Strip : " << closeness << " --> " << sbest << endl;
      
      demuxedHitPlane.push_back(currentPlane);
      demuxedHitStrip.push_back(sbest);
      demuxedHitQ.push_back(q);
      NdemuxedHits++;
      if(kView==PlaneView::kV) NdemuxedHitsV++;
      if(kView==PlaneView::kU) NdemuxedHitsU++;
      
      this->DemuxHitW(*literW, sbest);
      literW++;    }
  }

  return;
}




void DemuxFast::PrintWhatRemains()
{
  vector <PlexSEIdAltL*>::iterator literE;
  vector <PlexSEIdAltL*>::iterator literW;

  for(int i=0; i<500; i++){
    if(PlanesAltListsE[i].size()||PlanesAltListsW[i].size()){
      //MSG("DmxFast",Msg::kDebug) << " PLANE : " << i << "has " << planehit[i] <<  " Demuxed Hits, Left With   E : " << PlanesAltListsE[i].size() << ", W : " << PlanesAltListsW[i].size() << endl;
    }

    if(PlanesAltListsE[i].size()&&PlanesAltListsW[i].size()){
      literE = PlanesAltListsE[i].begin();
      while (literE != PlanesAltListsE[i].end()){
        literW = PlanesAltListsW[i].begin();
        while ( literW != PlanesAltListsW[i].end()){
          (*literE)->SetFirst();
          while( (*literE)->IsValid() ){
            (*literW)->SetFirst();
            while( (*literW)->IsValid() ){
              if((*literE)->GetCurrentSEId().GetStrip()==(*literW)->GetCurrentSEId().GetStrip()){
                MSG("DmxFast",Msg::kDebug) << " We have a possibilility " << i << " : " << (*literE)->GetCurrentItem().GetPE()*CalDigitType::kPE << " : " << (*literW)->GetCurrentItem().GetPE()*CalDigitType::kPE << " : " << (*literE)->GetCurrentSEId().GetStrip() << endl;
              }
              (*literW)->Next();
            }
            (*literE)->Next();
          }
          literW++;
        }
        literE++;
      }
    }
    if(PlanesAltListsE[i].size()){
      literE = PlanesAltListsE[i].begin();
      while (literE != PlanesAltListsE[i].end()){
        (*literE)->SetFirst();
        while( (*literE)->IsValid() ){
          MSG("DmxFast",Msg::kDebug) << " Single possibilility : " << i << " : " << (*literE)->GetCurrentItem().GetPE()*CalDigitType::kPE << " : " << (*literE)->GetCurrentSEId().GetStrip() << endl;
          (*literE)->Next();
        }
        literE++;
      }
    }
    if(PlanesAltListsW[i].size()){
      literW = PlanesAltListsW[i].begin();
      while (literW != PlanesAltListsW[i].end()){
        (*literW)->SetFirst();
        while( (*literW)->IsValid() ){
          MSG("DmxFast",Msg::kDebug) << " Single possibilility : " << i << " : " << (*literW)->GetCurrentItem().GetPE()*CalDigitType::kPE << " : " << (*literW)->GetCurrentSEId().GetStrip() << endl;
          (*literW)->Next();
        }
        literW++;
      }
    }
  }
  
  return;
}

bool DemuxFast::SelectHits(bool gold, bool useGold) 
{
  bool success = false;

  for(int ig=1;ig<=ngroup;ig++){
    
    MSG("DmxFast",Msg::kDebug) << "Asking Pattern Master for " << ningroupe[ig] << " : " << ningroupw[ig] << endl;
    MSG("DmxFast",Msg::kDebug) << "Returned : " << pMaster->SelectPattern(ningroupe[ig],ningroupw[ig]) << endl;
    MyDemuxPattern* pP;
    MyDemuxPattern* pBest;
    PatternPair wibble;
    int smin;
    int smax;
    int srange;
    int srange1;
    int srange2;
    int count;

    pBest = NULL;
    count  =0;
    srange1 = 1000;
    srange2 = 1000; 
    if(pMaster->SelectPattern(ningroupe[ig],ningroupw[ig])){
      while( (pP = pMaster->Next())!=NULL ){
        count++;
        bool patok = true;
        smin =999;
        smax =0;
        for(int i=0; i< pP->Size(); i++){
          wibble = pP->GetI(i);
          if(patok)patok = _amap[(egroup[ig][wibble.eEntry])][(wgroup[ig][wibble.wEntry])];
          // if(patok){
            int s = _smap[(egroup[ig][wibble.eEntry])][(wgroup[ig][wibble.wEntry])];
            if(s<smin)smin=s;
            if(s>smax)smax=s;
            //    }
        }
        if(patok){
          srange = smax-smin;
          if(srange<=srange1){
            srange2 = srange1;
            srange1 = srange;
            pBest = pP;
          }else{
            if(srange<=srange2)srange2=srange;
          }
        }
      }

      if(pBest==NULL)return false;

      if(srange1 < pBest->Size()+_rangeWindow && srange1+pBest->Size()<srange2){
        success = true;
        for(int i=0; i< pBest->Size(); i++){
          wibble = pBest->GetI(i);
          
          int s = _smap[(egroup[ig][wibble.eEntry])][(wgroup[ig][wibble.wEntry])];

          MSG("DmxFast",Msg::kDebug) << " **Using combination " << s << endl;
          if(gold)this->GoldHits(egroup[ig][wibble.eEntry],wgroup[ig][wibble.wEntry],s);
          if(!gold){
            bool found = false;
            if(useGold){
              for(int i=1;!found && i<=goldplanehit[currentPlane];i++){
                if(s==goldhitmap[currentPlane][i])found=true;
              }
            }
            if(!useGold ||found)this->DemuxHits(egroup[ig][wibble.eEntry],wgroup[ig][wibble.wEntry],s);
            if( useGold && !found)MSG("DmxFast",Msg::kDebug) << "VETOING THIS HIT " << endl;
          }
        }
      }
    }else{
      // Pattern Master says no ! too big ? 
      if( (ningroupe[ig]>3) && (ningroupw[ig]>3) ){
        success = this->DemuxBigGroup(ig,gold);
      }
    }
  }  // end of loop over groups 
  MSG("DmxFast",Msg::kDebug) << "Returning " << success << endl;
  return success; 
}



bool DemuxFast::DemuxBigGroup(int ig,bool gold) 
{ 
  bool success = false;
  MSG("DmxFast",Msg::kDebug) << "BIG GROUP TRY A DIFFERENT APPROACH" << endl;
  int strips[192];
  int estrips[192];
  int wstrips[192];
  for(int i=0;i<192;i++)strips[i]=0;
  for(int ie=1;ie<=ningroupe[ig];ie++){
    for(int iw=1;iw<=ningroupw[ig];iw++){
      if(_amap[(egroup[ig][ie])][(wgroup[ig][iw])]){
        int s = _smap[(egroup[ig][ie])][(wgroup[ig][iw])];
        strips[s]++;
        estrips[s] = ie;
        wstrips[s] = iw;
      }
    }
  }
  int istartStrip=-1;
  int iendStrip=-1;
  int ngroups = 0;
  int ming = ningroupe[ig];
  if(ningroupw[ig]<ming)ming = ningroupw[ig];
  int icount;
  for(int is=0; is<192-ming; is++){
    if(strips[is]==1){
      icount = 1;
      int iend = is+ming+5;
      int ie;
      if(iend>191)iend=192;
      for(ie=is+1; ie<iend && icount != ming; ie++){
        if(strips[ie]>0)icount++;
      }
      if(icount==ming){
        ngroups++;
        istartStrip = is;
        iendStrip   = ie-1;
        MSG("DmxFast",Msg::kDebug) << "Found a group : " << is << ":" << ie-1 << endl;
      }
    }
  }
  MSG("DmxFast",Msg::kDebug) << "Found " << ngroups << " groups " << endl;
  if(ngroups==1){
    success = true;
    int ie;
    int iw;
    for(int is=istartStrip; is<=iendStrip;is++){
      if(strips[is]==1){
        ie = estrips[is];
        iw = wstrips[is];
        MSG("DmxFast",Msg::kDebug) << " Strip : " << is << " ew " << ie << ":" << iw << endl;
        if(gold)this->GoldHits(egroup[ig][ie],wgroup[ig][iw],is);
        if(!gold)this->DemuxHits(egroup[ig][ie],wgroup[ig][iw],is);
      }     
    }
  } 
  return success;
}


float DemuxFast::IsItXTalk(int iew, int iplane, int iva, int ipixel)
{ 

  float crossTalk;
  if(iew==0){
    switch(ipixel){
    case 0:
      crossTalk = pixelE[iplane][iva][1] + 
                  pixelE[iplane][iva][4];
      break;
    case 1:
      crossTalk = pixelE[iplane][iva][0] + 
                  pixelE[iplane][iva][2] +
                  pixelE[iplane][iva][5];
      break;
    case 2:
      crossTalk = pixelE[iplane][iva][1] + 
                  pixelE[iplane][iva][3] +
                  pixelE[iplane][iva][6];
      break;
    case 3:
      crossTalk = pixelE[iplane][iva][2] + 
                  pixelE[iplane][iva][7];
      break;
    case 4:
      crossTalk = pixelE[iplane][iva][0] + 
                  pixelE[iplane][iva][5] +
                  pixelE[iplane][iva][8];
      break;
    case 5:
      crossTalk = pixelE[iplane][iva][1] + 
                  pixelE[iplane][iva][4] +
                  pixelE[iplane][iva][6] +
                  pixelE[iplane][iva][9];
      break;
    case 6:
      crossTalk = pixelE[iplane][iva][2] + 
                  pixelE[iplane][iva][5] +
                  pixelE[iplane][iva][7] +
                  pixelE[iplane][iva][10];
      break;
    case 7:
      crossTalk = pixelE[iplane][iva][3] + 
                  pixelE[iplane][iva][6] +
                  pixelE[iplane][iva][11];
      break;
    case 8:
      crossTalk = pixelE[iplane][iva][4] + 
                  pixelE[iplane][iva][9] +
                  pixelE[iplane][iva][12];
      break;
    case 9:
      crossTalk = pixelE[iplane][iva][5] + 
                  pixelE[iplane][iva][8] +
                  pixelE[iplane][iva][10] +
                  pixelE[iplane][iva][13];
      break;
    case 10:
      crossTalk = pixelE[iplane][iva][6] + 
                  pixelE[iplane][iva][9] +
                  pixelE[iplane][iva][11] +
                  pixelE[iplane][iva][14];
      break;
    case 11:
      crossTalk = pixelE[iplane][iva][7] + 
                  pixelE[iplane][iva][10] +
                  pixelE[iplane][iva][15];
      break;
    case 12:
      crossTalk = pixelE[iplane][iva][8] + 
                  pixelE[iplane][iva][13];
      break;
    case 13:
      crossTalk = pixelE[iplane][iva][9] + 
                  pixelE[iplane][iva][12]+
                  pixelE[iplane][iva][14];
      break;
    case 14:
      crossTalk = pixelE[iplane][iva][10] + 
                  pixelE[iplane][iva][13]+
                  pixelE[iplane][iva][15];
      break;
    case 15:
      crossTalk = pixelE[iplane][iva][11]+ 
                  pixelE[iplane][iva][14];
      break;
    default:
      crossTalk = 0;
      break;
    }
  }else{
    switch(ipixel){
    case 0:
      crossTalk = pixelW[iplane][iva][1] + 
                  pixelW[iplane][iva][4];
      break;
    case 1:
      crossTalk = pixelW[iplane][iva][0] + 
                  pixelW[iplane][iva][2] +
                  pixelW[iplane][iva][5];
      break;
    case 2:
      crossTalk = pixelW[iplane][iva][1] + 
                  pixelW[iplane][iva][3] +
                  pixelW[iplane][iva][6];
      break;
    case 3:
      crossTalk = pixelW[iplane][iva][2] + 
                  pixelW[iplane][iva][7];
      break;
    case 4:
      crossTalk = pixelW[iplane][iva][0] + 
                  pixelW[iplane][iva][5] +
                  pixelW[iplane][iva][8];
      break;
    case 5:
      crossTalk = pixelW[iplane][iva][1] + 
                  pixelW[iplane][iva][4] +
                  pixelW[iplane][iva][6] +
                  pixelW[iplane][iva][9];
      break;
    case 6:
      crossTalk = pixelW[iplane][iva][2] + 
                  pixelW[iplane][iva][5] +
                  pixelW[iplane][iva][7] +
                  pixelW[iplane][iva][10];
      break;
    case 7:
      crossTalk = pixelW[iplane][iva][3] + 
                  pixelW[iplane][iva][6] +
                  pixelW[iplane][iva][11];
      break;
    case 8:
      crossTalk = pixelW[iplane][iva][4] + 
                  pixelW[iplane][iva][9] +
                  pixelW[iplane][iva][12];
      break;
    case 9:
      crossTalk = pixelW[iplane][iva][5] + 
                  pixelW[iplane][iva][8] +
                  pixelW[iplane][iva][10] +
                  pixelW[iplane][iva][13];
      break;
    case 10:
      crossTalk = pixelW[iplane][iva][6] + 
                  pixelW[iplane][iva][9] +
                  pixelW[iplane][iva][11] +
                  pixelW[iplane][iva][14];
      break;
    case 11:
      crossTalk = pixelW[iplane][iva][7] + 
                  pixelW[iplane][iva][10] +
                  pixelW[iplane][iva][15];
      break;
    case 12:
      crossTalk = pixelW[iplane][iva][8] + 
                  pixelW[iplane][iva][13];
      break;
    case 13:
      crossTalk = pixelW[iplane][iva][9] + 
                  pixelW[iplane][iva][12]+
                  pixelW[iplane][iva][14];
      break;
    case 14:
      crossTalk = pixelW[iplane][iva][10] + 
                  pixelW[iplane][iva][13]+
                  pixelW[iplane][iva][15];
      break;
    case 15:
      crossTalk = pixelW[iplane][iva][11]+ 
                  pixelW[iplane][iva][14];
      break;
    default:
      crossTalk = 0.0;
      break;
    }
  }
  
  return crossTalk;
} 

void DemuxFast::DemuxHits(int ie,int iw, int is ){ 

  float qE;
  float qW;

  this->DemuxHitE(ie,is);
  this->DemuxHitW(iw,is);

  qE= _pAmapE[ie]->GetBestItem().GetPE()*CalDigitType::kPE;
  qW= _pAmapW[iw]->GetBestItem().GetPE()*CalDigitType::kPE;
  
  demuxedHitPlane.push_back(currentPlane);
  demuxedHitStrip.push_back(is);
  demuxedHitQ.push_back(qE+qW);
  NdemuxedHits++;
  
  planehit[currentPlane] += 1;
  hitmap[currentPlane][planehit[currentPlane]] = is;
  qhitmapE[currentPlane][planehit[currentPlane]] = qE;
  qhitmapW[currentPlane][planehit[currentPlane]] = qW;

  return;

}

void DemuxFast::GoldHits(int, //ie,
                         int, //iw,
                         int is)
{ 
  goldplanehit[currentPlane] += 1;
  goldhitmap[currentPlane][goldplanehit[currentPlane]] = is;
  
  return;
}


void DemuxFast::MakeGoldGuide(){ 

  for(int ip=1;ip<500;ip++){
    if(goldplanehit[ip-1]>0||goldplanehit[ip+1]>0){
      float n =0;
      float tot = 0;
      for(int i=1;i<=goldplanehit[ip-1];i++){
        n+=1;
        tot += goldhitmap[ip-1][i];
      }
      for(int i=1;i<=goldplanehit[ip+1];i++){
        n+=1;
        tot += goldhitmap[ip+1][i];
      }
      _goldGuide[ip] = tot/n;
      MSG("DmxFast",Msg::kDebug) << "Gold Guide " << ip << " : " <<  _goldGuide[ip] << endl;
    }
  }
 
  return;

}


void DemuxFast::DemuxHitE(int ie, int is){ 

  PlexSEIdAltL* pAltL;

  pAltL = _pAmapE[ie]; 
  this->DemuxHitE(pAltL,is);
  return;
}


void DemuxFast::DemuxHitW(int iw, int is){ 

  PlexSEIdAltL* pAltL;
  pAltL = _pAmapW[iw]; 
  this->DemuxHitW(pAltL,is);  

  return;
}

void DemuxFast::DemuxHitE(PlexSEIdAltL* pAltL, int is){ 

  vector <PlexSEIdAltL*>::iterator literA;
  bool notFound;
  float q;

  pAltL->SetFirst();


  q = pAltL->GetCurrentItem().GetPE();
  notFound = true;
  while(notFound && pAltL->IsValid()){
    if(pAltL->GetCurrentSEId().GetStrip()==is){
      pAltL->SetCurrentWeight(1.);
      notFound = false;
    }
    if(notFound)pAltL->Next();
  }

  literA = PlanesAltListsE[currentPlane].begin();
  notFound = true;
  while (notFound && literA != PlanesAltListsE[currentPlane].end()){
    if(*literA==pAltL){
      PlanesAltListsE[currentPlane].erase(literA);
      notFound = false;
    }
    literA++;
  }


  return;
}

void DemuxFast::DemuxHitW(PlexSEIdAltL* pAltL, int is){ 


  vector <PlexSEIdAltL*>::iterator literA;
  bool notFound;
  float q;


  pAltL->SetFirst();

  notFound = true;
  q = pAltL->GetCurrentItem().GetPE();
  while(notFound && pAltL->IsValid()){
    if(pAltL->GetCurrentSEId().GetStrip()==is){
      pAltL->SetCurrentWeight(1.);
      notFound = false;
    }
    if(notFound)pAltL->Next();
  }
  
  literA = PlanesAltListsW[currentPlane].begin();
  notFound = true;
  while (notFound && literA != PlanesAltListsW[currentPlane].end()){
    if(*literA==pAltL){
      PlanesAltListsW[currentPlane].erase(literA);
      notFound = false;
    }
    literA++;
  }
  return;
}


void DemuxFast::EndJob() 
{

  TFile *hfile = new TFile("FastDeMuxHistos.root","recreate");
 
  MSG("DmxFast",Msg::kDebug) << " Writing Histograms to file : DeMuxHistos.root " << endl;

  hfile->Close();
  delete hfile;

}

---