AlgAltDeMuxBase.cxx

Go to the documentation of this file.

// $Id: AlgAltDeMuxBase.cxx,v 1.21 2008/11/18 17:07:13 rhatcher Exp $
//
// AlgAltDeMuxBase
//
// An Algorithm Base class for the Alternative DeMuxing Algoriths 
// developed in Cambridge.
//
// Author:  M. Thomson April 2003
#include <cassert>
#include <cmath>
#include <algorithm>
#include <vector>
#include "Candidate/CandContext.h"
#include "Candidate/CandHandle.h"
#include "CandDigit/CandDeMuxDigitHandle.h"
#include "CandDigit/CandDeMuxDigitListHandle.h"
#include "MessageService/MsgService.h"
#include "Algorithm/AlgConfig.h"
#include "Algorithm/AlgFactory.h"
#include "Algorithm/AlgHandle.h"
#include "TObjArray.h"
#include "TH1.h"
#include "TFolder.h"
#include "TROOT.h"
#include "TPolyMarker.h"
#include "CandData/CandRecord.h"           // DigitList handling
#include "CandDigit/CandDigitListHandle.h" // "                "
#include "CandDigit/CandDigitHandle.h"     // "                "
#include "UgliGeometry/UgliGeomHandle.h"
#include "UgliGeometry/UgliPlnNode.h"
#include "Validity/VldContext.h"
#include "Plex/PlexPlaneId.h"
#include "AltDeMuxPatternMaster.h"
#include "AlgAltDeMuxBase.h"

ClassImp(AlgAltDeMuxBase)
  

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

CVSID("$Id: AlgAltDeMuxBase.cxx,v 1.21 2008/11/18 17:07:13 rhatcher Exp $");

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

AlgAltDeMuxBase::AlgAltDeMuxBase()
{
  //default constructor
  MSG("AltDeMux", Msg::kDebug) << "AlgAltDeMuxBase() Constructor" << endl;

  this->Initialize("");
  
  MSG("AltDeMux", Msg::kDebug) << "AlgAltDeMuxBase Leaving Constructor" << endl;
}

AlgAltDeMuxBase::AlgAltDeMuxBase(const char* name)
{
  //default constructor
  MSG("AltDeMux", Msg::kDebug) << "AlgAltDeMuxBase(name) Constructor" << endl;

  this->Initialize(name);
  
  MSG("AltDeMux", Msg::kDebug) << "AlgAltDeMuxBase Leaving Constructor" << endl;
  
}

void AlgAltDeMuxBase::Initialize(const char* name)
{
  
  fList = new TList();
  fXTalkFraction        = 0.05;
  fXTalk1PEFraction     = 0.25;
  fXTalk2PEFraction     = 0.15;
  fXTalk5PEFraction     = 0.10;
  fNoiseTimeWindow      = 100.;
  fSigmasForTimingWindow = 2.5;

  // Far Detector Monte Calro

  fScintillatorNMC = 1.75;  
  fWLSFibreNMC     = 1.75; 
  fClearFibreNMC   = 1.75;  
  fSigmaTMC        = 2.5; //(ns)

  // Far Detector DATA

  fScintillatorN = 1.77;  
  fWLSFibreN     = 1.77; 
  fClearFibreN   = 1.77;  
  fSigmaTData    = 2.5; //(ns)
                           
  fNumberOfStrips = 192;
  fEventType = UNKNOWN;
  fDiagnosticPlots = false;
  //  amWriting = false;
  amShowing = false;
  pCalculator = new AltDeMuxCalc();
  this->Setup();
  
  diagnosticCanvastitle = name;
  diagnosticCanvas = false;

  _pixelToVaChannel[0]  = 3;
  _pixelToVaChannel[1]  = 5;
  _pixelToVaChannel[2]  = 14;
  _pixelToVaChannel[3]  = 16;
  _pixelToVaChannel[4]  = 7;
  _pixelToVaChannel[5]  = 9;
  _pixelToVaChannel[6]  = 10;
  _pixelToVaChannel[7]  = 12;
  _pixelToVaChannel[8]  = 11;
  _pixelToVaChannel[9]  = 13;
  _pixelToVaChannel[10] = 6;
  _pixelToVaChannel[11] = 8;
  _pixelToVaChannel[12] = 17;
  _pixelToVaChannel[13] = 15;
  _pixelToVaChannel[14] = 2;
  _pixelToVaChannel[15] = 4;

  for(int i = 0; i<8; i++){
    for(int j = 0; j<9; j++){
      _pixelSpotXTalkMap[i][j]=0.0;
    }
  }
  
  // spot 0

  _pixelSpotXTalkMap[3][0] = 0.007; 
  _pixelSpotXTalkMap[3][1] = 0.025;
  _pixelSpotXTalkMap[3][2] = 0.002;
  _pixelSpotXTalkMap[3][3] = 0.025;
  _pixelSpotXTalkMap[3][5] = 0.003;
  _pixelSpotXTalkMap[3][6] = 0.001;
  _pixelSpotXTalkMap[3][7] = 0.003;
  _pixelSpotXTalkMap[3][8] = 0.002;
  
  // spot 1

  _pixelSpotXTalkMap[2][0] = 0.003; 
  _pixelSpotXTalkMap[2][1] = 0.025;
  _pixelSpotXTalkMap[2][2] = 0.003;
  _pixelSpotXTalkMap[2][3] = 0.006;
  _pixelSpotXTalkMap[2][5] = 0.006;
  _pixelSpotXTalkMap[2][6] = 0.001;
  _pixelSpotXTalkMap[2][7] = 0.004;
  _pixelSpotXTalkMap[2][8] = 0.001;
  

  // spot 2

  _pixelSpotXTalkMap[1][0] = 0.002; 
  _pixelSpotXTalkMap[1][1] = 0.025;
  _pixelSpotXTalkMap[1][2] = 0.007;
  _pixelSpotXTalkMap[1][3] = 0.003;
  _pixelSpotXTalkMap[1][5] = 0.025;
  _pixelSpotXTalkMap[1][6] = 0.001;
  _pixelSpotXTalkMap[1][7] = 0.003;
  _pixelSpotXTalkMap[1][8] = 0.002;
  
  // spot 3

  _pixelSpotXTalkMap[5][0] = 0.002; 
  _pixelSpotXTalkMap[5][1] = 0.008;
  _pixelSpotXTalkMap[5][2] = 0.001;
  _pixelSpotXTalkMap[5][3] = 0.011;
  _pixelSpotXTalkMap[5][5] = 0.004;
  _pixelSpotXTalkMap[5][6] = 0.002;
  _pixelSpotXTalkMap[5][7] = 0.008;
  _pixelSpotXTalkMap[5][8] = 0.001;
  

  // spot 4

  _pixelSpotXTalkMap[4][0] = 0.001; 
  _pixelSpotXTalkMap[4][1] = 0.008;
  _pixelSpotXTalkMap[4][2] = 0.002;
  _pixelSpotXTalkMap[4][3] = 0.004;
  _pixelSpotXTalkMap[4][5] = 0.011;
  _pixelSpotXTalkMap[4][6] = 0.001;
  _pixelSpotXTalkMap[4][7] = 0.008;
  _pixelSpotXTalkMap[4][8] = 0.002;
  

  // spot 5

  _pixelSpotXTalkMap[8][0] = 0.002; 
  _pixelSpotXTalkMap[8][1] = 0.003;
  _pixelSpotXTalkMap[8][2] = 0.001;
  _pixelSpotXTalkMap[8][3] = 0.025;
  _pixelSpotXTalkMap[8][5] = 0.003;
  _pixelSpotXTalkMap[8][6] = 0.007;
  _pixelSpotXTalkMap[8][7] = 0.025;
  _pixelSpotXTalkMap[8][8] = 0.002;
  

  // spot 6

  _pixelSpotXTalkMap[7][0] = 0.001; 
  _pixelSpotXTalkMap[7][1] = 0.004;
  _pixelSpotXTalkMap[7][2] = 0.001;
  _pixelSpotXTalkMap[7][3] = 0.006;
  _pixelSpotXTalkMap[7][5] = 0.006;
  _pixelSpotXTalkMap[7][6] = 0.003;
  _pixelSpotXTalkMap[7][7] = 0.025;
  _pixelSpotXTalkMap[7][8] = 0.003;
  

  // spot 7

  _pixelSpotXTalkMap[6][0] = 0.001; 
  _pixelSpotXTalkMap[6][1] = 0.003;
  _pixelSpotXTalkMap[6][2] = 0.002;
  _pixelSpotXTalkMap[6][3] = 0.003;
  _pixelSpotXTalkMap[6][5] = 0.025;
  _pixelSpotXTalkMap[6][6] = 0.002;
  _pixelSpotXTalkMap[6][7] = 0.025;
  _pixelSpotXTalkMap[6][8] = 0.007;

  for(Int_t i=0; i<MAX_NUMBER_OF_PMTS; i++){
    fPMTtot[i]=0.0;
    for(int j=0; j<16; j++){
      fPMTmap[i][j]=0.0;
      fXTalkmap[i][j]=0.0;
    }
    for(int j=0; j<22; j++){
      fVAmap[i][j]=0.0;
    }
  }
  return;
}

void AlgAltDeMuxBase::SetConstants(const VldContext* vldc){
  
  SimFlag::SimFlag_t simflag = vldc->GetSimFlag( );   

  if(simflag==SimFlag::kMC||simflag==SimFlag::kReroot ){
    // velocities of light in m/ns from refractive indices
    fClearFibreC   = 0.30/fClearFibreNMC;
    fWLSFibreC     = 0.30/fWLSFibreNMC;
    fScintillatorC = 0.30/fScintillatorNMC;
    // Timing resolution in ns
    fSigmaT        = fSigmaTMC;
    MSG("AltDeMux", Msg::kDebug) 
      << "IT IS Monte Carlo Set Constants " << endl;
  }else{
    // velocities of light in m/ns from refractive indices
    fClearFibreC   = 0.30/fClearFibreN;
    fWLSFibreC     = 0.30/fWLSFibreN;
    fScintillatorC = 0.30/fScintillatorN;
    // Timing resolution in ns
    fSigmaT        = fSigmaTData;
  }

  // resolution on strip number from timing 
  fSigmaStripFromTiming = fSigmaT*fScintillatorC/1.4142/0.041666;
  MSG("AltDeMux", Msg::kDebug)  
    << "AlgAltDeMuxBase::SetContants Sigma from Timing : " 
    << fSigmaStripFromTiming << " strip" << endl;

  // Tell the Calculator which constants to use 

  pCalculator->SetClearFibreC(fClearFibreC);
  pCalculator->SetWLSFibreC(fWLSFibreC);
  pCalculator->SetScintillatorC(fScintillatorC);
  pCalculator->SetNumberOfStrips(fNumberOfStrips);
  pCalculator->SetUgli(pUgh);

}



void AlgAltDeMuxBase::TidyUp() 
{    
  //fList->Delete();
}

//______________________________________________________________________


//-----------------------------------------------------------------------
// Default implementation of the demuxing - does nothing
void AlgAltDeMuxBase::RunAlg(AlgConfig & /* acd */, CandHandle & /* ch */, 
                             CandContext & /*cx */)
{

  return;
}


AlgAltDeMuxBase::~AlgAltDeMuxBase()
{

}


void AlgAltDeMuxBase::Trace(const char * /* c */) const
{
}

void AlgAltDeMuxBase::CreateDiagnosticCanvas()
{

  // If requested AlgAltDeMuxBase has a built-in diagnositic/debugging canvas
  // which provides a visual display of the DeMuxing as the algorithm
  // progresses through its various steps.

  if(diagnosticCanvas)return;

  diagnosticCanvas = true;
  string title  = "AlgAltDeMuxBase(";
  title = title + diagnosticCanvastitle;
  title = title + ") Diagnostics screen";

  fCanvas = new TCanvas(title.c_str(),diagnosticCanvastitle.c_str(),600,600);

  fUview  = NULL;
  fVview  = NULL;
  fUTime  = NULL;
  fVTime  = NULL;
  fUMask  = NULL;
  fVMask  = NULL;
  fHoughU = NULL;
  fHoughV = NULL;
  fHoughProjU = NULL;
  fHoughProjV = NULL;
  fHoughSliceU = NULL;
  fHoughSliceV = NULL;
  fUZFitS = NULL;
  fVZFitS = NULL;
  fUZFitT = NULL;
  fVZFitT = NULL;
  fUZFitSSM1 = NULL;
  fUZFitSSM2 = NULL;
  fUZFitQSSM1 = NULL;
  fUZFitQSSM2 = NULL;
  fUZFitTSM1 = NULL;
  fUZFitTSM2 = NULL;
  fVZFitSSM1 = NULL;
  fVZFitSSM2 = NULL;
  fVZFitTSM1 = NULL;
  fVZFitTSM2 = NULL;
  fVZFitQSSM1 = NULL;
  fVZFitQSSM2 = NULL;



// Create the pads;  Pad takes xlo, ylo, xhi, yhi in NC
  fUpad  = new TPad("upad","U pad",0.010,0.505,0.990,0.990);
  fVpad  = new TPad("vpad","V pad",0.010,0.010,0.990,0.495);

    // white background
  fUpad->SetFillColor(10);
  fVpad->SetFillColor(10);
    
    // tweak the margins to maximize histogram use of pads
  fUpad->SetLeftMargin(0.05);
  fUpad->SetRightMargin(0.0001);
  fUpad->SetTopMargin(0.0001);
  fUpad->SetBottomMargin(0.055);
  fVpad->SetLeftMargin(0.05);
  fVpad->SetRightMargin(0.0001);
  fVpad->SetTopMargin(0.0001);
  fVpad->SetBottomMargin(0.055);
  fUpad->Draw();
  fVpad->Draw();
    
  fCanvas->Draw();
}


void AlgAltDeMuxBase::ClearDiagnosticHistos()
{

  // Clear the diagnostic histograms - only called if fDiagnosticPlots==true

  if(!fDiagnosticPlots)return;
  MSG("AltDeMux", Msg::kDebug) << "AlgAltDeMuxBase::ClearDiagnosticHistos()" << endl;

  if(fUpad)fUpad->Clear("");
  if(fVpad)fVpad->Clear("");
  
// remove old histograms if they exists
  if ( fUview ) { delete fUview; fUview=0; }
  if ( fVview ) { delete fVview; fVview=0; }
  if ( fUTime ) { delete fUTime; fUTime=0; }
  if ( fVTime ) { delete fVTime; fVTime=0; }
  if ( fUMask ) { delete fUMask; fUMask=0; }
  if ( fVMask ) { delete fVMask; fVMask=0; }
  if ( fHoughU) { delete fHoughU; fHoughU=0; }
  if ( fHoughV) { delete fHoughV; fHoughV=0; }
  if ( fHoughProjU) { delete fHoughProjU; fHoughProjU=0; }
  if ( fHoughProjV) { delete fHoughProjV; fHoughProjV=0; }
  if ( fHoughSliceU) { delete fHoughSliceU; fHoughSliceU=0; }
  if ( fHoughSliceV) { delete fHoughSliceV; fHoughSliceV=0; }
  if(fUZFitS){delete fUZFitS; fUZFitS=0;}
  if(fVZFitS){delete fVZFitS; fVZFitS=0;}
  if(fUZFitT){delete fUZFitT; fUZFitT=0;}
  if(fVZFitT){delete fVZFitT; fVZFitT=0;}
  if(fUZFitSSM1){delete fUZFitSSM1; fUZFitSSM1=0;}
  if(fUZFitSSM2){delete fUZFitSSM2; fUZFitSSM2=0;}
  if(fUZFitQSSM1){delete fUZFitQSSM1; fUZFitQSSM1=0;}
  if(fUZFitQSSM2){delete fUZFitQSSM2; fUZFitQSSM2=0;}
  if(fVZFitQSSM1){delete fVZFitQSSM1; fVZFitQSSM1=0;}
  if(fVZFitQSSM2){delete fVZFitQSSM2; fVZFitQSSM2=0;}
  if(fUZFitTSM1){delete fUZFitTSM1; fUZFitTSM1=0;}
  if(fUZFitTSM2){delete fUZFitTSM2; fUZFitTSM2=0;}
  if(fVZFitSSM1){delete fVZFitSSM1; fVZFitSSM1=0;}
  if(fVZFitSSM2){delete fVZFitSSM2; fVZFitSSM2=0;}
  if(fVZFitTSM1){delete fVZFitTSM1; fVZFitTSM1=0;}
  if(fVZFitTSM2){delete fVZFitTSM2; fVZFitTSM2=0;}

  // create histograms that we'll use for World Coordinates
  // create histograms that we'll use for World Coordinates
  fUview = new TH2F("Uview","U view",501,-0.5,500.5,1,0.,193.);
  fVview = new TH2F("Vview","V view",501,-0.5,500.5,1,0.,193.);
  fUTime = new TH2F("UTime","U time view",501,-0.5,500.5,193,0.,193.);
  fVTime = new TH2F("VTime","V time view",501,-0.5,500.5,193,0.,193.);
  fUMask = new TH2F("UMask","U view mask",501,-0.5,500.5,193,0.,193.);
  fVMask = new TH2F("VMask","V view mask",501,-0.5,500.5,193,0.,193.);
  fHoughU = new TH2F("houghSpaceU", "U Hough Space", 400, -3., 1., 500, -250., 250.);
  fHoughV = new TH2F("houghSpaceV", "V Hough Space", 400, -3., 1., 500, -250., 250.);

  fHoughProjU = new TH1F("houghSpaceProjU", "U HoughX Space", 400, -3., 1.);
  fHoughProjV = new TH1F("houghSpaceProjV", "V HoughX Space", 400, -3., 1.);

  fHoughSliceU = new TH1F("houghSpaceSliceU", "U Hough c", 500, -250., 250.);
  fHoughSliceV = new TH1F("houghSpaceSliceV", "V Hough c", 500, -250., 250.);

    
  // don't draw the Stats box
  fUview->SetStats(kFALSE);
  fVview->SetStats(kFALSE);
  
  fUTime->SetStats(kFALSE);
  fVTime->SetStats(kFALSE);
  
  fUMask->SetStats(kFALSE);
  fVMask->SetStats(kFALSE);

  fHoughU->SetStats(kFALSE);
  fHoughV->SetStats(kFALSE);

  fHoughProjU->SetStats(kFALSE);
  fHoughProjV->SetStats(kFALSE);

  fHoughSliceU->SetStats(kFALSE);
  fHoughSliceV->SetStats(kFALSE);
    
  // take away any association with a "directory" for these histograms
  fUview->SetDirectory(0);
  fVview->SetDirectory(0);

  MSG("AltDeMux", Msg::kDebug) << "AlgAltDeMuxBase::ClearDiagnosticHistos() DONE" << endl;

  return;
}

void AlgAltDeMuxBase::ClearArrays()
{

  // Zero internal arrays/vectors used to DeMux event

  fEventType = UNKNOWN;

  MSG("AltDeMux", Msg::kDebug) << "AlgAltDeMuxBase::ClearArrays()" << endl;

  // Timelist will contain an ordered list of hit times.
  fTimeList.erase(fTimeList.begin(),fTimeList.end());

  // Reset the timing masks 
  ResetTimingMask();

  // Reset the DeMuxed group ID counter
  fUniqueDeMuxedGroupID=0;

  // Clear vector of DeMuxed strip end EW pairs

  // loop over planes/ends
  for(Int_t iplane=0; iplane<MAX_NUMBER_OF_PLANES;iplane++){
    fUVMap[iplane]=PlaneView::kUnknown;
    for(Int_t istrip=0; istrip<MAX_NUMBER_OF_STRIPS;istrip++){
      fTimingMask[iplane][istrip] = false;
    }
    fDeMuxedPairs[iplane].erase(fDeMuxedPairs[iplane].begin(),fDeMuxedPairs[iplane].end());
    fDeMuxedSingles[iplane].erase(fDeMuxedSingles[iplane].begin(),fDeMuxedSingles[iplane].end());
    NdemuxedHitsU[iplane] = 0;
    NdemuxedHitsV[iplane] = 0;
    for(Int_t iew=0; iew<=1;iew++){
      // Clear the arrays of vectors of AltLists
      fPlanesAltLists[iplane][iew].erase(fPlanesAltLists[iplane][iew].begin(),fPlanesAltLists[iplane][iew].end());
      fDeMuxedPlanesAltLists[iplane][iew].erase(fDeMuxedPlanesAltLists[iplane][iew].begin(),fDeMuxedPlanesAltLists[iplane][iew].end());
      fNoisePlanesAltLists[iplane][iew].erase(fNoisePlanesAltLists[iplane][iew].begin(),fNoisePlanesAltLists[iplane][iew].end());
      fXTalkPlanesAltLists[iplane][iew].erase(fXTalkPlanesAltLists[iplane][iew].begin(),fXTalkPlanesAltLists[iplane][iew].end());
    }
    // zero counters
    fPlaneHit[iplane] = 0;
    fPlanePair[iplane] = 0;
    fGoldPlaneHit[iplane] = 0;
    fQTotE[iplane] = 0;
    fQTotW[iplane] = 0;
    fQMaxE[iplane] = 0;
    fQMaxW[iplane] = 0;
  }
  _nDeMuxedPlanesU=0;
  _nDeMuxedPlanesV=0;
  _nHitPlanesU=0;
  _nHitPlanesV=0;


  // Zero PMT maps (for previously PMT with hits from previous event)
  for(int i=0; i<MAX_NUMBER_OF_PMTS; i++){
    if(fPMTtot[i]>0){
      fPMTtot[i]=0.0;
      for(int j=0; j<16; j++){
        fPMTmap[i][j]=0.0;
        fXTalkmap[i][j]=0.0;
      }
      for(int j=0; j<22; j++){
        fVAmap[i][j]=0.0;
      }
    }
  }

  // reset range of planes to DeMux 
  fLowestDeMuxedPairPlane = MAX_NUMBER_OF_PLANES-1;
  fHighestDeMuxedPairPlane = 0;

  fUseHoughSlope         = false;      
  fUseFitSlopeTime       = false;   
  fUseFitSlopeHits       = false;   
  fUseInterpolation      = false;      
  fUseSafeExtrapolationF = false; 
  fUseSafeExtrapolationB = false; 
  fUseLevelStripF        = false;         
  fUseLevelStripB        = false;         
  //************************************
  fUseExtrapolationF     = true;     
  fUseExtrapolationB     = true;     
  fUseSameStrip          = true;          
  //************************************

  // say goodbye
  MSG("AltDeMux", Msg::kDebug) << "AlgAltDeMuxBase::ClearArrays() DONE" << endl;
}


void AlgAltDeMuxBase::MakeAltListMap(CandDigitListHandle& cdlh)
{
  
  // Fill the arrays of {vectors of AltLists} which are to navigate through
  // the UNDEMUXed hits. Could have used Navigator instead but familiarity
  // won out. Arrays of vectors also provide a fast efficient method of
  // iterating over the data

  PlexSEIdAltL* paltlist;

  MSG("AltDeMux", Msg::kDebug) << "AlgAltDeMuxBase::MakeAltListMap" << endl;
  
  int ndigits = 0;
  fAbsTime = cdlh.GetAbsTime()*1.0E9;
  pCalculator->SetAbsTime(fAbsTime);

  CandDigitHandleItr cdhItr(cdlh.GetDaughterIterator());
  
  while ( CandDigitHandle *cdh = cdhItr() ) {
    // for each digit
    paltlist = &(cdh->GetPlexSEIdAltLWritable());
    int iplane = paltlist->GetPlane();
    if(!paltlist->IsVetoShield()){
      if(iplane>0&&iplane<MAX_NUMBER_OF_PLANES){
        if(paltlist->GetEnd()==StripEnd::kEast){
          fPlanesAltLists[iplane][ALG_EAST].push_back(paltlist);
        }else{
          fPlanesAltLists[iplane][ALG_WEST].push_back(paltlist);
        }
        fTimeList.push_back(paltlist->GetCurrentItem().GetTime()*1.0E9);
        fUVMap[iplane] = paltlist->GetPlaneView(); 
        ndigits++;
      }else{
        MSG("AltDeMux", Msg::kWarning) << "AlgAltDeMuxBase::MakeAltListMap => Plane out of array bounds : " << iplane << " - would give overflow (ignoring it)!" << endl;
      }
    }else{
      // MSG("AltDeMux", Msg::kVerbose) << "AlgAltDeMuxBase::MakeAltListMap => Veto Shield Plane : " << iplane << " - IGNORE IT !" << endl;
    }
  }

  return;
}

void  AlgAltDeMuxBase::MakePixelMap(CandDigitListHandle& cdlh)
{
  
  // Build up a map of charge deposits for each PMT pixel - for use in
  // crosstalk rejection. NOTE PMTmuxID is an internal number scheme
  // for FarDet PMTs

  PlexSEIdAltL* paltlist;
  
  CandDigitHandleItr cdhItr(cdlh.GetDaughterIterator());
  
  MSG("AltDeMux", Msg::kDebug) << "AlgAltDeMuxBase::MakePixelMap" << endl;

  while ( CandDigitHandle *cdh = cdhItr() ) {
    // for each digit
    paltlist = &(cdh->GetPlexSEIdAltLWritable());
    int iplane = paltlist->GetPlane();
    paltlist->SetFirst();
    
    if(!paltlist->IsVetoShield()){
      if(iplane>0&&iplane<MAX_NUMBER_OF_PLANES){

        PlexPixelSpotId pixelID = (paltlist->GetCurrentItem()).GetPixelSpotId(); 
        Int_t pixel  = pixelID.GetPixel();
        Int_t vaChannel = _pixelToVaChannel[pixel];
        Int_t PMTmuxID = pixelID.GetTube();
        PMTmuxID      += 3*pixelID.GetInRack();
        PMTmuxID      += 24*pixelID.GetRackBay();
        Char_t level = pixelID.GetRackLevel(); 
        Char_t ew = pixelID.GetEastWest(); 
        if(level=='U'){
          PMTmuxID += 450;
        }
        if(ew =='E'){
          PMTmuxID += 900;
        }
        //      Int_t uid = pixelID.GetUniquePmtEncodedValue();    

        if(PMTmuxID<MAX_NUMBER_OF_PMTS){
          Float_t q  = paltlist->GetCurrentItem().GetPE();
          Float_t qc = paltlist->GetCurrentItem().GetSigCorr()/60.;
          if(qc/q<0.1 || qc/q > 10.0){
            MSG("AltDeMux", Msg::kDebug) << "AlgAltDeMuxBase::MakePixelMap Large/small SigCor/SigPE ratio : " <<qc/q << " for Plane : " << iplane << endl;
            qc=q;
          }
          fPMTmap[PMTmuxID][pixel] += qc; 
          fVAmap[PMTmuxID][vaChannel] += qc; 
          fPMTtot[PMTmuxID]        += qc; 
        }else{
          MSG("AltDeMux", Msg::kError) << "AlgAltDeMuxBase::MakePixelMap => PMT out of array bounds : " << PMTmuxID << " ignoring it !" << endl;
        }
      }
    }
  }

  MSG("AltDeMux", Msg::kDebug) << "AlgAltDeMuxBase::MakePixelMap DONE" << endl;

  return;
}



void  AlgAltDeMuxBase::StripNoise()
{
  
  // Attempt to identify and remove probably out-of-time noise hits. 

  Int_t nNoiseHits=0;
  bool ok;

  if(fTimeList.size()==0){
    return;
  }

  sort(fTimeList.begin(),fTimeList.end());
  Int_t median = static_cast<Int_t>(fTimeList.size()*0.5);
  Float_t medianTime = fTimeList[median];


  MSG("AltDeMux", Msg::kVerbose) << "AlgAltDeMuxBase::StripNoiseHits - Median hit time : " << medianTime << endl;

  vector <PlexSEIdAltL*>::iterator literA;

  // Identify noise hits and store in fNoisePlanesAltLists 

  for(int iplane=0; iplane<MAX_NUMBER_OF_PLANES; iplane++){
    for(int iew = 0; iew<=1; iew++){
      if(fPlanesAltLists[iplane][iew].size()>0){
        literA = fPlanesAltLists[iplane][iew].begin();
        while (literA != fPlanesAltLists[iplane][iew].end()){
          if( (*literA)->GetCurrentItem().GetPE()<1.5){
            if(fabs(  (*literA)->GetCurrentItem().GetTime()*1E9-medianTime)>fNoiseTimeWindow){
              MSG("AltDeMux", Msg::kVerbose) << "AlgAltDeMuxBase::StripNoiseHits - Noise Hit in plane : " << iplane << " q : " << (*literA)->GetCurrentItem().GetPE() << " time : " << (*literA)->GetCurrentItem().GetTime()*1E9 << endl; 
              fNoisePlanesAltLists[iplane][iew].push_back(*literA);
              nNoiseHits++;
            }
          }
          *literA++;
        }
      }
    }
  }


  // Remove noise hits from fPlanesAltLists 

  for(int iplane=0; iplane<MAX_NUMBER_OF_PLANES; iplane++){
    for(int iew = 0; iew<=1; iew++){
      if(fNoisePlanesAltLists[iplane][iew].size()>0){
        literA = fNoisePlanesAltLists[iplane][iew].begin();
        while (literA != fNoisePlanesAltLists[iplane][iew].end()){
          ok = RemoveFromPlanesList(iplane,iew,*literA);
          if(!ok)MSG("AltDeMux", Msg::kError) << "AlgAltDeMuxBase::StripNoiseHits - hit not found !" << endl;
          *literA++;
        }
      }
    }
  }

  return;
}

bool AlgAltDeMuxBase::RemoveFromPlanesList(Int_t iplane, Int_t iew, PlexSEIdAltL* paltlist)
{

  // Find and remove an PlexSEIdAltL* from the fPlanesAltList array
  // which stores undemuxed hits.

  vector <PlexSEIdAltL*>::iterator literA;


  literA = fPlanesAltLists[iplane][iew].begin();
  while (literA != fPlanesAltLists[iplane][iew].end()){
    if( (*literA)==paltlist ){
      fPlanesAltLists[iplane][iew].erase(literA);
      return true;
    }
    literA++;
  }

  return false;
  
}

bool AlgAltDeMuxBase::RemoveSingle(Int_t iplane, PlexSEIdAltL* paltlist)
{

  // Find and remove an PlexSEIdAltL* from the fDeMuxedSingles array
  // which stores undemuxed hits.

  vector <DeMuxedSingle>::iterator literA;
 
  literA = fDeMuxedSingles[iplane].begin();
  while (literA != fDeMuxedSingles[iplane].end()){
    if( (*literA).altList==paltlist ){
      fDeMuxedSingles[iplane].erase(literA);
      return true;
    }
    literA++;
  }

  return false;
  
}


void  AlgAltDeMuxBase::StripCrossTalk(CandDeMuxDigitListHandle& cdlh)
{

  // Loop over all hits (stored in fPlanesAltList array) and use PMT
  // map to decide whether hit is likely to be cross-talk. If a hit
  //

  MSG("AltDeMux", Msg::kDebug) << "AlgAltDeMuxBase::StripCrossTalk" << endl;

  Int_t nXTalkHits=0;
  vector <PlexSEIdAltL*>::iterator literA;

  for(int iplane=0; iplane<MAX_NUMBER_OF_PLANES; iplane++){
    for(int iew = ALG_EAST; iew<=ALG_WEST; iew++){
      if(fPlanesAltLists[iplane][iew].size()>0){
        literA = fPlanesAltLists[iplane][iew].begin();
        while (literA != fPlanesAltLists[iplane][iew].end()){
          if(IsXTalk(*literA)){
            fXTalkPlanesAltLists[iplane][iew].push_back(*literA);
            MSG("AltDeMux", Msg::kVerbose) << "AlgAltDeMuxBase::StripCrossTalk - remove hit" << endl;
            nXTalkHits++;
          }
          literA++;
        }
      }
    }
  }


  // Remove cross talk hits from fPlanesAltLists 

  for(int iplane=0; iplane<MAX_NUMBER_OF_PLANES; iplane++){
    for(int iew = ALG_EAST; iew<=ALG_WEST; iew++){
      if(fXTalkPlanesAltLists[iplane][iew].size()>0){
        literA = fXTalkPlanesAltLists[iplane][iew].begin();
        while (literA != fXTalkPlanesAltLists[iplane][iew].end()){
          bool ok = RemoveFromPlanesList(iplane,iew,*literA);
          if(!ok)MSG("AltDeMux", Msg::kError) << "AlgAltDeMuxBase::StripCrossTalk - hit not found !" << endl;
          *literA++;
        }
      }
    }
  }

  this->TagCrossTalk(cdlh);

  MSG("AltDeMux", Msg::kDebug) << "AlgAltDeMuxBase::StripCrossTalk DONE" << endl;

  return;

}



void  AlgAltDeMuxBase::ReTagCrossTalk(CandDeMuxDigitListHandle& cdlh)
{


  CandDeMuxDigitHandleItr cdhItr(cdlh.GetDaughterIterator());
  
  while ( CandDeMuxDigitHandle *digit = cdhItr() ) {
    // for each digit
    PlexSEIdAltL* paltlist = &(digit->GetPlexSEIdAltLWritable());
    amShowing = false;
    paltlist->GetBestItem();
    if(!paltlist->IsValid())paltlist->SetFirst();
    if(paltlist->IsValid()){
      Int_t dmxXTalk = digit->GetDeMuxDigitFlagWord();
      if(dmxXTalk==0){
        if(IsXTalk(paltlist)){
          digit->SetDeMuxDigitFlagBit(CandDeMuxDigit::kXTalk);  
        }
      }else{
      }
    }else{
      //cout << "INVALID ALTLIST ! " << endl;
    }
    amShowing = false;
  }

  return;

}



void  AlgAltDeMuxBase::FinalReTagCrossTalk(CandDeMuxDigitListHandle& cdlh)
{

  CandDeMuxDigitHandleItr cdhItr(cdlh.GetDaughterIterator());
  
  while ( CandDeMuxDigitHandle *digit = cdhItr() ) {
    // for each digit
    PlexSEIdAltL* paltlist = &(digit->GetPlexSEIdAltLWritable());
    if(paltlist->GetSize()==0){
      // pixel spot does not correspond to valid strip - tag as xtalk 
      digit->SetDeMuxDigitFlagBit(CandDeMuxDigit::kXTalk);  
      return;
    }
    amShowing = false;
    paltlist->GetBestItem();
    if(!paltlist->IsValid())paltlist->SetFirst();
    if(paltlist->IsValid()){
      Int_t dmxXTalk = digit->GetDeMuxDigitFlagWord();
      if(dmxXTalk==0){
        if(IsXTalk(paltlist)){
          digit->SetDeMuxDigitFlagBit(CandDeMuxDigit::kXTalk);  
        }else{
          digit->UnSetDeMuxDigitFlagBit(CandDeMuxDigit::kXTalk);
        }
      }
      float Q     = paltlist->GetBestItem().GetSigCorr()/60.; 
      float qspot = PredictedSpotQ(paltlist);
      float dist = DistanceToNearestInPlane(paltlist);
      if(dmxXTalk!=0){
        if(dist==0){
          digit->UnSetDeMuxDigitFlagBit(CandDeMuxDigit::kXTalk);
          //      cout << "****************************UNSET XTALK FLAG !!!! " << Q << endl; 
        }
        if(dist==1){
          if(Q>3)digit->UnSetDeMuxDigitFlagBit(CandDeMuxDigit::kXTalk);
          //cout << "****************************UNSET XTALK FLAG !!!! " << Q << endl; 
        }
        if(dist==2){
          if(Q>5)digit->UnSetDeMuxDigitFlagBit(CandDeMuxDigit::kXTalk);
          //cout << "****************************UNSET XTALK FLAG !!!! " << Q << endl; 
        }
      }else{
        if(dist>8){
          if(qspot/Q>0.001&&Q<4)digit->SetDeMuxDigitFlagBit(CandDeMuxDigit::kXTalk);
        }
      }
    }else{
      //cout << "INVALID ALTLIST ! " << endl;
    }
    amShowing = false;
  }

  return;

}


Float_t AlgAltDeMuxBase::DistanceToNearestInPlane(PlexSEIdAltL* paltlist)
{

  Float_t dmin=999;
  PlexStripEndId  seid;
  PlexStripEndId dseid;
  
  int iplane = paltlist->GetPlane();
  seid = paltlist->GetBestSEId();
  int strip = seid.GetStrip();

  if(iplane>MAX_NUMBER_OF_PLANES)return dmin;

  for(int iew = ALG_EAST; iew<=ALG_WEST; iew++){
    for(unsigned int i=0;i<fDeMuxedPlanesAltLists[iplane][iew].size();i++){
      if(fDeMuxedPlanesAltLists[iplane][iew][i]!=paltlist){
        dseid = fDeMuxedPlanesAltLists[iplane][iew][i]->GetBestSEId();
        int dstrip = dseid.GetStrip();
        int d = abs(dstrip-strip);
        if(d<dmin)dmin=d;
      }
    }
  }

  return dmin;
}


Float_t AlgAltDeMuxBase::PredictedSpotQ(PlexSEIdAltL* paltlist)
{ 
  
  PlexPixelSpotId pixelID = (paltlist->GetBestItem()).GetPixelSpotId(); 
  Int_t pixel  = pixelID.GetPixel();
  Int_t PMTmuxID = pixelID.GetTube();
  PMTmuxID      += 3*pixelID.GetInRack();
  PMTmuxID      += 24*pixelID.GetRackBay();
  Char_t level = pixelID.GetRackLevel(); 
  Char_t ew = pixelID.GetEastWest(); 
  if(level=='U')PMTmuxID += 450;
  if(ew =='E')PMTmuxID += 900;

  return fXTalkmap[PMTmuxID][pixel];

} 

void  AlgAltDeMuxBase::TagCrossTalk(CandDeMuxDigitListHandle& cdlh)
{
  
  PlexSEIdAltL* paltlist;
  vector <PlexSEIdAltL*>::iterator literA;
  
  CandDeMuxDigitHandleItr cdhItr(cdlh.GetDaughterIterator());
  
  MSG("AltDeMux", Msg::kVerbose) << "AlgAltDeMuxBase::MakePixelMap" << endl;

  while ( CandDeMuxDigitHandle *digit = cdhItr() ) {
    // for each digit
    paltlist = &(digit->GetPlexSEIdAltLWritable());
    int iplane = paltlist->GetPlane();
    for(int iew = ALG_EAST; iew<=ALG_WEST; iew++){
      if(fXTalkPlanesAltLists[iplane][iew].size()>0){
        literA = fXTalkPlanesAltLists[iplane][iew].begin();
        while (literA != fXTalkPlanesAltLists[iplane][iew].end()){
          if(*literA==paltlist){
            digit->SetDeMuxDigitFlagBit(CandDeMuxDigit::kXTalk);  
          }
          *literA++;
        }
      }
    }
  }

  return;
}


void  AlgAltDeMuxBase::AddBackCrossTalk()
{

  vector <PlexSEIdAltL*>::iterator literA;

  for(int iplane=0; iplane<MAX_NUMBER_OF_PLANES; iplane++){
    for(int iew = ALG_EAST; iew<=ALG_WEST; iew++){
      if(fXTalkPlanesAltLists[iplane][iew].size()>0){
        literA = fXTalkPlanesAltLists[iplane][iew].begin();
        while (literA != fXTalkPlanesAltLists[iplane][iew].end()){
          fPlanesAltLists[iplane][iew].push_back(*literA);
          literA++;
        }
        fXTalkPlanesAltLists[iplane][iew].erase(fXTalkPlanesAltLists[iplane][iew].begin(),fXTalkPlanesAltLists[iplane][iew].end());
      }

    }
  }

  return;

}





void  AlgAltDeMuxBase::AddBackNoise()
{
  vector <PlexSEIdAltL*>::iterator literA;

  for(int iplane=0; iplane<MAX_NUMBER_OF_PLANES; iplane++){
    for(int iew = ALG_EAST; iew<=ALG_WEST; iew++){
      if(fNoisePlanesAltLists[iplane][iew].size()>0){
        literA = fNoisePlanesAltLists[iplane][iew].begin();
        while (literA != fNoisePlanesAltLists[iplane][iew].end()){
          fPlanesAltLists[iplane][iew].push_back(*literA);
          literA++;
        }
        fNoisePlanesAltLists[iplane][iew].erase(fNoisePlanesAltLists[iplane][iew].begin(),fNoisePlanesAltLists[iplane][iew].end());
      }

    }
  }

  return;

}




void  AlgAltDeMuxBase::FillLowestHighest()
{

  bool first=true;
  bool last =true;
  fLowestPlane = 0;
  fHighestPlane = MAX_NUMBER_OF_PLANES-1;

  for(Int_t iplane=0; iplane<MAX_NUMBER_OF_PLANES; iplane++){
    if(fPlanesAltLists[iplane][ALG_EAST].size()>0||fPlanesAltLists[iplane][ALG_WEST].size()>0){
      if(first){
        Int_t nextPlane=999;
        bool carryOn = true;
        for(Int_t j = iplane+1; carryOn && j < MAX_NUMBER_OF_PLANES; j++){
          if(fPlanesAltLists[j][ALG_EAST].size()>0||
             fPlanesAltLists[j][ALG_WEST].size()>0){
            nextPlane = j;
            carryOn = false;
          }
        }
        if((nextPlane-iplane)<10){
          first = false;
          fLowestPlane = iplane;
        }
      }
    }
  }


  for(Int_t iplane=MAX_NUMBER_OF_PLANES-1; iplane>0; iplane--){
    if(fPlanesAltLists[iplane][ALG_EAST].size()>0||fPlanesAltLists[iplane][ALG_WEST].size()>0){
      if(last){
        Int_t nextPlane=-999;
        bool carryOn = true;

        for(Int_t j = iplane-1; carryOn && j >= 0; j--){
          if(fPlanesAltLists[j][ALG_EAST].size()>0||
             fPlanesAltLists[j][ALG_WEST].size()>0){
            nextPlane = j;
            carryOn = false;
          }
        }
        if((iplane-nextPlane)<10){
          last = false;
          fHighestPlane = iplane;
        }
      }
    }
  }

  return;

}


void AlgAltDeMuxBase::Setup() 
{
  pMaster = new AltDeMuxPatternMaster();
  for(int i=0;i<MAX_NUMBER_OF_PMTS;i++){
    fPMTtot[i] = 0;
  }
  amPSing   = false;
  amHisting   = false;

  return;

}


void AlgAltDeMuxBase::GetFibreLengths()
{
  // Store the fibre lengths for strips in this event.  

  UgliStripHandle ush;
  vector <PlexSEIdAltL*>::iterator literA;

  MSG("AltDeMux", Msg::kVerbose) << "AlgAltDeMuxBase::GetFibreLengths " << endl;
 
  for(Int_t iplane=0;iplane<MAX_NUMBER_OF_PLANES;iplane++){
    for(Int_t iew = ALG_EAST; iew <= ALG_WEST; iew++){
      if(fPlanesAltLists[iplane][iew].size()>0){
        literA = fPlanesAltLists[iplane][iew].begin();
        while (literA != fPlanesAltLists[iplane][iew].end()){
          (*literA)->SetFirst();
          while( (*literA)->IsValid() ){
            ush = pUgh->GetStripHandle((*literA)->GetCurrentSEId());
            if(!ush.IsValid())MSG("AltDeMux", Msg::kFatal) << "AlgAltDeMuxBase::GetFibreLengths => UgliStripHandle NOT VALID : plane " << iplane << " (Carry on regardless)" <<  endl;
            if(iew==ALG_EAST)pCalculator->SetFibreLengthE(iplane,*literA);
            if(iew==ALG_WEST)pCalculator->SetFibreLengthW(iplane,*literA);
            (*literA)->Next();
          }
          *literA++;
        }
      }
    }
  }
  return;

}

void AlgAltDeMuxBase::MakeTimingMask(bool useMask){
  
  vector <PlexSEIdAltL*>::iterator literE;
  vector <PlexSEIdAltL*>::iterator literW;

  // if diagnostic/debug
  if(fDiagnosticPlots){
    if ( fUTime ) { delete fUTime; fUTime=0; }
    if ( fVTime ) { delete fVTime; fVTime=0; }
    fUTime = new TH2F("UTime","U time view",501,-0.5,500.5,193,0.,193.);
    fVTime = new TH2F("VTime","V time view",501,-0.5,500.5,193,0.,193.);
    fUTime->SetStats(kFALSE);
    fVTime->SetStats(kFALSE);
  }

  for(int iplane=0;iplane<MAX_NUMBER_OF_PLANES;iplane++){
    fMaskGroup[iplane].erase(fMaskGroup[iplane].begin(),fMaskGroup[iplane].end());
    fInMask[iplane] =  0;
    if(fPlanesAltLists[iplane][ALG_EAST].size()>0||fPlanesAltLists[iplane][ALG_WEST].size()>0){
      // Reset timing mask strip targets and target groups for this palne 
      for(int istrip=0;istrip<=MAX_NUMBER_OF_STRIPS;istrip++){
        fTimingMask[iplane][istrip] = false;
      }
    }

    if(fPlanesAltLists[iplane][ALG_EAST].size()>0&&fPlanesAltLists[iplane][ALG_WEST].size()>0){
      literE = fPlanesAltLists[iplane][ALG_EAST].begin();
      PlaneView::PlaneView_t kView = (*literE)->GetPlaneView();
      pCalculator->SetPlane(iplane);
      pCalculator->SetView(kView);
      while (literE != fPlanesAltLists[iplane][ALG_EAST].end()){
        literW = fPlanesAltLists[iplane][ALG_WEST].begin();
        while ( literW != fPlanesAltLists[iplane][ALG_WEST].end()){
          (*literE)->SetFirst();
          while( (*literE)->IsValid() ){
            Int_t  iStripE = (*literE)->GetCurrentSEId().GetStrip();
            pCalculator->SetEast(*literE,iStripE);
            bool goodComb = true;
            if(useMask && fUVmask[iplane][iStripE]==false)goodComb = false; 
            if(goodComb){             
              (*literW)->SetFirst();
              while( (*literW)->IsValid() ){
                Int_t  iStripW = (*literW)->GetCurrentSEId().GetStrip();
                if(iStripE==iStripW){
                  // In here we can check for a possibility
                  pCalculator->SetWest(*literW,iStripW);
                  pCalculator->CalcEastWest();
                  if(fabs(pCalculator->SigmaDQ())<4.0){
                    Int_t isaim = pCalculator->StripAim();
                    fInMask[iplane]++;
                    fTimingMask[iplane][isaim] = true;
                    if(fDiagnosticPlots){
                      if(kView==PlaneView::kV)fUTime->Fill(iplane,isaim,1.);
                      if(kView==PlaneView::kU)fVTime->Fill(iplane,isaim,1.);
                    }
                  }
                }
                (*literW)->Next();
              }
            }
            (*literE)->Next();
          }
          literW++;
        }
        literE++;
      }
    }
  }

  if(fDiagnosticPlots)this->DrawDiagnosticPlots(-2);

  this->MakeMaskGroups();

  for(int iplane=0;iplane<MAX_NUMBER_OF_PLANES;iplane++){
    if(fPlanesAltLists[iplane][ALG_EAST].size()>0||fPlanesAltLists[iplane][ALG_WEST].size()>0){
      bool found = false;
      if(iplane==0){
        int ip = 1;
        int ipp = 3; 
        found = found || MaskExtrapolateBack(iplane,ip,ipp);
      }else{
        // For planes with hits : check surrounding planes
        int im=iplane-1;
        int ip=iplane+1;
        found = found || MaskInterpolate(iplane,im,ip);
        if(!found){
          int imm = iplane-3;
          int ipp = iplane+3;
          if(imm>=0)found = found || MaskInterpolate(iplane,imm,ip);
          if(ipp<499)found = MaskInterpolate(iplane,im,ipp) || found;
          if(!found){
            if(imm>=0)found = found || MaskExtrapolateForwards(iplane,imm,im);
            if(ipp<499)found = MaskExtrapolateBack(iplane,ip,ipp) || found;
          }
        }
      }
      if(!found)for(int istrip=0;istrip<fNumberOfStrips;istrip++)this->SetMask(iplane,istrip);
    }
  }  

  if(fDiagnosticPlots)this->DrawDiagnosticPlots(-1);

  return;
  
} 






void AlgAltDeMuxBase::ReMakeTimingMask(bool useMask){
  
  vector <PlexSEIdAltL*>::iterator literE;
  vector <PlexSEIdAltL*>::iterator literW;

  // if diagnostic/debug
  if(fDiagnosticPlots){
    if ( fUTime ) { delete fUTime; fUTime=0; }
    if ( fVTime ) { delete fVTime; fVTime=0; }
    fUTime = new TH2F("UTime","U time view",501,-0.5,500.5,193,0.,193.);
    fVTime = new TH2F("VTime","V time view",501,-0.5,500.5,193,0.,193.);
    fUTime->SetStats(kFALSE);
    fVTime->SetStats(kFALSE);
  }

  for(int iplane=0;iplane<MAX_NUMBER_OF_PLANES;iplane++){
    fMaskGroup[iplane].erase(fMaskGroup[iplane].begin(),fMaskGroup[iplane].end());
    fInMask[iplane] =  0;
    if(fDeMuxedPlanesAltLists[iplane][ALG_EAST].size()>0||fDeMuxedPlanesAltLists[iplane][ALG_WEST].size()>0){
      // Reset timing mask strip targets and target groups for this palne 
      for(int istrip=0;istrip<=MAX_NUMBER_OF_STRIPS;istrip++){
        fTimingMask[iplane][istrip] = false;
      }
    }

    if(fDeMuxedPlanesAltLists[iplane][ALG_EAST].size()>0&&fDeMuxedPlanesAltLists[iplane][ALG_WEST].size()>0){
      literE = fDeMuxedPlanesAltLists[iplane][ALG_EAST].begin();
      PlaneView::PlaneView_t kView = (*literE)->GetPlaneView();
      pCalculator->SetPlane(iplane);
      pCalculator->SetView(kView);
      while (literE != fDeMuxedPlanesAltLists[iplane][ALG_EAST].end()){
        literW = fDeMuxedPlanesAltLists[iplane][ALG_WEST].begin();
        while ( literW != fDeMuxedPlanesAltLists[iplane][ALG_WEST].end()){
          (*literE)->SetFirst();
          while( (*literE)->IsValid() ){
            Int_t  iStripE = (*literE)->GetCurrentSEId().GetStrip();
            pCalculator->SetEast(*literE,iStripE);
            bool goodComb = true;
            if(useMask && fUVmask[iplane][iStripE]==false)goodComb = false; 
            if(goodComb){             
              (*literW)->SetFirst();
              while( (*literW)->IsValid() ){
                Int_t  iStripW = (*literW)->GetCurrentSEId().GetStrip();
                pCalculator->SetWest(*literW,iStripW);
                // In here we can check for a possibility
                if(iStripE==iStripW){
                  pCalculator->CalcEastWest();
                  if(fabs(pCalculator->SigmaDQ())<3.0){
                    Int_t isaim = pCalculator->StripAim();
                    fInMask[iplane]++;
                    fTimingMask[iplane][isaim] = true;
                    if(fDiagnosticPlots){
                      if(kView==PlaneView::kV)fUTime->Fill(iplane,isaim,1.);
                      if(kView==PlaneView::kU)fVTime->Fill(iplane,isaim,1.);
                    }
                  }
                }
                (*literW)->Next();
              }
            }
            (*literE)->Next();
          }
          literW++;
        }
        literE++;
      }
    }
  }

  if(fDiagnosticPlots)this->DrawDiagnosticPlots(-2);

  this->MakeMaskGroups();

  for(int iplane=0;iplane<MAX_NUMBER_OF_PLANES;iplane++){
    if(fDeMuxedPlanesAltLists[iplane][ALG_EAST].size()>0||fDeMuxedPlanesAltLists[iplane][ALG_WEST].size()>0){
      bool found = false;
      if(iplane==0){
        int ip = 1;
        int ipp = 3; 
        found = found || MaskExtrapolateBack(iplane,ip,ipp);
      }else{
        // For planes with hits : check surrounding planes
        int im=iplane-1;
        int ip=iplane+1;
        found = found || MaskInterpolate(iplane,im,ip);
        if(!found){
          int imm = iplane-3;
          int ipp = iplane+3;
          if(imm>=0)found = found || MaskInterpolate(iplane,imm,ip);
          if(ipp<499)found = found || MaskInterpolate(iplane,im,ipp);
          if(!found){
            if(imm>=0)found = found || MaskExtrapolateForwards(iplane,imm,im);
            if(ipp<499)found = found || MaskExtrapolateBack(iplane,ip,ipp);
          }
        }
      }
      if(!found)for(int istrip=0;istrip<fNumberOfStrips;istrip++)this->SetMask(iplane,istrip);
    }
  }  

  if(fDiagnosticPlots)this->DrawDiagnosticPlots(-1);
  if(fDiagnosticPlots)this->DrawDiagnosticPlots(1);

  return;
  
} 








bool AlgAltDeMuxBase::MaskInterpolate(int i, int im, int ip)
{
  bool found = false;
  if(fMaskGroup[im].size()>0&&fMaskGroup[ip].size()>0){
    found = true;
    int lm = i-im;
    int lp = ip-i;
    int lt = lp+lm;
    for(unsigned int jm = 0; jm < fMaskGroup[im].size();jm++){
      for(int km = fMaskGroup[im][jm].groupStart; km<= fMaskGroup[im][jm].groupEnd;km++)this->SetMask(i,km);
      for(unsigned int jp = 0; jp < fMaskGroup[ip].size();jp++){
        for(int kp = fMaskGroup[ip][jp].groupStart; kp<= fMaskGroup[ip][jp].groupEnd;kp++)this->SetMask(i,kp);
        for(int k = (fMaskGroup[im][jm].groupStart*lp+fMaskGroup[ip][jp].groupStart*lm)/lt; k<= (fMaskGroup[im][jm].groupEnd*lp+fMaskGroup[ip][jp].groupEnd*lm)/lt;k++){
          this->SetMask(i,k);
        }
      } 
    }  
  }
  return found;
}


bool AlgAltDeMuxBase::MaskExtrapolateBack(int i, int ip, int ipp)
{
  bool found = false;
  if(fMaskGroup[ip].size()>0&&fMaskGroup[ipp].size()>0){
    found = true;
    int lp  = ip-i;
    int lpp = ipp-i;
    int lt  = lpp-lp;
    for(unsigned int jp = 0; jp < fMaskGroup[ip].size();jp++){
      for(int kp = fMaskGroup[ip][jp].groupStart; kp<= fMaskGroup[ip][jp].groupEnd;kp++)this->SetMask(i,kp);
      for(unsigned int jpp = 0; jpp < fMaskGroup[ipp].size();jpp++){
        int ilow = (lpp*fMaskGroup[ip][jp].groupStart-lp*fMaskGroup[ipp][jpp].groupEnd)/lt;
        if(ilow<0)ilow=0;
        int ihigh = (lpp*fMaskGroup[ip][jp].groupEnd-lp*fMaskGroup[ipp][jpp].groupStart)/lt;
        if(ihigh>=MAX_NUMBER_OF_PLANES)ihigh=MAX_NUMBER_OF_PLANES-1;
        for(int kp = ilow; kp<=ihigh ;kp++)this->SetMask(i,kp);
      } 
    }  
  }
  return found;
}

bool AlgAltDeMuxBase::MaskExtrapolateForwards(int i, int imm, int im)
{
  bool found = false;
  if(fMaskGroup[im].size()>0&&fMaskGroup[imm].size()>0){
    found = true;
    int lm  = im-i;
    int lmm = imm-i;
    int lt  = lmm-lm;
    for(unsigned int jm = 0; jm < fMaskGroup[im].size();jm++){
      for(int km = fMaskGroup[im][jm].groupStart; km<= fMaskGroup[im][jm].groupEnd;km++)this->SetMask(i,km);
      for(unsigned int jmm = 0; jmm < fMaskGroup[imm].size();jmm++){
        int ilow = (lmm*fMaskGroup[im][jm].groupStart-lm*fMaskGroup[imm][jmm].groupEnd)/lt;
        int ihigh = (lmm*fMaskGroup[im][jm].groupEnd-lm*fMaskGroup[imm][jmm].groupStart)/lt;
        if(ilow<0)ilow=0;
        if(ihigh>192)ihigh=192;
        for(int km =ilow ; km<=ihigh ;km++)this->SetMask(i,km);
      } 
    }  
  }
  return found;
}



void AlgAltDeMuxBase::SetMask(int ip, int is)
{
  
  fUVmask[ip][is] = true;
  Int_t iuv = 0;
  
  if(fDiagnosticPlots){
    if(ip<249)iuv = (ip%2)+1;
    if(ip>249)iuv  = ((ip+1)%2)+1;
    if(iuv==1)fUMask->Fill(ip,is,1.0);
    if(iuv==2)fVMask->Fill(ip,is,1.0);
  }
  return;
}



void AlgAltDeMuxBase::ResetTimingMask()
{
  
  for(int iplane=0;iplane<MAX_NUMBER_OF_PLANES;iplane++){
    for(int istrip=0;istrip<MAX_NUMBER_OF_STRIPS;istrip++){
      fUVmask[iplane][istrip] = false;
    }
  }

  if(fDiagnosticPlots){
    if ( fUMask ) { delete fUMask; fUMask=0; }
    if ( fVMask ) { delete fVMask; fVMask=0; }
    fUMask = new TH2F("UMask","U view mask",501,-0.5,500.5,193,0.,193.);
    fVMask = new TH2F("VMask","V view mask",501,-0.5,500.5,193,0.,193.);
    fUMask->SetStats(kFALSE);
    fVMask->SetStats(kFALSE);
  }

}

void AlgAltDeMuxBase::MakeMaskGroups()
{
   
  ResetTimingMask();
  fTimingMaskWindow = static_cast<Int_t>(2.5*fSigmaStripFromTiming);

  for(int i=0;i<MAX_NUMBER_OF_PLANES;i++){
    if(fInMask[i]>0){
      DeMuxMaskGroup gm;
      bool inGroup = false;
      int groupS = -999;
      int groupE   = +999;
      for(int j=0;j<fNumberOfStrips;j++){
        if(inGroup){
          if(j>groupE+fTimingMaskWindow){
            inGroup = false;
            gm.groupStart = groupS;
            gm.groupEnd = groupE;
            fMaskGroup[i].push_back(gm);
          }
        }
        if(fTimingMask[i][j]){
          if(inGroup){
            groupE = j + fTimingMaskWindow;
            if(groupE>=fNumberOfStrips)groupE=fNumberOfStrips-1;
          }else{
            inGroup = true;
            groupS = j - fTimingMaskWindow;
            groupE = j + fTimingMaskWindow;
            if(groupS<0)groupS=0;
            if(groupE>=fNumberOfStrips)groupE=fNumberOfStrips-1;
          }
        }
      }
      if(inGroup){
        groupE = fNumberOfStrips-1;
        gm.groupStart = groupS;
        gm.groupEnd = groupE;
        fMaskGroup[i].push_back(gm);
      }
    }
  }
  return;
}







void AlgAltDeMuxBase::PrintMap(Int_t ne, Int_t nw){
  

  cout << "Print Map " << ne << " : " << nw << endl;
  for(Int_t ie=0;ie<=ne;ie++){
    for(Int_t iw=0;iw<=nw;iw++){
      cout << fAmap[ie][iw];
    }
    cout << endl;
  }

  return;
} 

void AlgAltDeMuxBase::ResetMap(Int_t ne, Int_t nw){
  
  for(Int_t ie=0;ie<=ne;ie++){
    for(Int_t iw=0;iw<=nw;iw++){
      fAmap[ie][iw] = false;
    }
  }

  return;
} 

bool AlgAltDeMuxBase::IsXTalk(PlexSEIdAltL* paltlist, bool useBest)
{ 

  Float_t crossTalk=0.0;
  Float_t diagCrossTalk=0.0;
  bool result = false;

  PlexPixelSpotId pixelID;
  if(!useBest)pixelID = (paltlist->GetCurrentItem()).GetPixelSpotId(); 
  if(useBest)pixelID = (paltlist->GetBestItem()).GetPixelSpotId(); 
  Int_t pixel  = pixelID.GetPixel();
  Int_t PMTmuxID = pixelID.GetTube();
  PMTmuxID      += 3*pixelID.GetInRack();
  PMTmuxID      += 24*pixelID.GetRackBay();
  Char_t level = pixelID.GetRackLevel(); 
  Char_t ew = pixelID.GetEastWest(); 
  if(level=='U')PMTmuxID += 450;
  if(ew =='E')PMTmuxID += 900;

  if(PMTmuxID>=MAX_NUMBER_OF_PMTS){
    MSG("AltDeMux", Msg::kError) << "AlgAltDeMuxBase::IsXTalk => PMT out of array bounds : " <<    PMTmuxID << " would give array overflow!" << endl;
    return false;
  }

  Float_t q  = paltlist->GetCurrentItem().GetPE();
  Float_t qc = paltlist->GetCurrentItem().GetSigCorr()/60.;
  
  if(qc/q<0.1 || qc/q > 10.0){
    //cout << " BUGGERED " << qc << ":" << q << endl;
    qc=q;
  }


  switch(pixel){
  case 0:
    crossTalk = fPMTmap[PMTmuxID][1] + 
      fPMTmap[PMTmuxID][4];
    diagCrossTalk = fPMTmap[PMTmuxID][5];
    break;
  case 1:
    crossTalk = fPMTmap[PMTmuxID][0] + 
      fPMTmap[PMTmuxID][2] +
      fPMTmap[PMTmuxID][5];
    diagCrossTalk = fPMTmap[PMTmuxID][4]+
      fPMTmap[PMTmuxID][6];
    break;
  case 2:
    crossTalk = fPMTmap[PMTmuxID][1] + 
      fPMTmap[PMTmuxID][3] +
      fPMTmap[PMTmuxID][6];
    diagCrossTalk = fPMTmap[PMTmuxID][5]+
      fPMTmap[PMTmuxID][7];
    break;
  case 3:
    crossTalk = fPMTmap[PMTmuxID][2] + 
      fPMTmap[PMTmuxID][7];
    diagCrossTalk = fPMTmap[PMTmuxID][6];
    break;
  case 4:
    crossTalk = fPMTmap[PMTmuxID][0] + 
      fPMTmap[PMTmuxID][5] +
      fPMTmap[PMTmuxID][8];
    diagCrossTalk = fPMTmap[PMTmuxID][1]+
      fPMTmap[PMTmuxID][9];
    break;
  case 5:
    crossTalk = fPMTmap[PMTmuxID][1] + 
      fPMTmap[PMTmuxID][4] +
      fPMTmap[PMTmuxID][6] +
      fPMTmap[PMTmuxID][9];
    diagCrossTalk = fPMTmap[PMTmuxID][0]+
      fPMTmap[PMTmuxID][2] +
      fPMTmap[PMTmuxID][8] +
      fPMTmap[PMTmuxID][10];
    break;
  case 6:
    crossTalk = fPMTmap[PMTmuxID][2] + 
      fPMTmap[PMTmuxID][5] +
      fPMTmap[PMTmuxID][7] +
      fPMTmap[PMTmuxID][10];
    diagCrossTalk = fPMTmap[PMTmuxID][1]+
      fPMTmap[PMTmuxID][3] +
      fPMTmap[PMTmuxID][9] +
      fPMTmap[PMTmuxID][11];
    break;
  case 7:
    crossTalk = fPMTmap[PMTmuxID][3] + 
      fPMTmap[PMTmuxID][6] +
      fPMTmap[PMTmuxID][11];
    diagCrossTalk = fPMTmap[PMTmuxID][2]+
      fPMTmap[PMTmuxID][10];
    break;
  case 8:
    crossTalk = fPMTmap[PMTmuxID][4] + 
      fPMTmap[PMTmuxID][9] +
      fPMTmap[PMTmuxID][12];
    diagCrossTalk = fPMTmap[PMTmuxID][5]+
      fPMTmap[PMTmuxID][13];
    break;
  case 9:
    crossTalk = fPMTmap[PMTmuxID][5] + 
      fPMTmap[PMTmuxID][8] +
      fPMTmap[PMTmuxID][10] +
      fPMTmap[PMTmuxID][13];
    diagCrossTalk = fPMTmap[PMTmuxID][4]+
      fPMTmap[PMTmuxID][6] +
      fPMTmap[PMTmuxID][12] +
      fPMTmap[PMTmuxID][14];
    break;
  case 10:
    crossTalk = fPMTmap[PMTmuxID][6] + 
      fPMTmap[PMTmuxID][9] +
      fPMTmap[PMTmuxID][11] +
      fPMTmap[PMTmuxID][14];
    diagCrossTalk = fPMTmap[PMTmuxID][5]+
      fPMTmap[PMTmuxID][7] +
      fPMTmap[PMTmuxID][13] +
      fPMTmap[PMTmuxID][15];
    break;
  case 11:
    crossTalk = fPMTmap[PMTmuxID][7] + 
      fPMTmap[PMTmuxID][10] +
      fPMTmap[PMTmuxID][15];
    diagCrossTalk = fPMTmap[PMTmuxID][6]+
      fPMTmap[PMTmuxID][14];
    break;
  case 12:
    crossTalk = fPMTmap[PMTmuxID][8] + 
      fPMTmap[PMTmuxID][13];
    diagCrossTalk = fPMTmap[PMTmuxID][9];
    break;
  case 13:
    crossTalk = fPMTmap[PMTmuxID][9] + 
      fPMTmap[PMTmuxID][12]+
      fPMTmap[PMTmuxID][14];
    diagCrossTalk = fPMTmap[PMTmuxID][8]+
      fPMTmap[PMTmuxID][10];
    break;
  case 14:
    crossTalk = fPMTmap[PMTmuxID][10] + 
      fPMTmap[PMTmuxID][13]+
      fPMTmap[PMTmuxID][15];
    diagCrossTalk = fPMTmap[PMTmuxID][9]+
      fPMTmap[PMTmuxID][11];
    break;
  case 15:
    crossTalk = fPMTmap[PMTmuxID][11]+ 
      fPMTmap[PMTmuxID][14];
    diagCrossTalk = fPMTmap[PMTmuxID][10];
    break;
  default:
    crossTalk = 0;
    diagCrossTalk = 0;
    break;
  }

  if(amShowing){
    int i = PMTmuxID;
    cout << " IsXTalk " << paltlist->GetPlane() << " : " << pixel << " q " << q << " qc " << qc << " t " << paltlist->GetCurrentItem().GetTime()*1.0E9-pCalculator->GetAbsTime() << endl;
    cout << "PLANE HITS " << fPlaneHit[paltlist->GetPlane()] << endl;

    cout  << fPMTmap[i][0]  << ":" << fPMTmap[i][1]  << 
      ":" << fPMTmap[i][2]  << ":" << fPMTmap[i][3]  << endl;
    cout  << fPMTmap[i][4]  << ":" << fPMTmap[i][5]  << 
      ":" << fPMTmap[i][6]  << ":" << fPMTmap[i][7]  << endl;
    cout  << fPMTmap[i][8]  << ":" << fPMTmap[i][9]  << 
      ":" << fPMTmap[i][10] << ":" << fPMTmap[i][11] << endl;
    cout  << fPMTmap[i][12] << ":" << fPMTmap[i][13] << 
      ":" << fPMTmap[i][14] << ":" << fPMTmap[i][15] << endl;

    cout << "----------------" << i << endl;

    cout  << fXTalkmap[i][0]  << ":" << fXTalkmap[i][1]  << 
      ":" << fXTalkmap[i][2]  << ":" << fXTalkmap[i][3]  << endl;
    cout  << fXTalkmap[i][4]  << ":" << fXTalkmap[i][5]  << 
      ":" << fXTalkmap[i][6]  << ":" << fXTalkmap[i][7]  << endl;
    cout  << fXTalkmap[i][8]  << ":" << fXTalkmap[i][9]  << 
      ":" << fXTalkmap[i][10] << ":" << fXTalkmap[i][11] << endl;
    cout  << fXTalkmap[i][12] << ":" << fXTalkmap[i][13] << 
      ":" << fXTalkmap[i][14] << ":" << fXTalkmap[i][15] << endl;

    cout << "----------------" << endl;

    cout << fVAmap[i][2] << endl;
    cout << fVAmap[i][3] << endl;
    cout << fVAmap[i][4] << endl;
    cout << fVAmap[i][5] << endl;
    cout << fVAmap[i][6] << endl;
    cout << fVAmap[i][7] << endl;
    cout << fVAmap[i][8] << endl;
    cout << fVAmap[i][9] << endl;
    cout << fVAmap[i][10] << endl;
    cout << fVAmap[i][11] << endl;
    cout << fVAmap[i][12] << endl;
    cout << fVAmap[i][13] << endl;
    cout << fVAmap[i][14] << endl;
    cout << fVAmap[i][15] << endl;
    cout << fVAmap[i][16] << endl;
    cout << fVAmap[i][17] << endl;
  }

  if(useBest)q=qc;
  Float_t XTalkFraction=1.0;
  crossTalk+= 0.5*diagCrossTalk;
  if(crossTalk>0)XTalkFraction = q/crossTalk;
  if(XTalkFraction<fXTalkFraction)result=true;
  if(q<1.5&&XTalkFraction<fXTalk1PEFraction)result=true;
  if(q<2.5&&XTalkFraction<fXTalk2PEFraction)result=true;
  if(q<5.0&&XTalkFraction<fXTalk5PEFraction)result=true;

  if(q<1.5 && q<0.05*fPMTtot[PMTmuxID])result=true;
  
  if(amShowing)cout << "NORMAL : " << q << ":" <<  XTalkFraction << ":" << result << endl;

  if(result){
    MSG("AltDeMux", Msg::kVerbose) << "AlgAltDeMuxBase::IsXTalk (tagged by Standard Algorithm) PMT " << PMTmuxID << " pixel : " << pixel << " charge : " << qc << endl;
    return result; 
  }

  if(fXTalkmap[PMTmuxID][pixel]>0.0001){
    XTalkFraction = q/fXTalkmap[PMTmuxID][pixel];
    if(q<1.0&&XTalkFraction<100.)result=true;
    if(q<2.0&&XTalkFraction<50.)result=true;
    if(q<3.0&&XTalkFraction<30.)result=true;
    if(q<5.0&&XTalkFraction<20.)result=true;
    if(amShowing)cout << "SPOT   : " << q << ":" <<  XTalkFraction << ":" << result << endl;

    if(result){
      MSG("AltDeMux", Msg::kVerbose) << "AlgAltDeMuxBase::IsXTalk (Tagged by Spot Algorithm) : PMT " << PMTmuxID << " pixel : " << pixel << " charge : " << qc << " pixel map " << fXTalkmap[PMTmuxID][pixel] << endl;
      return result; 
    }
  }

  Int_t vaChannel = _pixelToVaChannel[pixel];

  if((fVAmap[PMTmuxID][vaChannel+1]+fVAmap[PMTmuxID][vaChannel-1])>0){
    XTalkFraction = q/(fVAmap[PMTmuxID][vaChannel+1]+fVAmap[PMTmuxID][vaChannel-1]);
    if(q<1.5&&XTalkFraction<0.1)result=true;
    if(amShowing)cout << "VA     : " << q << ":" <<  XTalkFraction << ":" << result << endl;

    if(result){
      MSG("AltDeMux", Msg::kVerbose) << "AlgAltDeMuxBase::IsXTalk (VA Algorithm) : PMT " << PMTmuxID << " pixel : " << pixel << " charge : " << qc << "VA map  : " << fVAmap[PMTmuxID][vaChannel-1] << "," << fVAmap[PMTmuxID][vaChannel-1] << endl;
      return result; 
    }
  }

  return result;
} 








Float_t AlgAltDeMuxBase::XTalkCharge(PlexSEIdAltL* paltlist, Int_t istrip)
{ 

  Float_t crossTalk=-999;
  
  paltlist->SetFirst();
  bool notFound = true;
  while(notFound&&paltlist->IsValid()){
    if(paltlist->GetCurrentSEId().GetStrip()==istrip)notFound=false;
    if(notFound)paltlist->Next();
  }


  PlexPixelSpotId pixelID = (paltlist->GetCurrentItem()).GetPixelSpotId(); 
  Int_t pixel  = pixelID.GetPixel();
  Int_t PMTmuxID = pixelID.GetTube();
  PMTmuxID      += 3*pixelID.GetInRack();
  PMTmuxID      += 24*pixelID.GetRackBay();
  Char_t level = pixelID.GetRackLevel(); 
  Char_t ew = pixelID.GetEastWest(); 
  if(level=='U')PMTmuxID += 450;
  if(ew =='E')PMTmuxID += 900;
  if(PMTmuxID>=MAX_NUMBER_OF_PMTS){
    MSG("AltDeMux", Msg::kError) << "AlgAltDeMuxBase::IsXTalk => PMT out of array bounds : " <<    PMTmuxID << " woul give array overflow!" << endl;
    return 0.0;
  }
  Float_t q  = paltlist->GetCurrentItem().GetPE();
  Float_t qc = paltlist->GetCurrentItem().GetSigCorr()/60.;
  if(qc/q<0.1 || qc/q > 10.0){
    qc=q;
  }

  switch(pixel){
  case 0:
    crossTalk = fPMTmap[PMTmuxID][1] + 
      fPMTmap[PMTmuxID][4];
    break;
  case 1:
    crossTalk = fPMTmap[PMTmuxID][0] + 
      fPMTmap[PMTmuxID][2] +
      fPMTmap[PMTmuxID][5];
      break;
  case 2:
    crossTalk = fPMTmap[PMTmuxID][1] + 
      fPMTmap[PMTmuxID][3] +
      fPMTmap[PMTmuxID][6];
    break;
  case 3:
    crossTalk = fPMTmap[PMTmuxID][2] + 
      fPMTmap[PMTmuxID][7];
    break;
  case 4:
    crossTalk = fPMTmap[PMTmuxID][0] + 
      fPMTmap[PMTmuxID][5] +
      fPMTmap[PMTmuxID][8];
    break;
  case 5:
    crossTalk = fPMTmap[PMTmuxID][1] + 
      fPMTmap[PMTmuxID][4] +
      fPMTmap[PMTmuxID][6] +
      fPMTmap[PMTmuxID][9];
    break;
  case 6:
    crossTalk = fPMTmap[PMTmuxID][2] + 
      fPMTmap[PMTmuxID][5] +
      fPMTmap[PMTmuxID][7] +
      fPMTmap[PMTmuxID][10];
    break;
  case 7:
    crossTalk = fPMTmap[PMTmuxID][3] + 
      fPMTmap[PMTmuxID][6] +
      fPMTmap[PMTmuxID][11];
    break;
  case 8:
    crossTalk = fPMTmap[PMTmuxID][4] + 
      fPMTmap[PMTmuxID][9] +
      fPMTmap[PMTmuxID][12];
    break;
  case 9:
    crossTalk = fPMTmap[PMTmuxID][5] + 
      fPMTmap[PMTmuxID][8] +
      fPMTmap[PMTmuxID][10] +
      fPMTmap[PMTmuxID][13];
    break;
  case 10:
    crossTalk = fPMTmap[PMTmuxID][6] + 
      fPMTmap[PMTmuxID][9] +
      fPMTmap[PMTmuxID][11] +
      fPMTmap[PMTmuxID][14];
    break;
  case 11:
    crossTalk = fPMTmap[PMTmuxID][7] + 
      fPMTmap[PMTmuxID][10] +
      fPMTmap[PMTmuxID][15];
    break;
  case 12:
    crossTalk = fPMTmap[PMTmuxID][8] + 
      fPMTmap[PMTmuxID][13];
    break;
  case 13:
    crossTalk = fPMTmap[PMTmuxID][9] + 
      fPMTmap[PMTmuxID][12]+
      fPMTmap[PMTmuxID][14];
    break;
  case 14:
    crossTalk = fPMTmap[PMTmuxID][10] + 
      fPMTmap[PMTmuxID][13]+
      fPMTmap[PMTmuxID][15];
    break;
  case 15:
    crossTalk = fPMTmap[PMTmuxID][11]+ 
      fPMTmap[PMTmuxID][14];
    break;
  default:
    crossTalk = 0;
    break;
  }

  return crossTalk;
} 






Float_t AlgAltDeMuxBase::XTalkPixelMap(PlexSEIdAltL* paltlist)
{ 

  Float_t crossTalk=-999;
  
  PlexPixelSpotId pixelID = (paltlist->GetBestItem()).GetPixelSpotId(); 
  Int_t pixel  = pixelID.GetPixel();
  Int_t PMTmuxID = pixelID.GetTube();
  PMTmuxID      += 3*pixelID.GetInRack();
  PMTmuxID      += 24*pixelID.GetRackBay();
  Char_t level = pixelID.GetRackLevel(); 
  Char_t ew = pixelID.GetEastWest(); 
  if(level=='U')PMTmuxID += 450;
  if(ew =='E')PMTmuxID += 900;
  if(PMTmuxID>=MAX_NUMBER_OF_PMTS){
    MSG("AltDeMux", Msg::kError) << "AlgAltDeMuxBase::IsXTalk => PMT out of array bounds : " <<    PMTmuxID << " woul give array overflow!" << endl;
    return 0.0;
  }
  Float_t q  = paltlist->GetBestItem().GetPE();
  Float_t qc = paltlist->GetBestItem().GetSigCorr()/60.;
  if(qc/q<0.1 || qc/q > 10.0){
    qc=q;
  }

  cout << " PMTmuxID PIXEL : " << PMTmuxID << "," << pixel << "  : " << qc << endl;
  Int_t i=PMTmuxID;
  cout  << fPMTmap[i][0]  << ":" << fPMTmap[i][1]  << 
    ":" << fPMTmap[i][2]  << ":" << fPMTmap[i][3]  << endl;
  cout  << fPMTmap[i][4]  << ":" << fPMTmap[i][5]  << 
    ":" << fPMTmap[i][6]  << ":" << fPMTmap[i][7]  << endl;
  cout  << fPMTmap[i][8]  << ":" << fPMTmap[i][9]  << 
    ":" << fPMTmap[i][10] << ":" << fPMTmap[i][11] << endl;
  cout  << fPMTmap[i][12] << ":" << fPMTmap[i][13] << 
    ":" << fPMTmap[i][14] << ":" << fPMTmap[i][15] << endl;

  cout  << fXTalkmap[i][0]  << ":" << fXTalkmap[i][1]  << 
    ":" << fXTalkmap[i][2]  << ":" << fXTalkmap[i][3]  << endl;
  cout  << fXTalkmap[i][4]  << ":" << fXTalkmap[i][5]  << 
    ":" << fXTalkmap[i][6]  << ":" << fXTalkmap[i][7]  << endl;
  cout  << fXTalkmap[i][8]  << ":" << fXTalkmap[i][9]  << 
    ":" << fXTalkmap[i][10] << ":" << fXTalkmap[i][11] << endl;
  cout  << fXTalkmap[i][12] << ":" << fXTalkmap[i][13] << 
    ":" << fXTalkmap[i][14] << ":" << fXTalkmap[i][15] << endl;


  
  switch(pixel){
  case 0:
    crossTalk = fPMTmap[PMTmuxID][1] + 
      fPMTmap[PMTmuxID][4];
    break;
  case 1:
    crossTalk = fPMTmap[PMTmuxID][0] + 
      fPMTmap[PMTmuxID][2] +
      fPMTmap[PMTmuxID][5];
      break;
  case 2:
    crossTalk = fPMTmap[PMTmuxID][1] + 
      fPMTmap[PMTmuxID][3] +
      fPMTmap[PMTmuxID][6];
    break;
  case 3:
    crossTalk = fPMTmap[PMTmuxID][2] + 
      fPMTmap[PMTmuxID][7];
    break;
  case 4:
    crossTalk = fPMTmap[PMTmuxID][0] + 
      fPMTmap[PMTmuxID][5] +
      fPMTmap[PMTmuxID][8];
    break;
  case 5:
    crossTalk = fPMTmap[PMTmuxID][1] + 
      fPMTmap[PMTmuxID][4] +
      fPMTmap[PMTmuxID][6] +
      fPMTmap[PMTmuxID][9];
    break;
  case 6:
    crossTalk = fPMTmap[PMTmuxID][2] + 
      fPMTmap[PMTmuxID][5] +
      fPMTmap[PMTmuxID][7] +
      fPMTmap[PMTmuxID][10];
    break;
  case 7:
    crossTalk = fPMTmap[PMTmuxID][3] + 
      fPMTmap[PMTmuxID][6] +
      fPMTmap[PMTmuxID][11];
    break;
  case 8:
    crossTalk = fPMTmap[PMTmuxID][4] + 
      fPMTmap[PMTmuxID][9] +
      fPMTmap[PMTmuxID][12];
    break;
  case 9:
    crossTalk = fPMTmap[PMTmuxID][5] + 
      fPMTmap[PMTmuxID][8] +
      fPMTmap[PMTmuxID][10] +
      fPMTmap[PMTmuxID][13];
    break;
  case 10:
    crossTalk = fPMTmap[PMTmuxID][6] + 
      fPMTmap[PMTmuxID][9] +
      fPMTmap[PMTmuxID][11] +
      fPMTmap[PMTmuxID][14];
    break;
  case 11:
    crossTalk = fPMTmap[PMTmuxID][7] + 
      fPMTmap[PMTmuxID][10] +
      fPMTmap[PMTmuxID][15];
    break;
  case 12:
    crossTalk = fPMTmap[PMTmuxID][8] + 
      fPMTmap[PMTmuxID][13];
    break;
  case 13:
    crossTalk = fPMTmap[PMTmuxID][9] + 
      fPMTmap[PMTmuxID][12]+
      fPMTmap[PMTmuxID][14];
    break;
  case 14:
    crossTalk = fPMTmap[PMTmuxID][10] + 
      fPMTmap[PMTmuxID][13]+
      fPMTmap[PMTmuxID][15];
    break;
  case 15:
    crossTalk = fPMTmap[PMTmuxID][11]+ 
      fPMTmap[PMTmuxID][14];
    break;
  default:
    crossTalk = 0;
    break;
  }

  return crossTalk;
} 












void  AlgAltDeMuxBase::DisplayPixelMap()
{

  MSG("AltDeMux", Msg::kVerbose) << "AlgAltDeMuxBase::DisplayPixelMap : " << endl;
  for(int i=0; i<MAX_NUMBER_OF_PMTS; i++){
    if(fPMTtot[i]>0){
      MSG("AltDeMux", Msg::kDebug) << "AlgAltDeMuxBase::DisplayPixelMap PMT : " << i << endl;
      MSG("AltDeMux", Msg::kDebug) << fPMTmap[i][0]  << ":" << fPMTmap[i][1]  << 
        ":" << fPMTmap[i][2]  << ":" << fPMTmap[i][3]  << endl;
      MSG("AltDeMux", Msg::kDebug) << fPMTmap[i][4]  << ":" << fPMTmap[i][5]  << 
        ":" << fPMTmap[i][6]  << ":" << fPMTmap[i][7]  << endl;
      MSG("AltDeMux", Msg::kDebug) << fPMTmap[i][8]  << ":" << fPMTmap[i][9]  << 
        ":" << fPMTmap[i][10] << ":" << fPMTmap[i][11] << endl;
      MSG("AltDeMux", Msg::kDebug) << fPMTmap[i][12] << ":" << fPMTmap[i][13] << 
        ":" << fPMTmap[i][14] << ":" << fPMTmap[i][15] << endl;

    }
  }
  
  return;

}



void AlgAltDeMuxBase::DrawDiagnosticPlots(Int_t ipass) 
{  
  if(!fDiagnosticPlots)return;
  TPolyMarker* pTPU1;
  TPolyMarker* pTPV1;
  TPolyMarker* pTPU2;
  TPolyMarker* pTPV2;
  TPolyMarker* pTPU3;
  TPolyMarker* pTPV3;
  TPolyMarker* pTPU4;
  TPolyMarker* pTPV4;
  TPolyMarker* pTPU5;
  TPolyMarker* pTPV5;
  float xU1[1000];
  float yU1[1000];
  float xU2[1000];
  float yU2[1000];
  float xU3[1000];
  float yU3[1000];
  float xU4[1000];
  float yU4[1000];
  float xU5[1000];
  float yU5[1000];
  int nU1=0;
  int nU2=0;
  int nU3=0;
  int nU4=0;
  int nU5=0;
  float xV1[1000];
  float yV1[1000];
  float xV2[1000];
  float yV2[1000];
  float xV3[1000];
  float yV3[1000];
  float xV4[1000];
  float yV4[1000];
  float xV5[1000];
  float yV5[1000];
  int nV1=0;
  int nV2=0;
  int nV3=0;
  int nV4=0;
  int nV5=0;

  Float_t markerSize = 1.0;
  if(fEventType==MULTIPLE_MUON)markerSize =0.75;

  for(Int_t iplane=0;iplane<MAX_NUMBER_OF_PLANES;iplane++){
    for(Int_t i=0;i<NdemuxedHitsU[iplane];i++){
      for(Int_t j=i+1;j<NdemuxedHitsU[iplane];j++){
        if(demuxedHitStripU[iplane][i]==demuxedHitStripU[iplane][j]){
          demuxedHitQU[iplane][i] +=demuxedHitQU[iplane][j];
          demuxedHitQU[iplane][j] = 0;
        }
      }
    }

    for(Int_t i=0;i<NdemuxedHitsU[iplane];i++){
      if(demuxedHitQU[iplane][i]>0 && demuxedHitQU[iplane][i]<=3){
        xU1[nU1] = iplane;
        yU1[nU1] = demuxedHitStripU[iplane][i];
        nU1++;
      }
      if(demuxedHitQU[iplane][i]>=3 && demuxedHitQU[iplane][i]<=10){
        xU2[nU2] = iplane;
        yU2[nU2] = demuxedHitStripU[iplane][i];
        nU2++;
      }
      if(demuxedHitQU[iplane][i]>=10 && demuxedHitQU[iplane][i]<=25){
        xU3[nU3] = iplane;
        yU3[nU3] = demuxedHitStripU[iplane][i];
        nU3++;
      }
      if(demuxedHitQU[iplane][i]>=25 && demuxedHitQU[iplane][i]<=100){
        xU4[nU4] = iplane;
        yU4[nU4] = demuxedHitStripU[iplane][i];
        nU4++;
      }
      if(demuxedHitQU[iplane][i]>=100){
        xU5[nU5] = iplane;
        yU5[nU5] = demuxedHitStripU[iplane][i];
        nU5++;
      }
    }
  }


  for(Int_t iplane=0;iplane<MAX_NUMBER_OF_PLANES;iplane++){
    for(Int_t i=0;i<NdemuxedHitsV[iplane];i++){
      for(Int_t j=i+1;j<NdemuxedHitsV[iplane];j++){
        if(demuxedHitStripV[iplane][i]==demuxedHitStripV[iplane][j]){
          demuxedHitQV[iplane][i] +=demuxedHitQV[iplane][j];
          demuxedHitQV[iplane][j] = 0;
        }
      }
    }
    
    for(int i=0;i<NdemuxedHitsV[iplane];i++){
      if(demuxedHitQV[iplane][i]>=0 && demuxedHitQV[iplane][i]<=3){
        xV1[nV1] = iplane;
        yV1[nV1] = demuxedHitStripV[iplane][i];
        nV1++;
      }
      if(demuxedHitQV[iplane][i]>=3 && demuxedHitQV[iplane][i]<=10){
        xV2[nV2] = iplane;
        yV2[nV2] = demuxedHitStripV[iplane][i];
        nV2++;
      }
      if(demuxedHitQV[iplane][i]>=10 && demuxedHitQV[iplane][i]<=25){
        xV3[nV3] = iplane;
        yV3[nV3] = demuxedHitStripV[iplane][i];
        nV3++;
      }
      if(demuxedHitQV[iplane][i]>=25 && demuxedHitQV[iplane][i]<=100){
        xV4[nV4] = iplane;
        yV4[nV4] = demuxedHitStripV[iplane][i];
        nV4++;
      }
      if(demuxedHitQV[iplane][i]>=100){
        xV5[nV5] = iplane;
        yV5[nV5] = demuxedHitStripV[iplane][i];
        nV5++;
      }
    }
  }

  pTPU1 = new TPolyMarker(nU1,xU1,yU1);
  pTPU1->SetMarkerStyle(20);
  pTPU1->SetMarkerColor(kYellow);
  pTPU1->SetMarkerSize(markerSize);

  pTPU2 = new TPolyMarker(nU2,xU2,yU2);
  pTPU2->SetMarkerStyle(20);
  pTPU2->SetMarkerColor(kCyan);
  pTPU2->SetMarkerSize(markerSize);

  pTPU3 = new TPolyMarker(nU3,xU3,yU3);
  pTPU3->SetMarkerStyle(20);
  pTPU3->SetMarkerColor(kBlue);
  pTPU3->SetMarkerSize(markerSize);

  pTPU4 = new TPolyMarker(nU4,xU4,yU4);
  pTPU4->SetMarkerStyle(20);
  pTPU4->SetMarkerColor(kBlack);
  pTPU4->SetMarkerSize(markerSize);

  pTPU5 = new TPolyMarker(nU5,xU5,yU5);
  pTPU5->SetMarkerStyle(20);
  pTPU5->SetMarkerColor(kRed);
  pTPU5->SetMarkerSize(markerSize);

  pTPV1 = new TPolyMarker(nV1,xV1,yV1);
  pTPV1->SetMarkerStyle(20);
  pTPV1->SetMarkerColor(kYellow);
  pTPV1->SetMarkerSize(markerSize);

  pTPV2 = new TPolyMarker(nV2,xV2,yV2);
  pTPV2->SetMarkerStyle(20);
  pTPV2->SetMarkerColor(kCyan);
  pTPV2->SetMarkerSize(markerSize);

  pTPV3 = new TPolyMarker(nV3,xV3,yV3);
  pTPV3->SetMarkerStyle(20);
  pTPV3->SetMarkerColor(kBlue);
  pTPV3->SetMarkerSize(markerSize);

  pTPV4 = new TPolyMarker(nV4,xV4,yV4);
  pTPV4->SetMarkerStyle(20);
  pTPV4->SetMarkerColor(kBlack);
  pTPV4->SetMarkerSize(markerSize);

  pTPV5 = new TPolyMarker(nV5,xV5,yV5);
  pTPV5->SetMarkerStyle(20);
  pTPV5->SetMarkerColor(kRed);
  pTPV5->SetMarkerSize(markerSize);

  // Keep track of the TPolyMarkers - delete them later

  fList->Add(pTPV1);
  fList->Add(pTPV2);
  fList->Add(pTPV3);
  fList->Add(pTPV4);
  fList->Add(pTPV5);
  fList->Add(pTPU1);
  fList->Add(pTPU2);
  fList->Add(pTPU3);
  fList->Add(pTPU4);
  fList->Add(pTPU5);

  fUpad->cd();

  if(ipass==-2&&fUTime){
    fUTime->GetXaxis()->SetRangeUser(fLowestPlane,fHighestPlane); 
    fUTime->SetMaximum(0.1);
    fUTime->SetLineColor(kRed);
    fUTime->SetFillColor(kRed);
    fUTime->Draw("BOX");
  }
  if(ipass==-1&&fUMask){
    fUMask->GetXaxis()->SetRangeUser(fLowestPlane,fHighestPlane); 
    if(fUTime)fUMask->Add(fUTime,1.);
    fUMask->SetLineColor(kGreen);
    fUMask->SetFillColor(kGreen);
    fUMask->SetMaximum(1.);
    if(fUMask)fUMask->Draw("BOX");
  }

  if(ipass>=0){
    if (fUview){
      fUview->GetXaxis()->SetRangeUser(fLowestPlane,fHighestPlane);
      fUview->Draw(); 
    }
    if (fUTime){
      fUTime->SetMaximum(1.);
      fUTime->Draw();
    }
    if (fUMask){
      fUMask->GetXaxis()->SetRangeUser(fLowestPlane,fHighestPlane);
      fUMask->Add(fUTime,1.);
      fUMask->SetLineColor(kGreen); 
      fUMask->SetFillColor(kGreen);
      fUMask->SetMaximum(1.);
      fUMask->Draw("BOX");
    }
    pTPU1->Draw();
    pTPU2->Draw();
    pTPU3->Draw();
    pTPU4->Draw();
    pTPU5->Draw();
  }

  if(fUZFitS)fUZFitS->Draw();
  if(fUZFitT)fUZFitT->Draw();
  if(fUZFitSSM1)fUZFitSSM1->Draw();
  if(fUZFitQSSM2)fUZFitQSSM2->Draw();
  if(fUZFitQSSM1)fUZFitQSSM1->Draw();
  if(fUZFitSSM2)fUZFitSSM2->Draw();
  if(fUZFitTSM1)fUZFitTSM1->Draw();
  if(fUZFitTSM2)fUZFitTSM2->Draw();
  if(fEventType==MULTIPLE_MUON){
    DeMuxFitResult_t resultU;
    // initialize unused struct members
    resultU.nUsed = 0;
    resultU.nData = 0;
    resultU.a1 = 0;
    resultU.a2 = 0;
    resultU.a3 = 0;
    resultU.a4 = 0;
    resultU.chi2 = 0;
    resultU.chi2pdf = 0;
    // set the values
    resultU.a0 = fHoughSlopeU;
    resultU.status = true;
    for(UInt_t i = 0; i< multipleMuonInterceptsU.size();i++){
      resultU.a1 = fHoughSlopeU;
      resultU.a0 = multipleMuonInterceptsU[i];
      TPolyLine* tP1 = NULL;
      TPolyLine* tP2 = NULL;
      this->MakeFitPolyLines(resultU, tP1, tP2, 1, 1);
      tP1->Draw();
      tP2->Draw();
    }
  }


  fVpad->cd();

  if(ipass==-2&&fVTime){
    fVTime->GetXaxis()->SetRangeUser(fLowestPlane,fHighestPlane); 
    fVTime->SetMaximum(0.1);
    fVTime->SetLineColor(kRed);
    fVTime->SetFillColor(kRed);
    if(fVTime)fVTime->Draw("BOX");
  }
  if(ipass==-1&&fVMask){
    fVMask->GetXaxis()->SetRangeUser(fLowestPlane,fHighestPlane); 
    if(fVTime)fVMask->Add(fVTime,1.);
    fVMask->SetLineColor(kGreen);
    fVMask->SetFillColor(kGreen);
    fVMask->SetMaximum(1.);
    fVMask->Draw("BOX");
  }

  if(ipass>=0){
    if (fVview){
      fVview->GetXaxis()->SetRangeUser(fLowestPlane,fHighestPlane);
      fVview->Draw();
    }
    if (fVTime){
      fVTime->SetMaximum(1.);
      fVTime->Draw();
    }
    if (fVMask){
      fVMask->GetXaxis()->SetRangeUser(fLowestPlane,fHighestPlane);
      fVMask->Add(fVTime,1.);
      fVMask->SetLineColor(kGreen);
      fVMask->SetFillColor(kGreen);
      fVMask->SetMaximum(1.);
      fVMask->Draw("BOX");
    }
    pTPV1->Draw();    
    pTPV2->Draw();
    pTPV3->Draw();
    pTPV4->Draw();
    pTPV5->Draw();
  }

  if(fVZFitT)fVZFitT->Draw();
  if(fVZFitS)fVZFitS->Draw();
  if(fVZFitSSM1)fVZFitSSM1->Draw();
  if(fVZFitSSM2)fVZFitSSM2->Draw();
  if(fVZFitQSSM1)fVZFitQSSM1->Draw();
  if(fVZFitQSSM2)fVZFitQSSM2->Draw();
  if(fVZFitTSM1)fVZFitTSM1->Draw();
  if(fVZFitTSM2)fVZFitTSM2->Draw();

  if(fEventType==MULTIPLE_MUON){
    DeMuxFitResult_t resultV;
    // initialize unused struct members
    resultV.nUsed = 0;
    resultV.nData = 0;
    resultV.a1 = 0;
    resultV.a2 = 0;
    resultV.a3 = 0;
    resultV.a4 = 0;
    resultV.chi2 = 0;
    resultV.chi2pdf = 0;
    // set the values
    for(UInt_t i = 0; i< multipleMuonInterceptsV.size();i++){
      resultV.a1 = fHoughSlopeV;
      resultV.a0 = multipleMuonInterceptsV[i];
      resultV.status = true;
      TPolyLine* tP1 = NULL;
      TPolyLine* tP2 = NULL;
      this->MakeFitPolyLines(resultV, tP1, tP2, 1, 1);
      tP1->Draw();
      tP2->Draw();
    }


  }


  fCanvas->Update();
  return;
  
}




bool AlgAltDeMuxBase::ValidatePlane(Int_t iplane, bool useTimeMask){

  bool fitStatusT = false;
  bool fitStatusH = false;


  if(fPlaneHit[iplane]==0)return false;

  if(fEventType==MULTIPLE_MUON){
    MSG("AltDeMux", Msg::kWarning) << "AlgAltDeMuxBase::ValidatePlane doesn't yet handle Multiple Muons " << endl; 
    return false;
  }

  Int_t easthits = fDeMuxedPlanesAltLists[iplane][ALG_EAST].size()+
    fPlanesAltLists[iplane][ALG_EAST].size();
  Int_t westhits = fDeMuxedPlanesAltLists[iplane][ALG_WEST].size()+
    fPlanesAltLists[iplane][ALG_WEST].size();

  if(amWriting){
    if(amWriting)cout << "*****************************************************************  PLANE : " << iplane << endl;
    if(amWriting)cout << "ew : " << easthits << ":" << westhits << endl;
  }

  bool oneSided = false;
  if(easthits==0||westhits==0){
    if(easthits>0||westhits>0)oneSided = true;
  }


  Int_t istripH;
  Int_t istripT;

  Int_t jplane = iplane;
  if(jplane>249)jplane+=20;
  if( fUVMap[iplane]==PlaneView::kU){
    fitStatusH = fFitQHitU.status;
    istripH = static_cast<Int_t>(jplane*fFitQHitU.a1+fFitQHitU.a0);
    if(!fFitQHitU.status){
      istripH = static_cast<Int_t>(jplane*fFitHitU.a1+fFitHitU.a0);
      fitStatusH = fFitHitU.status;
    }
    fitStatusT = fFitTimeU.status;
    istripT = static_cast<Int_t>(jplane*fFitTimeU.a1+fFitTimeU.a0);
    if(amWriting){
      cout << " fit status : " << fitStatusH << " " << fitStatusT << endl;
      cout << "U HIT  STRIP AIM : " << istripH <<" "<< fFitQHitV.a0 << " : " << fFitQHitV.a1 << endl;
      cout << "U TIME STRIP AIM : " << istripT <<" "<< fFitTimeV.a0 << " : " << fFitTimeV.a1 << endl;
    }
  }

  if( fUVMap[iplane]==PlaneView::kV){
    fitStatusH = fFitQHitV.status;
    istripH = static_cast<Int_t>(jplane*fFitQHitV.a1+fFitQHitV.a0);
    if(!fitStatusH){
      fitStatusH = fFitHitV.status;
      istripH = static_cast<Int_t>(jplane*fFitHitV.a1+fFitHitV.a0);
    }
    fitStatusT = fFitTimeV.status;
    istripT = static_cast<Int_t>(jplane*fFitTimeV.a1+fFitTimeV.a0);
    if(amWriting){
      cout << "V HIT  STRIP AIM : " << istripH <<" "<< fFitQHitV.a0 << " : " << fFitQHitV.a1 << endl;
      cout << "V TIME STRIP AIM : " << istripT <<" "<< fFitTimeV.a0 << " : " << fFitTimeV.a1 << endl;
    }
  }

  if(istripH>=MAX_NUMBER_OF_STRIPS)istripH=MAX_NUMBER_OF_STRIPS; 
  if(istripT>=MAX_NUMBER_OF_STRIPS)istripT=MAX_NUMBER_OF_STRIPS; 
  if(istripH<0)istripH=0;
  if(istripT<0)istripT=0;
  
  bool returnFlag = false;
  bool found = false;
  bool useOldResult = false;

  PlaneValidity_t stripResult;
  PlaneValidity_t timeMaskResult;
  PlaneValidity_t oldResult;
  PlaneValidity_t hitResult;
  PlaneValidity_t timeResult;

  vector<Int_t>oldPattern;
  for(Int_t iHitStrip=1; iHitStrip<=fPlaneHit[iplane];iHitStrip++){
    oldPattern.push_back(fHitMap[iplane][iHitStrip]);
  }
  if(!oneSided)oldResult = this->ValidatePlaneForPattern(iplane, oldPattern);
  if( oneSided)oldResult = this->ValidateOneSidedPlaneForPattern(iplane, oldPattern);

  for(UInt_t i = 0; i<oldResult.strips.size(); i++){
    bool found = false;
    for(UInt_t ipair=0;ipair<fDeMuxedPairs[iplane].size();ipair++){
      Int_t istrip = fDeMuxedPairs[iplane][ipair].altListE->GetBestSEId().GetStrip();
      if(oldResult.strips[i]==istrip)found=true;
    }
    if(found==false){
      useOldResult=true;
      //cout << "USE OLD RESULT IS SET !!!!!!" << endl;
      //getchar();
    }
  }


  stripResult.largestContigGroup = -1;
  Int_t bestStrip;
  for(Int_t iHitStrip=1; iHitStrip<=fPlaneHit[iplane];iHitStrip++){
    vector<Int_t>pattern;
    pattern.push_back(fHitMap[iplane][iHitStrip]);
    PlaneValidity_t thisStripResult;
    if(!oneSided)thisStripResult = this->ValidatePlaneForPattern(iplane, pattern);
    if( oneSided)thisStripResult = this->ValidateOneSidedPlaneForPattern(iplane, pattern);
    if(thisStripResult.largestContigGroup>stripResult.largestContigGroup){
      stripResult = thisStripResult;
      bestStrip = fHitMap[iplane][iHitStrip];
    }
    if(thisStripResult.largestContigGroup==stripResult.largestContigGroup){
      if( fabs(thisStripResult.chi2DQ-stripResult.chi2DQ)>10){
        if(thisStripResult.chi2DQ+10.<stripResult.chi2DQ){
          stripResult = thisStripResult;
          bestStrip = fHitMap[iplane][iHitStrip];
        }
      }else{
        if(fitStatusH && fabs(thisStripResult.centroid-istripH)<fabs(stripResult.centroid-istripH)){
          stripResult = thisStripResult;
          bestStrip = fHitMap[iplane][iHitStrip];
        }
      }
    }
  }

  hitResult.largestContigGroup = 0;
  vector<Int_t>patternH;
  if(fitStatusH){
    patternH.push_back(istripH);
    if(!oneSided)hitResult =  this->ValidatePlaneForPattern(iplane, patternH);
    if( oneSided)hitResult =  this->ValidateOneSidedPlaneForPattern(iplane, patternH);
  }


  Int_t bestMaskStrip=-1;
  timeMaskResult.largestContigGroup = -1;
  if(useTimeMask){
    for(Int_t iStrip=0; iStrip<=MAX_NUMBER_OF_STRIPS;iStrip++){
      if(fUVmask[iplane][iStrip]==true){
        vector<Int_t>pattern;
        pattern.push_back(iStrip);
        PlaneValidity_t thisStripResult;
        if(!oneSided)thisStripResult = this->ValidatePlaneForPattern(iplane, pattern);
        if( oneSided)thisStripResult = this->ValidateOneSidedPlaneForPattern(iplane, pattern);
        if(thisStripResult.largestContigGroup>timeMaskResult.largestContigGroup){
          timeMaskResult = thisStripResult;
          bestMaskStrip = iStrip;
        }
        if(thisStripResult.largestContigGroup==timeMaskResult.largestContigGroup){
          if(oneSided){
            if(thisStripResult.stripSpan<=timeMaskResult.stripSpan){
              bestMaskStrip = iStrip;
              timeMaskResult = thisStripResult;
            }
          }else{
            if((timeMaskResult.fractionQE<0.25||timeMaskResult.fractionQW<0.25)||(thisStripResult.fractionQE>0.5&&thisStripResult.fractionQW>0.5)){
              if(thisStripResult.chi2DQ<timeMaskResult.chi2DQ+5.){
                bestMaskStrip = iStrip;
                timeMaskResult = thisStripResult;
              }
            }
          }
        }
        if(thisStripResult.largestContigGroup>=hitResult.largestContigGroup){
          if(amWriting)cout << "TIMING MASK : " << iStrip << endl;
          if(!oneSided)thisStripResult = this->ValidatePlaneForPattern(iplane, pattern);
          if( oneSided)thisStripResult = this->ValidateOneSidedPlaneForPattern(iplane, pattern);
        }
      }
    }
  }
      


  timeResult.largestContigGroup = 0;
  vector<Int_t>patternT;
  if(fitStatusT){
    patternT.push_back(istripT);
    if(!oneSided)timeResult =  this->ValidatePlaneForPattern(iplane, patternT);
    if( oneSided)timeResult =  this->ValidateOneSidedPlaneForPattern(iplane, patternT);
  }

  bool useTimeFit   = false;
  bool useHitFit    = false;
  bool useBestStrip = false;
  bool useTimeMaskHit  = false;

  if(useTimeMask&&!oneSided){
    if(timeMaskResult.fractionQE>0.25 && timeMaskResult.fractionQW>0.25)useTimeMaskHit = true;
    if(timeMaskResult.chi2DQ>oldResult.chi2DQ+20.)useTimeMaskHit = false;
  }

  if(fitStatusT){
    if(timeResult.largestContigGroup>oldResult.largestContigGroup){
      if(oldResult.fractionQE<0.25||oldResult.fractionQW<0.25||(timeResult.fractionQE>0.5&&timeResult.fractionQW>0.5))useTimeFit = true;
    } 
    if(timeResult.largestContigGroup==oldResult.largestContigGroup){
      if(timeResult.chi2DQ+10.<oldResult.chi2DQ){
        if(oldResult.fractionQE+oldResult.fractionQW<timeResult.fractionQE+timeResult.fractionQW>0.5)useTimeFit = true;
      }
    } 
    if(timeResult.fractionQE<0.25||timeResult.fractionQW<0.25)useTimeFit = false;
    if(timeResult.chi2DQ>oldResult.chi2DQ+20.)useTimeFit = false;
  }

  if(fitStatusH){
    if(hitResult.largestContigGroup>oldResult.largestContigGroup){
      if(oldResult.fractionQE<0.25||oldResult.fractionQW<0.25||(hitResult.fractionQE>0.5&&hitResult.fractionQW>0.5))useHitFit = true;
    } 
    if(hitResult.largestContigGroup>=oldResult.largestContigGroup){
      if(hitResult.fractionQE>0.75&&hitResult.fractionQW>0.75&&(hitResult.chi2DQ+20.0<oldResult.chi2DQ))useHitFit = true;
    }



    if(hitResult.fractionQE<0.25||hitResult.fractionQW<0.25)useHitFit = false;
    if(hitResult.chi2DQ>oldResult.chi2DQ+20.)useHitFit = false;
    if(hitResult.largestContigGroup>oldResult.largestContigGroup){
      if(oldResult.fractionQE<0.25||oldResult.fractionQW<0.25&&(hitResult.fractionQE>0.5&&hitResult.fractionQW>0.5))useHitFit = true;
    } 
  }

  if(stripResult.largestContigGroup>oldResult.largestContigGroup){
    if(oldResult.fractionQE<0.25||oldResult.fractionQW<0.25||(stripResult.fractionQE>0.5&&stripResult.fractionQW>0.5))useBestStrip = true;
    if(stripResult.chi2DQ>oldResult.chi2DQ+20.)useBestStrip = false;
  } 

  if(oneSided){
    if(fitStatusT)useTimeFit = true;
    if(fitStatusH)useHitFit = true;
    useBestStrip= true;
  }
 

  if(useHitFit){
    //amWriting = true;
    //    if(!found)this->ValidatePlaneForPattern(iplane, oldPattern);
    found = true;
    if(amWriting)cout  << " ALERT **HITS** " << endl; 
    //this->ValidatePlaneForPattern(iplane, patternH);
    found = true;
    if(hitResult.largestContigGroup>=timeResult.largestContigGroup&&
       hitResult.largestContigGroup>=stripResult.largestContigGroup){
      if(!oneSided)this->ReMuxPlane(iplane, patternH);
      if( oneSided)this->ReMuxSingleSidedPlane(iplane, patternH);
    }
  }

  if(useBestStrip){
    //amWriting = true;
    //if(!found)this->ValidatePlaneForPattern(iplane, oldPattern);
    found = true;
    if(amWriting)cout  << " ALERT **BEST** " << bestStrip << endl; 
    vector<Int_t>pattern;
    pattern.push_back(bestStrip);
    //this->ValidatePlaneForPattern(iplane, pattern);
    found = true;
    if(stripResult.largestContigGroup>=timeResult.largestContigGroup&&
       stripResult.largestContigGroup>hitResult.largestContigGroup){
      if(!oneSided)this->ReMuxPlane(iplane, pattern);
      if( oneSided)this->ReMuxSingleSidedPlane(iplane, pattern);
    }
  }

  if(useTimeFit){
    //amWriting = true;
    //if(!found)this->ValidatePlaneForPattern(iplane, oldPattern);
    found = true;
    if(amWriting)cout  << " ALERT **TIME** " << endl; 
    //this->ValidatePlaneForPattern(iplane, patternT);
    found = true;
    if(timeResult.largestContigGroup>hitResult.largestContigGroup&&
       timeResult.largestContigGroup>stripResult.largestContigGroup){
      if(!oneSided)this->ReMuxPlane(iplane, patternT);
      if( oneSided)this->ReMuxSingleSidedPlane(iplane, patternT);
    }
  }



  if(useTimeMaskHit){
    //amWriting = true;
    //if(!found)this->ValidatePlaneForPattern(iplane, oldPattern);
    if(amWriting)cout  << " ALERT ** TIME MASK !!!!!! ** " << bestMaskStrip << endl; 
    vector<Int_t>pattern;
    pattern.push_back(bestMaskStrip);
    found = true;
    if(amWriting)cout << "TM : " << timeMaskResult.largestContigGroup << "   H : " << hitResult.largestContigGroup << endl;
    if(timeMaskResult.largestContigGroup>hitResult.largestContigGroup){
      if(!oneSided)this->ReMuxPlane(iplane, pattern);
      if( oneSided){
        cout << "1 Sided Time Mask ReMux : " << timeMaskResult.largestContigGroup << endl;
        if(timeMaskResult.largestContigGroup>1){
          this->ReMuxSingleSidedPlane(iplane, pattern);
        }
      }
    }
    if(timeMaskResult.largestContigGroup==oldResult.largestContigGroup){
      if(!oneSided){
        if((timeMaskResult.fractionQE+timeMaskResult.fractionQW>
            oldResult.fractionQE+oldResult.fractionQW)  ||
           (timeMaskResult.chi2DQ+5.0<oldResult.chi2DQ))this->ReMuxPlane(iplane, pattern);
      }
      if(oneSided){
        if(timeMaskResult.largestContigGroup>1){
          this->ReMuxSingleSidedPlane(iplane, pattern);
            if(amWriting)cout << "One Sided Time Mask ReMux : " << timeMaskResult.largestContigGroup << endl;
        }
      }
    }
  }  

  returnFlag = found;

  return returnFlag;
}










bool AlgAltDeMuxBase::DumpValidateBeamPlane(Int_t iplane, bool useTimeMask){

  bool fitStatusT = false;
  bool fitStatusH = false;


  if(fPlaneHit[iplane]==0)return false;

  if(fEventType==MULTIPLE_MUON){
    MSG("AltDeMux", Msg::kWarning) << "AlgAltDeMuxBase::ValidateBeamPlane doesn't yet Multiple Muons " << endl; 
    return false;
  }
  amWriting = false;


  Int_t easthits = fDeMuxedPlanesAltLists[iplane][ALG_EAST].size()+
    fPlanesAltLists[iplane][ALG_EAST].size();
  Int_t westhits = fDeMuxedPlanesAltLists[iplane][ALG_WEST].size()+
    fPlanesAltLists[iplane][ALG_WEST].size();

  if(amWriting){
    if(amWriting)cout << "*****************************************************************  PLANE : " << iplane << endl;
    if(amWriting)cout << "ew : " << easthits << ":" << westhits << endl;
  }

  bool oneSided = false;
  if(easthits==0||westhits==0){
    if(easthits>0||westhits>0)oneSided = true;
  }

  Int_t istripH;
  Int_t istripT;

  Int_t jplane = iplane;
  if(jplane>249)jplane+=20;
  if( fUVMap[iplane]==PlaneView::kU){
    fitStatusH = fFitQHitU.status;
    istripH = static_cast<Int_t>(jplane*fFitQHitU.a1+fFitQHitU.a0);
    if(!fFitQHitU.status){
      istripH = static_cast<Int_t>(jplane*fFitHitU.a1+fFitHitU.a0);
      fitStatusH = fFitHitU.status;
    }
    fitStatusT = fFitTimeU.status;
    istripT = static_cast<Int_t>(jplane*fFitTimeU.a1+fFitTimeU.a0);
    if(amWriting){
      cout << " fit status : " << fitStatusH << " " << fitStatusT << endl;
      cout << "U HIT  STRIP AIM : " << istripH <<" "<< fFitQHitV.a0 << " : " << fFitQHitV.a1 << endl;
      cout << "U TIME STRIP AIM : " << istripT <<" "<< fFitTimeV.a0 << " : " << fFitTimeV.a1 << endl;
    }
  }
  if( fUVMap[iplane]==PlaneView::kV){
    fitStatusH = fFitQHitV.status;
    istripH = static_cast<Int_t>(jplane*fFitQHitV.a1+fFitQHitV.a0);
    if(!fitStatusH){
      fitStatusH = fFitHitV.status;
      istripH = static_cast<Int_t>(jplane*fFitHitV.a1+fFitHitV.a0);
    }
    fitStatusT = fFitTimeV.status;
    istripT = static_cast<Int_t>(jplane*fFitTimeV.a1+fFitTimeV.a0);
    if(amWriting){
      cout << "V HIT  STRIP AIM : " << istripH <<" "<< fFitQHitV.a0 << " : " << fFitQHitV.a1 << endl;
      cout << "V TIME STRIP AIM : " << istripT <<" "<< fFitTimeV.a0 << " : " << fFitTimeV.a1 << endl;
    }
  }

  if(istripH>=MAX_NUMBER_OF_STRIPS)istripH=MAX_NUMBER_OF_STRIPS; 
  if(istripT>=MAX_NUMBER_OF_STRIPS)istripT=MAX_NUMBER_OF_STRIPS; 
  if(istripH<0)istripH=0;
  if(istripT<0)istripT=0;

  
  bool returnFlag = false;
  bool found = false;
  bool useOldResult = false;

  PlaneValidity_t stripResult;
  PlaneValidity_t timeMaskResult;
  PlaneValidity_t oldResult;
  PlaneValidity_t hitResult;
  PlaneValidity_t timeResult;


  // Determine pattern for current result
  vector<Int_t>oldPattern;
  for(Int_t iHitStrip=1; iHitStrip<=fPlaneHit[iplane];iHitStrip++){
    oldPattern.push_back(fHitMap[iplane][iHitStrip]);
  }
  if(!oneSided)oldResult = this->ValidatePlaneForPattern(iplane, oldPattern);
  if( oneSided)oldResult = this->ValidateOneSidedPlaneForPattern(iplane, oldPattern);

  for(UInt_t i = 0; i<oldResult.strips.size(); i++){
    bool found = false;
    for(UInt_t ipair=0;ipair<fDeMuxedPairs[iplane].size();ipair++){
      Int_t istrip = fDeMuxedPairs[iplane][ipair].altListE->GetBestSEId().GetStrip();
      if(oldResult.strips[i]==istrip)found=true;
    }
    if(found==false){
      useOldResult=true;
      //cout << "USE OLD RESULT IS SET !!!!!!" << endl;
      //getchar();
    }
  }



  // Look at patterns centred on the hit strips
  stripResult.largestContigGroup = -1;
  Int_t bestStrip;
  for(Int_t iHitStrip=1; iHitStrip<=fPlaneHit[iplane];iHitStrip++){
    vector<Int_t>pattern;
    pattern.push_back(fHitMap[iplane][iHitStrip]);
    PlaneValidity_t thisStripResult;
    if(!oneSided)thisStripResult = this->ValidatePlaneForPattern(iplane, pattern);
    if( oneSided)thisStripResult = this->ValidateOneSidedPlaneForPattern(iplane, pattern);
    if(this->ValidityComp(stripResult,thisStripResult,istripH,istripT,oneSided)){
      stripResult = thisStripResult;
      bestStrip = fHitMap[iplane][iHitStrip];
    }
  }


  hitResult.largestContigGroup = 0;
  vector<Int_t>patternH;
  if(fitStatusH){
    patternH.push_back(istripH);
    if(!oneSided)hitResult =  this->ValidatePlaneForPattern(iplane, patternH);
    if( oneSided)hitResult =  this->ValidateOneSidedPlaneForPattern(iplane, patternH);
  }


  Int_t bestMaskStrip=-1;
  timeMaskResult.largestContigGroup = -1;
  if(useTimeMask){
    for(Int_t iStrip=0; iStrip<=MAX_NUMBER_OF_STRIPS;iStrip++){
      if(fUVmask[iplane][iStrip]==true){
        vector<Int_t>pattern;
        pattern.push_back(iStrip);
        PlaneValidity_t thisStripResult;
        if(!oneSided)thisStripResult = this->ValidatePlaneForPattern(iplane, pattern);
        if( oneSided)thisStripResult = this->ValidateOneSidedPlaneForPattern(iplane, pattern);
        if(this->ValidityComp(timeMaskResult,thisStripResult,istripH,istripT,oneSided)){
          timeMaskResult = thisStripResult;
          bestMaskStrip = iStrip;
        }else{
          if(oneSided && thisStripResult.largestContigGroup==timeMaskResult.largestContigGroup){
            if(thisStripResult.stripSpan<=timeMaskResult.stripSpan){
              bestMaskStrip = iStrip;
              timeMaskResult = thisStripResult;
            }
          }     
        }
      }
    }
  }
      
  timeResult.largestContigGroup = 0;
  vector<Int_t>patternT;
  if(fitStatusT){
    patternT.push_back(istripT);
    if(!oneSided)timeResult =  this->ValidatePlaneForPattern(iplane, patternT);
    if( oneSided)timeResult =  this->ValidateOneSidedPlaneForPattern(iplane, patternT);
  }

  bool useTimeFit   = false;
  bool useHitFit    = false;
  bool useBestStrip = false;
  bool useTimeMaskHit  = false;

  if(useTimeMask){
    if(oneSided){
    }else{
      if(timeMaskResult.fractionQE>0.25 && timeMaskResult.fractionQW>0.25)useTimeMaskHit = true;
      if(timeMaskResult.chi2DQ>oldResult.chi2DQ+20.)useTimeMaskHit = false;
    }
  }

  if(fitStatusT){
    if(timeResult.largestContigGroup>oldResult.largestContigGroup){
      if(oldResult.fractionQE<0.25||oldResult.fractionQW<0.25||(timeResult.fractionQE>0.5&&timeResult.fractionQW>0.5))useTimeFit = true;
    } 
    if(timeResult.fractionQE<0.25||timeResult.fractionQW<0.25)useTimeFit = false;
    if(timeResult.chi2DQ>oldResult.chi2DQ+20.)useTimeFit = false;
  }

  if(fitStatusH){
    if(hitResult.largestContigGroup>oldResult.largestContigGroup){
      if(oldResult.fractionQE<0.25||oldResult.fractionQW<0.25||(hitResult.fractionQE>0.5&&hitResult.fractionQW>0.5))useHitFit = true;
    } 
    if(hitResult.largestContigGroup>=oldResult.largestContigGroup){
      if(hitResult.fractionQE>0.75&&hitResult.fractionQW>0.75&&(hitResult.chi2DQ+20.0<oldResult.chi2DQ))useHitFit = true;
    }

    if(hitResult.fractionQE<0.25||hitResult.fractionQW<0.25)useHitFit = false;
    if(hitResult.chi2DQ>oldResult.chi2DQ+20.)useHitFit = false;
    if(hitResult.largestContigGroup>oldResult.largestContigGroup){
      if(oldResult.fractionQE<0.25||oldResult.fractionQW<0.25&&(hitResult.fractionQE>0.5&&hitResult.fractionQW>0.5))useHitFit = true;
    } 
  }

  if(stripResult.largestContigGroup>oldResult.largestContigGroup){
    if(oldResult.fractionQE<0.25||oldResult.fractionQW<0.25||(stripResult.fractionQE>0.5&&stripResult.fractionQW>0.5))useBestStrip = true;
    if(stripResult.chi2DQ>oldResult.chi2DQ+20.)useBestStrip = false;
  } 

  if(oneSided){
    if(fitStatusT)useTimeFit = true;
    if(fitStatusH)useHitFit = true;
    useBestStrip= true;
  }
 

  if(useHitFit){
    //amWriting = true;
    //    if(!found)this->ValidatePlaneForPattern(iplane, oldPattern);
    found = true;
    if(amWriting)cout  << " ALERT **HITS** " << endl; 
    //this->ValidatePlaneForPattern(iplane, patternH);
    found = true;
    if(hitResult.largestContigGroup>=timeResult.largestContigGroup&&
       hitResult.largestContigGroup>=stripResult.largestContigGroup){
      //if(!oneSided)this->ReMuxPlane(iplane, patternH);
      //if( oneSided)this->ReMuxSingleSidedPlane(iplane, patternH);
    }
  }

  if(useBestStrip){
    found = true;
    if(amWriting)cout  << " ALERT **BEST** " << bestStrip << endl; 
    vector<Int_t>pattern;
    pattern.push_back(bestStrip);
    //this->ValidatePlaneForPattern(iplane, pattern);
    found = true;
    if(stripResult.largestContigGroup>=timeResult.largestContigGroup&&
       stripResult.largestContigGroup>hitResult.largestContigGroup){
      //if(!oneSided)this->ReMuxPlane(iplane, pattern);
      //if( oneSided)this->ReMuxSingleSidedPlane(iplane, pattern);
    }
  }

  if(useTimeFit){
    found = true;
    if(amWriting)cout  << " ALERT **TIME** " << endl; 
    found = true;
    if(timeResult.largestContigGroup>hitResult.largestContigGroup&&
       timeResult.largestContigGroup>stripResult.largestContigGroup){
      //if(!oneSided)this->ReMuxPlane(iplane, patternT);
      //if( oneSided)this->ReMuxSingleSidedPlane(iplane, patternT);
    }
  }



  if(useTimeMaskHit){
    if(amWriting)cout  << " ALERT ** TIME MASK !!!!!! ** " << bestMaskStrip << endl; 
    vector<Int_t>pattern;
    pattern.push_back(bestMaskStrip);
    found = true;
    if(amWriting)cout << "TM : " << timeMaskResult.largestContigGroup << "   H : " << hitResult.largestContigGroup << endl;
    if(timeMaskResult.largestContigGroup>hitResult.largestContigGroup){
      if(!oneSided)this->ReMuxPlane(iplane, pattern);
      if( oneSided){
        cout << "1 Sided Time Mask ReMux : " << timeMaskResult.largestContigGroup << endl;
        if(timeMaskResult.largestContigGroup>1){
          //  this->ReMuxSingleSidedPlane(iplane, pattern);
        }
      }
    }
    if(timeMaskResult.largestContigGroup==oldResult.largestContigGroup){
      if(!oneSided){
        //      if((timeMaskResult.fractionQE+timeMaskResult.fractionQW>oldResult.fractionQE+oldResult.fractionQW)  ||(timeMaskResult.chi2DQ+5.0<oldResult.chi2DQ))this->ReMuxPlane(iplane, pattern);
      }
      if(oneSided){
        if(timeMaskResult.largestContigGroup>1){
          //this->ReMuxSingleSidedPlane(iplane, pattern);
            if(amWriting)cout << "One Sided Time Mask ReMux : " << timeMaskResult.largestContigGroup << endl;
        }
      }
    }
  }  

  returnFlag = found;

  amWriting = false;
  return returnFlag;
}







bool AlgAltDeMuxBase::ValidateBeamPlane(Int_t iplane, bool useTimeMask){

  bool fitStatusT = false;
  bool fitStatusH = false;


  if(fPlaneHit[iplane]==0)return false;

  if(fEventType==MULTIPLE_MUON){
    MSG("AltDeMux", Msg::kWarning) << "AlgAltDeMuxBase::ValidateBeamPlane doesn't yet Multiple Muons " << endl; 
    return false;
  }
  amWriting = false;


  Int_t easthits = fDeMuxedPlanesAltLists[iplane][ALG_EAST].size()+
    fPlanesAltLists[iplane][ALG_EAST].size();
  Int_t westhits = fDeMuxedPlanesAltLists[iplane][ALG_WEST].size()+
    fPlanesAltLists[iplane][ALG_WEST].size();

  if(amWriting){
    if(amWriting)cout << "*****************************************************************  PLANE : " << iplane << endl;
    if(amWriting)cout << "ew : " << easthits << ":" << westhits << endl;
  }

  bool oneSided = false;
  if(easthits==0||westhits==0){
    if(easthits>0||westhits>0)oneSided = true;
  }


  Int_t istripH;
  Int_t istripT;

  Int_t jplane = iplane;
  if(jplane>249)jplane+=20;
  if( fUVMap[iplane]==PlaneView::kU){
    fitStatusH = fFitQHitU.status;
    istripH = static_cast<Int_t>(jplane*fFitQHitU.a1+fFitQHitU.a0);
    if(!fFitQHitU.status){
      istripH = static_cast<Int_t>(jplane*fFitHitU.a1+fFitHitU.a0);
      fitStatusH = fFitHitU.status;
    }
    fitStatusT = fFitTimeU.status;
    istripT = static_cast<Int_t>(jplane*fFitTimeU.a1+fFitTimeU.a0);
    if(amWriting){
      cout << " fit status : " << fitStatusH << " " << fitStatusT << endl;
      cout << "U HIT  STRIP AIM : " << istripH <<" "<< fFitQHitV.a0 << " : " << fFitQHitV.a1 << endl;
      cout << "U TIME STRIP AIM : " << istripT <<" "<< fFitTimeV.a0 << " : " << fFitTimeV.a1 << endl;
    }
  }
  if( fUVMap[iplane]==PlaneView::kV){
    fitStatusH = fFitQHitV.status;
    istripH = static_cast<Int_t>(jplane*fFitQHitV.a1+fFitQHitV.a0);
    if(!fitStatusH){
      fitStatusH = fFitHitV.status;
      istripH = static_cast<Int_t>(jplane*fFitHitV.a1+fFitHitV.a0);
    }
    fitStatusT = fFitTimeV.status;
    istripT = static_cast<Int_t>(jplane*fFitTimeV.a1+fFitTimeV.a0);
    if(amWriting){
      cout << "V HIT  STRIP AIM : " << istripH <<" "<< fFitQHitV.a0 << " : " << fFitQHitV.a1 << endl;
      cout << "V TIME STRIP AIM : " << istripT <<" "<< fFitTimeV.a0 << " : " << fFitTimeV.a1 << endl;
    }
  }

  if(istripH>=MAX_NUMBER_OF_STRIPS)istripH=MAX_NUMBER_OF_STRIPS; 
  if(istripT>=MAX_NUMBER_OF_STRIPS)istripT=MAX_NUMBER_OF_STRIPS; 
  if(istripH<0)istripH=0;
  if(istripT<0)istripT=0;

  
  bool returnFlag = false;
  bool found = false;
  bool useOldResult = false;

  PlaneValidity_t stripResult;
  PlaneValidity_t timeMaskResult;
  PlaneValidity_t oldResult;
  PlaneValidity_t hitResult;
  PlaneValidity_t timeResult;


  vector<Int_t>oldPattern;
  for(Int_t iHitStrip=1; iHitStrip<=fPlaneHit[iplane];iHitStrip++){
    oldPattern.push_back(fHitMap[iplane][iHitStrip]);
  }
  if(!oneSided)oldResult = this->ValidatePlaneForPattern(iplane, oldPattern);
  if( oneSided)oldResult = this->ValidateOneSidedPlaneForPattern(iplane, oldPattern);

  for(UInt_t i = 0; i<oldResult.strips.size(); i++){
    bool found = false;
    for(UInt_t ipair=0;ipair<fDeMuxedPairs[iplane].size();ipair++){
      Int_t istrip = fDeMuxedPairs[iplane][ipair].altListE->GetBestSEId().GetStrip();
      if(oldResult.strips[i]==istrip)found=true;
    }
    if(found==false){
      useOldResult=true;
      //cout << "USE OLD RESULT IS SET !!!!!!" << endl;
      //getchar();
    }
  }


  stripResult.largestContigGroup = 0;
  Int_t bestStrip;
  for(Int_t iHitStrip=1; iHitStrip<=fPlaneHit[iplane];iHitStrip++){
    vector<Int_t>pattern;
    pattern.push_back(fHitMap[iplane][iHitStrip]);
    PlaneValidity_t thisStripResult;
    if(!oneSided)thisStripResult = this->ValidatePlaneForPattern(iplane, pattern);
    if( oneSided)thisStripResult = this->ValidateOneSidedPlaneForPattern(iplane, pattern);
    if(this->ValidityComp(oldResult,thisStripResult,istripH,istripT,oneSided)){
      stripResult = thisStripResult;
      bestStrip = fHitMap[iplane][iHitStrip];
    }
  }

  hitResult.largestContigGroup = 0;
  vector<Int_t>patternH;
  if(fitStatusH){
    patternH.push_back(istripH);
    if(!oneSided)hitResult =  this->ValidatePlaneForPattern(iplane, patternH);
    if( oneSided)hitResult =  this->ValidateOneSidedPlaneForPattern(iplane, patternH);
  }


  Int_t bestMaskStrip=-1;
  timeMaskResult.largestContigGroup = -1;
  if(useTimeMask){
    for(Int_t iStrip=0; iStrip<=MAX_NUMBER_OF_STRIPS;iStrip++){
      if(fUVmask[iplane][iStrip]==true){
        vector<Int_t>pattern;
        pattern.push_back(iStrip);
        PlaneValidity_t thisStripResult;
        if(!oneSided)thisStripResult = this->ValidatePlaneForPattern(iplane, pattern);
        if( oneSided)thisStripResult = this->ValidateOneSidedPlaneForPattern(iplane, pattern);
        if(this->ValidityComp(timeMaskResult,thisStripResult,istripH,istripT,oneSided)){
          timeMaskResult = thisStripResult;
          bestMaskStrip = iStrip;
        }else{
          if(oneSided && thisStripResult.largestContigGroup==timeMaskResult.largestContigGroup){
            if(thisStripResult.stripSpan<=timeMaskResult.stripSpan){
              bestMaskStrip = iStrip;
              timeMaskResult = thisStripResult;
            }
          }     
        }
      }
    }
  }
      
  timeResult.largestContigGroup = 0;
  vector<Int_t>patternT;
  if(fitStatusT){
    patternT.push_back(istripT);
    if(!oneSided)timeResult =  this->ValidatePlaneForPattern(iplane, patternT);
    if( oneSided)timeResult =  this->ValidateOneSidedPlaneForPattern(iplane, patternT);
  }

  bool useTimeFit   = false;
  bool useHitFit    = false;
  bool useBestStrip = false;
  bool useTimeMaskHit  = false;

  if(useTimeMask){
    if(oneSided){
    }else{
      if(timeMaskResult.fractionQE>0.25 && timeMaskResult.fractionQW>0.25)useTimeMaskHit = true;
      if(timeMaskResult.chi2DQ>oldResult.chi2DQ+20.)useTimeMaskHit = false;
    }
  }

  if(fitStatusT){
    if(timeResult.largestContigGroup>oldResult.largestContigGroup){
      if(oldResult.fractionQE<0.25||oldResult.fractionQW<0.25||(timeResult.fractionQE>0.5&&timeResult.fractionQW>0.5))useTimeFit = true;
    } 
    if(timeResult.fractionQE<0.25||timeResult.fractionQW<0.25)useTimeFit = false;
    if(timeResult.chi2DQ>oldResult.chi2DQ+20.)useTimeFit = false;
    if(timeResult.largestContigGroup==oldResult.largestContigGroup){

    }
  }

  if(fitStatusH){
    if(hitResult.largestContigGroup>oldResult.largestContigGroup){
      if(oldResult.fractionQE<0.25||oldResult.fractionQW<0.25||(hitResult.fractionQE>0.5&&hitResult.fractionQW>0.5))useHitFit = true;
    } 
    if(hitResult.largestContigGroup>=oldResult.largestContigGroup){
      if(hitResult.fractionQE>0.75&&hitResult.fractionQW>0.75&&(hitResult.chi2DQ+20.0<oldResult.chi2DQ))useHitFit = true;
    }

    if(hitResult.fractionQE<0.25||hitResult.fractionQW<0.25)useHitFit = false;
    if(hitResult.chi2DQ>oldResult.chi2DQ+20.)useHitFit = false;
    if(hitResult.largestContigGroup>oldResult.largestContigGroup){
      if(oldResult.fractionQE<0.25||oldResult.fractionQW<0.25&&(hitResult.fractionQE>0.5&&hitResult.fractionQW>0.5))useHitFit = true;
    } 
  }

  if(stripResult.largestContigGroup>oldResult.largestContigGroup){
    if(oldResult.fractionQE<0.25||oldResult.fractionQW<0.25||(stripResult.fractionQE>0.5&&stripResult.fractionQW>0.5))useBestStrip = true;
    if(stripResult.chi2DQ>oldResult.chi2DQ+20.)useBestStrip = false;
  } 

  if(oneSided){
    if(fitStatusT)useTimeFit = true;
    if(fitStatusH)useHitFit = true;
    useBestStrip= true;
  }
 
  // NOW HAVE ALL VALIDATE PATTERNS and BEST in each TYPE
  // Decide which to use


  if(useHitFit){
    //amWriting = true;
    //    if(!found)this->ValidatePlaneForPattern(iplane, oldPattern);
    found = true;
    if(amWriting)cout  << " ALERT **HITS** " << endl; 
    //this->ValidatePlaneForPattern(iplane, patternH);
    found = true;
    if(hitResult.largestContigGroup>=timeResult.largestContigGroup&&
       hitResult.largestContigGroup>=stripResult.largestContigGroup){
      if(!oneSided)this->ReMuxPlane(iplane, patternH);
      if( oneSided)this->ReMuxSingleSidedPlane(iplane, patternH);
    }
  }

  if(useBestStrip){
    //amWriting = true;
    //if(!found)this->ValidatePlaneForPattern(iplane, oldPattern);
    found = true;
    if(amWriting)cout  << " ALERT **BEST** " << bestStrip << endl; 
    vector<Int_t>pattern;
    pattern.push_back(bestStrip);
    //this->ValidatePlaneForPattern(iplane, pattern);
    found = true;
    if(stripResult.largestContigGroup>=timeResult.largestContigGroup&&
       stripResult.largestContigGroup>hitResult.largestContigGroup){
      if(!oneSided)this->ReMuxPlane(iplane, pattern);
      if( oneSided)this->ReMuxSingleSidedPlane(iplane, pattern);
    }
  }

  if(useTimeFit){
    //amWriting = true;
    //if(!found)this->ValidatePlaneForPattern(iplane, oldPattern);
    found = true;
    if(amWriting)cout  << " ALERT **TIME** " << endl; 
    //this->ValidatePlaneForPattern(iplane, patternT);
    found = true;
    if(timeResult.largestContigGroup>hitResult.largestContigGroup&&
       timeResult.largestContigGroup>stripResult.largestContigGroup){
      if(!oneSided)this->ReMuxPlane(iplane, patternT);
      if( oneSided)this->ReMuxSingleSidedPlane(iplane, patternT);
    }
  }



  if(useTimeMaskHit){
    //amWriting = true;
    //if(!found)this->ValidatePlaneForPattern(iplane, oldPattern);
    if(amWriting)cout  << " ALERT ** TIME MASK !!!!!! ** " << bestMaskStrip << endl; 
    vector<Int_t>pattern;
    pattern.push_back(bestMaskStrip);
    found = true;
    if(amWriting)cout << "TM : " << timeMaskResult.largestContigGroup << "   H : " << hitResult.largestContigGroup << endl;
    if(timeMaskResult.largestContigGroup>hitResult.largestContigGroup){
      if(!oneSided)this->ReMuxPlane(iplane, pattern);
      if( oneSided){
        cout << "1 Sided Time Mask ReMux : " << timeMaskResult.largestContigGroup << endl;
        if(timeMaskResult.largestContigGroup>1){
          this->ReMuxSingleSidedPlane(iplane, pattern);
        }
      }
    }
    if(timeMaskResult.largestContigGroup==oldResult.largestContigGroup){
      if(!oneSided){
        if((timeMaskResult.fractionQE+timeMaskResult.fractionQW>
            oldResult.fractionQE+oldResult.fractionQW)  ||
           (timeMaskResult.chi2DQ+5.0<oldResult.chi2DQ))this->ReMuxPlane(iplane, pattern);
      }
      if(oneSided){
        if(timeMaskResult.largestContigGroup>1){
          this->ReMuxSingleSidedPlane(iplane, pattern);
            if(amWriting)cout << "One Sided Time Mask ReMux : " << timeMaskResult.largestContigGroup << endl;
        }
      }
    }
  }  

  returnFlag = found;

  amWriting = false;
  return returnFlag;
}




bool AlgAltDeMuxBase::ValidityComp(PlaneValidity_t currentValidity, PlaneValidity_t newValidity, int istripH, int istripT, bool onesided){

  bool spoton=false;
  if(istripH==istripT)spoton=true;
  if(onesided)spoton=false;

  if(newValidity.largestContigGroup>currentValidity.largestContigGroup)return true;

  if(newValidity.largestContigGroup==currentValidity.largestContigGroup){
    if((currentValidity.fractionQE<0.25||currentValidity.fractionQW<0.25)&&(newValidity.fractionQE>0.5&&newValidity.fractionQW>0.5))return true;
    if(currentValidity.chi2DQ-newValidity.chi2DQ>10)return true;
    if(fFitQHitU.status){
      if(fabs(newValidity.centroid-istripH)<fabs(currentValidity.centroid-istripH))return true;
    }
  }  
  
  return false;
}



bool AlgAltDeMuxBase::BestGuessForPlane(Int_t iplane, bool doSingleSided){

  if(fPlaneHit[iplane]!=0)return false;

  Int_t easthits = fDeMuxedPlanesAltLists[iplane][ALG_EAST].size()+
    fPlanesAltLists[iplane][ALG_EAST].size();
  Int_t westhits = fDeMuxedPlanesAltLists[iplane][ALG_WEST].size()+
    fPlanesAltLists[iplane][ALG_WEST].size();

  if(fDiagnosticPlots){
    if(amWriting)cout << "*****************************************************************  PLANE : " << iplane << endl;
    if(amWriting)cout << "ew : " << easthits << ":" << westhits << endl;
  }

  bool oneSided = false;
  if(easthits==0||westhits==0){
    if(easthits>0||westhits>0)oneSided = true;
  }

  if(oneSided && !doSingleSided)return false;

  bool returnFlag = false;
  bool found = false;

  PlaneValidity_t timeMaskResult;
  timeMaskResult.largestContigGroup = -1;
  timeMaskResult.stripSpan          = 0;
  timeMaskResult.centroid           = 0.;
  timeMaskResult.chi2DQ             = 99999.;
  timeMaskResult.fractionQE = 0.;
  timeMaskResult.fractionQW = 0.;

  Int_t bestMaskStrip=-1;

  for(Int_t iStrip=0; iStrip<=MAX_NUMBER_OF_STRIPS;iStrip++){
    if(fUVmask[iplane][iStrip]==true){
      vector<Int_t>pattern;
      if(amWriting)cout << "TIMING MASK : " << iStrip << endl;
      pattern.push_back(iStrip);
      PlaneValidity_t thisStripResult;
      if(!oneSided)thisStripResult = this->ValidatePlaneForPattern(iplane, pattern);
      if( oneSided)thisStripResult = this->ValidateOneSidedPlaneForPattern(iplane, pattern);
      if(thisStripResult.largestContigGroup>timeMaskResult.largestContigGroup){
        timeMaskResult = thisStripResult;
        bestMaskStrip = iStrip;
      }
      if(thisStripResult.largestContigGroup==timeMaskResult.largestContigGroup){
        if(oneSided){
          if(thisStripResult.stripSpan<=timeMaskResult.stripSpan){
            bestMaskStrip = iStrip;
            timeMaskResult = thisStripResult;
          }
        }else{
          if( (thisStripResult.fractionQE+thisStripResult.fractionQW)>
              (timeMaskResult.fractionQE+timeMaskResult.fractionQW) ){
            if(thisStripResult.chi2DQ<timeMaskResult.chi2DQ+10.){
              bestMaskStrip = iStrip;
              timeMaskResult = thisStripResult;
            }
          }
        }
      }
    }
  }


  if(timeMaskResult.largestContigGroup>0){
    vector<Int_t>pattern;
    pattern.push_back(bestMaskStrip);
    if(!oneSided)this->ReMuxPlane(iplane, pattern);
    if( oneSided){
      if(timeMaskResult.largestContigGroup>1){
        this->ReMuxSingleSidedPlane(iplane, pattern);
      }
    }
    return true;
  }
  
      
  for(Int_t iStrip=0; iStrip<=MAX_NUMBER_OF_STRIPS;iStrip++){
    vector<Int_t>pattern;
    pattern.push_back(iStrip);
    PlaneValidity_t thisStripResult;
    if(!oneSided)thisStripResult = this->ValidatePlaneForPattern(iplane, pattern);
    if( oneSided)thisStripResult = this->ValidateOneSidedPlaneForPattern(iplane, pattern);
    if(thisStripResult.largestContigGroup>timeMaskResult.largestContigGroup){
      timeMaskResult = thisStripResult;
      bestMaskStrip = iStrip;
    }
    if(thisStripResult.largestContigGroup==timeMaskResult.largestContigGroup){
      if(oneSided){
        if(thisStripResult.stripSpan<=timeMaskResult.stripSpan){
          bestMaskStrip = iStrip;
          timeMaskResult = thisStripResult;
        }
      }else{
        if( (thisStripResult.fractionQE+thisStripResult.fractionQW)>
            (timeMaskResult.fractionQE+timeMaskResult.fractionQW) ){
          if(thisStripResult.chi2DQ<timeMaskResult.chi2DQ+10.){
            bestMaskStrip = iStrip;
            timeMaskResult = thisStripResult;
          }
        }
      }
    }
  }
      
  returnFlag = found;

  if(timeMaskResult.largestContigGroup>0){
    vector<Int_t>pattern;
    pattern.push_back(bestMaskStrip);
    if(!oneSided)this->ReMuxPlane(iplane, pattern);
    if( oneSided){
      if(timeMaskResult.largestContigGroup>1){
        this->ReMuxSingleSidedPlane(iplane, pattern);
      }
    }
  }
  
  return returnFlag;
}






bool AlgAltDeMuxBase::BestGuessForSingleSidedHits(Int_t iplane){

  vector <PlexSEIdAltL*>::iterator literA;

  //  if(fPlaneHit[iplane]!=0)return false;
  
  Int_t Nm =0;
  Int_t Np =0;
  Float_t wm = 0.0;
  Float_t wp = 0.0;
     
  for(Int_t iStrip=0; iStrip<=MAX_NUMBER_OF_STRIPS;iStrip++){
    if(iplane>1){
      if(fTimingMask[iplane-1][iStrip]){
        wm+= iStrip;
        Nm++;
      }
    }
    if(iplane<MAX_NUMBER_OF_PLANES-2){
      if(fTimingMask[iplane+1][iStrip]){
        wp+= iStrip;
        Np++;
      }
    }
  }
  
  Float_t target = 0.;
  if(Nm==0&&Np==0){
    for(Int_t jplane=iplane;jplane<500 && jplane<iplane+11;jplane+=2){
      Int_t easthits = fDeMuxedPlanesAltLists[jplane][ALG_EAST].size();
      Int_t westhits = fDeMuxedPlanesAltLists[jplane][ALG_WEST].size();
      for(Int_t iE=0;iE<easthits;iE++){
        wp += fDeMuxedPlanesAltLists[jplane][ALG_EAST][iE]->GetBestSEId().GetStrip();
        Np++;
      }
      for(Int_t iW=0;iW<westhits;iW++){
        wp += fDeMuxedPlanesAltLists[jplane][ALG_WEST][iW]->GetBestSEId().GetStrip();
        Np++;
      }
    }

    for(Int_t jplane=iplane-2;jplane>0 && jplane >iplane-11;jplane-=2){
      Int_t easthits = fDeMuxedPlanesAltLists[jplane][ALG_EAST].size();
      Int_t westhits = fDeMuxedPlanesAltLists[jplane][ALG_WEST].size();
      for(Int_t iE=0;iE<easthits;iE++){
        wm += fDeMuxedPlanesAltLists[jplane][ALG_EAST][iE]->GetBestSEId().GetStrip();
        Nm++;
      }
      for(Int_t iW=0;iW<westhits;iW++){
        wm += fDeMuxedPlanesAltLists[jplane][ALG_WEST][iW]->GetBestSEId().GetStrip();
        Nm++;
      }
    }


  }
  if(Nm==0&&Np==0)return false;

  if(Nm==0&&Np>0)target =  wp/static_cast<Float_t>(Np);
  if(Np==0&&Nm>0)target =  wm/static_cast<Float_t>(Nm);
  if(Np>0&&Nm>0)target =  (wm/static_cast<Float_t>(Nm) + wp/static_cast<Float_t>(Np))/2.0;

  for(Int_t iew=ALG_EAST;iew<=ALG_WEST;iew++){
    if(fPlanesAltLists[iplane][iew].size()>0){
      while (fPlanesAltLists[iplane][iew].size()>0){
        Int_t sbest =0;
        Float_t closeness = 999;
        literA = fPlanesAltLists[iplane][iew].begin();
        (*literA)->SetFirst();
        while( (*literA)->IsValid() ){
          Int_t s = (*literA)->GetCurrentSEId().GetStrip();
          if(fabs(target-s)<closeness){
            closeness = fabs(target-s);
            sbest = s;
          }                     
          (*literA)->Next();
        }
        if(closeness<999){
          if(iew==ALG_EAST)this->DeMuxSingleHitE(iplane,*literA, sbest);
          if(iew==ALG_WEST)this->DeMuxSingleHitW(iplane,*literA, sbest);
        }
      }
    }
  }
  
  return true;
}







bool AlgAltDeMuxBase::ValidateContainedCandidateEndPlane(Int_t iplane){
  if(fPlaneHit[iplane]==0)return false;
  bool useTimeMask = true;
  Int_t iLowHit = 999;

  if(fEventType==MULTIPLE_MUON){
    MSG("AltDeMux", Msg::kWarning) << "AlgAltDeMuxBase::ValidateContainedCandidateEndPlane does nothandle Multiple Muons" << endl; 
    return false;
  }

  Int_t easthits = fDeMuxedPlanesAltLists[iplane][ALG_EAST].size()+
    fPlanesAltLists[iplane][ALG_EAST].size();
  Int_t westhits = fDeMuxedPlanesAltLists[iplane][ALG_WEST].size()+
    fPlanesAltLists[iplane][ALG_WEST].size();

  if(fDiagnosticPlots){
    if(amWriting)cout << "*****************************************************************  PLANE : " << iplane << endl;
    if(amWriting)cout << "ew : " << easthits << ":" << westhits << endl;
  }

  bool oneSided = false;
  if(easthits==0||westhits==0){
    if(easthits>0||westhits>0)oneSided = true;
  }

  PlaneValidity_t timeMaskResult;
  timeMaskResult.largestContigGroup = -1;
  timeMaskResult.stripSpan          = 0;
  timeMaskResult.centroid           = 0.;
  timeMaskResult.chi2DQ             = 99999.;
  timeMaskResult.fractionQE = 0.;
  timeMaskResult.fractionQW = 0.;

  PlaneValidity_t oldResult;

  vector<Int_t>oldPattern;
  for(Int_t iHitStrip=1; iHitStrip<=fPlaneHit[iplane];iHitStrip++){
    if(fHitMap[iplane][iHitStrip]<iLowHit)iLowHit = fHitMap[iplane][iHitStrip]; 
    oldPattern.push_back(fHitMap[iplane][iHitStrip]);
  }
  if(!oneSided)oldResult = this->ValidatePlaneForPattern(iplane, oldPattern);
  if( oneSided)oldResult = this->ValidateOneSidedPlaneForPattern(iplane, oldPattern);

  Int_t bestMaskStrip=-1;
  if(useTimeMask){
    for(Int_t iStrip=iLowHit; iStrip<=MAX_NUMBER_OF_STRIPS;iStrip++){
      if(fUVmask[iplane][iStrip]==true){
        vector<Int_t>pattern;
        pattern.push_back(iStrip);
        PlaneValidity_t thisStripResult;
        if(!oneSided)thisStripResult = this->ValidatePlaneForPattern(iplane, pattern);
        if( oneSided)thisStripResult = this->ValidateOneSidedPlaneForPattern(iplane, pattern);
        if(thisStripResult.largestContigGroup>timeMaskResult.largestContigGroup){
          timeMaskResult = thisStripResult;
          bestMaskStrip = iStrip;
        }
        if(thisStripResult.largestContigGroup==timeMaskResult.largestContigGroup){
          if(oneSided){
            if(thisStripResult.stripSpan<=timeMaskResult.stripSpan){
              bestMaskStrip = iStrip;
              timeMaskResult = thisStripResult;
            }
          }else{
            if((timeMaskResult.fractionQE<0.25||timeMaskResult.fractionQW<0.25)&&(thisStripResult.fractionQE>0.5&&thisStripResult.fractionQW>0.5)){
              if(thisStripResult.chi2DQ<timeMaskResult.chi2DQ+10.){
                bestMaskStrip = iStrip;
                timeMaskResult = thisStripResult;
              }
            }
            if((timeMaskResult.fractionQE<0.25||timeMaskResult.fractionQW<0.25)&&(thisStripResult.fractionQE>0.5||thisStripResult.fractionQW>0.5)){
              if(thisStripResult.chi2DQ<timeMaskResult.chi2DQ+5.){
                bestMaskStrip = iStrip;
                timeMaskResult = thisStripResult;
              }
            }

          }
        }
        if(thisStripResult.largestContigGroup>=oldResult.largestContigGroup){
          if(amWriting)cout << "TIMING MASK : " << iStrip << endl;
          if(!oneSided)thisStripResult = this->ValidatePlaneForPattern(iplane, pattern);
          if( oneSided)thisStripResult = this->ValidateOneSidedPlaneForPattern(iplane, pattern);
        }
      }
    }
  }
      
  bool useTimeMaskHit  = false;

  if(useTimeMask){
    if(oneSided){
    }else{
      if(timeMaskResult.fractionQE>0.25 && timeMaskResult.fractionQW>0.25)useTimeMaskHit = true;
    }
  }

  bool found = false;

  if(useTimeMaskHit){
    //amWriting = true;
    //if(!found)this->ValidatePlaneForPattern(iplane, oldPattern);
    if(amWriting)cout  << " ALERT ** TIME MASK !!!!!! ** " << bestMaskStrip << endl; 
    vector<Int_t>pattern;
    pattern.push_back(bestMaskStrip);
    found = true;
    if(amWriting)cout << "TM : " << timeMaskResult.largestContigGroup << "   H : " << oldResult.largestContigGroup << endl;
    if(timeMaskResult.largestContigGroup>oldResult.largestContigGroup){
      if(!oneSided)this->ReMuxPlane(iplane, pattern);
      if( oneSided){
        cout << "1 Sided Time Mask ReMux : " << timeMaskResult.largestContigGroup << endl;
        if(timeMaskResult.largestContigGroup>1){
          this->ReMuxSingleSidedPlane(iplane, pattern);
        }
      }
    }
    if(timeMaskResult.largestContigGroup==oldResult.largestContigGroup){
      if(!oneSided){
        if((timeMaskResult.fractionQE+timeMaskResult.fractionQW>
            oldResult.fractionQE+oldResult.fractionQW)  ||
           (timeMaskResult.chi2DQ+5.0<oldResult.chi2DQ))this->ReMuxPlane(iplane, pattern);
      }
      if(oneSided){
        if(timeMaskResult.largestContigGroup>1){
          this->ReMuxSingleSidedPlane(iplane, pattern);
          if(amWriting)cout << "One Sided Time Mask ReMux : " << timeMaskResult.largestContigGroup << endl;
        }
      }
    }
  }  

  bool returnFlag = found;

  return returnFlag;
}




bool AlgAltDeMuxBase::ValidatePlaneAgainstTarget(Int_t iplane, Int_t targetStrip){


  vector <PlexSEIdAltL*>::iterator literA;

  bool returnFlag = false;

  if(fPlaneHit[iplane]==0)return false;

  if(fEventType==MULTIPLE_MUON){
    MSG("AltDeMux", Msg::kWarning) << "AlgAltDeMuxBase::ValidateContainedCandidateEndPlane does nothandle Multiple Muons" << endl; 
    return false;
  }

  Int_t easthits = fDeMuxedPlanesAltLists[iplane][ALG_EAST].size()+
    fPlanesAltLists[iplane][ALG_EAST].size();

  Int_t westhits = fDeMuxedPlanesAltLists[iplane][ALG_WEST].size()+
    fPlanesAltLists[iplane][ALG_WEST].size();

  bool oneSided = false;
  if(easthits==0||westhits==0){
    if(easthits>0||westhits>0)oneSided = true;
  }

  if(oneSided)return false;

  PlaneValidity_t oldResult;
  vector<Int_t>oldPattern;
  for(Int_t iHitStrip=1; iHitStrip<=fPlaneHit[iplane];iHitStrip++){
    oldPattern.push_back(fHitMap[iplane][iHitStrip]);
  }

  PlaneValidity_t targetResult;
  vector<Int_t>pattern;
  pattern.push_back(targetStrip);
  PlaneValidity_t thisStripResult;

  if(!oneSided){
    oldResult = this->ValidatePlaneForPattern(iplane, oldPattern);
    targetResult = this->ValidatePlaneForPattern(iplane, pattern);
  }else{
    oldResult = this->ValidateOneSidedPlaneForPattern(iplane, oldPattern);
    targetResult = this->ValidateOneSidedPlaneForPattern(iplane, pattern);
  }

  bool remux = false;
  if(targetResult.largestContigGroup>oldResult.largestContigGroup){
    if(targetResult.chi2DQ<oldResult.chi2DQ+10)remux=true;
    if(targetResult.chi2DQ<oldResult.chi2DQ+20&&targetResult.fractionQE>oldResult.fractionQE&&targetResult.fractionQW>oldResult.fractionQW )remux=true;
  }

  if(targetResult.largestContigGroup==oldResult.largestContigGroup){
    int excold = 0;
    int excnew = 0;
    int oldnew = 0;
    for(unsigned int i=0;i<targetResult.strips.size();i++){
      bool found=false;
      for(unsigned int j=0;j<oldResult.strips.size();j++){
        if(targetResult.strips[i]==oldResult.strips[j])found= true;
      }
      if(found)oldnew++;
      if(!found)excnew++;
    }
    for(unsigned int i=0;i<oldResult.strips.size();i++){
      bool found=false;
      for(unsigned int j=0;j<targetResult.strips.size();j++){
        if(oldResult.strips[i]==targetResult.strips[j])found= true;
      }
      if(!found)excold++;
    }

    if(excold>0||excnew>0){
      if(excnew>0&&excold==0)remux=true;
      if(excnew>0&&excold>0){
        float points = 0;
        points+= (targetResult.fractionQE-oldResult.fractionQE)/0.1;
        points+= (targetResult.fractionQW-oldResult.fractionQW)/0.1;
        points-= (targetResult.stripSpan-oldResult.stripSpan)/5.;
        points-= (targetResult.chi2DQ-oldResult.chi2DQ)/5.;
        if(points>2)remux=true;
      }
    }
  }

  if(remux){
    this->ReMuxPlane(iplane, pattern);
    for(Int_t iew=ALG_EAST;iew<=ALG_WEST;iew++){
      while (fPlanesAltLists[iplane][iew].size()>0){
        int sbest =0;
        int closeness = 999;
        literA = fPlanesAltLists[iplane][iew].begin();
        (*literA)->SetFirst();
        while( (*literA)->IsValid() ){
          int s = (*literA)->GetCurrentSEId().GetStrip();
          for(unsigned int t=0;t<pattern.size();t++){
            if(abs(pattern[t]-s)<closeness){
              closeness = abs(pattern[t]-s);
              sbest = s;                        
            }
          }
          (*literA)->Next();
        }
        if(closeness<999){
          if(iew==ALG_EAST)this->DeMuxSingleHitE(iplane,*literA, sbest);
          if(iew==ALG_WEST)this->DeMuxSingleHitW(iplane,*literA, sbest);
        }
      }
    }
  }

  if(remux)returnFlag=true;

  return returnFlag;
}



bool AlgAltDeMuxBase::ValidateContainedCandidateEndPlanes(){

  bool changed = false;

  Int_t doWhat[MAX_NUMBER_OF_PLANES];
  const Int_t DO_NOTHING=0;
  const Int_t DO_LOOK_ABOVE=1;
  //  const Int_t DO_LOOK_BELOW=2;

  for(Int_t i=0; i<MAX_NUMBER_OF_PLANES;i++){
    doWhat[i]=DO_NOTHING;
  } 
  

  if(amWriting){
    cout << " Low/High " << fLowestPlane << ":" << fHighestPlane << endl;
    cout << " HighCC   " << fCCHighestPlane << endl;
    cout << " NearCC   " << fCCNearestPlane << endl;
  }

  Int_t eventLowPlane  = fCCHighestPlane;
  Int_t eventHighPlane = fCCHighestPlane;
  Int_t nGap = 0;
  bool  done = false;
  for(Int_t iplane=fCCHighestPlane; !done && iplane<MAX_NUMBER_OF_PLANES; iplane++){
    if(fPlaneHit[iplane]>0){
      eventHighPlane = iplane;
      nGap = 0;
    }
    if(fPlaneHit[iplane]==0)nGap++;
    if(nGap>=3)done=true;
  }
  nGap = 0;
  done = false;
  for(Int_t iplane=fCCHighestPlane; !done && iplane>=0; iplane--){
    if(fPlaneHit[iplane]>0){
      eventLowPlane = iplane;
      nGap = 0;
    }
    if(fPlaneHit[iplane]==0)nGap++;
    if(nGap>=3)done=true;
  }

  if(amWriting){
    cout << " HighEvent " << eventHighPlane << endl;
    cout << " LowEvent  " << eventLowPlane << endl;
  }

  bool foundU = false;
  bool foundV = false;
  if( abs(eventHighPlane-fCCHighestPlane)<abs(eventLowPlane-fCCHighestPlane)){
    for(Int_t iplane=fCCHighestPlane+5; iplane>=fCCHighestPlane-5;iplane--){
      if(fUVMap[iplane]==PlaneView::kU){
        if(!foundU && (fPlaneHit[iplane]>0) ){
          doWhat[iplane] = DO_LOOK_ABOVE;
          if(fDeMuxedPairs[iplane].size()>0)foundU=true;
          if(amWriting)cout << "Need to check U plane : " << iplane << endl;
        } 
      }
      if(fUVMap[iplane]==PlaneView::kV){
        if(!foundV && (fPlaneHit[iplane]>0)){
          doWhat[iplane] = DO_LOOK_ABOVE;
          if(fDeMuxedPairs[iplane].size()>0)foundV=true;
          if(amWriting)cout << "Need to check V plane : " << iplane << endl;
        } 
      }
    }
  }else{
    for(Int_t iplane=fCCHighestPlane-5; iplane<=fCCHighestPlane+5;iplane++){
      if(fUVMap[iplane]==PlaneView::kU){
        if(!foundU && (fPlaneHit[iplane]>0) ){
          doWhat[iplane] = DO_LOOK_ABOVE;
          if(fDeMuxedPairs[iplane].size()>0)foundU=true;
          if(amWriting)cout << "Need to check U plane : " << iplane << endl;
        } 
      }
      if(fUVMap[iplane]==PlaneView::kV){
        if(!foundV && (fPlaneHit[iplane]>0)){
          doWhat[iplane] = DO_LOOK_ABOVE;
          if(fDeMuxedPairs[iplane].size()>0)foundV=true;
          if(amWriting)cout << "Need to check V plane : " << iplane << endl;
        } 
      }
    }
  }

  changed = false;
  for(Int_t i=0; i<MAX_NUMBER_OF_PLANES;i++){
    if(doWhat[i]!=DO_NOTHING){
      //      cout << " Validating Plane : " << i << endl;
      bool thisPlaneChanged = ValidateContainedCandidateEndPlane(i);
      changed = changed || thisPlaneChanged;
    }
  }

  return changed;
}


void AlgAltDeMuxBase::MakeMultipleTargets(Int_t iplane){

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

  Int_t jplane = iplane;
  if(iplane>248)jplane+=20;
  if(fUVMap[iplane]==PlaneView::kU){
    for(UInt_t iline=0; iline<multipleMuonInterceptsU.size();iline++){
      Float_t rtarget = fHoughSlopeU*jplane + multipleMuonInterceptsU[iline];
      Int_t itarget = static_cast<Int_t>(rtarget);
      if(itarget<198&&itarget>-10){
        if(itarget>190)itarget=191;
        if(itarget<0)itarget=0;
        fTargetStrips.push_back(itarget);
      }
    }
  }
  if(fUVMap[iplane]==PlaneView::kV){
    for(UInt_t iline=0; iline<multipleMuonInterceptsV.size();iline++){
      Float_t rtarget = fHoughSlopeV*jplane + multipleMuonInterceptsV[iline];
      Int_t itarget = static_cast<Int_t>(rtarget);
      if(itarget<198&&itarget>-10){
        if(itarget>190)itarget=191;
        if(itarget<0)itarget=0;
        fTargetStrips.push_back(itarget);
      }
    }
  }

  return;
}




bool AlgAltDeMuxBase::ValidateCCEndPlanes(){


  //amWriting=true;
  bool changed = false;

  Int_t doWhat[MAX_NUMBER_OF_PLANES];
  const Int_t DO_NOTHING=0;
  const Int_t DO_LOOK_ABOVE=1;
  //  const Int_t DO_LOOK_BELOW=2;

  for(Int_t i=0; i<MAX_NUMBER_OF_PLANES;i++){
    doWhat[i]=DO_NOTHING;
  } 
  

  if(amWriting){
    cout << " Low/High " << fLowestPlane << ":" << fHighestPlane << endl;
    cout << " HighCC   " << fCCHighestPlane << endl;
    cout << " NearCC   " << fCCNearestPlane << endl;
  }

  Int_t eventLowPlane  = fCCHighestPlane;
  Int_t eventHighPlane = fCCHighestPlane;
  Int_t nGap = 0;
  bool  done = false;
  for(Int_t iplane=fCCHighestPlane; !done && iplane<MAX_NUMBER_OF_PLANES; iplane++){
    if(fPlaneHit[iplane]>0){
      eventHighPlane = iplane;
      nGap = 0;
    }
    if(fPlaneHit[iplane]==0)nGap++;
    if(nGap>=3)done=true;
  }
  nGap = 0;
  done = false;
  for(Int_t iplane=fCCHighestPlane; !done && iplane>=0; iplane--){
    if(fPlaneHit[iplane]>0){
      eventLowPlane = iplane;
      nGap = 0;
    }
    if(fPlaneHit[iplane]==0)nGap++;
    if(nGap>=3)done=true;
  }

  if(amWriting){
    cout << " HighEvent " << eventHighPlane << endl;
    cout << " LowEvent  " << eventLowPlane << endl;
  }

  bool foundU = false;
  bool foundV = false;
  if( abs(eventHighPlane-fCCHighestPlane)<abs(eventLowPlane-fCCHighestPlane)){
    for(Int_t iplane=fCCHighestPlane+5; iplane>=fCCHighestPlane-5;iplane--){
      if(fUVMap[iplane]==PlaneView::kU){
        if(!foundU && (fPlaneHit[iplane]>0) ){
          doWhat[iplane] = DO_LOOK_ABOVE;
          if(fPlaneHit[iplane-2]>0)doWhat[iplane-2] = DO_LOOK_ABOVE;
          if(fDeMuxedPairs[iplane].size()>0)foundU=true;
          if(amWriting)cout << "Need to check U plane : " << iplane << endl;
        } 
      }
      if(fUVMap[iplane]==PlaneView::kV){
        if(!foundV && (fPlaneHit[iplane]>0)){
          doWhat[iplane] = DO_LOOK_ABOVE;
          if(fPlaneHit[iplane-2]>0)doWhat[iplane-2] = DO_LOOK_ABOVE;
          if(fDeMuxedPairs[iplane].size()>0)foundV=true;
          if(amWriting)cout << "Need to check V plane : " << iplane << endl;
        } 
      }
    }
  }else{
    for(Int_t iplane=fCCHighestPlane-5; iplane<=fCCHighestPlane+5;iplane++){
      if(fUVMap[iplane]==PlaneView::kU){
        if(!foundU && (fPlaneHit[iplane]>0) ){
          doWhat[iplane] = DO_LOOK_ABOVE;
          if(fPlaneHit[iplane+2]>0)doWhat[iplane+2] = DO_LOOK_ABOVE;
          if(fDeMuxedPairs[iplane].size()>0)foundU=true;
          if(amWriting)cout << "Need to check U plane : " << iplane << endl;
        } 
      }
      if(fUVMap[iplane]==PlaneView::kV){
        if(!foundV && (fPlaneHit[iplane]>0)){
          doWhat[iplane] = DO_LOOK_ABOVE;
          if(fPlaneHit[iplane+2]>0)doWhat[iplane+2] = DO_LOOK_ABOVE;
          if(fDeMuxedPairs[iplane].size()>0)foundV=true;
          if(amWriting)cout << "Need to check V plane : " << iplane << endl;
        } 
      }
    }
  }

  changed = false;
  for(Int_t i=0; i<MAX_NUMBER_OF_PLANES;i++){
    if(doWhat[i]!=DO_NOTHING){

      if(fFitTimeU.status){
        int istripT;
        int istripH;
        int istrip;
        int j = i;
        if(j>249)j=i+20;
        if(fUVMap[i]==PlaneView::kU){
          istripT = static_cast<Int_t>(j*fFitTimeU.a1+fFitTimeU.a0);
          istripH = static_cast<Int_t>(j*fFitHitU.a1+fFitHitU.a0);
        }else{
          istripT = static_cast<Int_t>(j*fFitTimeV.a1+fFitTimeV.a0);
          istripH = static_cast<Int_t>(j*fFitHitV.a1+fFitHitV.a0);
        }
        istrip = max(istripT,istripH);
        if(istrip>192&&istrip<212)istrip=192;
        if(istrip<=MAX_NUMBER_OF_PLANES){
          if(amWriting)cout << " FINAL Validating Plane : " << i << " vs " << istrip << endl;
          bool remux = ValidatePlaneAgainstTarget(i,istrip);
          if(remux&&amWriting)cout << " REMUXED !!!!!!!!!!!!! " << endl;
        }
      }
    }
  }

  //  amWriting=false;
  return changed;
}




PlaneValidity_t AlgAltDeMuxBase::ValidatePlaneForPattern(Int_t iplane, vector<Int_t> stripPattern)
{ 
  vector <PlexSEIdAltL*>::iterator literE;
  vector <PlexSEIdAltL*>::iterator literW;
  PlexSEIdAltL* stripE[MAX_NUMBER_OF_STRIPS+1];
  PlexSEIdAltL* stripW[MAX_NUMBER_OF_STRIPS+1];

  Float_t Q = 0;
  PlaneValidity_t returnValidity;
  returnValidity.strips.erase(returnValidity.strips.begin(),returnValidity.strips.end());

  pCalculator->SetPlane(iplane);

  Float_t QTotE = 0;
  Float_t QTotW = 0;
  if(fDiagnosticPlots){
    if(amWriting)cout << "******HITSTIP ";
    for(UInt_t i=0;i<stripPattern.size();i++){
      if(amWriting)cout << ":" << stripPattern[i];
    }
    if(amWriting)cout << endl;
  }
  for(Int_t i=0; i<MAX_NUMBER_OF_STRIPS; i++){
    stripE[i] = NULL;
    stripW[i] = NULL;
  }
  literE = fDeMuxedPlanesAltLists[iplane][ALG_EAST].begin();
  while (literE != fDeMuxedPlanesAltLists[iplane][ALG_EAST].end()){
    Int_t delta = 999;
    Int_t ibest = 999;
    (*literE)->SetFirst();
    while( (*literE)->IsValid() ){
      Int_t iStripE = (*literE)->GetCurrentSEId().GetStrip();
      for(UInt_t i = 0; i<stripPattern.size(); i++){
        Int_t d =abs(iStripE-stripPattern[i]);
        if(d<delta){
          delta = d;
          ibest = iStripE;
          Q = pCalculator->CurrentQ(*literE);
        }
      }
      (*literE)->Next();
    }
    if(ibest<=MAX_NUMBER_OF_STRIPS)stripE[ibest] =  *literE;
    literE++;
    QTotE+= Q;
  }
  
  literE = fPlanesAltLists[iplane][ALG_EAST].begin();
  while (literE != fPlanesAltLists[iplane][ALG_EAST].end()){
    Int_t delta = 999;
    Int_t ibest = 999;
    (*literE)->SetFirst();
    while( (*literE)->IsValid() ){
      Int_t iStripE = (*literE)->GetCurrentSEId().GetStrip();
      for(UInt_t i = 0; i<stripPattern.size(); i++){
        Int_t d =abs(iStripE-stripPattern[i]);
        if(d<delta){
          delta = d;
          ibest = iStripE;
          Q = pCalculator->CurrentQ(*literE);
        }
      }
      (*literE)->Next();
    }
    QTotE+= Q;
    if(ibest<=MAX_NUMBER_OF_STRIPS)stripE[ibest] =  *literE;
    literE++;
  }
  
  literW = fDeMuxedPlanesAltLists[iplane][ALG_WEST].begin();
  while (literW != fDeMuxedPlanesAltLists[iplane][ALG_WEST].end()){
    Int_t delta = 999;
    Int_t ibest = 999;
    (*literW)->SetFirst();
    while( (*literW)->IsValid() ){
      Int_t iStripW = (*literW)->GetCurrentSEId().GetStrip();
      for(UInt_t i = 0; i<stripPattern.size(); i++){
        Int_t d =abs(iStripW-stripPattern[i]);
        if(d<delta){
          delta = d;
          ibest = iStripW;
          Q     = pCalculator->CurrentQ(*literW);
        }
      }
      (*literW)->Next();
    }
    if(ibest<=MAX_NUMBER_OF_STRIPS)stripW[ibest] =  *literW;
    literW++;
    QTotW+=Q;
  }
  
  literW = fPlanesAltLists[iplane][ALG_WEST].begin();
  while (literW != fPlanesAltLists[iplane][ALG_WEST].end()){
    Int_t delta = 999;
    Int_t ibest = 999;
    (*literW)->SetFirst();
    while( (*literW)->IsValid() ){
      Int_t iStripW = (*literW)->GetCurrentSEId().GetStrip();
      for(UInt_t i = 0; i<stripPattern.size(); i++){
        Int_t d =abs(iStripW-stripPattern[i]);
        if(d<delta){
          delta = d;
          ibest = iStripW;
          Q= pCalculator->CurrentQ(*literW);
        }
      }
      (*literW)->Next();
    }
    QTotW+=Q;
    if(ibest<=MAX_NUMBER_OF_STRIPS)stripW[ibest] =  *literW;
    literW++;
  }
  // Have mathched E/W : now check consistency
  
  Float_t QMatchedE=0;
  Float_t QMatchedW=0;
  Float_t chi2 =0;
  Int_t   lowStrip =999;
  Int_t   highStrip =0;
  Int_t   contigLow =999;
  Int_t   contigHigh =0;
  bool    contig = false;
  Int_t   nContigGroup = 0;
  Int_t   contigGroup = 0;
  Int_t   nInGroup = 0;
  Int_t   contigLast = 0;

  for(Int_t i = 0;i<MAX_NUMBER_OF_STRIPS; i++){
    if(stripE[i]!=NULL&&stripW[i]!=NULL){
      returnValidity.strips.push_back(i);
      if(i<lowStrip)lowStrip=i;
      highStrip=i;
      if(contig){
        if( (i-contigLast)<=2){
          contigLast = i;
          nInGroup++;
        }else{
          contig = false;
          contigHigh = contigLast;
          if(contigHigh+1-contigLow>contigGroup)contigGroup =contigHigh+1-contigLow; 
          if(nInGroup>nContigGroup)nContigGroup = nInGroup;
        }
      }

      if(!contig){
        nInGroup = 1;
        contigLow = i;
        contigLast = i;
        contig = true;
      }      

      PlaneView::PlaneView_t kView = stripE[i]->GetPlaneView();
      pCalculator->SetPlane(iplane);
      pCalculator->SetView(kView);
      pCalculator->SetEastToStrip(stripE[i],i);
      pCalculator->SetWestToStrip(stripW[i],i);
      pCalculator->CalcEastWest();
      QMatchedE += pCalculator->QSigCorE();
      QMatchedW += pCalculator->QSigCorW();
      Float_t sigmaQ = pCalculator->SigmaDQ();
      chi2+= sigmaQ*sigmaQ;
      if(amWriting)cout << " Match : " << i << " QE/W : " << pCalculator->QSigCorE() << ":"          << pCalculator->QSigCorW() << " SDQ : " << sigmaQ << endl;
    }
  }
  if(contig){
    contigHigh = contigLast;
    if(contigHigh+1-contigLow>contigGroup)contigGroup =contigHigh+1-contigLow; 
    if(nInGroup>nContigGroup)nContigGroup = nInGroup;
  }

  Float_t fracE = 0.0;
  if(QTotE>0.0)fracE = QMatchedE/QTotE;
  Float_t fracW = 0.0;
  if(QTotW>0.0)fracW = QMatchedW/QTotW;
  if(amWriting)cout << " Frac : " << fracE << "/" << fracW << " chi2 : " << chi2 <<endl;

  returnValidity.fractionQE = fracE;
  returnValidity.fractionQW = fracW;
  returnValidity.chi2DQ = chi2;
  returnValidity.largestContigGroup = nContigGroup;
  returnValidity.stripSpan          = highStrip-lowStrip+1;
  returnValidity.centroid           = (highStrip+lowStrip)/2.0;

  if(amWriting){
    cout << " SPAN          : " << returnValidity.stripSpan  << endl;
    cout << " Contig GROUP  : " << returnValidity.largestContigGroup  << endl;
    cout << " NContig GROUP : " << nContigGroup  << endl;
  }

  return returnValidity;
}








PlaneValidity_t AlgAltDeMuxBase::ValidateOneSidedPlaneForPattern(Int_t iplane, vector<Int_t> stripPattern)
{ 
  vector <PlexSEIdAltL*>::iterator literE;
  vector <PlexSEIdAltL*>::iterator literW;
  PlexSEIdAltL* stripE[MAX_NUMBER_OF_STRIPS];
  PlexSEIdAltL* stripW[MAX_NUMBER_OF_STRIPS];

  Float_t Q;

    pCalculator->SetPlane(iplane);

  Float_t QTotE = 0;
  Float_t QTotW = 0;
  if(amWriting){
    cout << "******HITSTIP ";
    for(UInt_t i=0;i<stripPattern.size();i++)cout << ":" << stripPattern[i];
    cout << endl;
  }
  for(Int_t i=0; i<MAX_NUMBER_OF_STRIPS; i++){
    stripE[i] = NULL;
    stripW[i] = NULL;
  }


  literE = fDeMuxedPlanesAltLists[iplane][ALG_EAST].begin();
  while (literE != fDeMuxedPlanesAltLists[iplane][ALG_EAST].end()){
    Int_t delta = 999;
    Int_t ibest = 999;
    (*literE)->SetFirst();
    while( (*literE)->IsValid() ){
      Int_t iStripE = (*literE)->GetCurrentSEId().GetStrip();
      for(UInt_t i = 0; i<stripPattern.size(); i++){
        Int_t d =abs(iStripE-stripPattern[i]);
        if(d<delta){
          delta = d;
          ibest = iStripE;
          Q = pCalculator->CurrentQ(*literE);
        }
      }
      (*literE)->Next();
    }
    stripE[ibest] =  *literE;
    literE++;
    QTotE+= Q;
  }
  
  literE = fPlanesAltLists[iplane][ALG_EAST].begin();
  while (literE != fPlanesAltLists[iplane][ALG_EAST].end()){
    Int_t delta = 999;
    Int_t ibest = 999;
    (*literE)->SetFirst();
    while( (*literE)->IsValid() ){
      Int_t iStripE = (*literE)->GetCurrentSEId().GetStrip();
      for(UInt_t i = 0; i<stripPattern.size(); i++){
        Int_t d =abs(iStripE-stripPattern[i]);
        if(d<delta){
          delta = d;
          ibest = iStripE;
          Q = pCalculator->CurrentQ(*literE);
        }
      }
      (*literE)->Next();
    }
    QTotE+= Q;
    stripE[ibest] =  *literE;
    literE++;
  }
  
  literW = fDeMuxedPlanesAltLists[iplane][ALG_WEST].begin();
  while (literW != fDeMuxedPlanesAltLists[iplane][ALG_WEST].end()){
    Int_t delta = 999;
    Int_t ibest = 999;
    (*literW)->SetFirst();
    while( (*literW)->IsValid() ){
      Int_t iStripW = (*literW)->GetCurrentSEId().GetStrip();
      for(UInt_t i = 0; i<stripPattern.size(); i++){
        Int_t d =abs(iStripW-stripPattern[i]);
        if(d<delta){
          delta = d;
          ibest = iStripW;
          Q     = pCalculator->CurrentQ(*literW);
        }
      }
      (*literW)->Next();
    }
    stripW[ibest] =  *literW;
    literW++;
    QTotW+=Q;
  }
  
  literW = fPlanesAltLists[iplane][ALG_WEST].begin();
  while (literW != fPlanesAltLists[iplane][ALG_WEST].end()){
    Int_t delta = 999;
    Int_t ibest = 999;
    (*literW)->SetFirst();
    while( (*literW)->IsValid() ){
      Int_t iStripW = (*literW)->GetCurrentSEId().GetStrip();
      for(UInt_t i = 0; i<stripPattern.size(); i++){
        Int_t d =abs(iStripW-stripPattern[i]);
        if(d<delta){
          delta = d;
          ibest = iStripW;
          Q= pCalculator->CurrentQ(*literW);
        }
      }
      (*literW)->Next();
    }
    QTotW+=Q;
    stripW[ibest] =  *literW;
    literW++;
  }
  // Have mathched E/W : now check consistency
  
  // Float_t QMatchedE=0;
  // Float_t QMatchedW=0;
  // Float_t chi2 =0;
  Int_t   lowStrip =999;
  Int_t   highStrip =0;
  Int_t   contigLow =999;
  Int_t   contigHigh =0;
  bool    contig = false;
  Int_t   nContigGroup = 0;
  Int_t   contigGroup = 0;
  Int_t   nInGroup = 0;
  Int_t   contigLast = 0;

  for(Int_t i = 0;i<MAX_NUMBER_OF_STRIPS; i++){
    if(stripE[i]!=NULL||stripW[i]!=NULL){
      if(i<lowStrip)lowStrip=i;
      highStrip=i;
      if(contig){
        if( (i-contigLast)<=2){
          contigLast = i;
          nInGroup++;
        }else{
          contig = false;
          contigHigh = contigLast;
          if(contigHigh+1-contigLow>contigGroup)contigGroup =contigHigh+1-contigLow; 
          if(nInGroup>nContigGroup)nContigGroup = nInGroup;
        }
      }

      if(!contig){
        nInGroup = 1;
        contigLow = i;
        contigLast = i;
        contig = true;
      }      
      if(amWriting)cout << " Match : " << i << endl;
    }
  }
  if(contig){
    contigHigh = contigLast;
    if(contigHigh+1-contigLow>contigGroup)contigGroup =contigHigh+1-contigLow; 
    if(nInGroup>nContigGroup)nContigGroup = nInGroup;
  }
  PlaneValidity_t returnValidity;
  returnValidity.largestContigGroup = nContigGroup;
  returnValidity.stripSpan          = highStrip-lowStrip+1;
  returnValidity.centroid           = (highStrip+lowStrip)/2.0;
  returnValidity.chi2DQ             = 0.;
  returnValidity.fractionQE = 0.;
  returnValidity.fractionQW = 0.;


  if(amWriting){
    cout << " SPAN          : " << returnValidity.stripSpan  << endl;
    cout << " Contig GROUP  : " << returnValidity.largestContigGroup  << endl;
    cout << " NContig GROUP : " << nContigGroup  << endl;
  }

  return returnValidity;
}





void AlgAltDeMuxBase::ReMuxPlane(Int_t iplane, vector<Int_t> stripPattern)
{ 
  vector <PlexSEIdAltL*>::iterator literE;
  vector <PlexSEIdAltL*>::iterator literW;
  PlexSEIdAltL* stripE[MAX_NUMBER_OF_STRIPS];
  PlexSEIdAltL* stripW[MAX_NUMBER_OF_STRIPS];

  Int_t nE=0;
  Int_t nW=0;


  for(Int_t i=0; i<MAX_NUMBER_OF_STRIPS; i++){
    stripE[i] = NULL;
    stripW[i] = NULL;
  }
  literE = fDeMuxedPlanesAltLists[iplane][ALG_EAST].begin();
  while (literE != fDeMuxedPlanesAltLists[iplane][ALG_EAST].end()){
    nE++;
    Int_t delta = 999;
    Int_t ibest = 999;
    (*literE)->SetFirst();
    while( (*literE)->IsValid() ){
      Int_t iStripE = (*literE)->GetCurrentSEId().GetStrip();
      for(UInt_t i = 0; i<stripPattern.size(); i++){
        Int_t d =abs(iStripE-stripPattern[i]);
        if(d<delta){
          delta = d;
          ibest = iStripE;
        }
      }
      (*literE)->Next();
    }
    stripE[ibest] =  *literE;
    literE++;
  }
  
  literE = fPlanesAltLists[iplane][ALG_EAST].begin();
  while (literE != fPlanesAltLists[iplane][ALG_EAST].end()){
    nE++;
    Int_t delta = 999;
    Int_t ibest = 999;
    (*literE)->SetFirst();
    while( (*literE)->IsValid() ){
      Int_t iStripE = (*literE)->GetCurrentSEId().GetStrip();
      for(UInt_t i = 0; i<stripPattern.size(); i++){
        Int_t d =abs(iStripE-stripPattern[i]);
        if(d<delta){
          delta = d;
          ibest = iStripE;
        }
      }
      (*literE)->Next();
    }
    stripE[ibest] =  *literE;
    literE++;
  }
  
  literW = fDeMuxedPlanesAltLists[iplane][ALG_WEST].begin();
  while (literW != fDeMuxedPlanesAltLists[iplane][ALG_WEST].end()){
    nW++;
    Int_t delta = 999;
    Int_t ibest = 999;
    (*literW)->SetFirst();
    while( (*literW)->IsValid() ){
      Int_t iStripW = (*literW)->GetCurrentSEId().GetStrip();
      for(UInt_t i = 0; i<stripPattern.size(); i++){
        Int_t d =abs(iStripW-stripPattern[i]);
        if(d<delta){
          delta = d;
          ibest = iStripW;
        }
      }
      (*literW)->Next();
    }
    stripW[ibest] =  *literW;
    literW++;
  }
  
  literW = fPlanesAltLists[iplane][ALG_WEST].begin();
  while (literW != fPlanesAltLists[iplane][ALG_WEST].end()){
    nW++;
    Int_t delta = 999;
    Int_t ibest = 999;
    (*literW)->SetFirst();
    while( (*literW)->IsValid() ){
      Int_t iStripW = (*literW)->GetCurrentSEId().GetStrip();
      for(UInt_t i = 0; i<stripPattern.size(); i++){
        Int_t d =abs(iStripW-stripPattern[i]);
        if(d<delta){
          delta = d;
          ibest = iStripW;
        }
      }
      (*literW)->Next();
    }
    stripW[ibest] =  *literW;
    literW++;
  }
  // Have matched E/W : now use pattern remux plane

  this->ReMuxPlane(iplane);

  for(Int_t i = 0;i<MAX_NUMBER_OF_STRIPS; i++){
    if(stripE[i]!=NULL&&stripW[i]!=NULL){
      this->DeMuxHits(iplane, stripE[i], stripW[i], i);
    }
  }

  return;
}

void AlgAltDeMuxBase::ReMuxSingleSidedPlane(Int_t iplane, vector<Int_t> stripPattern)
{ 
  vector <PlexSEIdAltL*>::iterator literE;
  vector <PlexSEIdAltL*>::iterator literW;
  PlexSEIdAltL* stripE[MAX_NUMBER_OF_STRIPS];
  PlexSEIdAltL* stripW[MAX_NUMBER_OF_STRIPS];

  if(amWriting)cout << " DO REMUX SINGLE HIT " << endl;

  for(Int_t i=0; i<MAX_NUMBER_OF_STRIPS; i++){
    stripE[i] = NULL;
    stripW[i] = NULL;
  }
  literE = fDeMuxedPlanesAltLists[iplane][ALG_EAST].begin();
  while (literE != fDeMuxedPlanesAltLists[iplane][ALG_EAST].end()){
    Int_t delta = 999;
    Int_t ibest = 999;
    (*literE)->SetFirst();
    while( (*literE)->IsValid() ){
      Int_t iStripE = (*literE)->GetCurrentSEId().GetStrip();
      for(UInt_t i = 0; i<stripPattern.size(); i++){
        Int_t d =abs(iStripE-stripPattern[i]);
        if(d<delta){
          delta = d;
          ibest = iStripE;
        }
      }
      (*literE)->Next();
    }
    stripE[ibest] =  *literE;
    literE++;
  }
  
  literE = fPlanesAltLists[iplane][ALG_EAST].begin();
  while (literE != fPlanesAltLists[iplane][ALG_EAST].end()){
    Int_t delta = 999;
    Int_t ibest = 999;
    (*literE)->SetFirst();
    while( (*literE)->IsValid() ){
      Int_t iStripE = (*literE)->GetCurrentSEId().GetStrip();
      for(UInt_t i = 0; i<stripPattern.size(); i++){
        Int_t d =abs(iStripE-stripPattern[i]);
        if(d<delta){
          delta = d;
          ibest = iStripE;
        }
      }
      (*literE)->Next();
    }
    stripE[ibest] =  *literE;
    literE++;
  }
  
  literW = fDeMuxedPlanesAltLists[iplane][ALG_WEST].begin();
  while (literW != fDeMuxedPlanesAltLists[iplane][ALG_WEST].end()){
    Int_t delta = 999;
    Int_t ibest = 999;
    (*literW)->SetFirst();
    while( (*literW)->IsValid() ){
      Int_t iStripW = (*literW)->GetCurrentSEId().GetStrip();
      for(UInt_t i = 0; i<stripPattern.size(); i++){
        Int_t d =abs(iStripW-stripPattern[i]);
        if(d<delta){
          delta = d;
          ibest = iStripW;
        }
      }
      (*literW)->Next();
    }
    stripW[ibest] =  *literW;
    literW++;
  }
  
  literW = fPlanesAltLists[iplane][ALG_WEST].begin();
  while (literW != fPlanesAltLists[iplane][ALG_WEST].end()){
    Int_t delta = 999;
    Int_t ibest = 999;
    (*literW)->SetFirst();
    while( (*literW)->IsValid() ){
      Int_t iStripW = (*literW)->GetCurrentSEId().GetStrip();
      for(UInt_t i = 0; i<stripPattern.size(); i++){
        Int_t d =abs(iStripW-stripPattern[i]);
        if(d<delta){
          delta = d;
          ibest = iStripW;
        }
      }
      (*literW)->Next();
    }
    stripW[ibest] =  *literW;
    literW++;
  }
  // Have matched E/W : now use pattern remux plane

  this->ReMuxPlane(iplane);

  for(Int_t i = 0;i<MAX_NUMBER_OF_STRIPS; i++){
    if(stripE[i]!=NULL)this->DeMuxSingleHitE(iplane, stripE[i], i);
    if(stripW[i]!=NULL)this->DeMuxSingleHitW(iplane, stripW[i], i);
  }

  return;
}




void AlgAltDeMuxBase::ReMuxPlane(Int_t iplane){

  vector <PlexSEIdAltL*>::iterator literA;

  for(Int_t iew=ALG_EAST; iew<=ALG_WEST;iew++){
    if(fDeMuxedPlanesAltLists[iplane][iew].size()>0){
      literA = fDeMuxedPlanesAltLists[iplane][iew].begin();
      while( literA != fDeMuxedPlanesAltLists[iplane][iew].end()){
        (*literA)->ClearWeights();
        fPlanesAltLists[iplane][iew].push_back(*literA);
        literA++;
      }
    }
  }

  fDeMuxedPairs[iplane].erase(fDeMuxedPairs[iplane].begin(),fDeMuxedPairs[iplane].end());
  fDeMuxedSingles[iplane].erase(fDeMuxedSingles[iplane].begin(),fDeMuxedSingles[iplane].end());

  for(Int_t iew=0; iew<=1;iew++){
    // Clear the arrays of vectors of AltLists
    fDeMuxedPlanesAltLists[iplane][iew].erase(fDeMuxedPlanesAltLists[iplane][iew].begin(),fDeMuxedPlanesAltLists[iplane][iew].end());
  }
  // zero counters
  fPlaneHit[iplane] = 0;
  fPlanePair[iplane] = 0;
  NdemuxedHitsU[iplane] = 0;
  NdemuxedHitsV[iplane] = 0;

  return;
}

void AlgAltDeMuxBase::DeMuxPass(Int_t ipass){

  vector <DeMuxSearchTactic>::iterator literS;

  amShowing = false;
  fCutUseMultipleLines = false;

  switch(ipass){
  case 0:
    fCutRawPE            = 0.0;
    fCutCorPE            = 1.0;
    fCutSigmaQ           = 3.5;
    fCutUseTimingMask    = true;
    fCutUseTargetStrips  = false;
    fCutGuessing         = false;
    fStripWindow         = 5;

    for(int iplane=0; iplane<MAX_NUMBER_OF_PLANES; iplane++){
      if(fPlanesAltLists[iplane][ALG_EAST].size()&&fPlanesAltLists[iplane][ALG_WEST].size()){

        if(amWriting)MSG("AltDeMux", Msg::kDebug) << "DeMuxPass0 : " << iplane << " : " << fPlanesAltLists[iplane][ALG_EAST].size() << " : " << fPlanesAltLists[iplane][ALG_WEST].size() << endl;
        this->ResetMap(fPlanesAltLists[iplane][ALG_EAST].size(),fPlanesAltLists[iplane][ALG_WEST].size());
        this->MakePlaneMap(iplane);
        //  this->PrintPlaneMap();
        this->GroupHits();
        this->SelectHits(iplane,true);
      }
    }

    MSG("AltDeMux", Msg::kDebug) << "AlgAltDeMuxBase::DeMuxPass Finished DeMuxPass 0" << endl;
    break;
  case 1:
    fCutRawPE            = 0.5;
    fCutCorPE            = 2.0;
    fCutSigmaQ           = 3.0;
    fCutUseTimingMask    = true;
    fCutUseTargetStrips  = false;
    fCutGuessing         = false;
    fStripWindow         = 5;
    for(Int_t iplane=0; iplane<MAX_NUMBER_OF_PLANES; iplane++){
      NdemuxedHitsU[iplane]=0;
      NdemuxedHitsV[iplane]=0;
      if(fPlanesAltLists[iplane][ALG_EAST].size()&&fPlanesAltLists[iplane][ALG_WEST].size()){
        this->ResetMap(fPlanesAltLists[iplane][ALG_EAST].size(),fPlanesAltLists[iplane][ALG_WEST].size());
        this->MakePlaneMap(iplane);
        this->GroupHits();
        this->SelectHits(iplane,false,true);
      }
    }
    MSG("AltDeMux", Msg::kDebug) << "AlgAltDeMuxBase::DeMuxPass Finished DeMuxPass 1" << endl;
    if(fDiagnosticPlots){
      this->DrawDiagnosticPlots(1);
    }
    break;


  case 12:
    fCutRawPE            = 0.0;
    fCutCorPE            = 0.0;
    fCutSigmaQ           = 5.0;
    fCutUseTimingMask    = false;
    fCutUseTargetStrips  = false;
    fCutGuessing         = false;
    fCutUseMultipleLines = false;
    fStripWindow         = 5;
    for(Int_t iplane=0; iplane<MAX_NUMBER_OF_PLANES; iplane++){
      if(fPlanesAltLists[iplane][ALG_EAST].size()&&fPlanesAltLists[iplane][ALG_WEST].size()){
        this->ResetMap(fPlanesAltLists[iplane][ALG_EAST].size(),fPlanesAltLists[iplane][ALG_WEST].size());
        this->MakeMultipleTargets(iplane);
        this->MakePlaneMap(iplane);
        this->GroupHits();
        this->SelectHits(iplane,false,true);
      }
    }
    MSG("AltDeMux", Msg::kDebug) << "AlgAltDeMuxBase::DeMuxPass Finished DeMuxPass 1" << endl;
    if(fDiagnosticPlots){
      this->DrawDiagnosticPlots(1);
    }
    break;


  case 11:
    fCutRawPE            = 0.5;
    fCutCorPE            = 0.5;
    fCutSigmaQ           = 5.0;
    fCutUseTimingMask    = true;
    fCutUseTargetStrips  = true;
    fCutGuessing         = false;
    fCutUseMultipleLines = true;
    fStripWindow         = 12;
    for(Int_t iplane=0; iplane<MAX_NUMBER_OF_PLANES; iplane++){
      if(fPlanesAltLists[iplane][ALG_EAST].size()&&fPlanesAltLists[iplane][ALG_WEST].size()){
        this->ResetMap(fPlanesAltLists[iplane][ALG_EAST].size(),fPlanesAltLists[iplane][ALG_WEST].size());
        this->MakeMultipleTargets(iplane);
        this->MakePlaneMap(iplane);
        this->GroupHits();
        this->SelectHits(iplane,false,true);
      }
    }
    MSG("AltDeMux", Msg::kDebug) << "AlgAltDeMuxBase::DeMuxPass Finished DeMuxPass 1" << endl;
    if(fDiagnosticPlots){
      this->DrawDiagnosticPlots(1);
    }
    break;

  case 22:
    fCutRawPE            = 0.0;
    fCutCorPE            = 0.5;
    fCutSigmaQ           = 4.0;
    fCutUseTimingMask    = true;
    fCutUseTargetStrips  = true;
    fCutGuessing         = false;
    fTrackingLowPECut    = 1.5;
    fStripWindow         = 5;

    this->MakeSearchTactics();

    for(unsigned int i=0; i<fSearchTactics.size(); i++){
      int iplane = fSearchTactics[i].iplane;
      if(fSearchTactics[i].goodTactic){
        this->ResetMap(fPlanesAltLists[iplane][ALG_EAST].size(),fPlanesAltLists[iplane][ALG_WEST].size());
        this->MakePlaneMap(fSearchTactics[i]);
        this->GroupHits();
        if(this->SelectHits(iplane,false)){
          this->NewTactic(fSearchTactics[i]);
        }else{
          this->NewTactic(fSearchTactics[i]);
        }
      }else{
        this->NewTactic(fSearchTactics[i]);
      }
    }
    MSG("AltDeMux", Msg::kDebug) << "AlgAltDeMuxBase::DeMuxPass Finished DeMuxPass 2" << endl;
    if(fDiagnosticPlots){
      this->DrawDiagnosticPlots(2);
    }
    break;

  case 2:
    fCutRawPE            = 0.0;
    fCutCorPE            = 1.5;
    fCutSigmaQ           = 3.0;
    fCutUseTimingMask    = false;
    fCutUseTargetStrips  = true;
    fCutGuessing         = false;
    fTrackingLowPECut    = 2.5;
    fStripWindow         = 100;

    this->MakeSearchTactics();

    for(unsigned int i=0; i<fSearchTactics.size(); i++){
      int iplane = fSearchTactics[i].iplane;
      if(fSearchTactics[i].goodTactic){
        this->ResetMap(fPlanesAltLists[iplane][ALG_EAST].size(),fPlanesAltLists[iplane][ALG_WEST].size());
        this->MakePlaneMap(fSearchTactics[i]);
        this->GroupHits();
        if(this->SelectHits(iplane,false)){
          this->NewTactic(fSearchTactics[i]);
        }else{
          this->NewTactic(fSearchTactics[i]);
        }
      }else{
        this->NewTactic(fSearchTactics[i]);
      }
    }
    MSG("AltDeMux", Msg::kDebug) << "AlgAltDeMuxBase::DeMuxPass Finished DeMuxPass 2" << endl;
    if(fDiagnosticPlots){
      this->DrawDiagnosticPlots(2);
    }
    break;

  case 3:
    fCutRawPE            = 0.0;
    fCutCorPE            = 0.0;
    fCutSigmaQ           = 4.0;
    fCutUseTimingMask    = false;
    fCutUseTargetStrips  = true;
    fCutGuessing         = false;
    fTrackingLowPECut    = 2.5;
    fStripWindow         = 100;

    this->MakeSearchTacticsX();
    if(fDiagnosticPlots)DrawDiagnosticPlots(3);
    for(unsigned int i=0; i<fSearchTactics.size(); i++){
      int iplane = fSearchTactics[i].iplane;
      if(fSearchTactics[i].goodTactic){
        this->ResetMap(fPlanesAltLists[iplane][ALG_EAST].size(),fPlanesAltLists[iplane][ALG_WEST].size());
        this->MakePlaneMap(fSearchTactics[i]);
        this->GroupHits();
        if(this->SelectHits(iplane,false)){
          this->NewTactic(fSearchTactics[i]);
        }else{
          this->NewTactic(fSearchTactics[i]);
        }
      }else{
        this->NewTactic(fSearchTactics[i]);
      }
    }
    MSG("AltDeMux", Msg::kDebug) << "AlgAltDeMuxBase::DeMuxPass Finished DeMuxPass 3" << endl;
    if(fDiagnosticPlots){
      this->DrawDiagnosticPlots(3);
    }
    break;


  case 33:
    fCutRawPE            = 0.0;
    fCutCorPE            = 0.0;
    fCutSigmaQ           = 5.0;
    fCutUseTimingMask    = true;
    fCutUseTargetStrips  = false;
    fCutGuessing         = false;
    fTrackingLowPECut    = 2.5;
    fStripWindow         = 5;

    this->MakeSearchTacticsX();

    for(Int_t iplane = 0; iplane<MAX_NUMBER_OF_PLANES; iplane++){
      if(fPlanesAltLists[iplane][ALG_EAST].size()>0 && fPlanesAltLists[iplane][ALG_WEST].size()>0){
        this->ResetMap(fPlanesAltLists[iplane][ALG_EAST].size(),fPlanesAltLists[iplane][ALG_WEST].size());
        this->MakePlaneMap(iplane);
        this->GroupHits();
        this->SelectHits(iplane,false,true);
      }
    }
    MSG("AltDeMux", Msg::kDebug) << "AlgAltDeMuxBase::DeMuxPass Finished DeMuxPass 33" << endl;
    if(fDiagnosticPlots){
      this->DrawDiagnosticPlots(3);
    }
    break;
  case 4:
    //amShowing = true;
  case 5:
    fCutRawPE            = 0.0;
    fCutCorPE            = 0.0;
    fCutSigmaQ           = 0.0;
    fCutUseTimingMask    = false;
    fCutUseTargetStrips  = true;
    fCutGuessing         = false;
    fTrackingLowPECut    = 2.5;
    fStripWindow         = 100;
    this->MakeSearchTacticsY();
    literS = fSearchTactics.begin();
    while(literS!=fSearchTactics.end()){
      if((*literS).goodTactic){
        this->DeMuxSingles((*literS));
      }
      literS++;
    }
    MSG("AltDeMux", Msg::kDebug) << "AlgAltDeMuxBase::DeMuxPass Finished DeMuxPass " << ipass << endl;
    if(fDiagnosticPlots)this->DrawDiagnosticPlots(4);
    amShowing = false;
    break;

  default:
    MSG("AltDeMux", Msg::kError) << "AlgAltDeMuxBase::DeMuxPass - try to access undefined pass " << ipass << endl;
    break;
  }
  
  return;
  
}




void AlgAltDeMuxBase::DeMuxWhatsLeft(){

  fCutRawPE            = 0.0;
  fCutCorPE            = 0.0;
  fCutSigmaQ           = 10.0;
  fCutUseTimingMask    = false;
  fCutUseTargetStrips  = false;
  fCutGuessing         = false;
  fCutUseMultipleLines = false;
  fStripWindow         = 5;
  for(Int_t iplane=0; iplane<MAX_NUMBER_OF_PLANES; iplane++){
    if(fPlanesAltLists[iplane][ALG_EAST].size()>0&&fPlanesAltLists[iplane][ALG_WEST].size()>0){
      this->ResetMap(fPlanesAltLists[iplane][ALG_EAST].size(),fPlanesAltLists[iplane][ALG_WEST].size());
      this->MakePlaneMap(iplane);
      this->GroupHits();
      this->SelectHits(iplane,false);
    }
  }

  

  // Next try demux groups which are golden with timing mask

  fCutRawPE            = 0.0;
  fCutCorPE            = 0.0;
  fCutSigmaQ           = 10.0;
  fCutUseTimingMask    = true;
  fCutUseTargetStrips  = false;
  fCutGuessing         = false;
  fCutUseMultipleLines = false;
  fStripWindow         = 5;
  for(Int_t iplane=0; iplane<MAX_NUMBER_OF_PLANES; iplane++){
    if(fPlanesAltLists[iplane][ALG_EAST].size()>0&&fPlanesAltLists[iplane][ALG_WEST].size()>0){
      //cout << "*********************************WHATS LEFT : PASS 1 like " << iplane << endl;
      this->ResetMap(fPlanesAltLists[iplane][ALG_EAST].size(),fPlanesAltLists[iplane][ALG_WEST].size());
      this->MakePlaneMap(iplane);
      this->GroupHits();
      this->SelectHits(iplane,false);
    }
  }
  

  // Demux remaining pairs - using validate plane and the timing mask as a seed
  for(Int_t iplane=0; iplane<MAX_NUMBER_OF_PLANES; iplane++){
    if(fPlanesAltLists[iplane][ALG_EAST].size()>0&&fPlanesAltLists[iplane][ALG_WEST].size()>0){
      //      cout << "*********************************WHATS LEFT : VALIDATE PLANE " << iplane << fPlanesAltLists[iplane][ALG_EAST].size() << " : " << fPlanesAltLists[iplane][ALG_EAST].size() << endl;
      //BestGuessForPlane(iplane);
    }
  }
  
  // Should only have singles left now.....
  DeMuxPass(4);
  for(Int_t iplane=0; iplane<MAX_NUMBER_OF_PLANES; iplane++){
    if(fPlanesAltLists[iplane][ALG_EAST].size()>0||fPlanesAltLists[iplane][ALG_WEST].size()>0){
      //  cout << "*********************************WHATS LEFT : SINGLES " << iplane << endl;
      this->BestGuessForSingleSidedHits(iplane);
    }
  }

  return;
  
}






void AlgAltDeMuxBase::MakePlaneMap(Int_t iplane,bool useTargets)
{

  if(useTargets); // obsolete but keep backward compatibility
  // Look for stripend pairs which satisfy the some set of cuts 

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

  literE = fPlanesAltLists[iplane][ALG_EAST].begin();
  fECount = -1;
  PlaneView::PlaneView_t kView = (*literE)->GetPlaneView();
  pCalculator->SetPlane(iplane);
  pCalculator->SetView(kView);
  if(fPlanesAltLists[iplane][ALG_EAST].size()>static_cast<UInt_t>(MAX_HITS_PLANE))MSG("AltDeMux", Msg::kError) << "AlgAltDeMuxBase::MakePlaneMap => Too many WEST hits in plane " << iplane << endl;
  if(fPlanesAltLists[iplane][ALG_WEST].size()>static_cast<UInt_t>(MAX_HITS_PLANE))MSG("AltDeMux", Msg::kError) << "AlgAltDeMuxBase::MakePlaneMap => Too many EAST hits in plane " << iplane << endl;
  while (literE != fPlanesAltLists[iplane][ALG_EAST].end()){
    fECount++;
    if(fECount<MAX_HITS_PLANE){
      pPlaneAltMapE[fECount] = (*literE);
      literW = fPlanesAltLists[iplane][ALG_WEST].begin();
      fWCount = -1;
      while ( literW != fPlanesAltLists[iplane][ALG_WEST].end()){
        fWCount++;
        if(fWCount<MAX_HITS_PLANE){
          pPlaneAltMapW[fWCount] = (*literW);
          (*literE)->SetFirst();
          while( (*literE)->IsValid() ){
            Int_t iStripE = (*literE)->GetCurrentSEId().GetStrip();
            pCalculator->SetEast(*literE,iStripE);
            (*literW)->SetFirst();
            while( (*literW)->IsValid() ){
              Int_t iStripW = (*literW)->GetCurrentSEId().GetStrip();
              pCalculator->SetWest(*literW,iStripW);
              // In here we can check for a possibility
              if(iStripE==iStripW){
                Int_t iStrip = iStripE;
                bool goodComb = true;
                pCalculator->CalcEastWest();
                // If desired require the strip is in the road defined by timing
                if(fCutUseTimingMask && fUVmask[iplane][iStrip]==false)goodComb = false; 
                // Apply charge cuts on this EAST-WEST strip possibility
                if(goodComb){
                  if(pCalculator->QRawE() < fCutRawPE || 
                     pCalculator->QRawW() < fCutRawPE)goodComb = false;
                  if(pCalculator->QSigCorE() < fCutCorPE || 
                     pCalculator->QSigCorW() < fCutCorPE)goodComb = false;
                }
                
                if(goodComb)goodComb = (fabs(pCalculator->SigmaDQ())<fCutSigmaQ);

                // goodComb = goodComb && (abs(pCalculator->SigmaDQ())<fCutSigmaQ);
                
                // If we have defined a set of target strips can insist
                // strip is near one of the target positions 
                if(goodComb&&fCutUseTargetStrips){
                  bool found = false;
                  for(unsigned int t=0;t<fTargetStrips.size()&&found==false;t++){
                    if(abs(fTargetStrips[t]-iStrip)<12){
                      found = true;
                    }
                  } 
                  goodComb = found;
                }
                if(amWriting){
                  if(goodComb)MSG("AltDeMux", Msg::kDebug) << "MakePlane(" <<iplane << ") " << pCalculator->QSigCorE() << ":" << pCalculator->QSigCorW()<<  "::" << pCalculator->QAttCorE() << ":" << pCalculator->QAttCorW() << "::" << " : " << pCalculator->SigmaDQ() << " : " << iStripE << "*" << endl;
                  if(!goodComb)MSG("AltDeMux", Msg::kDebug) << "MakePlane(" << iplane << ") " << pCalculator->QSigCorE() << ":" << pCalculator->QSigCorW()<<  "::" << pCalculator->QAttCorE() << ":" << pCalculator->QAttCorW() << "::" << " : " << pCalculator->SigmaDQ() << " : " << iStripE << endl;
                }
                if(goodComb)fAmap[fECount][fWCount] = true;
                fSmap[fECount][fWCount] = iStripE;
              }
              (*literW)->Next();
            }
            (*literE)->Next();
          }
        }
        literW++;
      }
    }
    literE++;
  }

  return;
}


void AlgAltDeMuxBase::GroupHits(){

  for(Int_t iw=0;iw<=fWCount; iw++){
    for(Int_t iwp=0;iwp<=fWCount; iwp++){
      fBmap[iw][iwp] = false;
    }
  }

  for(Int_t ie =0; ie<=fECount; ie++){
    for(Int_t iw=0; iw<=fWCount; iw++){
      if(fAmap[ie][iw]){
        for(Int_t iwp =0;iwp<=fWCount; iwp++){
          if(fAmap[ie][iwp]){
            fBmap[iw][iwp] = true;
            fBmap[iwp][iw] = true;
          }
        }
      }
    }
  }

  for(Int_t iw=0;iw<=fWCount; iw++){
    fBmap[iw][iw] = true;
    for(Int_t iwp=0;iwp<=fWCount; iwp++){
      if(fBmap[iw][iwp]==false){
        for(Int_t k=0;k<=fWCount; k++)fBmap[iw][iwp] |= fBmap[iw][k] && fBmap[k][iwp];
      }
    }
  }


  fNGroups = 0;
  for(Int_t iw=0;iw<=fWCount; iw++){fWFound[iw]=false;}
  for(Int_t ie=0;ie<=fECount; ie++){fEFound[ie]=false;}

  for(Int_t iw=0;iw<=fWCount; iw++){
    if(fWFound[iw]==false){
      fNGroups++;
      fNInGroupW[fNGroups]=0;
      for(int iwp=0;iwp<=fWCount; iwp++){
        if(fBmap[iw][iwp]){
          fNInGroupW[fNGroups]++;
          fWGroup[fNGroups][fNInGroupW[fNGroups]]=iwp;
          fWFound[iwp]=true;
        }
      }
    }
  }
      
  if(fNGroups>0){
    for(int ig=1;ig<=fNGroups;ig++){
      fNInGroupE[ig]=0;
      for(int iw=1;iw<=fNInGroupW[ig];iw++){
        for(int ie=0;ie<=fECount;ie++){
          if(fEFound[ie]==false && fAmap[ie][(fWGroup[ig][iw])]){
            fNInGroupE[ig]++;
            fEGroup[ig][fNInGroupE[ig]]=ie;
            fEFound[ie] = true;
          }
        }
      }
    }
  }

  return;
}


bool AlgAltDeMuxBase::SelectHits(Int_t iPlane, bool gold, bool useGold) 
{
  bool success = false;

  for(int ig=1;ig<=fNGroups;ig++){
    AltDeMuxPattern* pP;
    AltDeMuxPattern* pBest;
    PatternPair wibble;
    Int_t smin=999;
    Int_t smax=0;
    Int_t srange;
    Int_t srange1;
    Int_t srange2;
    Int_t count;
    pBest = NULL;
    count  =0;
    srange1 = 1000;
    srange2 = 1000; 
    if(pMaster->SelectPattern(fNInGroupE[ig],fNInGroupW[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 = fAmap[(fEGroup[ig][wibble.eEntry])][(fWGroup[ig][wibble.wEntry])];
          if(patok){
            Int_t s = fSmap[(fEGroup[ig][wibble.eEntry])][(fWGroup[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 no golden pattern found return false
      if(pBest==NULL)return false;


      // have found a golden combination so now do something with it

      if(srange1 < pBest->Size()+fStripWindow && srange1+pBest->Size()<srange2){
        success = true;
        if(!gold)fUniqueDeMuxedGroupID++;
        // have found a golden combination - iterate over it and demux hits
        for(int i=0; i< pBest->Size(); i++){
          wibble = pBest->GetI(i);
          
          Int_t iStrip = fSmap[(fEGroup[ig][wibble.eEntry])][(fWGroup[ig][wibble.wEntry])];

          if(amWriting)MSG("AltDeMux", Msg::kDebug) << "AlgAltDeMuxBass::SelectHits using combination " << iStrip << endl;
          if(gold)this->GoldHits(iPlane,iStrip);
          if(!gold){
            bool found = false;
            if(useGold){
              for(int i=1;!found && i<=fGoldPlaneHit[iPlane];i++){
                if(iStrip==fGoldHitMap[iPlane][i])found=true;
              }
            }
            if(!useGold || fCutGuessing || found )this->DeMuxHits(iPlane,fEGroup[ig][wibble.eEntry],fWGroup[ig][wibble.wEntry],iStrip);
          }
        }
      }
    }else{
      // Pattern Master says no ! too big ? 
      if( (fNInGroupE[ig]>3) && (fNInGroupW[ig]>3) ){
        int nfound  = this->DeMuxBigGroup(iPlane,ig,gold);
        if(nfound==1)success=true;
      }
    }
  }  // end of loop over groups 
  return success; 
}



Int_t AlgAltDeMuxBase::DeMuxBigGroup(Int_t iplane, Int_t ig, bool gold) 
{ 
  bool success = false;

  vector<BigGroup>theGroups;

  int strips[192];
  int estrips[192];
  int wstrips[192];
  for(int i=0;i<192;i++)strips[i]=0;
  for(int ie=1;ie<=fNInGroupE[ig];ie++){
    for(int iw=1;iw<=fNInGroupW[ig];iw++){
      if(fAmap[(fEGroup[ig][ie])][(fWGroup[ig][iw])]){
        int s = fSmap[(fEGroup[ig][ie])][(fWGroup[ig][iw])];
        strips[s]++;
        estrips[s] = ie;
        wstrips[s] = iw;
      }
    }
  }
  int istartStrip = 0;
  int iendStrip = 0;
  int ngroups = 0;
  int ilast=0;

  for(int i=0;i<=192;i++){
    _smask[i] = false;
  }

  int ming = fNInGroupE[ig];
  if(fNInGroupW[ig]<ming)ming = fNInGroupW[ig];

  int best = ming-3;
  if(ming<12)best = ming-2;
  if(ming<7)best = ming-1;
  best = ming -1;

  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){
          ilast = ie;
          icount++;
        }
      }
      
      if(icount>=best){
        BigGroup aBigGroup;
        aBigGroup.groupStart = is;
        aBigGroup.groupEnd = ilast;
        aBigGroup.groupCount = icount;
        theGroups.push_back(aBigGroup);
        best = icount;
        if(amWriting)cout << "Found a (small ?) group : " << is << ":" << ilast << " : " << icount << endl;
      }
      

      if(icount==ming){
        ngroups++;
        istartStrip = is;
        iendStrip   = ie-1;
        if(amWriting)cout << "Found a group : " << is << ":" << ie-1 << endl;
        for(int i=is;i<=ie;i++){
          _smask[i] = true;
        }
      }
    }
  }
  if(amWriting)cout << "Found " << ngroups << " groups " << endl;


  ngroups = 0;
  for(unsigned int igroup =0; igroup<theGroups.size();igroup++){
    if(theGroups[igroup].groupCount==best){
      ngroups++;
      istartStrip = theGroups[igroup].groupStart;
      iendStrip = theGroups[igroup].groupEnd;
      if(amWriting)cout << " A good group " << theGroups[igroup].groupStart << " " << theGroups[igroup].groupEnd << " "<< theGroups[igroup].groupCount << endl;
      for(int i=theGroups[igroup].groupStart;i<=theGroups[igroup].groupEnd;i++){
        _smask[i] = true;
      }   
    }
  }

  // if one and only one group is found then demux it
  if(ngroups==1){
    success = true;
    // fUniqueDeMuxedGroupID is an ugly cludge to tag each group of gold hits 
    fUniqueDeMuxedGroupID++;
    Int_t ie;
    Int_t iw;
    for(Int_t is=istartStrip; is<=iendStrip;is++){
      if(strips[is]==1){
        ie = estrips[is];
        iw = wstrips[is];
        if(amWriting)cout << " Strip : " << is << " ew " << ie << ":" << iw << endl;
        // if the flag gold is 
        if(gold)this->GoldHits(iplane,is);
        if(!gold)this->DeMuxHits(iplane,fEGroup[ig][ie],fWGroup[ig][iw],is);
      }     
    }
  } 

  if(ngroups>1){
    for(int ie=1;ie<=fNInGroupE[ig];ie++){
      PlexSEIdAltL* pAltL;
      pAltL = pPlaneAltMapE[(fEGroup[ig][ie])]; 
      pAltL->SetFirst();
      while(pAltL->IsValid()){
        int is = pAltL->GetCurrentSEId().GetStrip();
        if(!_smask[is])pAltL->SetCurrentWeight(-999.);
        pAltL->Next();
      }
    }
    for(int iw=1;iw<=fNInGroupW[ig];iw++){
      PlexSEIdAltL* pAltL;
      pAltL = pPlaneAltMapW[(fWGroup[ig][iw])]; 
      pAltL->SetFirst();
      while(pAltL->IsValid()){
        int is = pAltL->GetCurrentSEId().GetStrip();
        if(!_smask[is])pAltL->SetCurrentWeight(-999.);
        pAltL->Next();
      }
    }
  }

  return ngroups;
}

void AlgAltDeMuxBase::GoldHits(Int_t iplane, Int_t istrip){ 

  fGoldPlaneHit[iplane] += 1;
  fGoldHitMap[iplane][fGoldPlaneHit[iplane]] = istrip;

  return;

}

void AlgAltDeMuxBase::DeMuxHits(Int_t iplane, Int_t ie, Int_t iw, Int_t istrip ){ 
  this->DeMuxHits(iplane, pPlaneAltMapE[ie], pPlaneAltMapW[iw], istrip );

  if(amWriting)cout << "DEMUXED STRIPs : " << ie << ":" << iw << " -> " << istrip << endl;
  
  return;
}

void AlgAltDeMuxBase::DeMuxHits(Int_t iplane, PlexSEIdAltL* pAltE, PlexSEIdAltL* pAltW, Int_t istrip )
{ 
  
  this->DeMuxHitE(iplane,pAltE,istrip);
  this->DeMuxHitW(iplane,pAltW,istrip);

  if(amWriting)cout << "DEMUX THIS HIT ! " << iplane << ":" << istrip << endl;

  DeMuxedPair thisPair;
  thisPair.altListE = pAltE;
  thisPair.altListW = pAltW;
  thisPair.status   = true;
  if(iplane<fLowestDeMuxedPairPlane)fLowestDeMuxedPairPlane = iplane;
  if(iplane>fHighestDeMuxedPairPlane)fHighestDeMuxedPairPlane = iplane;


  PlaneView::PlaneView_t kView = pAltE->GetPlaneView();
  pCalculator->SetPlane(iplane);
  pCalculator->SetView(kView);
  pCalculator->SetEast(pAltE,istrip);
  pCalculator->SetWest(pAltW,istrip);
  pCalculator->CalcBestEastWest();

  thisPair.orthogonalStripFromTiming = pCalculator->StripAim();
  thisPair.uniqueGroupID = fUniqueDeMuxedGroupID;
  thisPair.weightQ = 1.0;
  thisPair.pairQCor = pCalculator->PairQCor();

  fDeMuxedPairs[iplane].push_back(thisPair);

  if(kView==PlaneView::kU){
    if(NdemuxedHitsU[iplane]<MAX_DISPLAYED_HITS){
      demuxedHitStripU[iplane][NdemuxedHitsU[iplane]] = istrip;
      demuxedHitQU[iplane][NdemuxedHitsU[iplane]]     = pCalculator->PairQCor();
      NdemuxedHitsU[iplane]++;
    }
  }
  if(kView==PlaneView::kV){
    if(NdemuxedHitsV[iplane]<MAX_DISPLAYED_HITS){
      demuxedHitStripV[iplane][NdemuxedHitsV[iplane]] = istrip;
      demuxedHitQV[iplane][NdemuxedHitsV[iplane]]     = pCalculator->PairQCor();
      NdemuxedHitsV[iplane]++;
    }
  }

  
  if(fPlaneHit[iplane]==0){
    if(kView==PlaneView::kU)_nDeMuxedPlanesU++;
    if(kView==PlaneView::kV)_nDeMuxedPlanesV++; 
  } 
  fPlaneHit[iplane]++;
  fPlanePair[iplane]++;
  fHitMap[iplane][fPlaneHit[iplane]]  = istrip;
  fQHitMapE[iplane][fPlaneHit[iplane]] = pCalculator->QSigCorE();
  fQHitMapW[iplane][fPlaneHit[iplane]] = pCalculator->QSigCorW();

  return;

}


void AlgAltDeMuxBase::DeMuxHitE(Int_t iplane, Int_t ie, Int_t is){ 

  PlexSEIdAltL* pAltL;

  pAltL = pPlaneAltMapE[ie]; 
  this->DeMuxHitE(iplane,pAltL,is);
  return;
}


void AlgAltDeMuxBase::DeMuxHitW(Int_t iplane, Int_t iw, Int_t is){ 

  PlexSEIdAltL* pAltL;
  pAltL = pPlaneAltMapW[iw]; 
  this->DeMuxHitW(iplane,pAltL,is);  

  return;
}

void AlgAltDeMuxBase::DeMuxSingleHitE(Int_t iplane, PlexSEIdAltL* pAltL, Int_t istrip){ 

  PlaneView::PlaneView_t kView = pAltL->GetPlaneView();
  pCalculator->SetPlane(iplane);
  pCalculator->SetView(kView);
  pCalculator->SetEast(pAltL,istrip);
  pCalculator->CalcBestEast();

  DeMuxedSingle thisSingle;
  thisSingle.altList = pAltL;
  thisSingle.status  =  true;
  thisSingle.Qcor    = pCalculator->QSigCorE();
  fDeMuxedSingles[iplane].push_back(thisSingle);

  if(fDiagnosticPlots){
    if(kView==PlaneView::kU){
      if(NdemuxedHitsU[iplane]<MAX_DISPLAYED_HITS){
        demuxedHitStripU[iplane][NdemuxedHitsU[iplane]] = istrip;
        demuxedHitQU[iplane][NdemuxedHitsU[iplane]]     = pCalculator->QSigCorE();
        NdemuxedHitsU[iplane]++;
      }
    }
    if(kView==PlaneView::kV){
      if(NdemuxedHitsV[iplane]<MAX_DISPLAYED_HITS){
        demuxedHitStripV[iplane][NdemuxedHitsV[iplane]] = istrip;
        demuxedHitQV[iplane][NdemuxedHitsV[iplane]]     = pCalculator->QSigCorE();
        NdemuxedHitsV[iplane]++;
      }
    }
  }
  
  fPlaneHit[iplane]++;
  fHitMap[iplane][fPlaneHit[iplane]]  = istrip;
  fQHitMapE[iplane][fPlaneHit[iplane]] = pCalculator->QSigCorE();

  //  cout << "DEMUXING SINGLE E : " << iplane << ":" << istrip  << " : " << pCalculator->QSigCorE() << ":" << this->XTalkCharge(pAltL,istrip) << endl;

  this->DeMuxHitE(iplane,pAltL,istrip);

  return;
}



void AlgAltDeMuxBase::DeMuxSingleHitW(Int_t iplane, PlexSEIdAltL* pAltL, Int_t istrip){ 

  PlaneView::PlaneView_t kView = pAltL->GetPlaneView();
  pCalculator->SetPlane(iplane);
  pCalculator->SetView(kView);
  pCalculator->SetWest(pAltL,istrip);
  pCalculator->CalcBestWest();


  DeMuxedSingle thisSingle;
  thisSingle.altList = pAltL;
  thisSingle.status  = true;
  thisSingle.Qcor    = pCalculator->QSigCorW();
  fDeMuxedSingles[iplane].push_back(thisSingle);

  if(fDiagnosticPlots){
    if(kView==PlaneView::kU){
      if(NdemuxedHitsU[iplane]<MAX_DISPLAYED_HITS){
        demuxedHitStripU[iplane][NdemuxedHitsU[iplane]] = istrip;
        demuxedHitQU[iplane][NdemuxedHitsU[iplane]]     = pCalculator->QSigCorW();
        NdemuxedHitsU[iplane]++;
      }
    }
    if(kView==PlaneView::kV){
      if(NdemuxedHitsV[iplane]<MAX_DISPLAYED_HITS){
        demuxedHitStripV[iplane][NdemuxedHitsV[iplane]] = istrip;
        demuxedHitQV[iplane][NdemuxedHitsV[iplane]]     = pCalculator->QSigCorW();
        NdemuxedHitsV[iplane]++;
      }
    }
  }
  
  fPlaneHit[iplane]++;
  fHitMap[iplane][fPlaneHit[iplane]]  = istrip;
  fQHitMapW[iplane][fPlaneHit[iplane]] = pCalculator->QSigCorW();
  this->DeMuxHitW(iplane,pAltL,istrip);

  return;
}



void AlgAltDeMuxBase::DeMuxHitE(Int_t iplane, PlexSEIdAltL* pAltL, Int_t is){ 

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

  pAltL->SetFirst();

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

  literA = fPlanesAltLists[iplane][ALG_EAST].begin();
  notFound = true;
  while (notFound && literA != fPlanesAltLists[iplane][ALG_EAST].end()){
    if(*literA==pAltL){
      fPlanesAltLists[iplane][ALG_EAST].erase(literA);
      notFound = false;
    }
    literA++;
  }
  fDeMuxedPlanesAltLists[iplane][ALG_EAST].push_back(pAltL);

  this->UpdateXTalkMap(pAltL);

  return;
}


void AlgAltDeMuxBase::VetoHitE(Int_t iplane, PlexSEIdAltL* pAltL){ 

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

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

  return;
}

void AlgAltDeMuxBase::VetoHitW(Int_t iplane, PlexSEIdAltL* pAltL){ 

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

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

  return;
}


void AlgAltDeMuxBase::DeMuxHitW(Int_t iplane, PlexSEIdAltL* pAltL, Int_t is){ 


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


  pAltL->SetFirst();

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

  fDeMuxedPlanesAltLists[iplane][ALG_WEST].push_back(pAltL);
  this->UpdateXTalkMap(pAltL);

  return;
}
 

DeMuxSearchTactic AlgAltDeMuxBase::MakeSearchTactics(Int_t iplane)
{

  bool foundH = false;
  bool foundL = false;

  DeMuxSearchTactic tactic;
  tactic.iplane = iplane;

  Int_t imax = iplane+12;
  if(imax>MAX_NUMBER_OF_PLANES-2)imax=MAX_NUMBER_OF_PLANES-3;
  for(int i=iplane+2; i<imax &&!foundH ; i+=2){
    if( fUVMap[i]==fUVMap[iplane]){
      foundH = true;
      tactic.highplane  = i;
    }
  }
  Int_t imin = iplane - 12;
  if(imin<2)imin=1;
  for(int i=iplane-2; i>imin &&!foundL ; i-=2){
    if( fUVMap[i]==fUVMap[iplane]){
      foundL = true;
      tactic.lowplane  = i;
    }
  }
  if(foundL||foundH)tactic.goodTactic = true;

  return tactic;
}

void AlgAltDeMuxBase::MakeSearchTactics()
{

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


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

  for(int i=0; i<MAX_NUMBER_OF_PLANES; i++){
    fSearched[i] = false;
    if(fPlaneHit[i]>0){
      if(ifirstU==false){
        if( fUVMap[i]==PlaneView::kU){
          ifirstU = true;
          firstUplane = i;
        }
      }
      if(ifirstV==false){
        if( fUVMap[i]==PlaneView::kV){
          ifirstV = true;
          firstVplane = i;
        }
      }



      if(fUVMap[i]==PlaneView::kU)lastUplane =i;
      if(fUVMap[i]==PlaneView::kV)lastVplane =i;

      int inext = i+2;
      if(inext==249)inext=250;
      if(inext==250)inext=251;

      if(fPlaneHit[inext]==0){
        int j = inext+1;
        bool found = false;
        while(found==false&&j-inext <=24 && j<MAX_NUMBER_OF_PLANES-2){
          j++;
          if(fUVMap[j]==fUVMap[i]&&fPlaneHit[j]>0)found=true;
        }
        if(found){
          bool lfound = false;
          // Step forward in gap
          for(int k=i+2; k<=j-2; k++){
            if(fUVMap[k]==fUVMap[i]){
              if(!lfound && fPlanesAltLists[k][ALG_EAST].size()&&fPlanesAltLists[k][ALG_WEST].size()){
                lfound = true;
                DeMuxSearchTactic tactic;
                foundPlane = k;
                tactic.iplane = k;
                tactic.searchType = SEARCH_GAP_F;
                tactic.lowplane  = i;
                tactic.highplane = j;
                tactic.goodTactic = true;
                fSearchTactics.push_back(tactic);
                fSearched[k] = true;
                if(tactic.highplane>=MAX_NUMBER_OF_PLANES)MSG("AltDeMux", Msg::kFatal) << "AlgAltDeMuxBase::MakeSearchTactics highplane out of range : " << tactic.highplane << " :" << i << ":" << j << ":" << k << endl;
              }
            }
          }
          // Step backwards in gap
          if(lfound){
            bool found = false;
            for(int k=j-2; k>=foundPlane+2; k--){
              if(fUVMap[k]==fUVMap[i]){
                if(!found &&fPlanesAltLists[k][ALG_EAST].size()&&fPlanesAltLists[k][ALG_WEST].size()){
                  found = true;
                  DeMuxSearchTactic tactic;
                  tactic.iplane = k;
                  tactic.searchType = SEARCH_GAP_B;
                  tactic.lowplane  = i;
                  tactic.highplane = j;
                  tactic.goodTactic = true;
                  fSearchTactics.push_back(tactic);
                  fSearched[k] = true;
                }
              }
            }
          } 
        }       
      }
    }
  }

  if(ifirstU){
    DeMuxSearchTactic tactic;
    tactic.iplane = firstUplane;
    tactic.lowplane = firstUplane;
    tactic.highplane = firstUplane;
    tactic.searchType = SEARCH_BACKWARDS;
    tactic.goodTactic = false;
    fSearchTactics.push_back(tactic);


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

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

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


void AlgAltDeMuxBase::MakePlaneMap(DeMuxSearchTactic tactic)
{

  Int_t i = tactic.iplane;
  Int_t j = tactic.lowplane;
  Int_t k = tactic.highplane;

  Float_t target = 0;
  Int_t itarget;
  Int_t it;


  if(j<0&&j>-100)MSG("AltDeMux", Msg::kFatal) << "AlgAltDeMuxBase::MakePlaneMap lowplane out of range : " << j << endl;
  if(k>=MAX_NUMBER_OF_PLANES)MSG("AltDeMux", Msg::kFatal) << "AlgAltDeMuxBase::MakePlaneMap highplane out of range : " << k << endl;

  fTargetStrips.erase(fTargetStrips.begin(),fTargetStrips.end());
  if(fEventType==MULTIPLE_MUON)MakeMultipleTargets(i);

  bool useHoughSlope         = fUseHoughSlope;
  bool useFitSlopeTime       = fUseFitSlopeTime;
  bool useFitSlopeHits       = fUseFitSlopeHits;
  bool useInterpolation      = false;
  // bool useSafeExtrapolationF = false;
  // bool useSafeExtrapolationB = false;
  bool useExtrapolationF     = false;
  bool useExtrapolationB     = false;
  bool useSameStrip          = false;
  bool useLevelStripF        = false;
  bool useLevelStripB        = false;


  bool treatAsUNKNOWN        = false;
  if(fEventType==UNKNOWN)treatAsUNKNOWN = true;
  if(fEventType==SINGLE_MUON)useFitSlopeHits = true;
  if(fEventType==THROUGH_GOING_MUON)useFitSlopeHits = true;
  if(fEventType==STRAIGHT_THROUGH_GOING_MUON)useFitSlopeHits = true;

  if(fEventType==MULTIPLE_MUON){
    if( (fHoughStatus==true)&&(j>0||k>0))useHoughSlope = true;
    if( (fHoughStatus==false)||(j==0&&k==0))treatAsUNKNOWN = true;
  }

  if(treatAsUNKNOWN){
    useInterpolation  = true;
    if(tactic.searchType != SEARCH_FORWARDS && 
       tactic.searchType != SEARCH_GAP_F)useLevelStripB = fUseLevelStripB;
    if(tactic.searchType != SEARCH_BACKWARDS && 
       tactic.searchType != SEARCH_GAP_B)useLevelStripF = fUseLevelStripF;
    useExtrapolationF = fUseExtrapolationF;
    useExtrapolationB = fUseExtrapolationB;
    useSameStrip      = fUseSameStrip;
  }

  for(Int_t index = 0; index<3; index++){
    Float_t slopeU = 0.;
    Float_t slopeV = 0.;
    bool    useSlope = false;
    if(index==0){
      useSlope = useFitSlopeHits;
      if(!fFitQHitU.status)slopeU  = fFitHitU.a1;
      if(!fFitQHitV.status)slopeV  = fFitHitV.a1;
      if(fFitQHitU.status)slopeU  = fFitQHitU.a1;
      if(fFitQHitV.status)slopeV  = fFitQHitV.a1;
    }
    if(index==1){
      useSlope = useFitSlopeTime;
      slopeU  = fFitTimeU.a1;
      slopeV  = fFitTimeU.a1;
    }
    if(index==2){
      useSlope = useHoughSlope;
      slopeU  = fHoughSlopeU;
      slopeV  = fHoughSlopeV;
    }

    if(useSlope){
      if(j>0){
        for(int jj=1;jj<=fPlanePair[j];jj++){
          Int_t je = j;
          if(i>249&&j<249)je-=20;
          if(fUVMap[i]==PlaneView::kU)target = fHitMap[j][jj] + slopeU*(i-je);
          if(fUVMap[i]==PlaneView::kV)target = fHitMap[j][jj] + slopeV*(i-je);
          itarget = static_cast<int>(target);
          fTargetStrips.push_back(itarget);
        }
      }
      if(k>0 && k<MAX_NUMBER_OF_PLANES){
        for(int kk=1;kk<=fPlanePair[k];kk++){
          Int_t ke = k;
          if(i<249&&k>249)ke+=20;
          if(fUVMap[i]==PlaneView::kU)target = fHitMap[k][kk] + slopeU*(i-ke);
          if(fUVMap[i]==PlaneView::kV)target = fHitMap[k][kk] + slopeV*(i-ke);
          itarget = static_cast<int>(target);
          fTargetStrips.push_back(itarget);
        }
      }
    }
  }

  if(useSameStrip&&fPlanePair[i]>0){
    for(int ii=1;ii<=fPlanePair[i];ii++){
      itarget = fHitMap[i][ii];
      fTargetStrips.push_back(itarget);
    }
  }

  if(fPlanePair[i]==0){
    if(j>0 && useLevelStripB){
      for(int jj=1;jj<=fPlanePair[j];jj++){
        itarget = fHitMap[j][jj];
        fTargetStrips.push_back(itarget);
      }
    }
    if(k>0 && k<MAX_NUMBER_OF_PLANES  && useLevelStripF){
      for(int kk=1;kk<=fPlaneHit[k];kk++){
        itarget = fHitMap[k][kk];
        fTargetStrips.push_back(itarget);
      }
    }
  }
  
  
  if(j>0 && k>0 && k<MAX_NUMBER_OF_PLANES && useInterpolation){
    for(int jj=1;jj<=fPlanePair[j];jj++){
      if(fQHitMapE[j][jj]>fTrackingLowPECut && fQHitMapW[j][jj]>fTrackingLowPECut){
        for(int kk=1;kk<=fPlanePair[k];kk++){
          if(fQHitMapE[k][kk]>fTrackingLowPECut && fQHitMapW[k][kk]>fTrackingLowPECut){
            it =fHitMap[j][jj] + (fHitMap[k][kk]-fHitMap[j][jj])*(i-j)/(k-j);
            fTargetStrips.push_back(it);  
          }
        }
      }
    }
  }

  this->MakePlaneMap(i,true);

  return;
}



void AlgAltDeMuxBase::NewTactic(DeMuxSearchTactic oldTactic){
  

  bool foundh;
  bool foundl;
  bool found;
  DeMuxSearchTactic newTactic;

  switch(oldTactic.searchType){
  case SEARCH_GAP:

    break;
  case SEARCH_GAP_B:
    found = false;
    for(int i=oldTactic.iplane-2;i>=oldTactic.lowplane+2&&found==false;i-=2){
      if(!fSearched[i]&&fPlanesAltLists[i][ALG_EAST].size()&&fPlanesAltLists[i][ALG_WEST].size()){
        found = true;
        newTactic.iplane = i;
        newTactic.goodTactic = true;
        newTactic.lowplane = oldTactic.lowplane;
        if(fPlaneHit[oldTactic.iplane]>0){ 
          newTactic.highplane = oldTactic.iplane;
        }else{
          newTactic.highplane = oldTactic.highplane;
        }
        newTactic.searchType = SEARCH_GAP_B;
      }
    }
    if(found){
      fSearchTactics.push_back(newTactic);
      fSearched[newTactic.iplane] = true;
    }
    break;
  case SEARCH_GAP_F:
    found = false;
    for(int i=oldTactic.iplane+2;i<=oldTactic.highplane-2&&found==false;i+=2){
      if(!fSearched[i]&&fPlanesAltLists[i][ALG_EAST].size()&&fPlanesAltLists[i][ALG_WEST].size()){
        found = true;
        newTactic.iplane = i;
        newTactic.goodTactic = true;
        if(fPlaneHit[oldTactic.iplane]>0){ 
          newTactic.lowplane = oldTactic.iplane;
        }else{
          newTactic.lowplane = oldTactic.lowplane;
        }
        newTactic.highplane = oldTactic.highplane;
        newTactic.searchType = SEARCH_GAP_F;
      }
    }
    if(found){
      fSearchTactics.push_back(newTactic);
      fSearched[newTactic.iplane] = true;
    }
    break;
  case SEARCH_FORWARDS:
    foundh = false;
    foundl = false;
    if(oldTactic.goodTactic){
      for(int i=oldTactic.iplane+2;i<MAX_NUMBER_OF_PLANES-2&&foundh==false;i+=2){
        if(fPlanesAltLists[i][ALG_EAST].size()&&fPlanesAltLists[i][ALG_WEST].size()){
          foundh = true;
          newTactic.iplane = i;
          newTactic.goodTactic = true;
          newTactic.highplane = oldTactic.iplane;
          newTactic.lowplane = oldTactic.highplane;
          newTactic.searchType = SEARCH_FORWARDS;
        }
      }
    }else{
      for(int i=oldTactic.iplane+2;i<MAX_NUMBER_OF_PLANES-2&&foundh==false;i+=2){
        if(fPlanesAltLists[i][ALG_EAST].size()&&fPlanesAltLists[i][ALG_WEST].size()){
          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(fPlaneHit[i]>0){
          foundl = true;
          newTactic.lowplane = i;
        }
      }
    }
    if(foundh){
      fSearchTactics.push_back(newTactic);
    }
    break;
  case SEARCH_BACKWARDS:
    foundh = false;
    foundl = false;
    if(oldTactic.goodTactic){
      for(int i=oldTactic.iplane-2;i>0&&foundl==false;i-=2){
        if(fPlanesAltLists[i][ALG_EAST].size()&&fPlanesAltLists[i][ALG_WEST].size()){
          foundl = true;
          newTactic.iplane = i;
          newTactic.lowplane = oldTactic.iplane;
          newTactic.goodTactic = true;
          newTactic.highplane = oldTactic.lowplane;
          newTactic.searchType = SEARCH_BACKWARDS;
        }
      }
    }else{
      for(int i=oldTactic.iplane-2;i>0&&foundl==false;i-=2){
        if(fPlanesAltLists[i][ALG_EAST].size()&&fPlanesAltLists[i][ALG_WEST].size()){
          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(fPlaneHit[i]>0){
          foundh = true;
          newTactic.highplane = i;
        }
      }
    }
    if(foundl){
      fSearchTactics.push_back(newTactic);
    }
    break;
  default:
    break;
  }
  
  return;
} 

void AlgAltDeMuxBase::MakeSearchTacticsX()
{

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

  for(int i=0; i<MAX_NUMBER_OF_PLANES; i++){
    if(fPlaneHit[i]>=0){
      if(fPlanesAltLists[i][ALG_EAST].size()&&fPlanesAltLists[i][ALG_WEST].size()){
        int j = -100;
        int k = -100;
        if(i>1){
          int jj = i-2;
          if(jj==248 || jj==249)jj--;
          found = false;
          while(found==false){
            if(fPlaneHit[jj]){
              j=jj;
              found = true;
            }
            jj-=2;
            if(jj==248 || jj==249)jj--;
            if(jj<0||jj<i-24)found =true;
          }
        }
        if(i<MAX_NUMBER_OF_PLANES-2){
          int kk = i+2;
          if(kk==249 || kk==250)kk++;
          found = false;
          while(found==false){
            if(fPlaneHit[kk]){
              k=kk;
              found = true;
            }
            kk+=2;
            if(kk==249 || kk==250)kk++;
            if(kk>MAX_NUMBER_OF_PLANES-2||kk>i+24)found =true;
          }
        }
        DeMuxSearchTactic tactic;
        tactic.iplane = i;
        tactic.searchType = SEARCH_GAP;
        tactic.lowplane  = j;
        tactic.highplane = k;
        tactic.goodTactic = true;
        fSearchTactics.push_back(tactic);
      }
    }
  }    
  return;
}


void AlgAltDeMuxBase::MakeSearchTacticsY()
{

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

  for(int i=0; i<MAX_NUMBER_OF_PLANES; i++){
    if(fPlanesAltLists[i][ALG_EAST].size()||fPlanesAltLists[i][ALG_WEST].size()){
      int j = -100;
      int k = -100;
      if(i>1){
        int jj = i-2;
        if(jj==248 || jj==249)jj--;
        found = false;
        while(found==false){
          if(fPlaneHit[jj]){
            j=jj;
            found = true;
          }
          jj-=2;
          if(jj==248 || jj==249)jj--;
          if(jj<0||jj<i-24

)found =true;
        }
      }
      if(i<MAX_NUMBER_OF_PLANES-2){
        int kk = i+2;
        if(kk==249 || kk==250)kk++;
        found = false;
        while(found==false){
          if(fPlaneHit[kk]){
            k=kk;
            found = true;
          }
          kk+=2;
          if(kk==249 || kk==250)kk++;
          if(kk>MAX_NUMBER_OF_PLANES-2||kk>i+24)found =true;
        }
      }
      DeMuxSearchTactic tactic;
      tactic.iplane = i;
      tactic.searchType = SEARCH_SINGLES;
      tactic.lowplane  = j;
      tactic.highplane = k;
      tactic.goodTactic = true;
      fSearchTactics.push_back(tactic);
    }
  }    
  return;
}



void AlgAltDeMuxBase::DeMuxSingles(DeMuxSearchTactic tactic)
{
  vector <PlexSEIdAltL*>::iterator literA;

  int i = tactic.iplane;
  int j = tactic.lowplane;
  int k = tactic.highplane;
  Float_t target = 0.;
  int itarget;
  int it;
  int s;
  int sbest;
  int closeness; 

  int sbest1;
  int closeness1;
  int sbest2;
  int closeness2;

  fTargetStrips.erase(fTargetStrips.begin(),fTargetStrips.end());
  if(fEventType==MULTIPLE_MUON)MakeMultipleTargets(i);
  
  bool useHoughSlope         = fUseHoughSlope;
  bool useFitSlopeTime       = fUseFitSlopeTime;
  bool useFitSlopeHits       = fUseFitSlopeHits;
  bool useInterpolation      = false;
  // bool useSafeExtrapolationF = false;
  // bool useSafeExtrapolationB = false;
  bool useExtrapolationF     = false;
  bool useExtrapolationB     = false;
  bool useSameStrip          = fUseSameStrip;
  bool useLevelStripF        = false;
  bool useLevelStripB        = false;
  bool treatAsUNKNOWN        = false;

  if(fEventType==UNKNOWN)treatAsUNKNOWN = true;
  if(fEventType==SINGLE_MUON)useFitSlopeHits=true;
  if(fEventType==THROUGH_GOING_MUON)useFitSlopeHits=true;
  if(fEventType==STRAIGHT_THROUGH_GOING_MUON)useFitSlopeHits=true;
  if(fEventType==MULTIPLE_MUON){
    useSameStrip = false;
    if( (fHoughStatus==true)&&(j>0||k>0))useHoughSlope = true;
    if( (fHoughStatus==false)||(j==0&&k==0))treatAsUNKNOWN = true;
  }

  if(treatAsUNKNOWN){
    if(fPlaneHit[i]==0)useInterpolation  = fUseInterpolation;
    // if(fPlaneHit[i]==0)useExtrapolationF = fUseExtrapolationF;
    //if(fPlaneHit[i]==0)useExtrapolationB = fUseExtrapolationB;
    if(i>=247&&i<=251 ){
      useInterpolation   = false;
      if(i>249){
        useExtrapolationF = fUseExtrapolationF;
        useExtrapolationB = false;
      }else{
        useExtrapolationB = fUseExtrapolationB;
        useExtrapolationF = false;
      }
    }
    useSameStrip      = fUseSameStrip;
  }



  for(Int_t index = 0; index<3; index++){
    Float_t slopeU = 0.;
    Float_t slopeV = 0.;
    bool    useSlope = false;
    if(index==0){
      useSlope = useFitSlopeHits;
      if(!fFitQHitU.status)slopeU  = fFitHitU.a1;
      if(!fFitQHitV.status)slopeV  = fFitHitV.a1;
      if(fFitQHitU.status)slopeU  = fFitQHitU.a1;
      if(fFitQHitV.status)slopeV  = fFitQHitV.a1;
    }
    if(index==1){
      useSlope = useFitSlopeTime;
      slopeU  = fFitTimeU.a1;
      slopeV  = fFitTimeU.a1;
    }
    if(index==2){
      useSlope = useHoughSlope;
      slopeU  = fHoughSlopeU;
      slopeV  = fHoughSlopeV;
    }

    if(useSlope){
      if(j>0){
        for(int jj=1;jj<=fPlanePair[j];jj++){
          Int_t je = j;
          if(i>249&&j<249)je-=20;
          if(fUVMap[i]==PlaneView::kU)target = fHitMap[j][jj] + slopeU*(i-je);
          if(fUVMap[i]==PlaneView::kV)target = fHitMap[j][jj] + slopeV*(i-je);
          itarget = static_cast<int>(target);
          if(itarget>-24&&itarget<216)fTargetStrips.push_back(itarget);
          if(amWriting)cout << "Slope Target j : " << itarget << endl;
        }
      }
      if(k>0){
        for(int kk=1;kk<=fPlanePair[k];kk++){
          Int_t ke = k;
          if(i<249&&k>249)ke+=20;
          if(fUVMap[i]==PlaneView::kU)target = fHitMap[k][kk] + slopeU*(i-ke);
          if(fUVMap[i]==PlaneView::kV)target = fHitMap[k][kk] + slopeV*(i-ke);
          itarget = static_cast<int>(target);
          if(itarget>-24&&itarget<216)fTargetStrips.push_back(itarget);
          if(amWriting)cout << "Slope Target k : " << itarget << endl;
        }
      }
    }
  }

  if(useSameStrip&&fPlanePair[i]>0){
    for(int ii=1;ii<=fPlanePair[i];ii++){
      itarget = fHitMap[i][ii];
      fTargetStrips.push_back(itarget);
      if(amWriting)cout << "USE SAME STRIP : " << itarget << endl;
    }
  }

  if(useInterpolation && j>0 && k>0){
    for(int jj=1;jj<=fPlanePair[j];jj++){
      if(fQHitMapE[j][jj]>fTrackingLowPECut && fQHitMapW[j][jj]>fTrackingLowPECut){
        for(int kk=1;kk<=fPlaneHit[k];kk++){
          if(fQHitMapE[k][kk]>fTrackingLowPECut && fQHitMapW[k][kk]>fTrackingLowPECut){
            it =fHitMap[j][jj] + (fHitMap[k][kk]-fHitMap[j][jj])*(i-j)/(k-j);
            // Interpolate accross SM boundart 
            if(j<249 && i>249)it =fHitMap[j][jj] + (fHitMap[k][kk]-fHitMap[j][jj])*(i-j+15)/(k-j+20);
            if(i<249 && k>249)it =fHitMap[j][jj] + (fHitMap[k][kk]-fHitMap[j][jj])*(i-j)/(k+20-j);
            fTargetStrips.push_back(it);  
            if(amWriting)cout << "INTERPOLATE : " << it << endl;
          }
        }
      }
    }
  }
  
  if(useExtrapolationF){
    if(k>0 && k<MAX_NUMBER_OF_PLANES-2){
      int n = (k-i)/2;
      for(int kk=1;kk<=fPlanePair[k];kk++){
        int kp = k+2;
        if(k>249||kp<249){
          for (int kkp=1;kkp<=fPlanePair[kp];kkp++){
            itarget = (n+1)*fHitMap[k][kk] - n*fHitMap[kp][kkp];
            fTargetStrips.push_back(itarget);
            if(amWriting)cout << "EXTRAPOLATEF : " << itarget << endl;
          }
        }
      }
    }
  }

  if(useExtrapolationB){
    if(j>=2){
      int n = (i-j)/2;
      for(int jj=1;jj<=fPlanePair[j];jj++){
        int jm = j-2;
        if(jm>249||j<249){
          for(int jjm=1;jjm<=fPlanePair[jm];jjm++){
            itarget = (n+1)*fHitMap[j][jj] - n*fHitMap[jm][jjm];
            fTargetStrips.push_back(itarget);
            if(amWriting)cout << "EXTRAPOLATEB : " << itarget << endl;
          }
        }
      }
    }
  }

  useLevelStripF = false;
  useLevelStripB = false;

  if(fTargetStrips.size()==0)useLevelStripF = true;
  if(fTargetStrips.size()==0)useLevelStripB = true;
 
  if(j>0 && useLevelStripB){
    if(j!=247&&j!=248){
      for(int jj=1;jj<=fPlanePair[j];jj++){      
        itarget = fHitMap[j][jj];
        fTargetStrips.push_back(itarget);
        if(amWriting)cout << "LEVEL B       : " << itarget << endl;
      }
    }
  }
  if(k>0 && useLevelStripF){
    if(k!=247&&k!=248){
      for(int kk=1;kk<=fPlanePair[k];kk++){
        itarget = fHitMap[k][kk];
        fTargetStrips.push_back(itarget);
        if(amWriting)cout << "LEVEL F       : " << itarget << endl;
      }
    }
  }  

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

  Int_t currentPlane = i;  
  PlaneView::PlaneView_t kView;

  for(Int_t iew=ALG_EAST;iew<=ALG_WEST;iew++){
    if(fPlanesAltLists[i][iew].size()>0){
      while (fPlanesAltLists[i][iew].size()>0){
        sbest =0;
        closeness = 999;
        sbest1 =0;
        closeness1 = 999;
        sbest2 =0;
        closeness2 = 999;
        literA = fPlanesAltLists[i][iew].begin();
        (*literA)->SetFirst();
        kView = (*literA)->GetPlaneView();
        while( (*literA)->IsValid() ){
          s = (*literA)->GetCurrentSEId().GetStrip();
          bool found = false;
          if(fCutUseTimingMask==false || fUVmask[i][s]){  
            if((*literA)->GetCurrentWeight()>-1.){
              for(unsigned int t=0;t<fTargetStrips.size()&&found==false;t++){
                if(abs(fTargetStrips[t]-s)<closeness){
                  closeness = abs(fTargetStrips[t]-s);
                  sbest = s;                    
                  if(closeness==0)found = true;
                }
              }
            }else{
              for(unsigned int t=0;t<fTargetStrips.size()&&found==false;t++){
                if(abs(fTargetStrips[t]-s)<closeness1){
                  closeness1 = abs(fTargetStrips[t]-s);
                  sbest1 = s;                   
                  if(closeness1==0)found = true;
                }
              }
            }
          }else{
            for(unsigned int t=0;t<fTargetStrips.size()&&found==false;t++){
              if(abs(fTargetStrips[t]-s)<closeness2){
                closeness2 = abs(fTargetStrips[t]-s);
                sbest2 = s;                     
              }
            }
          }
          (*literA)->Next();
        }
        if(closeness>=999|| (closeness>5 && closeness1<closeness)  ){
          sbest=sbest1;
          closeness=closeness1;
        }
        if(closeness>=999&&closeness1>=999){
          sbest=sbest2;
          closeness=closeness2;
        }
        if(closeness<999){
          if(amShowing){
            bool foundit = false;
            for(int ix=1;ix<=fPlaneHit[currentPlane];ix++){
              if(abs(sbest-fHitMap[currentPlane][ix])<2.5)foundit=true;
            }
            if(foundit==false){
              (*literA)->SetFirst();
              IsXTalk(*literA);
            }
          }
          if(iew==ALG_EAST)this->DeMuxSingleHitE(currentPlane,*literA, sbest);
          if(iew==ALG_WEST)this->DeMuxSingleHitW(currentPlane,*literA, sbest);
        }else{
          if(iew==ALG_EAST)this->VetoHitE(currentPlane,*literA);
          if(iew==ALG_WEST)this->VetoHitW(currentPlane,*literA);                }
      }
    }
  }
  
  return;
}

void AlgAltDeMuxBase::StripCrossTalkSingles(CandDeMuxDigitListHandle& cdlh)
{
  
  PlexSEIdAltL* paltlist;
  vector <PlexSEIdAltL*>::iterator literA;
  
  CandDeMuxDigitHandleItr cdhItr(cdlh.GetDaughterIterator());
  
  MSG("AltDeMux", Msg::kDebug) << "AlgAltDeMuxBase::MakePixelMap" << endl;
  while ( CandDeMuxDigitHandle *digit = cdhItr() ) {
    // for each digit
    paltlist = &(digit->GetPlexSEIdAltLWritable());
    Int_t iplane = paltlist->GetPlane();
    if(!paltlist->IsVetoShield()){
      if(iplane>0&&iplane<MAX_NUMBER_OF_PLANES){
        for(Int_t iew=ALG_EAST;iew<=ALG_WEST;iew++){
          if(fPlanesAltLists[iplane][iew].size()>0){
            literA = fPlanesAltLists[iplane][iew].begin();
            while (literA != fPlanesAltLists[iplane][iew].end()){
              if((*literA)==paltlist){
                (*literA)->SetFirst();
                if(IsXTalk(paltlist)){
                  digit->SetDeMuxDigitFlagBit(CandDeMuxDigit::kXTalk);  
                  fXTalkPlanesAltLists[iplane][iew].push_back(*literA);
                }
              }
              *literA++;
            }
          }
        }
      }else{
        MSG("AltDeMux", Msg::kWarning) << "AlgAltDeMuxBase::StripCrossTalkSingles - CandDigit with invalid plane  : " << iplane << endl;
      }
    }
  }

  // Remove cross talk hits from fPlanesAltLists 

  for(int iplane=0; iplane<MAX_NUMBER_OF_PLANES; iplane++){
    for(int iew = ALG_EAST; iew<=ALG_WEST; iew++){
      if(fXTalkPlanesAltLists[iplane][iew].size()>0){
        literA = fXTalkPlanesAltLists[iplane][iew].begin();
        while (literA != fXTalkPlanesAltLists[iplane][iew].end()){
          RemoveFromPlanesList(iplane,iew,*literA);
          *literA++;
        }
      }
    }
  }

  return;
}

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

  for(int i=0; i<MAX_NUMBER_OF_PLANES; i++){
    if(fPlanesAltLists[i][ALG_EAST].size()||fPlanesAltLists[i][ALG_WEST].size()){
      MSG("AltDeMux",Msg::kVerbose) << "AlgAltDeMuxBase::PrintWhatRemains() PLANE : " << i << "has " << fPlaneHit[i] <<  " DeMuxed Hits, Left With   E : " << fPlanesAltLists[i][ALG_EAST].size() << ", W : " << fPlanesAltLists[i][ALG_WEST].size() << endl;
    }

    if(fPlanesAltLists[i][ALG_EAST].size()&&fPlanesAltLists[i][ALG_WEST].size()){
      literE = fPlanesAltLists[i][ALG_EAST].begin();
      while (literE != fPlanesAltLists[i][ALG_EAST].end()){
        literW = fPlanesAltLists[i][ALG_WEST].begin();
        while ( literW != fPlanesAltLists[i][ALG_WEST].end()){
          (*literE)->SetFirst();
          while( (*literE)->IsValid() ){
            (*literW)->SetFirst();
            while( (*literW)->IsValid() ){
              if((*literE)->GetCurrentSEId().GetStrip()==(*literW)->GetCurrentSEId().GetStrip()){
                MSG("AltDeMux",Msg::kVerbose) << "AlgAltDeMuxBase::PrintWhatRemains() Poss " << i << " : " << (*literE)->GetCurrentItem().GetPE() << " : " << (*literW)->GetCurrentItem().GetPE() << " : " << (*literE)->GetCurrentSEId().GetStrip() << endl;
              }
              (*literW)->Next();
            }
            (*literE)->Next();
          }
          literW++;
        }
        literE++;
      }
    }
    if(fPlanesAltLists[i][ALG_EAST].size()){
      literE = fPlanesAltLists[i][ALG_EAST].begin();
      while (literE != fPlanesAltLists[i][ALG_EAST].end()){
        (*literE)->SetFirst();
        while( (*literE)->IsValid() ){
          MSG("AltDeMux",Msg::kVerbose) << "AlgAltDeMuxBase::PrintWhatRemains() Single possibilility : " << i << " : " << (*literE)->GetCurrentItem().GetPE() << " : " << (*literE)->GetCurrentSEId().GetStrip() << endl;
          (*literE)->Next();
        }
        literE++;
      }
    }
    if(fPlanesAltLists[i][ALG_WEST].size()){
      literW = fPlanesAltLists[i][ALG_WEST].begin();
      while (literW != fPlanesAltLists[i][ALG_WEST].end()){
        (*literW)->SetFirst();
        while( (*literW)->IsValid() ){
          MSG("AltDeMux",Msg::kVerbose) << "AlgAltDeMuxBase::PrintWhatRemains() Single possibilility : " << i << " : " << (*literW)->GetCurrentItem().GetPE() << " : " << (*literW)->GetCurrentSEId().GetStrip() << endl;
          (*literW)->Next();
        }
        literW++;
      }
    }
  }
  
  return;
}



void AlgAltDeMuxBase::PrintXTalk()
{
  vector <PlexSEIdAltL*>::iterator literE;
  vector <PlexSEIdAltL*>::iterator literW;
  MSG("AltDeMux",Msg::kDebug) << "AlgAltDeMuxBase::PrintXTalk" << endl;
  for(int i=0; i<MAX_NUMBER_OF_PLANES; i++){
    if(fXTalkPlanesAltLists[i][ALG_EAST].size()||fXTalkPlanesAltLists[i][ALG_WEST].size()){
      if(amWriting)cout << " PLANE : " << i << "has " << fPlaneHit[i] <<  " DeMuxed Hits, Left With   E : " << fXTalkPlanesAltLists[i][ALG_EAST].size() << ", W : " << fXTalkPlanesAltLists[i][ALG_WEST].size() << endl;
    }

    if(fXTalkPlanesAltLists[i][ALG_EAST].size()&&fXTalkPlanesAltLists[i][ALG_WEST].size()){
      literE = fXTalkPlanesAltLists[i][ALG_EAST].begin();
      while (literE != fXTalkPlanesAltLists[i][ALG_EAST].end()){
        literW = fXTalkPlanesAltLists[i][ALG_WEST].begin();
        while ( literW != fXTalkPlanesAltLists[i][ALG_WEST].end()){
          (*literE)->SetFirst();
          while( (*literE)->IsValid() ){
            (*literW)->SetFirst();
            while( (*literW)->IsValid() ){
              if((*literE)->GetCurrentSEId().GetStrip()==(*literW)->GetCurrentSEId().GetStrip()){
                if(amWriting)cout << " Poss " << i << " : " << (*literE)->GetCurrentItem().GetPE() << " : " << (*literW)->GetCurrentItem().GetPE() << " : " << (*literE)->GetCurrentSEId().GetStrip() << endl;
              }
              (*literW)->Next();
            }
            (*literE)->Next();
          }
          literW++;
        }
        literE++;
      }
    }
    if(fXTalkPlanesAltLists[i][ALG_EAST].size()){
      literE = fXTalkPlanesAltLists[i][ALG_EAST].begin();
      while (literE != fXTalkPlanesAltLists[i][ALG_EAST].end()){
        (*literE)->SetFirst();
        while( (*literE)->IsValid() ){
          if(amWriting)cout << " Single possibilility : " << i << " : " << (*literE)->GetCurrentItem().GetPE() << " : " << (*literE)->GetCurrentSEId().GetStrip() << endl;
          (*literE)->Next();
        }
        literE++;
      }
    }
    if(fXTalkPlanesAltLists[i][ALG_WEST].size()){
      literW = fXTalkPlanesAltLists[i][ALG_WEST].begin();
      while (literW != fXTalkPlanesAltLists[i][ALG_WEST].end()){
        (*literW)->SetFirst();
        while( (*literW)->IsValid() ){
          if(amWriting)cout << " Single possibilility : " << i << " : " << (*literW)->GetCurrentItem().GetPE() << " : " << (*literW)->GetCurrentSEId().GetStrip() << endl;
          (*literW)->Next();
        }
        literW++;
      }
    }
  }
  
  return;
}




void AlgAltDeMuxBase::PrintNoise()
{
  vector <PlexSEIdAltL*>::iterator literE;
  vector <PlexSEIdAltL*>::iterator literW;

  for(int i=0; i<MAX_NUMBER_OF_PLANES; i++){
    if(fNoisePlanesAltLists[i][ALG_EAST].size()||fNoisePlanesAltLists[i][ALG_WEST].size()){
      cout << " PLANE : " << i << "has " << fPlaneHit[i] <<  " DeMuxed Hits, Left With   E : " << fNoisePlanesAltLists[i][ALG_EAST].size() << ", W : " << fNoisePlanesAltLists[i][ALG_WEST].size() << endl;
    }

    if(fNoisePlanesAltLists[i][ALG_EAST].size()&&fNoisePlanesAltLists[i][ALG_WEST].size()){
      literE = fNoisePlanesAltLists[i][ALG_EAST].begin();
      while (literE != fNoisePlanesAltLists[i][ALG_EAST].end()){
        literW = fNoisePlanesAltLists[i][ALG_WEST].begin();
        while ( literW != fNoisePlanesAltLists[i][ALG_WEST].end()){
          (*literE)->SetFirst();
          while( (*literE)->IsValid() ){
            (*literW)->SetFirst();
            while( (*literW)->IsValid() ){
              if((*literE)->GetCurrentSEId().GetStrip()==(*literW)->GetCurrentSEId().GetStrip()){
                if(amWriting)cout << " Poss " << i << " : " << (*literE)->GetCurrentItem().GetPE() << " : " << (*literW)->GetCurrentItem().GetPE() << " : " << (*literE)->GetCurrentSEId().GetStrip() << endl;
              }
              (*literW)->Next();
            }
            (*literE)->Next();
          }
          literW++;
        }
        literE++;
      }
    }
    if(fNoisePlanesAltLists[i][ALG_EAST].size()){
      literE = fNoisePlanesAltLists[i][ALG_EAST].begin();
      while (literE != fNoisePlanesAltLists[i][ALG_EAST].end()){
        (*literE)->SetFirst();
        while( (*literE)->IsValid() ){
          if(amWriting)cout << " Single possibilility : " << i << " : " << (*literE)->GetCurrentItem().GetPE() << " : " << (*literE)->GetCurrentSEId().GetStrip() << endl;
          (*literE)->Next();
        }
        literE++;
      }
    }
    if(fNoisePlanesAltLists[i][ALG_WEST].size()){
      literW = fNoisePlanesAltLists[i][ALG_WEST].begin();
      while (literW != fNoisePlanesAltLists[i][ALG_WEST].end()){
        (*literW)->SetFirst();
        while( (*literW)->IsValid() ){
          if(amWriting)cout << " Single possibilility : " << i << " : " << (*literW)->GetCurrentItem().GetPE() << " : " << (*literW)->GetCurrentSEId().GetStrip() << endl;
          (*literW)->Next();
        }
        literW++;
      }
    }
  }
  
  return;
}




void AlgAltDeMuxBase::FitAsCosmic(bool useSingles)
{
  Float_t weightedStrip[MAX_NUMBER_OF_PLANES];
  Float_t Qtotal[MAX_NUMBER_OF_PLANES];

  vector<DeMuxFitData_t>HitsU;
  vector<DeMuxFitData_t>HitsV;
  vector<DeMuxFitData_t>QHitsU;
  vector<DeMuxFitData_t>QHitsV;
  vector<DeMuxFitData_t>TimesU;
  vector<DeMuxFitData_t>TimesV;
 
  Int_t lowestUplane=999;
  Int_t lowestVplane=999;
  Int_t highestUplane=-999;
  Int_t highestVplane=-999;

  if(fEventType==MULTIPLE_MUON)return;

  for(Int_t iplane=0;iplane<MAX_NUMBER_OF_PLANES;iplane++){
    Qtotal[iplane] = 0.0;
    Float_t Qw = 0.0;
    Float_t Q  = 0.0;
    for(UInt_t ipair=0;ipair<fDeMuxedPairs[iplane].size();ipair++){
      Int_t istrip = fDeMuxedPairs[iplane][ipair].altListE->GetBestSEId().GetStrip();
      Q += fDeMuxedPairs[iplane][ipair].pairQCor;      
      Qw+= istrip*fDeMuxedPairs[iplane][ipair].pairQCor;
      PlaneView::PlaneView_t kView = fDeMuxedPairs[iplane][ipair].altListE->GetPlaneView();
      if(kView==PlaneView::kU){
        if(iplane<lowestUplane)lowestUplane=iplane;
        if(iplane>highestUplane)highestUplane=iplane;
      }
      if(kView==PlaneView::kV){
        if(iplane<lowestVplane)lowestVplane=iplane;
        if(iplane>highestVplane)highestVplane=iplane;
      }
    }
    if(useSingles){
      for(UInt_t isingle=0;isingle<fDeMuxedSingles[iplane].size();isingle++){
        Int_t istrip = fDeMuxedSingles[iplane][isingle].altList->GetBestSEId().GetStrip();
        Q  += fDeMuxedSingles[iplane][isingle].Qcor;      
        Qw += istrip*fDeMuxedSingles[iplane][isingle].Qcor;
        PlaneView::PlaneView_t kView = fDeMuxedSingles[iplane][isingle].altList->GetPlaneView();
        if(kView==PlaneView::kU){
          if(iplane<lowestUplane)lowestUplane=iplane;
          if(iplane>highestUplane)highestUplane=iplane;
        }
        if(kView==PlaneView::kV){
          if(iplane<lowestVplane)lowestVplane=iplane;
          if(iplane>highestVplane)highestVplane=iplane;
        }
      }
    }
    if(Q>0)weightedStrip[iplane] = Qw/Q;
    if(Q>0)Qtotal[iplane] = Q;
    //if(Q>0)cout << " Weighted : " << iplane << ":" << Qw/Q << " using : " << Q << endl;
  }
  // Decide on appropriate level of Q cut for weighted plane fit

  Float_t Ntotal = 0;
  Float_t Nabove1=0;
  Float_t Nabove2=0;
  Float_t Nabove3=0;
  for(Int_t iplane=0;iplane<MAX_NUMBER_OF_PLANES;iplane++){
    if(Qtotal[iplane]>0){
      Ntotal++;
      if(Qtotal[iplane]>3)Nabove1++;
      if(Qtotal[iplane]>5)Nabove2++;
      if(Qtotal[iplane]>10)Nabove3++;
    }
  }
  Float_t Qcut = 3.0;
  if(Ntotal>0.0){
    if(amWriting){
      cout << "fraction above 3 pe  " << Nabove1/Ntotal << endl;
      cout << "fraction above 5 pe  " << Nabove2/Ntotal << endl;
      cout << "fraction above 10 pe " << Nabove3/Ntotal << endl;
    }
    if(Nabove2/Ntotal > 0.8)Qcut= 5.0;
    if(Nabove3/Ntotal > 0.8)Qcut=10.0;
  }



  // Deal with the pairs

  for(Int_t iplane=0;iplane<MAX_NUMBER_OF_PLANES;iplane++){
    for(UInt_t ipair=0;ipair<fDeMuxedPairs[iplane].size();ipair++){
      PlaneView::PlaneView_t kView = fDeMuxedPairs[iplane][ipair].altListE->GetPlaneView();
      Int_t istrip = fDeMuxedPairs[iplane][ipair].altListE->GetBestSEId().GetStrip();
      Int_t isaim  = fDeMuxedPairs[iplane][ipair].orthogonalStripFromTiming;
      Int_t jplane = iplane;
      if(jplane>249)jplane+=20;
      DeMuxFitData_t hit;
      DeMuxFitData_t time;
      hit.x = jplane;
      hit.y = istrip;
      hit.status = true;
      time.x = jplane;
      time.y = isaim;
      time.status = true;
      if(kView==PlaneView::kV){
        if(iplane>=lowestUplane-1&&iplane<=highestUplane+1){
          HitsV.push_back(hit);
          TimesU.push_back(time);
        }
      }
      if(kView==PlaneView::kU){
        if(iplane>=lowestVplane-1&&iplane<=highestVplane+1){
          HitsU.push_back(hit);
          TimesV.push_back(time);
        }
      }
    }
  }


  if(useSingles){
    for(Int_t iplane=0;iplane<MAX_NUMBER_OF_PLANES;iplane++){
      for(UInt_t isingle=0;isingle<fDeMuxedSingles[iplane].size();isingle++){
        PlaneView::PlaneView_t kView = fDeMuxedSingles[iplane][isingle].altList->GetPlaneView();
        Int_t istrip = fDeMuxedSingles[iplane][isingle].altList->GetBestSEId().GetStrip();
        Int_t jplane = iplane;
        if(jplane>249)jplane+=20;
        DeMuxFitData_t hit;
        hit.x = jplane;
        hit.y = istrip;
        hit.status = true;
        if(kView==PlaneView::kV){
          if(iplane>=lowestUplane-1&&iplane<=highestUplane+1)HitsV.push_back(hit);
        }
        if(kView==PlaneView::kU){
          if(iplane>=lowestVplane-1&&iplane<=highestVplane+1)HitsU.push_back(hit);
        }
      }
    }
  }

  for(Int_t iplane=0;iplane<MAX_NUMBER_OF_PLANES;iplane++){
    Int_t usedHits = fDeMuxedPairs[iplane].size();
    if(useSingles)usedHits+=fDeMuxedSingles[iplane].size();
    if(usedHits>0 && Qtotal[iplane]>Qcut){
      PlaneView::PlaneView_t kView = fUVMap[iplane];
      Int_t jplane = iplane;
      if(jplane>249)jplane+=20;
      DeMuxFitData_t hit;
      hit.x = jplane;
      hit.y = weightedStrip[iplane];
      hit.status = true;
      if(kView==PlaneView::kV){
        if(iplane>=lowestUplane-1&&iplane<=highestUplane+1)QHitsV.push_back(hit);
      }
      if(kView==PlaneView::kU){
        if(iplane>=lowestVplane-1&&iplane<=highestVplane+1)QHitsU.push_back(hit);
      }
    }
  }

  fFitHitU  = LinearFit(HitsU, 15.0);
  fFitHitV  = LinearFit(HitsV, 15.0);
  fFitQHitU = LinearFit(QHitsU, 15.0);
  fFitQHitV = LinearFit(QHitsV, 15.0);
  fFitTimeU = LinearFit(TimesU);
  fFitTimeV = LinearFit(TimesV);

  if(fDiagnosticPlots){
    MakeFitPolyLines(fFitQHitU,fUZFitQSSM1,fUZFitQSSM2,2,1);
    MakeFitPolyLines(fFitQHitV,fVZFitQSSM1,fVZFitQSSM2,2,1);
    MakeFitPolyLines(fFitHitU,fUZFitSSM1,fUZFitSSM2);
    MakeFitPolyLines(fFitHitV,fVZFitSSM1,fVZFitSSM2);
    MakeFitPolyLines(fFitTimeU,fUZFitTSM1,fUZFitTSM2,4,2);
    MakeFitPolyLines(fFitTimeV,fVZFitTSM1,fVZFitTSM2,4,2);
  }


  if(fDiagnosticPlots)this->DrawDiagnosticPlots(5);

  MSG("AltDeMux", Msg::kDebug) << "AlgDeMuxBase::FitAsCosmic() chi2 U HitsQ" << fFitQHitU.chi2 << " ndof = " << fFitQHitU.nUsed-2 << endl;
  MSG("AltDeMux", Msg::kDebug) << "AlgDeMuxBase::FitAsCosmic() chi2 V HitsQ" << fFitQHitV.chi2 << " ndof = " << fFitQHitV.nUsed-2 << endl;
  MSG("AltDeMux", Msg::kDebug) << "AlgDeMuxBase::FitAsCosmic() chi2 U Hits " << fFitHitU.chi2 << " ndof = " << fFitHitU.nUsed-2 << endl;
  MSG("AltDeMux", Msg::kDebug) << "AlgDeMuxBase::FitAsCosmic() chi2 V Hits" << fFitHitV.chi2 << " ndof = " << fFitHitV.nUsed-2 << endl;
  MSG("AltDeMux", Msg::kDebug) << "AlgDeMuxBase::FitAsCosmic() c2U  U Time " << fFitTimeU.chi2<< " ndof = " << fFitTimeU.nUsed-2 << endl;
  MSG("AltDeMux", Msg::kDebug) << "AlgDeMuxBase::FitAsComsic() c2V  V Time " << fFitTimeV.chi2<< " ndof = " << fFitTimeV.nUsed-2 << endl;

  
  bool doReMux = false;
  if(fFitQHitU.nUsed>4&&fFitQHitV.nUsed>4){
    if(fFitQHitU.chi2pdf<5.0&&fFitQHitV.chi2pdf<5.0){
      if(fEventType==UNKNOWN){
        MSG("AltDeMux", Msg::kDebug) << "AlgAltDeMuxBase::FitAsCosmic - Event Identified as Single Muon : " << fFitQHitV.nUsed << "," << fFitQHitU.nUsed << ":" << fFitQHitU.chi2 << "," << fFitQHitV.chi2 <<endl; 
        fEventType = SINGLE_MUON;
      }
      if(fEventType==SINGLE_MUON||fEventType==THROUGH_GOING_MUON||fEventType==STRAIGHT_THROUGH_GOING_MUON)doReMux = true;
    }
  }
  if(fDiagnosticPlots)this->DrawDiagnosticPlots(5);

  if(doReMux){
    for(Int_t iplane=0;iplane<MAX_NUMBER_OF_PLANES;iplane++){
      bool carryOn =true;
      for(UInt_t ipair=0; carryOn && ipair<fDeMuxedPairs[iplane].size(); ipair++){
        PlaneView::PlaneView_t kView = fDeMuxedPairs[iplane][0].altListE->GetPlaneView();
        Int_t jplane = iplane;
        if(jplane>249)jplane+=20;
        Int_t istrip = fDeMuxedPairs[iplane][ipair].altListE->GetBestSEId().GetStrip();
        Double_t yFromFit = 0;
        if(kView==PlaneView::kU)yFromFit = fFitQHitU.a0 + fFitQHitU.a1*jplane;
        if(kView==PlaneView::kV)yFromFit = fFitQHitV.a0 + fFitQHitV.a1*jplane;
        Double_t delta = fabs(istrip-yFromFit);
        if(delta>12){
          this->ReMuxPlane(iplane);
          carryOn = false;
        }
      }
      if(carryOn&&useSingles){
        for(UInt_t isingle=0; carryOn && isingle<fDeMuxedSingles[iplane].size(); isingle++){
          PlaneView::PlaneView_t kView = fDeMuxedSingles[iplane][isingle].altList->GetPlaneView();
          Int_t jplane = iplane;
          if(jplane>249)jplane+=20;
          Int_t istrip = fDeMuxedSingles[iplane][isingle].altList->GetBestSEId().GetStrip();
          Double_t yFromFit = 0.;
          if(kView==PlaneView::kU)yFromFit = fFitQHitU.a0 + fFitQHitU.a1*jplane;
          if(kView==PlaneView::kV)yFromFit = fFitQHitV.a0 + fFitQHitV.a1*jplane;
          Double_t delta = fabs(istrip-yFromFit);
          if(delta>12){
            this->ReMuxPlane(iplane);
            carryOn = false;
          }
        }
      }
    }
    if(fDiagnosticPlots)this->DrawDiagnosticPlots(5);
  }
}




void AlgAltDeMuxBase::CleanMultiple()
{


  if(fDiagnosticPlots)DrawDiagnosticPlots(5);

  if(fEventType!=MULTIPLE_MUON){
    return;
  }

  // Deal with the pairs

  for(Int_t iplane=0;iplane<MAX_NUMBER_OF_PLANES;iplane++){
    bool needReMux = false;
    for(UInt_t ipair=0;!needReMux&&ipair<fDeMuxedPairs[iplane].size();ipair++){
      PlaneView::PlaneView_t kView = fDeMuxedPairs[iplane][ipair].altListE->GetPlaneView();
      Int_t istrip = fDeMuxedPairs[iplane][ipair].altListE->GetBestSEId().GetStrip();
      Int_t jplane = iplane;
      if(jplane>249)jplane+=20;
      bool hitIsGood = false;
      if(kView==PlaneView::kU){
        for(UInt_t iline=0; !hitIsGood&&iline<multipleMuonInterceptsU.size();iline++){
          Float_t delta = fabs(fHoughSlopeU*jplane + multipleMuonInterceptsU[iline] -istrip);

          if(delta<13)hitIsGood=true; 
        }
      }
      if(kView==PlaneView::kV){
        for(UInt_t iline=0; !hitIsGood&&iline<multipleMuonInterceptsV.size();iline++){
          Float_t delta = fabs(fHoughSlopeV*jplane + multipleMuonInterceptsV[iline] -istrip);
          if(delta<13)hitIsGood=true; 
        }
      }
      if(!hitIsGood)needReMux=true;
    }
    for(UInt_t isingle=0;isingle<fDeMuxedSingles[iplane].size();isingle++){
      PlaneView::PlaneView_t kView = fDeMuxedSingles[iplane][isingle].altList->GetPlaneView();
      Int_t istrip = fDeMuxedSingles[iplane][isingle].altList->GetBestSEId().GetStrip();
      Int_t jplane = iplane;
      if(jplane>249)jplane+=20;
      bool hitIsGood = false;
      if(kView==PlaneView::kU){
        for(UInt_t iline=0; !hitIsGood&&iline<multipleMuonInterceptsU.size();iline++){
          Float_t delta = fabs(fHoughSlopeU*jplane + multipleMuonInterceptsU[iline] -istrip);

          if(delta<13)hitIsGood=true; 
        }
      }
      if(kView==PlaneView::kV){
        for(UInt_t iline=0; !hitIsGood&&iline<multipleMuonInterceptsV.size();iline++){
          Float_t delta = fabs(fHoughSlopeV*jplane + multipleMuonInterceptsV[iline] -istrip);
          if(delta<13)hitIsGood=true; 
        }
      }
      if(!hitIsGood)needReMux=true;
    }
    if(needReMux)MSG("AltDeMux",Msg::kVerbose) << "AlgAltDeMuxBase::CleanMultiple Will ReMux Plane : " << iplane << endl;
    if(needReMux)ReMuxPlane(iplane);
  }

  if(fDiagnosticPlots)DrawDiagnosticPlots(5);
}



void AlgAltDeMuxBase::Hough()
{
  
  const Int_t MAX_NUMBER_OF_GROUPS=10000; 

  Float_t groupQ[MAX_NUMBER_OF_GROUPS];
  Float_t NU=0;
  Float_t NV=0;
  Float_t xU=0;
  Float_t xV=0;
  Float_t yU=0;
  Float_t yV=0;
  Float_t yUT=0;
  Float_t yVT=0;
  Int_t   icMinU=499;
  Int_t   icMaxU=0;
  Int_t   icMinV=499;
  Int_t   icMaxV=0;
  Float_t HU[400];
  Float_t HV[400];
  Float_t HSU[400][MAX_NUMBER_OF_PLANES];
  Float_t HSV[400][MAX_NUMBER_OF_PLANES];
  for(Int_t i=0; i<MAX_NUMBER_OF_GROUPS;i++)groupQ[i]=0;

  for(Int_t i=0; i<400;i++){
    HU[i] = 0;
    HV[i] = 0;
    for(Int_t j=0; j<MAX_NUMBER_OF_PLANES;j++){
      HSU[i][j] = 0;
      HSV[i][j] = 0;
    }
  }

  MSG("AltDeMux",Msg::kDebug) << "AlgAltDeMuxBase::Hough  performing new Hough transform" << endl;
  for(Int_t iplane=0;iplane<MAX_NUMBER_OF_PLANES;iplane++){
    for(UInt_t ipair=0;ipair<fDeMuxedPairs[iplane].size();ipair++){
      if(fDeMuxedPairs[iplane][ipair].uniqueGroupID>=MAX_NUMBER_OF_GROUPS)MSG("AltDeMux",Msg::kFatal) << "AlgAltDeMuxBase::Hough  uniqueGroupID too large" << endl;
      groupQ[fDeMuxedPairs[iplane][ipair].uniqueGroupID] += fDeMuxedPairs[iplane][ipair].pairQCor;
    }
  }
  for(Int_t iplane=0;iplane<MAX_NUMBER_OF_PLANES;iplane++){
    for(UInt_t ipair=0;ipair<fDeMuxedPairs[iplane].size();ipair++){
      fDeMuxedPairs[iplane][ipair].weightQ =  fDeMuxedPairs[iplane][ipair].pairQCor/groupQ[fDeMuxedPairs[iplane][ipair].uniqueGroupID];
    }
  }

  for(Int_t iplane=0;iplane<MAX_NUMBER_OF_PLANES;iplane++){
    for(UInt_t ipair=0;ipair<fDeMuxedPairs[iplane].size();ipair++){
      PlaneView::PlaneView_t kView = fDeMuxedPairs[iplane][ipair].altListE->GetPlaneView();
      Int_t istrip = fDeMuxedPairs[iplane][ipair].altListE->GetBestSEId().GetStrip();
      if(kView==PlaneView::kU){
        NU  += 1.;
        xU  = iplane-(fHighestDeMuxedPairPlane+fLowestDeMuxedPairPlane)/2.;
        if(iplane>249)xU=xU+20.;
        yU  = istrip-96.;
        yUT = fDeMuxedPairs[iplane][ipair].orthogonalStripFromTiming;
        for(Int_t im=0;im<200;im++){
          Float_t m = (im/100.)-0.995;
          Float_t c = yU-m*xU;
          Int_t ic = 250+static_cast<Int_t>(c); 
          if(fDiagnosticPlots)fHoughU->Fill(m,c,fDeMuxedPairs[iplane][ipair].weightQ);
          if(ic>0&&ic<MAX_NUMBER_OF_PLANES){
            HSU[im+200][ic]+=fDeMuxedPairs[iplane][ipair].weightQ;
          }
          c = xU-m*yU;
          ic = 250+static_cast<Int_t>(c); 
          m = -2.-m;
          if(fDiagnosticPlots)fHoughU->Fill(m,c,fDeMuxedPairs[iplane][ipair].weightQ);
          if(ic>0&&ic<MAX_NUMBER_OF_PLANES){
            HSU[199-im][ic]+=fDeMuxedPairs[iplane][ipair].weightQ;
            if(ic>icMaxU)icMaxU=ic;
            if(ic<icMinU)icMinU=ic;
          }
        }
      }
      
      

      if(kView==PlaneView::kV){
        NV  += 1.;
        xV  = iplane-(fHighestDeMuxedPairPlane+fLowestDeMuxedPairPlane)/2.;
        if(iplane>249)xV=xV+20.;
        yV  = istrip-96.;
        yVT = fDeMuxedPairs[iplane][ipair].orthogonalStripFromTiming;
        for(Int_t im=0;im<200;im++){
          Float_t m = (im/100.)-0.995;
          Float_t c = yV-m*xV;
          Int_t ic = 250+static_cast<Int_t>(c); 
          if(fDiagnosticPlots)fHoughV->Fill(m,c,fDeMuxedPairs[iplane][ipair].weightQ);
          if(ic>0&&ic<MAX_NUMBER_OF_PLANES){
            HSV[im+200][ic]+=fDeMuxedPairs[iplane][ipair].weightQ;
          }
          c = xV-m*yV;
          ic = 250+static_cast<Int_t>(c); 
          m = -2.-m;
          if(fDiagnosticPlots)fHoughV->Fill(m,c,fDeMuxedPairs[iplane][ipair].weightQ);
          if(ic>0&&ic<MAX_NUMBER_OF_PLANES){
          HSV[199-im][ic]+=fDeMuxedPairs[iplane][ipair].weightQ;
          if(ic>icMaxV)icMaxV=ic;
          if(ic<icMinV)icMinV=ic;
          }
        }
      }
    }
  }  
  // 10 ms/event upto here.
  // 11 ms/event with icMaxV...
  if(fDiagnosticPlots){
    fUpad->cd();
    fHoughU->Draw();
    fVpad->cd();
    fHoughV->Draw();
    fCanvas->Update();
  }


  Int_t   imU = 0;
  Int_t   imV = 0;
  Float_t umax=-999.;
  Float_t vmax=-999.;

  for(Int_t i=0; i<400;i++){
    Float_t m = (static_cast<Float_t>(i))/100.0-2.995;
    for(Int_t j=icMinU; j<icMaxU;j++){
      if(HSU[i][j]>0)HU[i] += HSU[i][j]*HSU[i][j];
    }
    for(Int_t j=icMinV; j<icMaxV;j++){
      if(HSV[i][j]>0)HV[i] += HSV[i][j]*HSV[i][j];
    }
    if(fDiagnosticPlots){
      fHoughProjU->Fill(m,HU[i]);
      fHoughProjV->Fill(m,HV[i]);
    }
    if(HU[i]>umax){
      umax=HU[i];
      imU = i;
    }
    if(HV[i]>vmax){
      vmax=HV[i];
      imV = i;
    }
  }
  // 20 ms/event upto here.
  // 15 ms/event with icMax

  // Look at width of peaks in Hough space
  Int_t   imUm=999;
  Int_t   imVm=999;
  Int_t   imUp=0;
  Int_t   imVp=0;

  bool foundU = false;
  bool foundV = false;
  for(Int_t i=0; i<400;i++){
    if(!foundU && HU[i]>umax/2.0){
      imUm = i;
      foundU = true;
    }
    if(!foundV && HV[i]>vmax/2.0){
      imVm = i;
      foundV = true;
    }
  }

  foundU = false;
  foundV = false;
  for(Int_t i=400; i>0;i--){
    if(!foundU && HU[i]>umax/2.0){
      imUp = i;
      foundU = true;
    }
    if(!foundV && HV[i]>vmax/2.0){
      imVp = i;
      foundV = true;
    }
  }

  Float_t houghUwidth = static_cast<Float_t>(imUp-imUm);
  Float_t houghVwidth = static_cast<Float_t>(imVp-imVm);

  fHoughSlopeU = (static_cast<Float_t>(imU))/100.0-2.995;
  if(fHoughSlopeU<-1.)fHoughSlopeU = 1.0/(-2.0-fHoughSlopeU);
  fHoughSlopeV = (static_cast<Float_t>(imV))/100.0-2.995;
  if(fHoughSlopeV<-1.)fHoughSlopeV = 1.0/(-2.0-fHoughSlopeV);

  Int_t nUTracks = 0;
  Int_t nVTracks = 0;


  MSG("AltDeMux",Msg::kDebug) << "AlgAltDeMuxBase::Hough Gradient from U Hough Space : " << fHoughSlopeU << endl;
  MSG("AltDeMux",Msg::kDebug) << "AlgAltDeMuxBase::Hough Gradient from V Hough Space : " << fHoughSlopeV << endl;

  if(fDiagnosticPlots){
    fUpad->cd();
    fHoughProjU->Draw();
    fVpad->cd();
    fHoughProjV->Draw();
    fCanvas->Update();
    for(Int_t i=0; i<MAX_NUMBER_OF_PLANES;i++){
      Float_t c = static_cast<Float_t>(i)-250.;
      fHoughSliceU->Fill(c,HSU[imU][i]);
      fHoughSliceV->Fill(c,HSV[imV][i]);
    }
    fUpad->cd();
    fHoughSliceU->Draw();
    fVpad->cd();
    fHoughSliceV->Draw();
    fCanvas->Update();
  }

  Float_t fTrackCut = 2.5;
  Float_t fHCTrackCut = 6.0;
  Float_t fTrackCutS = 2.5;
  if(houghUwidth>20||houghVwidth>20)fTrackCutS = 3.5;
  if(houghUwidth>20&&houghVwidth>20)fTrackCutS = 4.5;
  if(fEventType==MULTIPLE_MUON)fTrackCut = 1.5;


  multipleMuonInterceptsU.erase(multipleMuonInterceptsU.begin(),multipleMuonInterceptsU.end());
  multipleMuonInterceptsV.erase(multipleMuonInterceptsV.begin(),multipleMuonInterceptsV.end());

  Int_t NUTR = 0;
  Int_t NVTR = 0;

  Int_t NHighConfidenceUTR = 0;
  Int_t NHighConfidenceVTR = 0;

  
  for(Int_t i=1; i<499;i++){
    if( (HSU[imU][i]>HSU[imU][i-1])&&(HSU[imU][i]>=HSU[imU][i+1])){
      if(HSU[imU][i]>fTrackCut){
        // found local maximum - but is it the best in the group
        Float_t maxInGroup = 0.;
        bool found = false; 
        for(Int_t j=i; !found && j<499;j++){
          if(HSU[imU][j]>maxInGroup)maxInGroup=HSU[imU][j];
          if(HSU[imU][j]<0.25)found=true;
        }
        found = false;
        for(Int_t j=i; !found && j>1;j--){
          if(HSU[imU][j]>maxInGroup)maxInGroup=HSU[imU][j];
          if(HSU[imU][j]<0.25)found=true;
        }
        if(HSU[imU][i]>maxInGroup/2.0 && HSU[imU][i]>fTrackCutS){
          NUTR++;
          if(HSU[imU][i]>fHCTrackCut && houghUwidth<10)NHighConfidenceUTR++;
        }
        nUTracks++;
        if(imU>=200){
          Float_t c = 96.0 - 250.0 + i - fHoughSlopeU*(fHighestDeMuxedPairPlane+fLowestDeMuxedPairPlane)/2.;
          if(amWriting)cout << " shallow U intercept : " << i << " -> " << c << endl;
          multipleMuonInterceptsU.push_back(c);
        }
        if(imU<200 ){
          Float_t c = 96. - ((fHighestDeMuxedPairPlane+fLowestDeMuxedPairPlane)/2. +i-250)*fHoughSlopeU;
          if(amWriting)cout << " steep   U intercept : " << i << " -> " << c << endl;
          multipleMuonInterceptsU.push_back(c);
        }
      }
    }
  }

  for(Int_t i=1; i<499;i++){
    if((HSV[imV][i]>HSV[imV][i-1])&&(HSV[imV][i]>=HSV[imV][i+1])){
      if(HSV[imV][i]>fTrackCut){

        Float_t maxInGroup = 0.;
        bool found = false; 
        for(Int_t j=i; !found && j<499;j++){
          if(HSV[imV][j]>maxInGroup)maxInGroup=HSV[imV][j];
          if(HSV[imV][j]<0.25)found=true;
        }
        found = false;
        for(Int_t j=i; !found && j>1;j--){
          if(HSV[imV][j]>maxInGroup)maxInGroup=HSV[imV][j];
          if(HSV[imV][j]<0.25)found=true;
        }


        if(HSV[imV][i]>maxInGroup/2.0 && HSV[imV][i]>fTrackCutS){
          NVTR++;
          if(HSV[imV][i]>fHCTrackCut && houghVwidth<10)NHighConfidenceVTR++;
        }
        nVTracks++;
        if(imV>=200){
          Float_t c = 96.0 - 250.0 + i-fHoughSlopeV*(fHighestDeMuxedPairPlane+fLowestDeMuxedPairPlane)/2.;
          if(amWriting)cout << " shallow V intercept : " << i << " -> " << c << endl;
          multipleMuonInterceptsV.push_back(c);
        }
        if(imV<200 ){
          Float_t c = 96 - ( (fHighestDeMuxedPairPlane+fLowestDeMuxedPairPlane)/2. +i-250)*fHoughSlopeV;
          if(amWriting)cout << " steep   V intercept : " << i << " -> " << c << endl;
          multipleMuonInterceptsV.push_back(c);
        }
      }
    }
  }

  MSG("AltDeMux",Msg::kDebug) << "AlgAltDeMuxBase::Hough Hough multiplicity : " << nUTracks << "," << NUTR << endl; 
  MSG("AltDeMux",Msg::kDebug) << "AlgAltDeMuxBase::Hough Hough multiplicity : " << nUTracks << "," << NVTR << endl; 
  // 15ms/event
  fHoughStatus = true;
  if(fabs(fHoughSlopeU)>50.||fabs(fHoughSlopeV)>50.){
    MSG("AltDeMux", Msg::kWarning) << "AlgAltDeMuxBase::Hough - Gradient too steep  : " << fHoughSlopeU << "," << fHoughSlopeV << endl;
    fHoughStatus = false;
  }

  if(fHoughStatus==true){
    if(nUTracks>=2&&nVTracks>=2 && NUTR>=2&&NVTR>=2){
      // looks like a multiple muon
      // but check to see if it is coming from FNAL
      // before tagging it as such
      float cosfnal=0.;
      float mx = 0.4914*(fHoughSlopeU-fHoughSlopeV);
      float my = 0.4914*(fHoughSlopeU+fHoughSlopeV);
      float mz = 1.0;
      float norm = sqrt(1.0+mx*mx+my*my);
      cosfnal = 0.058*my/norm+0.9983*mz/norm;

      MSG("AltDeMux", Msg::kDebug) << "AlgAltDeMuxBase::Hough - Event Identified as Multiple Muon, multiplicity : " << nUTracks << "," << nVTracks << endl; 
      MSG("AltDeMux", Msg::kDebug) << "AlgAltDeMuxBase::Hough - Event Identified as Multiple Muon, multiplicity : " << NUTR << "," << NVTR << endl; 
      
      if(amWriting){
        cout << " h widths  " << houghUwidth << "," <<  houghVwidth << endl;
        cout << " HC counts " << NHighConfidenceUTR << "," << NHighConfidenceVTR << endl;    
        cout << " cosfnal : " << cosfnal << endl;
      }
      if(cosfnal>0.85){
        MSG("AltDeMux", Msg::kDebug) << "AlgAltDeMuxBase::Hough() - Event Identified as Multiple Muon, BUT coming from FNAL" << endl;
//      cout << " MULTIPLE FROM FNAL " << endl;
        //getchar();
      }else{
        MSG("AltDeMux", Msg::kDebug) << "AlgAltDeMuxBase::Hough - Event Identified as Multiple Muon, multiplicity : " << nUTracks << "," << nVTracks << endl; 
        MSG("AltDeMux", Msg::kDebug) << "AlgAltDeMuxBase::Hough - Event Identified as Multiple Muon, multiplicity : " << NUTR << "," << NVTR << endl; 
        fEventType = MULTIPLE_MUON;
        if(amWriting){
          cout << " **** U ---> " << houghUwidth << endl;
          cout << " **** V ---> " << houghVwidth << endl;
        }
        if(fDiagnosticPlots){
          fUpad->cd();
          fHoughProjU->Draw();
          fVpad->cd();
          fHoughProjV->Draw();
          fCanvas->Update();
        }
      }
    }
  }
  
  return;

}


void AlgAltDeMuxBase::ReBuildXTalkMap(){
  
  for(int i=0; i<MAX_NUMBER_OF_PMTS; i++){
    if(fPMTtot[i]>0){
      for(int j=0; j<16; j++){
        fXTalkmap[i][j]=0.0;
        fPMTmap[i][j]=0.0;
      }
      fPMTtot[i]=0;
    }
  }

  for(Int_t iplane=0;iplane<MAX_NUMBER_OF_PLANES;iplane++){
    for(UInt_t ipair=0;ipair<fDeMuxedPairs[iplane].size();ipair++){
      this->UpdateXTalkMap(fDeMuxedPairs[iplane][ipair].altListE);
      this->UpdateXTalkMap(fDeMuxedPairs[iplane][ipair].altListW);
    }
    for(UInt_t isingle=0;isingle<fDeMuxedSingles[iplane].size();isingle++){
      this->UpdateXTalkMap(fDeMuxedSingles[iplane][isingle].altList);
    }
  }

  return;
}

void AlgAltDeMuxBase::CleanIsolatedHits(){
 
  Int_t easthits;
  Int_t westhits;
  Int_t ilow;
  Int_t ihigh;
  Int_t nlow;
  Int_t nhigh = 0;
  Int_t ilower;
  Int_t ihigher;
  Int_t nlower;
  Int_t nhigher;
  Int_t sl;
  Int_t sh;
  Int_t sll;
  Int_t shh;

  Int_t bestdm;
  vector<int> stripE;
  vector<int> stripW;
  PlexSEIdAltL* stripMapE[MAX_NUMBER_OF_STRIPS];
  PlexSEIdAltL* stripMapW[MAX_NUMBER_OF_STRIPS];

  int increment = 1;
  for(Int_t iplane=0; iplane<MAX_NUMBER_OF_PLANES;iplane+=increment){
    bool found = false;
    for(unsigned int i = 0;!found && i<fDeMuxedSingles[iplane].size();i++){
      for(unsigned int j = i+1;!found && j<fDeMuxedSingles[iplane].size();j++){
        PlexSEIdAltL* paltListi = fDeMuxedSingles[iplane][i].altList;
        PlexSEIdAltL* paltListj = fDeMuxedSingles[iplane][j].altList;
        int si = paltListi->GetBestSEId().GetStrip();
        int sj = paltListj->GetBestSEId().GetStrip();
        if(si==sj){
          if(paltListi->GetEnd()==StripEnd::kEast&&
             paltListj->GetEnd()==StripEnd::kWest){
            found = true;
            this->RemoveSingle(iplane, paltListi);
            this->RemoveSingle(iplane, paltListj);
            this->DeMuxHits(iplane, paltListi, paltListj, si);
          }
          if(paltListi->GetEnd()==StripEnd::kWest&&
             paltListj->GetEnd()==StripEnd::kEast){
            found = true;
            this->RemoveSingle(iplane, paltListi);
            this->RemoveSingle(iplane, paltListj);
            this->DeMuxHits(iplane, paltListj, paltListi, si);
          }
        }
      }
    }
    // loop over plane again if hits removed
    increment = 1;
    if(found)increment=0;
  }
  
  for(Int_t iplane=0; iplane<MAX_NUMBER_OF_PLANES;iplane++){

    easthits = fDeMuxedPlanesAltLists[iplane][ALG_EAST].size();
    //     +fPlanesAltLists[iplane][ALG_EAST].size();
    westhits = fDeMuxedPlanesAltLists[iplane][ALG_WEST].size();
    // +fPlanesAltLists[iplane][ALG_WEST].size();

    if(iplane==248||iplane==250)easthits=0;
    if(iplane==248||iplane==250)westhits=0;


    bool found;
    bool possibleDeMuxError=false;
    set<int>strips;
    Int_t s;

    if(easthits+westhits>0){
      stripE.clear();
      stripW.clear();
      ilow = iplane-2;
      ihigh = iplane+2;
      nlow = 0;
      if(ilow>=0)nlow = fDeMuxedPairs[ilow].size();
      if(ihigh<500)nhigh = fDeMuxedPairs[ihigh].size();

      int ntarget=0;
      float sumtarget=0;
      float sumsqtarget=0;
      for(int alg_ew=ALG_EAST;alg_ew<=ALG_WEST;alg_ew++){
        for(UInt_t iEW=0;iEW<fDeMuxedPlanesAltLists[iplane][alg_ew].size();iEW++){
          s = fDeMuxedPlanesAltLists[iplane][alg_ew][iEW]->GetBestSEId().GetStrip();
          Float_t diff = 999.;
          Float_t diffdm = 999.;
          found = false;
          if(nlow>0&&nhigh>0){
            for(Int_t ilpair=0;!found&&ilpair<nlow;ilpair++){
              sl = fDeMuxedPairs[ilow][ilpair].altListE->GetBestSEId().GetStrip();
              for(Int_t ihpair=0;!found&&ihpair<nhigh;ihpair++){
                sh = fDeMuxedPairs[ihigh][ihpair].altListE->GetBestSEId().GetStrip();
                Float_t target = (sl+sh)/2.0;
                sumtarget+=target;
                sumsqtarget+=target*target;
                ntarget++;
                Float_t delta = fabs(target-s);
                if(delta<diff)diff=delta;
                Float_t deltadm = fmod(delta+23.5,23.5);
                if(deltadm>50)deltadm=0;
                if(diff<5)found = true;
                if(!found&&deltadm<diffdm){
                  fDeMuxedPlanesAltLists[iplane][alg_ew][iEW]->SetFirst();
                  Float_t del=999; 
                  while (fDeMuxedPlanesAltLists[iplane][alg_ew][iEW]->IsValid()){
                    Int_t sc = fDeMuxedPlanesAltLists[iplane][alg_ew][iEW]->GetCurrentSEId().GetStrip();
                    if(fabs(sc-target)<del){
                      if(abs(sc-sl)<5&&abs(sc-sh)<5){
                        diffdm = fabs(sc-target);
                        del    = diffdm;
                        bestdm = sc;
                      }
                    }
                    fDeMuxedPlanesAltLists[iplane][alg_ew][iEW]->Next();
                  }
                }
              }
            }
          }
          if(nlow>0&&nhigh==0){
            ilower = iplane-4;
            nlower = 0;
            if(ilower>=0)nlower = fDeMuxedPairs[ilower].size();
            if(nlower>0){
              for(Int_t ilpair=0;!found&&ilpair<nlow;ilpair++){
                sl = fDeMuxedPairs[ilow][ilpair].altListE->GetBestSEId().GetStrip();
                for(Int_t illpair=0;!found&&illpair<nlower;illpair++){
                  sll = fDeMuxedPairs[ilower][illpair].altListE->GetBestSEId().GetStrip();
                  Float_t target = 2*sl-sll;
                  sumtarget+=target;
                  sumsqtarget+=target*target;
                  ntarget++;
                  Float_t delta = fabs(target-s);
                  if(delta<diff)diff=delta;
                  Float_t deltadm = fmod(delta+23.5,23.5);
                  if(deltadm>50)deltadm=0;
                  if(diff<5)found = true;
                  if(!found&&deltadm<diffdm){
                    fDeMuxedPlanesAltLists[iplane][alg_ew][iEW]->SetFirst();
                    Float_t del=999; 
                    while (fDeMuxedPlanesAltLists[iplane][alg_ew][iEW]->IsValid()){
                      Int_t sc = fDeMuxedPlanesAltLists[iplane][alg_ew][iEW]->GetCurrentSEId().GetStrip();
                      if(fabs(sc-target)<del){
                        if(abs(sc-sl)<4&&abs(sc-sll)<8){
                          diffdm = fabs(sc-target);
                          del    = diffdm;
                          bestdm = sc;
                        }
                      }
                      fDeMuxedPlanesAltLists[iplane][alg_ew][iEW]->Next();
                    }
                  }
                }
              }
            }
          }
          if(nhigh>0&&nlow==0){
            ihigher = iplane+4;
            nhigher = 0;
            if(ihigher<=500)nhigher = fDeMuxedPairs[ihigher].size();
            if(nhigher>0){
              for(Int_t ihpair=0;!found&&ihpair<nhigh;ihpair++){
                sh = fDeMuxedPairs[ihigh][ihpair].altListE->GetBestSEId().GetStrip();
                for(Int_t ihhpair=0;!found&&ihhpair<nhigher;ihhpair++){
                  shh = fDeMuxedPairs[ihigher][ihhpair].altListE->GetBestSEId().GetStrip();
                  Float_t target = 2*sh-shh;
                  sumtarget+=target;
                  sumsqtarget+=target*target;
                  ntarget++;
                  Float_t delta = fabs(target-s);
                  if(delta<diff)diff=delta;
                  Float_t deltadm = fmod(delta+23.5,23.5);
                  if(deltadm>50)deltadm=0;
                  if(diff<5)found = true;
                  if(!found&&deltadm<diffdm){
                    fDeMuxedPlanesAltLists[iplane][alg_ew][iEW]->SetFirst();
                    Float_t del=999; 
                    while (fDeMuxedPlanesAltLists[iplane][alg_ew][iEW]->IsValid()){
                      Int_t sc = fDeMuxedPlanesAltLists[iplane][alg_ew][iEW]->GetCurrentSEId().GetStrip();
                      if(fabs(sc-target)<del){
                        if(abs(sc-shh)<8&&abs(sc-sh)<4){
                          diffdm = fabs(sc-target);
                          del    = diffdm;
                          bestdm = sc;
                        }
                      }
                      fDeMuxedPlanesAltLists[iplane][alg_ew][iEW]->Next();
                    }
                  }
                }
              }
            }
          }
          if(!found&&diffdm<2.25){
            possibleDeMuxError  =true;
            if(alg_ew==ALG_EAST)stripE.push_back(bestdm);
            if(alg_ew==ALG_WEST)stripW.push_back(bestdm);
          }else{
            if(alg_ew==ALG_EAST)stripE.push_back(s);
            if(alg_ew==ALG_WEST)stripW.push_back(s);
          }
        }
      }





      if(possibleDeMuxError){
        for(int i=0;i<MAX_NUMBER_OF_STRIPS;i++){
          stripMapE[i]=NULL;
          stripMapW[i]=NULL;
        }
        for(int i=0;i<easthits;i++){
          stripMapE[stripE[i]] = fDeMuxedPlanesAltLists[iplane][ALG_EAST][i];
        }
        for(int i=0;i<westhits;i++){
          stripMapW[stripW[i]] = fDeMuxedPlanesAltLists[iplane][ALG_WEST][i];
        }
        this->ReMuxPlane(iplane);
        for(int i=0;i<MAX_NUMBER_OF_STRIPS;i++){
          
          if(stripMapW[i]!=NULL&&stripMapE[i]!=NULL){
            this->DeMuxHits(iplane, stripMapE[i], stripMapW[i], i);
          }else{
            if(stripMapE[i]!=NULL)this->DeMuxSingleHitE(iplane, stripMapE[i], i);
            if(stripMapW[i]!=NULL)this->DeMuxSingleHitW(iplane, stripMapW[i], i);
          }
        }
      }
      if(ntarget>0){
        float mean = sumtarget/ntarget;
        int istrip = static_cast<int>(mean+0.5);
        ValidatePlaneAgainstTarget(iplane,istrip);
        //      float rms = sumsqtarget/ntarget-mean*mean;
      }
    }
  }

  return;
}









void AlgAltDeMuxBase::UpdateXTalkMap(PlexSEIdAltL* paltlist){

  PlexPixelSpotId pixelID = (paltlist->GetBestItem()).GetPixelSpotId(); 
  Int_t pixel  = pixelID.GetPixel();
  Int_t PMTmuxID = pixelID.GetTube();
  PMTmuxID      += 3*pixelID.GetInRack();
  PMTmuxID      += 24*pixelID.GetRackBay();
  Char_t level = pixelID.GetRackLevel(); 
  Char_t ew = pixelID.GetEastWest(); 
  if(level=='U')PMTmuxID += 450;
  if(ew =='E')PMTmuxID += 900;
  if(PMTmuxID<MAX_NUMBER_OF_PMTS){
    Float_t q  = paltlist->GetBestItem().GetPE();
    Float_t qc = paltlist->GetBestItem().GetSigCorr()/60.;
    if(qc/q<0.1 || qc/q > 10.0){
      qc=q;
    }
    Int_t pixelSpot = pixelID.GetSpot();
    fPMTmap[PMTmuxID][pixel]+=qc;
    fPMTtot[PMTmuxID]+=qc;
        
    switch(pixel){
    case 0:
      fXTalkmap[PMTmuxID][1] += qc*_pixelSpotXTalkMap[pixelSpot][5]; 
      fXTalkmap[PMTmuxID][4] += qc*_pixelSpotXTalkMap[pixelSpot][7];
      fXTalkmap[PMTmuxID][5] += qc*_pixelSpotXTalkMap[pixelSpot][8];
      break;
    case 1:
      fXTalkmap[PMTmuxID][0] += qc*_pixelSpotXTalkMap[pixelSpot][3]; 
      fXTalkmap[PMTmuxID][2] += qc*_pixelSpotXTalkMap[pixelSpot][5];
      fXTalkmap[PMTmuxID][4] += qc*_pixelSpotXTalkMap[pixelSpot][6];
      fXTalkmap[PMTmuxID][5] += qc*_pixelSpotXTalkMap[pixelSpot][7];
      fXTalkmap[PMTmuxID][6] += qc*_pixelSpotXTalkMap[pixelSpot][8];
      break;
    case 2:
      fXTalkmap[PMTmuxID][1] += qc*_pixelSpotXTalkMap[pixelSpot][3]; 
      fXTalkmap[PMTmuxID][3] += qc*_pixelSpotXTalkMap[pixelSpot][5];
      fXTalkmap[PMTmuxID][5] += qc*_pixelSpotXTalkMap[pixelSpot][6];
      fXTalkmap[PMTmuxID][6] += qc*_pixelSpotXTalkMap[pixelSpot][7];
      fXTalkmap[PMTmuxID][7] += qc*_pixelSpotXTalkMap[pixelSpot][8];
      break;
    case 3:
      fXTalkmap[PMTmuxID][2] += qc*_pixelSpotXTalkMap[pixelSpot][3]; 
      fXTalkmap[PMTmuxID][6] += qc*_pixelSpotXTalkMap[pixelSpot][6];
      fXTalkmap[PMTmuxID][7] += qc*_pixelSpotXTalkMap[pixelSpot][7];
      break;
    case 4:
      fXTalkmap[PMTmuxID][0] += qc*_pixelSpotXTalkMap[pixelSpot][1]; 
      fXTalkmap[PMTmuxID][1] += qc*_pixelSpotXTalkMap[pixelSpot][2];
      fXTalkmap[PMTmuxID][5] += qc*_pixelSpotXTalkMap[pixelSpot][5];
      fXTalkmap[PMTmuxID][8] += qc*_pixelSpotXTalkMap[pixelSpot][7];
      fXTalkmap[PMTmuxID][9] += qc*_pixelSpotXTalkMap[pixelSpot][8];
      break;
    case 5:
      fXTalkmap[PMTmuxID][0] += qc*_pixelSpotXTalkMap[pixelSpot][0]; 
      fXTalkmap[PMTmuxID][1] += qc*_pixelSpotXTalkMap[pixelSpot][1];
      fXTalkmap[PMTmuxID][2] += qc*_pixelSpotXTalkMap[pixelSpot][2];
      fXTalkmap[PMTmuxID][4] += qc*_pixelSpotXTalkMap[pixelSpot][3];
      fXTalkmap[PMTmuxID][6] += qc*_pixelSpotXTalkMap[pixelSpot][5];
      fXTalkmap[PMTmuxID][8] += qc*_pixelSpotXTalkMap[pixelSpot][6];
      fXTalkmap[PMTmuxID][9] += qc*_pixelSpotXTalkMap[pixelSpot][7];
      fXTalkmap[PMTmuxID][10]+= qc*_pixelSpotXTalkMap[pixelSpot][8];
      break;
    case 6:
      fXTalkmap[PMTmuxID][1] += qc*_pixelSpotXTalkMap[pixelSpot][0]; 
      fXTalkmap[PMTmuxID][2] += qc*_pixelSpotXTalkMap[pixelSpot][1];
      fXTalkmap[PMTmuxID][3] += qc*_pixelSpotXTalkMap[pixelSpot][2];
      fXTalkmap[PMTmuxID][5] += qc*_pixelSpotXTalkMap[pixelSpot][3];
      fXTalkmap[PMTmuxID][7] += qc*_pixelSpotXTalkMap[pixelSpot][5];
      fXTalkmap[PMTmuxID][9] += qc*_pixelSpotXTalkMap[pixelSpot][6];
      fXTalkmap[PMTmuxID][10]+= qc*_pixelSpotXTalkMap[pixelSpot][7];
      fXTalkmap[PMTmuxID][11]+= qc*_pixelSpotXTalkMap[pixelSpot][8];
      break;
    case 7:
      fXTalkmap[PMTmuxID][2] += qc*_pixelSpotXTalkMap[pixelSpot][0]; 
      fXTalkmap[PMTmuxID][3] += qc*_pixelSpotXTalkMap[pixelSpot][1];
      fXTalkmap[PMTmuxID][6] += qc*_pixelSpotXTalkMap[pixelSpot][3];
      fXTalkmap[PMTmuxID][10]+= qc*_pixelSpotXTalkMap[pixelSpot][6];
      fXTalkmap[PMTmuxID][11]+= qc*_pixelSpotXTalkMap[pixelSpot][7];
      break;
    case 8:
      fXTalkmap[PMTmuxID][4]  += qc*_pixelSpotXTalkMap[pixelSpot][1]; 
      fXTalkmap[PMTmuxID][5]  += qc*_pixelSpotXTalkMap[pixelSpot][2];
      fXTalkmap[PMTmuxID][9]  += qc*_pixelSpotXTalkMap[pixelSpot][5];
      fXTalkmap[PMTmuxID][12] += qc*_pixelSpotXTalkMap[pixelSpot][7];
      fXTalkmap[PMTmuxID][13] += qc*_pixelSpotXTalkMap[pixelSpot][8];
      break;
    case 9:
      fXTalkmap[PMTmuxID][4] += qc*_pixelSpotXTalkMap[pixelSpot][0]; 
      fXTalkmap[PMTmuxID][5] += qc*_pixelSpotXTalkMap[pixelSpot][1];
      fXTalkmap[PMTmuxID][6] += qc*_pixelSpotXTalkMap[pixelSpot][2];
      fXTalkmap[PMTmuxID][8] += qc*_pixelSpotXTalkMap[pixelSpot][3];
      fXTalkmap[PMTmuxID][10]+= qc*_pixelSpotXTalkMap[pixelSpot][5];
      fXTalkmap[PMTmuxID][12]+= qc*_pixelSpotXTalkMap[pixelSpot][6];
      fXTalkmap[PMTmuxID][13]+= qc*_pixelSpotXTalkMap[pixelSpot][7];
      fXTalkmap[PMTmuxID][14]+= qc*_pixelSpotXTalkMap[pixelSpot][8];
      break;
    case 10:
      fXTalkmap[PMTmuxID][5] += qc*_pixelSpotXTalkMap[pixelSpot][0]; 
      fXTalkmap[PMTmuxID][6] += qc*_pixelSpotXTalkMap[pixelSpot][1];
      fXTalkmap[PMTmuxID][7] += qc*_pixelSpotXTalkMap[pixelSpot][2];
      fXTalkmap[PMTmuxID][9] += qc*_pixelSpotXTalkMap[pixelSpot][3];
      fXTalkmap[PMTmuxID][11]+= qc*_pixelSpotXTalkMap[pixelSpot][5];
      fXTalkmap[PMTmuxID][13]+= qc*_pixelSpotXTalkMap[pixelSpot][6];
      fXTalkmap[PMTmuxID][14]+= qc*_pixelSpotXTalkMap[pixelSpot][7];
      fXTalkmap[PMTmuxID][15]+= qc*_pixelSpotXTalkMap[pixelSpot][8];
      break;
    case 11:
      fXTalkmap[PMTmuxID][6] += qc*_pixelSpotXTalkMap[pixelSpot][0]; 
      fXTalkmap[PMTmuxID][7] += qc*_pixelSpotXTalkMap[pixelSpot][1];
      fXTalkmap[PMTmuxID][10]+= qc*_pixelSpotXTalkMap[pixelSpot][3];
      fXTalkmap[PMTmuxID][14]+= qc*_pixelSpotXTalkMap[pixelSpot][6];
      fXTalkmap[PMTmuxID][15]+= qc*_pixelSpotXTalkMap[pixelSpot][7];
      break;
    case 12:
      fXTalkmap[PMTmuxID][8] += qc*_pixelSpotXTalkMap[pixelSpot][1]; 
      fXTalkmap[PMTmuxID][9] += qc*_pixelSpotXTalkMap[pixelSpot][2];
      fXTalkmap[PMTmuxID][13]+= qc*_pixelSpotXTalkMap[pixelSpot][5];
      break;
    case 13:
      fXTalkmap[PMTmuxID][8] += qc*_pixelSpotXTalkMap[pixelSpot][0]; 
      fXTalkmap[PMTmuxID][9] += qc*_pixelSpotXTalkMap[pixelSpot][1];
      fXTalkmap[PMTmuxID][10]+= qc*_pixelSpotXTalkMap[pixelSpot][2];
      fXTalkmap[PMTmuxID][12]+= qc*_pixelSpotXTalkMap[pixelSpot][3];
      fXTalkmap[PMTmuxID][14]+= qc*_pixelSpotXTalkMap[pixelSpot][5];
      break;
    case 14:
      fXTalkmap[PMTmuxID][9] += qc*_pixelSpotXTalkMap[pixelSpot][0]; 
      fXTalkmap[PMTmuxID][10]+= qc*_pixelSpotXTalkMap[pixelSpot][1];
      fXTalkmap[PMTmuxID][11]+= qc*_pixelSpotXTalkMap[pixelSpot][2];
      fXTalkmap[PMTmuxID][13]+= qc*_pixelSpotXTalkMap[pixelSpot][3];
      fXTalkmap[PMTmuxID][15]+= qc*_pixelSpotXTalkMap[pixelSpot][5];
      break;
    case 15:
      fXTalkmap[PMTmuxID][10]+= qc*_pixelSpotXTalkMap[pixelSpot][0]; 
      fXTalkmap[PMTmuxID][11]+= qc*_pixelSpotXTalkMap[pixelSpot][1];
      fXTalkmap[PMTmuxID][14]+= qc*_pixelSpotXTalkMap[pixelSpot][3];
      break;
    default:
      break;
    }
  }else{
    MSG("AltDeMux", Msg::kError) << "AlgAltDeMuxBase::UpdateXTalkMap => PMT out of array bounds : " << PMTmuxID << " ignoring it !" << endl;
  }
}


void AlgAltDeMuxBase::ReMakeMask()
{
  
  // if diagnostic/debug
  if(fDiagnosticPlots){
    if ( fUTime ) { delete fUTime; fUTime=0; }
    if ( fVTime ) { delete fVTime; fVTime=0; }
    fUTime = new TH2F("UTime","U time view",501,-0.5,500.5,193,0.,193.);
    fVTime = new TH2F("VTime","V time view",501,-0.5,500.5,193,0.,193.);
    fUTime->SetStats(kFALSE);
    fVTime->SetStats(kFALSE);
  }
  
  // Use a 2.5 sigma timing window
  fTimingMaskWindow     = static_cast<Int_t>(fSigmasForTimingWindow*fSigmaStripFromTiming);

  for(Int_t iplane=0;iplane<MAX_NUMBER_OF_PLANES;iplane++){
    if(fDeMuxedPlanesAltLists[iplane][ALG_EAST].size()>0||fDeMuxedPlanesAltLists[iplane][ALG_WEST].size()>0){
      fMaskGroup[iplane].erase(fMaskGroup[iplane].begin(),fMaskGroup[iplane].end());
      fInMask[iplane] =  0;
      // Reset timing mask strip targets and target groups for this palne 
      for(Int_t istrip=0;istrip<MAX_NUMBER_OF_STRIPS;istrip++){
        fTimingMask[iplane][istrip] = false;
      }
    }else{
      if(fDiagnosticPlots){
        for(Int_t isaim = 0;isaim <MAX_NUMBER_OF_STRIPS; isaim++){
          if(fTimingMask[iplane][isaim]){
            if(fUVMap[iplane]==PlaneView::kV)fUTime->Fill(iplane,isaim,1.);
            if(fUVMap[iplane]==PlaneView::kU)fVTime->Fill(iplane,isaim,1.);
          }
        }
      }
    }
  }

  PlaneView::PlaneView_t kView;
  for(Int_t iplane=0;iplane<MAX_NUMBER_OF_PLANES;iplane++){
    for(unsigned int ipair=0;ipair<fDeMuxedPairs[iplane].size();ipair++){
      kView = fDeMuxedPairs[iplane][ipair].altListE->GetPlaneView();
      Int_t isaim = fDeMuxedPairs[iplane][ipair].orthogonalStripFromTiming;
      if(fDiagnosticPlots){
        if(kView==PlaneView::kV)fUTime->Fill(iplane,isaim,1.);
        if(kView==PlaneView::kU)fVTime->Fill(iplane,isaim,1.);
      }
      if(kView==PlaneView::kV){
        fInMask[iplane]++;
        fTimingMask[iplane][isaim] = true;
      }     
      if(kView==PlaneView::kU){
        fInMask[iplane]++;
        fTimingMask[iplane][isaim] = true;
      }
    }
  }
  this->MakeMaskGroups();

  for(int iplane=0;iplane<MAX_NUMBER_OF_PLANES;iplane++){
    if(fPlanesAltLists[iplane][ALG_EAST].size()>0||
       fPlanesAltLists[iplane][ALG_WEST].size()>0||
       fDeMuxedPlanesAltLists[iplane][ALG_EAST].size()>0||
       fDeMuxedPlanesAltLists[iplane][ALG_WEST].size()>0){
      bool found = false;
      if(iplane==0){
        int ip = 1;
        int ipp = 3; 
        found = found || MaskExtrapolateBack(iplane,ip,ipp);
      }else{
        // For planes with hits : check surrounding planes
        int im=iplane-1;
        int ip=iplane+1;
        found = found || MaskInterpolate(iplane,im,ip);
        if(!found){
          int imm = iplane-3;
          int ipp = iplane+3;
          if(imm>=0)found = found || MaskInterpolate(iplane,imm,ip);
          if(ipp<MAX_NUMBER_OF_PLANES-1)found = found || MaskInterpolate(iplane,im,ipp);
          if(!found){
            if(imm>=0)found = found || MaskExtrapolateForwards(iplane,imm,im);
            if(ipp<MAX_NUMBER_OF_PLANES-1)found = found || MaskExtrapolateBack(iplane,ip,ipp);
          }
        }
      }
      if(!found)for(int istrip=0;istrip<fNumberOfStrips;istrip++)this->SetMask(iplane,istrip);
    }
  }
  
  if(fDiagnosticPlots)this->DrawDiagnosticPlots(-2);
  if(fDiagnosticPlots)this->DrawDiagnosticPlots(5);
  
  return;
  
} 

void AlgAltDeMuxBase::MakeFitPolyLines(DeMuxFitResult_t result, TPolyLine* &pPolyLine1, 
TPolyLine* &pPolyLine2, Int_t color, Int_t style){
  
  Float_t xp[2];
  Float_t yp[2];

  if(result.status){
    xp[0] = 0;
    xp[1] = 249.;
    yp[0] = result.a0;
    yp[1] = result.a1*249.+result.a0;
    if(pPolyLine1)delete pPolyLine1;
    pPolyLine1 = new TPolyLine(2,xp,yp);
    pPolyLine1->SetLineColor(color);
    pPolyLine1->SetLineStyle(style);
    pPolyLine1->SetLineWidth(2);
    xp[0] = 249;
    xp[1] = 500.;
    yp[0] = result.a1*269.+result.a0;
    yp[1] = result.a1*520.+result.a0;
    if(pPolyLine2)delete pPolyLine2;
    pPolyLine2 = new TPolyLine(2,xp,yp);
    pPolyLine2->SetLineColor(color);
    pPolyLine2->SetLineStyle(style);
    pPolyLine2->SetLineWidth(2);
  }

  return;

}




DeMuxEventType_t AlgAltDeMuxBase::EventID() 
{  
  Float_t d;
  Int_t iedge;
  Float_t QFiducial[12];
  Float_t QPlane[MAX_NUMBER_OF_PLANES];
  Float_t QSPlane[MAX_NUMBER_OF_PLANES];
  Float_t U;
  Float_t V;
  Float_t x;
  Float_t y;
  Float_t Qhighest = 0.;


  for(Int_t i=0;i<12;i++)QFiducial[i]=0.0;

  for(Int_t i=0;i<MAX_NUMBER_OF_PLANES;i++){
    QPlane[i]=0.0;
    QSPlane[i]=0.0;
  }

  for(Int_t iplane=0;iplane<MAX_NUMBER_OF_PLANES;iplane++){
    for(Int_t i=0;i<NdemuxedHitsU[iplane];i++){
      QPlane[iplane] += demuxedHitQU[iplane][i];
      QSPlane[iplane] += demuxedHitQU[iplane][i]*demuxedHitStripU[iplane][i];
    }
    for(Int_t i=0;i<NdemuxedHitsV[iplane];i++){
      QPlane[iplane] += demuxedHitQV[iplane][i];
      QSPlane[iplane] += demuxedHitQV[iplane][i]*demuxedHitStripV[iplane][i];
    }
  }

  Float_t dmin = 999.0;
  Float_t ymax = -999.0;
  Int_t nearestPlane = -1;
  Int_t highestPlane = -1;
  for(Int_t iplane=0;iplane<MAX_NUMBER_OF_PLANES;iplane++){
    for(Int_t i=0;i<NdemuxedHitsU[iplane];i++){
      Int_t iU = iplane;
      U = demuxedHitStripU[iplane][i];
      bool ok =false;
      if(iU>0&&iU<MAX_NUMBER_OF_PLANES-1){
        if(QPlane[iU-1]>0 && QPlane[iU+1]>0){
          Float_t sm = QSPlane[iU-1]/QPlane[iU-1];
          Float_t sp = QSPlane[iU+1]/QPlane[iU+1];
          V = (sm+sp)/2.0;
          ok = true;
        }
      }
      if(!ok&&iU>3){
        if(QPlane[iU-3]>0 && QPlane[iU-1]>0){
          Float_t smm = QSPlane[iU-3]/QPlane[iU-3];
          Float_t sm  = QSPlane[iU-1]/QPlane[iU-1];
          V = (3*sm-smm)/2.0;
          ok = true;
        }
      }
      if(!ok&&iU<MAX_NUMBER_OF_PLANES-3){
        if(QPlane[iU+3]>0 && QPlane[iU+1]>0){
          Float_t spp = QSPlane[iU+3]/QPlane[iU+3];
          Float_t sp  = QSPlane[iU+1]/QPlane[iU+1];
          V = (3*sp-spp)/2.0;
          ok = true;
        }
      }
      if(ok){
        x = ((U-V)*0.0417)/1.4142;
        y = ((U+V)*0.0417-8.0)/1.4142;
        pCalculator->FindNearestEdge(x,y,iedge,d);
        if(iplane<4)iedge=0;
        if(iplane>244&&iplane<249)iedge=9;
        if(iplane>249&&iplane<254)iedge=10;
        if(iplane>481)iedge=11;
        if(d<0.5||iedge==0||iedge>=9)QFiducial[iedge]+=demuxedHitQU[iplane][i];
        if(d<dmin){
          dmin = d;
          nearestPlane = iplane;
        }
        if(y>ymax){
          ymax = y;
          highestPlane = iplane;
          Qhighest = 0.;
          if(d<0.5||iedge==0||iedge>=9)Qhighest = demuxedHitQU[iplane][i];
        }
      }
    }
    for(Int_t i=0;i<NdemuxedHitsV[iplane];i++){
      Int_t iV = iplane;
      V = demuxedHitStripV[iplane][i];
      bool ok =false;
      if(iV>0&&iV<MAX_NUMBER_OF_PLANES-1){
        if(QPlane[iV-1]>0 && QPlane[iV+1]>0){
          Float_t sm = QSPlane[iV-1]/QPlane[iV-1];
          Float_t sp = QSPlane[iV+1]/QPlane[iV+1];
          U = (sm+sp)/2.0;
          ok = true;
        }
      }
      if(!ok&&iV>3){
        if(QPlane[iV-3]>0 && QPlane[iV-1]>0){
          Float_t smm = QSPlane[iV-3]/QPlane[iV-3];
          Float_t sm  = QSPlane[iV-1]/QPlane[iV-1];
          U = (3*sm-smm)/2.0;
          ok = true;
        }
      }
      if(!ok&&iV<MAX_NUMBER_OF_PLANES-3){
        if(QPlane[iV+3]>0 && QPlane[iV+1]>0){
          Float_t spp = QSPlane[iV+3]/QPlane[iV+3];
          Float_t sp  = QSPlane[iV+1]/QPlane[iV+1];
          U = (3*sp-spp)/2.0;
          ok = true;
        }
      }
      if(ok){
        x = ((U-V)*0.0417)/1.4142;
        y = ((U+V)*0.0417-8.0)/1.4142;
        pCalculator->FindNearestEdge(x,y,iedge,d);
        if(iplane<4)iedge=0;
        if(iplane>244&&iplane<249)iedge=9;
        if(iplane>249&&iplane<254)iedge=10;
        if(iplane>481)iedge=11;
        if(d<0.5||iedge==0||iedge>=9)QFiducial[iedge]+=demuxedHitQV[iplane][i]; 
        if(d<dmin){
          dmin = d;
          nearestPlane = iplane;
        }
        if(y>ymax){
          ymax = y;
          highestPlane = iplane;
          Qhighest = 0.;
          if(d<0.5||iedge==0||iedge>=9)Qhighest = demuxedHitQV[iplane][i]; 
        }
      }
    }
  }


  Int_t icount=0;
  for(int i=0;i<12;i++){
    if(amWriting)cout << " Edge " << i << " : " << QFiducial[i] << endl; 
    if(QFiducial[i]>2.0)icount++;
  }
  DeMuxEventType_t eventType = fEventType;
  if(fEventType!=MULTIPLE_MUON){
    if(icount==0)eventType =  CONTAINED_EVENT;
    if(icount==1){
      eventType = STOPPING_MUON;
      if(Qhighest<0.01)eventType = PARTIALLY_CONTAINED_EVENT;
    }
    if(icount>=2){
      if(fEventType==SINGLE_MUON||fEventType==STRAIGHT_THROUGH_GOING_MUON){
        eventType = STRAIGHT_THROUGH_GOING_MUON;
      }else{
        eventType = THROUGH_GOING_MUON;
      }
    }
  }

  
  if(eventType==CONTAINED_EVENT || eventType==PARTIALLY_CONTAINED_EVENT){
    fCCNearestPlane=nearestPlane;
    fCCHighestPlane=highestPlane;
  }

  return eventType;
}



DeMuxFitResult_t AlgAltDeMuxBase::LinearFit(vector<DeMuxFitData_t>& data, Float_t refitDistance){

  Double_t N=0.0;
  Double_t sumX=0.0;
  Double_t sumY=0.0;
  Double_t sumXY=0.0;
  Double_t sumXX=0.0;
  Double_t sumYY=0.0;
  Double_t det;
  DeMuxFitResult_t result;
  result.status = false;
  result.a0 = 0.;
  result.a1 = 0.;
  result.a2 = 0.;
  result.a3 = 0.;
  result.a4 = 0.;
  result.chi2    = 999999.;
  result.chi2pdf = 999999.;
  result.nUsed = 0;
  result.nData = 0;

  for(UInt_t i=0; i<data.size(); i++){
    N += 1.; 
    sumX += data[i].x;
    sumY += data[i].y;
    sumXX += data[i].x*data[i].x;
    sumXY += data[i].x*data[i].y;
    sumYY += data[i].y*data[i].y;
  }
  
  det = sumXX*N-sumX*sumX;
  if(det>0){
    result.status = true;
    result.a0     = (-sumX*sumXY + sumXX*sumY)/det;
    result.a1     = (N*sumXY - sumX*sumY)/det;
    if(refitDistance>0){
      for(UInt_t i=0; i<data.size(); i++){
        Double_t yFromFit = result.a0 + result.a1*data[i].x;
        Double_t delta = fabs(data[i].y-yFromFit);
        if(delta>refitDistance){
          data[i].status = false;
          N -= 1.; 
          sumX  -= data[i].x;
          sumY  -= data[i].y;
          sumXX -= data[i].x*data[i].x;
          sumXY -= data[i].x*data[i].y;
          sumYY -= data[i].y*data[i].y;
        }
      }
    } 
  }

  Double_t chi2=0.;
  det = sumXX*N-sumX*sumX;
  result.status = false;
  result.a0     = 0.;
  result.a1     = 0.;
  
  if(det>0){
    result.status = true;
    result.a0     = (-sumX*sumXY + sumXX*sumY)/det;
    result.a1     = (N*sumXY - sumX*sumY)/det;
    for(UInt_t i=0; i<data.size(); i++){
      if(data[i].status){
        Double_t yFromFit = result.a0 + result.a1*data[i].x;
        Double_t delta = (data[i].y-yFromFit);
        chi2+=delta*delta;
      }
    }
    result.nUsed = static_cast<Int_t>(N);
    result.nData = data.size();
    result.chi2  = chi2;
    if(result.nUsed>2)result.chi2pdf  = chi2/(result.nUsed-2);
  }

  return result;
}


void AlgAltDeMuxBase::SearchAndDestroy(){
  
  Float_t Qtotal[MAX_NUMBER_OF_PLANES];
  Float_t Qpairs[MAX_NUMBER_OF_PLANES];
  
  if(fEventType==MULTIPLE_MUON)return;
  
  for(Int_t iplane=0;iplane<MAX_NUMBER_OF_PLANES;iplane++){
    Qtotal[iplane] = 0.;
    Qpairs[iplane] = 0.;
    
    for(UInt_t ipair=0;ipair<fDeMuxedPairs[iplane].size();ipair++){
      Qtotal[iplane]  += fDeMuxedPairs[iplane][ipair].pairQCor;      
      Qpairs[iplane] += fDeMuxedPairs[iplane][ipair].pairQCor;      
    }
  
    for(UInt_t isingle=0;isingle<fDeMuxedSingles[iplane].size();isingle++){
      Qtotal[iplane]  += fDeMuxedSingles[iplane][isingle].Qcor;      
    }
    if(Qtotal[iplane]>0){
      if(amWriting)cout << "Fraction " << iplane << " : " << Qpairs[iplane] << "," <<  
        Qtotal[iplane] << "-->" << Qpairs[iplane]/Qtotal[iplane] << endl;
      if(Qpairs[iplane]/Qtotal[iplane]<10.0){ 
        if(amWriting)cout << "ValidatePlane : " << iplane << endl;
        bool useTimeMask = false;
        this->ValidatePlane(iplane,useTimeMask);
      }
    }
  }

  return;

}

bool AlgAltDeMuxBase::BestGuessForView(PlaneView::PlaneView_t kView){

  for(Int_t iplane=0;iplane<MAX_NUMBER_OF_PLANES;iplane++){
    if(fUVMap[iplane]==kView){
      if(fPlanesAltLists[iplane][ALG_EAST].size()>0&&fPlanesAltLists[iplane][ALG_WEST].size()>0){
        this->BestGuessForPlane(iplane, false);
      }
    }
  }
  return true;
}

---