#include "mMuoRecoModule.h"
#include <iostream>
#include "PHNode.h"
#include "PHCompositeNode.h"
#include "PHIODataNode.h"
#include "PHNodeIterator.h"
#include "mfm_setfscale.h"
#include "mfm_getfscale.h"
#include <dMuiDCMGhitRelWrapper.h>
#include <dMuiReadoutControlWrapper.h>
#include <dMuiClusterControlWrapper.h>
#include <dMuiMuonIdProfileParWrapper.h>
#include <dMuiRoadControlWrapper.h>
#include <dMuiClusterControlWrapper.h>
#include <dMuiMuonIdProfileParWrapper.h>
#include <dMuiPseudoTriggerOutv1.h>
#include <dMuoFindTracksParWrapper.h>
#include <dMutGlobalParWrapper.h>
#include <dMutHistosWrapper.h>
#include <mumdigiparWrapper.h>
#include <mMutCathodePulseParams.hh>
#include <dMfmParWrapper.h>
#include <mumgeoWrapper.h>
#include <mumhitsWrapper.h>
#include <munhitsWrapper.h>
#include <dMutAnodesDCMWrapper.h>
#include <dMutAnodesDCMMCWrapper.h>
#include <dMutAnodesFEMWrapper.h>
#include <dMutAnodesFEMMCWrapper.h>
#include <dMutCathodeChargeWrapper.h>
#include <dMutCathodesDCMWrapper.h>
#include <dMutCathodesDCMMCWrapper.h>
#include <dMutCathodesFEMWrapper.h>
#include <dMutCathodesFEMMCWrapper.h>
#include <dMutClusterGhitRelWrapper.h>
#include <dMutCSCGeomWrapper.h>
#include <dMutRawAnGhitRelWrapper.h>
#include <dMuiRoadFkinRelWrapper.h>
#include <dMuoTrackRoadRelWrapper.h>
#include <dMuiRoadRawRelWrapper.h>
#include <RunHeader.h>
#include <Event.h>
#include <dMuoTracksWrapper.h>
#include <dMuiRoadsWrapper.h>
#include <dMuiClustersWrapper.h>
#include <dMuiClusterRawRelWrapper.h>
#include <dMutCalibCathodesOut.h>
#include <dMutCalibCathodesWrapper.h>
#include <dMutCathodeClustersWrapper.h>
#include <RunToTimeObjy.hh>

mMuoRecoModule::mMuoRecoModule()
:ppFlag(0), embeddingFlag(0), evaluationFlag(0),
simulationFlag(0), mapFileFlag(2), init_done(0),
runNumber(0),
startTime(),
mMuiDCMUnpack(),
mMuiClusterFinder(),
mMuiFillRoadRawRel(),
mMuiReadTubeEff(),
mMuiRoadFind(),
mMuiRoadFind2(),
mMuiHistoBase(),
mMuiInit(),
mMuiEnd(),
mMuiMuonId(),
 mMuiPseudoTrig(),
 mMuiDSTMixer(),
 mMfmMT(),

 mMutdbInitM(),
 mMutRootInit(),
 mumUser(),
 mMutZeroSuptoRawDataM(),
 mMutApplyCalibM(),
 mMutFindCathodeClustsTM(),
 mMutFitCathodeClustsT(),
 mMuoFindTracksM(),
 mMuoFillDataMineVars(),
 mMutEnd(),
 mMutCloseRootFile(),

// Evaluation
 mMuiFillRawFkinRel(),
 mMuiFillClusterFkinRel(),
 mMuiFillRoadFkinRel(),
 mMuiEvaluator(),
 mMutFillRawCathGhitRel(),
 mMutFillClusterGhitRel(),
 mMutCathFitEvaluator()

{
}

mMuoRecoModule::~mMuoRecoModule()
{
}

// Reconstruct this event
PHBoolean mMuoRecoModule::event(PHCompositeNode *topNode)
{
  //
  return 0;
}

PHBoolean mMuoRecoModule::response_first_event(PHCompositeNode *topNode)
{
  init_common(topNode);
  return 0;
}

// Setup up parameters appropriate for this reconstruction process.
PHBoolean mMuoRecoModule::first_event(PHCompositeNode *topNode)
{
  _findRunNumberAndTime(topNode);
  init_mupar(topNode);
  init_common(topNode);

  return 0;
}

PHBoolean mMuoRecoModule::setRunNumber(int newRunNumber)
{
  // Use time stamp consistent with the run database.
  runNumber = newRunNumber;
  RunToTimeObjy runTime;
  PHTimeStamp* beginTime = runTime.getBeginTime(abs(runNumber));
  if(beginTime == NULL)
  {
    cout<<PHWHERE<<"Run not found in the database.  Assume simulation."<<endl;
    setSimulationFlag();
  }else
  {
    startTime = *(beginTime);
  }
  
  return 0;
}

PHBoolean mMuoRecoModule::setSimulationFlag(int flag = 1)
{
  simulationFlag = flag;

  if(simulationFlag == 1)
  {
    PHTimeStamp simTimeStamp(2001, 5, 4, 0, 0, 0);
    startTime = simTimeStamp;
  }
  return 0;
}

PHBoolean mMuoRecoModule::init_mupar(PHCompositeNode* topNode)
{
  if(init_done > 0)
  {
    cout<< PHWHERE << "Mupar.root already read."<<endl;
    return 0;
  }
  PHNodeIterator mainIter(topNode);
  PHBoolean IsFile;

  // Find PAR node
  PHCompositeNode* parNode = static_cast<PHCompositeNode*>
    (mainIter.findFirst("PHCompositeNode", "PAR"));

  // Read in par file used in response chain if we are doing reconstruction:
  PHNodeIOManager * parIn = new PHNodeIOManager();
  IsFile = parIn->setFile("mupar.root","",PHReadOnly);
  if (!IsFile) {
    cout << "EXIT : File mupar.root does not exist" << endl;
  }
  parIn->read(parNode);

  return 0;
}

PHBoolean mMuoRecoModule::_findRunNumberAndTime(PHCompositeNode* topNode)
{
  // Lets find the EventHeader
  PHIODataNode<RunHeader>::iterator iRunHeader(topNode);
  PHNodeIterator mainIter(topNode);

  if(iRunHeader.find("RunHeader")==0)
  {
    cout<<"Run Header not found.! Try PRDF."<< endl;
    //Lets try the prdf
    // Find the node with the Event object; it is called "PRDF".
    PHDataNode<Event>* prdfNode = static_cast<PHDataNode<Event>*>(mainIter.findFirst("PHDataNode", "PRDF"));
    if (!prdfNode) {
      cout<< PHWHERE << "No Run Header and no PRDF node. What is the input file?\n";
      return 0;
    }else
    {
      Event* pEvent = prdfNode->getData();
      if (!pEvent) {
        cout<<"Event data not found on prdf node.\n";
      }else{
        setRunNumber(pEvent->getRunNumber());
      }
      
    }
  }else
  {
    setRunNumber((*iRunHeader).get_RunNumber());
  }

  if(runNumber <=0)
  {
    cout<<PHWHERE<< "Assuming simulation for RunNumber " << runNumber <<endl;
  }
  return 0;
}

PHBoolean mMuoRecoModule::init_common(PHCompositeNode* topNode)
{
  if(init_done > 0)
  {
    cout<< PHWHERE << "Initialization already performed."<<endl;
    return 0;
  }
  cout << "Performing Muon Reconstruction Initialization.\n";
  
  PHNodeIterator* mainIter = new PHNodeIterator(topNode);
  // Find MUI node
  PHCompositeNode* muiNode = static_cast<PHCompositeNode*>
    (mainIter->findFirst("PHCompositeNode", "MUI"));
  if(muiNode == 0)
  {
    muiNode = new PHCompositeNode("MUI");
    topNode->addNode(muiNode);
  }
  // Find PAR node
  PHCompositeNode* mutNode = static_cast<PHCompositeNode*>
    (mainIter->findFirst("PHCompositeNode", "MUT"));
  if(mutNode == 0)
  {
    mutNode = new PHCompositeNode("MUT");
    topNode->addNode(mutNode);
  }
  PHBoolean IsFile;
  int msgnum = 0;
  size_t mr;
  PHIODataNode<TObject>* dn;
  
  // Find PAR node
  PHCompositeNode* parNode = static_cast<PHCompositeNode*>
    (mainIter->findFirst("PHCompositeNode", "PAR"));

  // Find DCM node
  PHCompositeNode* dcmNode = static_cast<PHCompositeNode*>
    (mainIter->findFirst("PHCompositeNode", "DCM"));
  if(dcmNode == 0)
  {
    dcmNode = new PHCompositeNode("DCM");
    topNode->addNode(dcmNode);
  }
  
  // Find DST node
  PHCompositeNode* dstNode = static_cast<PHCompositeNode*>
    (mainIter->findFirst("PHCompositeNode","DST"));
  
  // EVAL
  if (evaluationFlag > 0) {

    // Open the geant evaluation file in an elegant way
    //    ioEval = new PHNodeIOManager("rawrel.root",PHReadOnly);
    ioEval = new PHNodeIOManager();
    IsFile = ioEval->setFile("rawrel.root","",PHReadOnly);
    if (!IsFile) {
      cout << "EXIT : File rawrel.root needed for Evaluation does not exist" << endl;
    }
    // find geaNode
    PHCompositeNode* geaNode = static_cast<PHCompositeNode*>
      (mainIter->findFirst("PHCompositeNode","GEA"));
    // Create GEA hits table
    mumhitsWrapper* mumhits = new mumhitsWrapper;
    dn = new PHIODataNode<TObject>(mumhits,"mumhits");
    geaNode->addNode(dn);
    munhitsWrapper* munhits = new munhitsWrapper;
    dn = new PHIODataNode<TObject>(munhits,"munhits");
    geaNode->addNode(dn);
    //EOEVAL
  }

  dMuiPseudoTriggerOut* PseudoTriggerOut = new dMuiPseudoTriggerOutv1();;
  PHIODataNode<PHObject>* PseudoTriggerOutNode = new PHIODataNode<PHObject>(PseudoTriggerOut, "dMuiPseudoTriggerOut","PHObject");
  dstNode->addNode( PseudoTriggerOutNode );

  //Find dMuiRaw
  PHIODataNode<dMuiRawWrapper>::iterator idMuiRaw(topNode);
  if(idMuiRaw.find("dMuiRaw")==0)
  {
    dMuiRawWrapper* dMuiRawW = new dMuiRawWrapper("dMuiRaw", 2000);
    PHIODataNode<PHTable>* dMuiRawNode =
      new PHIODataNode<PHTable>(dMuiRawW, "dMuiRaw");

    muiNode->addNode(dMuiRawNode);
    // Now let's try to cheat?
    dstNode->addNode(dMuiRawNode);

  }
  PHIODataNode<dMuiRoadRawRelWrapper>::iterator idMuiRoadRawRel(topNode);
  if(idMuiRoadRawRel.find("dMuiRoadRawRel")==0)
  {
    dMuiRoadRawRelWrapper* dMuiRoadRawRelW = new dMuiRoadRawRelWrapper("dMuiRoadRawRel", 120000);

    PHIODataNode<PHTable>* dMuiRoadRawRelNode =
      new PHIODataNode<PHTable>(dMuiRoadRawRelW, "dMuiRoadRawRel");

    muiNode->addNode(dMuiRoadRawRelNode);
    // Now let's try to cheat?
    dstNode->addNode(dMuiRoadRawRelNode);
  }
  
  mr=1;
  dMuiReadoutControlWrapper* dMuiReadoutControl = new dMuiReadoutControlWrapper("dMuiReadoutControl",mr);
  PHIODataNode<PHTable>* dMuiReadoutControlNode = new PHIODataNode<PHTable>(dMuiReadoutControl,"dMuiReadoutControl");
  parNode->addNode(dMuiReadoutControlNode);

  dMuiRoadControlWrapper* dMuiRoadControl = new
    dMuiRoadControlWrapper;
  dn = new PHIODataNode<TObject>(dMuiRoadControl, "dMuiRoadControl");
  parNode->addNode(dn);

  dMuiClusterControlWrapper* dMuiClusterControl = new
    dMuiClusterControlWrapper;
  dn = new
    PHIODataNode<TObject>(dMuiClusterControl, "dMuiClusterControl");
  parNode->addNode(dn);

  dMuiMuonIdProfileParWrapper* dMuiMuonIdProfilePar = new
    dMuiMuonIdProfileParWrapper;
  dn = new
    PHIODataNode<TObject>(dMuiMuonIdProfilePar, "dMuiMuonIdProfilePar");
  parNode->addNode(dn);

  dMuoFindTracksParWrapper* dMuoFindTracksPar = new
    dMuoFindTracksParWrapper;
  dn = new
    PHIODataNode<TObject>(dMuoFindTracksPar, "dMuoFindTracksPar");
  parNode->addNode(dn);

  PHIODataNode<PHTable>* DMUTGLOBALPARNode = (PHIODataNode<PHTable>*)mainIter->findFirst("PHIODataNode", "dMutGlobalPar");
  dMutGlobalParWrapper* dMutGlobalPar;
  if (DMUTGLOBALPARNode)
  {
    dMutGlobalPar = (dMutGlobalParWrapper*)DMUTGLOBALPARNode->getData();
  }
  else
  {
    dMutGlobalPar = new dMutGlobalParWrapper;
    dn = new PHIODataNode<TObject>(dMutGlobalPar, "dMutGlobalPar");
    parNode->addNode(dn);
  }

  dMutHistosWrapper* dMutHistos = new dMutHistosWrapper;
  dn = new PHIODataNode<TObject>(dMutHistos, "dMutHistos");
  parNode->addNode(dn);

  PHIODataNode<PHTable>* MumDigiParNode = (PHIODataNode<PHTable>*)mainIter->findFirst("PHIODataNode", "mumdigipar");
  mumdigiparWrapper* mumdigipar;
  if (MumDigiParNode)
  {
    mumdigipar = (mumdigiparWrapper*)MumDigiParNode->getData();
  }
  else
  {
    mumdigipar = new mumdigiparWrapper;
    dn = new PHIODataNode<TObject>(mumdigipar, "mumdigipar");
    parNode->addNode(dn);
  }
  PHIODataNode<PHTable>* dMutCathodePulseParamsNode = (PHIODataNode<PHTable>*)mainIter->findFirst("PHIODataNode", "dMutCathodePulseParams");
  mMutCathodePulseParams* dMutCathodePulseParams;
  if (dMutCathodePulseParamsNode){
    dMutCathodePulseParams = (mMutCathodePulseParams*)dMutCathodePulseParamsNode->getData();
  }
  else{
    dMutCathodePulseParams = new mMutCathodePulseParams;
    dn = new PHIODataNode<TObject>(dMutCathodePulseParams, "dMutCathodePulseParams");
    parNode->addNode(dn);
  }

  PHIODataNode<PHTable>* dMfmParNode = (PHIODataNode<PHTable>*)mainIter->findFirst("PHIODataNode", "dMfmPar");
  dMfmParWrapper* dMfmPar;
  if (dMfmParNode){
    dMfmPar = (dMfmParWrapper*)dMfmParNode->getData();
  }
  else{
    dMfmPar = new dMfmParWrapper;
    dn = new PHIODataNode<TObject>(dMfmPar, "dMfmPar");
    parNode->addNode(dn);
  }
  // Define tables which are used for evaluations, but also in the interface
  // of general reconstruction in the mut code:
  // These tables are defined by the evaluation routines, if they are called

  if (!evaluationFlag) {
    PHIODataNode<dMutAnodesDCMWrapper>::iterator iMutAnodesDCM(topNode);
    if(iMutAnodesDCM.find("dMutAnodesDCM")==0)
    {
      dMutAnodesDCMWrapper* dMutAnodesDCM = new dMutAnodesDCMWrapper;
      dn = new PHIODataNode<TObject>(dMutAnodesDCM, "dMutAnodesDCM");
      dcmNode->addNode(dn);
    }
    PHIODataNode<dMutClusterGhitRelWrapper>::iterator iMutClusterGhitRel(topNode);
    if(iMutClusterGhitRel.find("dMutClusterGhitRel")==0)
    {
      dMutClusterGhitRelWrapper* dMutClusterGhitRel = new dMutClusterGhitRelWrapper;
      dn = new PHIODataNode<TObject>(dMutClusterGhitRel, "dMutClusterGhitRel");
      dstNode->addNode(dn);
    }
  }

  PHIODataNode<dMuiRoadFkinRelWrapper>::iterator iMuiRoadFkinRel(topNode);
  if(iMuiRoadFkinRel.find("dMuiRoadFkinRel")==0)
  {
    dMuiRoadFkinRelWrapper* dMuiRoadFkinRel = new dMuiRoadFkinRelWrapper;
    dn = new PHIODataNode<TObject>(dMuiRoadFkinRel, "dMuiRoadFkinRel");
    //  Seems like this should be the eva node.  Revisit this later.  RJN
    dstNode->addNode(dn);
  }

  PHIODataNode<dMuoTrackRoadRelWrapper>::iterator iMuoTrackRoadRel(topNode);
  if(iMuoTrackRoadRel.find("dMuoTrackRoadRel")==0)
  {
    dMuoTrackRoadRelWrapper* dMuoTrackRoadRel =
       new dMuoTrackRoadRelWrapper("dMuoTrackRoadRel", 1000);
    dn = new PHIODataNode<TObject>(dMuoTrackRoadRel, "dMuoTrackRoadRel");
    dstNode->addNode(dn);
  }

  
  dMuiReadoutControl->SetRowCount((size_t)1);
  Int_t i;
  for (i = 0; i < 5; i++) {
    dMuiReadoutControl->set_NeutronEffic(i,0,0.0);
    dMuiReadoutControl->set_GammaEffic(i,0,0.0);
    dMuiReadoutControl->set_ChargeEffic(i,0,97.0);
    dMuiReadoutControl->set_AveNoiseHits(i,0,0.0);
    dMuiReadoutControl->set_RmsNoiseHits(i,0,0.0);
  }


  dMuiRoadControl->SetRowCount((size_t)1);
  dMuiRoadControl->set_NumSeedLoops(0, 2);
  for (Int_t i = 0; i < 2; i++)
  {
    dMuiRoadControl->set_SearchLength(i, 0, 6);
  }
  dMuiRoadControl->set_SearchOrder(0, 0, 0, -1);
  dMuiRoadControl->set_SearchOrder(0, 1, 0, 1);
  dMuiRoadControl->set_SearchOrder(0, 2, 0, 0);
  dMuiRoadControl->set_SearchOrder(0, 3, 0, 2);
  dMuiRoadControl->set_SearchOrder(0, 4, 0, 3);
  dMuiRoadControl->set_SearchOrder(0, 5, 0, 4);
  dMuiRoadControl->set_SearchOrder(1, 0, 0, -1);
  dMuiRoadControl->set_SearchOrder(1, 1, 0, 2);
  dMuiRoadControl->set_SearchOrder(1, 2, 0, 1);
  dMuiRoadControl->set_SearchOrder(1, 3, 0, 0);
  dMuiRoadControl->set_SearchOrder(1, 4, 0, 3);
  dMuiRoadControl->set_SearchOrder(1, 5, 0, 4);
  dMuiRoadControl->set_ClusterCollectMode(0, 0);
  dMuiRoadControl->set_minLastGap1D(0, 2);
  dMuiRoadControl->set_minFiredGaps(0, 2);
  dMuiRoadControl->set_maxSkippedGaps(0, 2);
  dMuiRoadControl->set_minSharedHits1D(0, 5);
  dMuiRoadControl->set_maxXRef1D(0, 180.0);
  dMuiRoadControl->set_maxYRef1D(0, 180.0);
  dMuiRoadControl->set_minLastGap2D(0, 2);
  dMuiRoadControl->set_maxDelLastGap(0, 1);
  dMuiRoadControl->set_maxDelHitsPerGap(0, 1);
  dMuiRoadControl->set_maxDelTotalHits(0, 1);
  dMuiRoadControl->set_maxXRef2D(0, 180.0);
  dMuiRoadControl->set_maxYRef2D(0, 180.0);
  dMuiRoadControl->set_maxXChisq(0, 1000.0);
  dMuiRoadControl->set_maxYChisq(0, 1000.0);
  dMuiRoadControl->set_minSharedHits2D(0, 8);
  dMuiRoadControl->set_mvdvertex(0, 0);
  for (Int_t i = 0; i < 5; i++)
  {
    dMuiRoadControl->set_WeightPar1D(i, 0, 1.0);
    dMuiRoadControl->set_WeightPar2D(i, 0, 1.0);
    dMuiRoadControl->set_WindowParAlpha(i, 0, 0.0);
    dMuiRoadControl->set_WindowParBeta(i, 0, 0.0);
    dMuiRoadControl->set_WindowParGamma(i, 0, 15.0);
  }

  // yajun's new muid ghost/group parameters
  dMuiRoadControl->set_MutrWindow(0, 20.0);
  dMuiRoadControl->set_MuidWindow(0, 30.0);

  dMuiClusterControl->SetRowCount(1);
  dMuiClusterControl->set_xClusterSep(0, 1);
  dMuiClusterControl->set_yClusterSep(0, 1);

  for (Int_t i = 0;i < 5;i++)
  {
    dMuiClusterControl->set_xMaxClusterSize(i, 0, 1);
    dMuiClusterControl->set_yMaxClusterSize(i, 0, 1);
  }

  dMuiMuonIdProfilePar->SetRowCount(1);
  dMuiMuonIdProfilePar->set_pmax(0, 0, 0.0);
  dMuiMuonIdProfilePar->set_pmax(1, 0, 1.0);
  dMuiMuonIdProfilePar->set_pmax(2, 0, 1.3);
  dMuiMuonIdProfilePar->set_pmax(3, 0, 1.7);
  dMuiMuonIdProfilePar->set_pmax(4, 0, 200.0);
  dMuiMuonIdProfilePar->set_xVertexCut(0, 80.0);
  dMuiMuonIdProfilePar->set_yVertexCut(0, 80.0);
  // Monte Carlo, real data dependent variables for MuTr:

  if (simulationFlag)
  {
    dMutGlobalPar->set_MCData(0, 0);

    mumdigipar->set_OfflineCathodeDCMScheme(0, 0);

    mumdigipar->set_LandauScale(0,0,40.0);
    mumdigipar->set_LandauScale(1,0,40.0);
    mumdigipar->set_LandauScale(2,0,40.0);
    mumdigipar->set_LandauScale(3,0,40.0);
    mumdigipar->set_LandauScale(4,0,40.0);
    mumdigipar->set_LandauScale(5,0,40.0);

    mumdigipar->set_LandauOffset(0,0,165.0);
    mumdigipar->set_LandauOffset(1,0,165.0);
    mumdigipar->set_LandauOffset(2,0,165.0);
    mumdigipar->set_LandauOffset(3,0,165.0);
    mumdigipar->set_LandauOffset(4,0,165.0);
    mumdigipar->set_LandauOffset(5,0,165.0);

    mumdigipar->set_resolution(0, 0, 0.02);
    mumdigipar->set_resolution(1, 0, 0.02);
    mumdigipar->set_resolution(2, 0, 0.02);
    mumdigipar->set_resolution(3, 0, 0.00);
    mumdigipar->set_resolution(4, 0, 0.00);
    
    dMutCathodePulseParams->setTrise(500.);
    dMutCathodePulseParams->setTfall(1500.);
    dMutCathodePulseParams->setFitRise(0);
    dMutCathodePulseParams->setFitFall(0);
    dMutCathodePulseParams->setFitType("exp");
  }
  else
  {
    dMutGlobalPar->set_MCData(0, 0);

    mumdigipar->set_OfflineCathodeDCMScheme(0, 0);

    mumdigipar->set_resolution(0, 0, 0.06);
    mumdigipar->set_resolution(1, 0, 0.06);
    mumdigipar->set_resolution(2, 0, 0.06);
    mumdigipar->set_resolution(3, 0, 0.06);
    mumdigipar->set_resolution(4, 0, 0.06);

    dMutCathodePulseParams->setTrise(4500.);
    dMutCathodePulseParams->setTfall(1000.);
    dMutCathodePulseParams->setFitRise(1);
    dMutCathodePulseParams->setFitFall(1);
    dMutCathodePulseParams->setFitType("avg");
  }

  dMuoFindTracksPar->SetRowCount(1);
  dMuoFindTracksPar->set_weed_chisq_imp(0, 0, 4.0);
  dMuoFindTracksPar->set_weed_chisq_imp(1, 0, 4.0);

  dMuoFindTracksPar->set_maskw_the(0, 0, 8.0);
  dMuoFindTracksPar->set_maskw_the(1, 0, 12.0);
  dMuoFindTracksPar->set_maskw_the(2, 0, 14.0);
  dMuoFindTracksPar->set_maskw_the(3, 0, 20.0);
  dMuoFindTracksPar->set_maskw_the(4, 0, 30.0);
  dMuoFindTracksPar->set_maskw_the(5, 0, 50.0);

  dMuoFindTracksPar->set_maskw_phi(0, 0, 10.0);
  dMuoFindTracksPar->set_maskw_phi(1, 0, 25.0);
  dMuoFindTracksPar->set_maskw_phi(2, 0, 40.0);
  dMuoFindTracksPar->set_maskw_phi(3, 0, 10.0);
  dMuoFindTracksPar->set_maskw_phi(4, 0, 25.0);
  dMuoFindTracksPar->set_maskw_phi(5, 0, 40.0);

  dMuoFindTracksPar->set_candtr_sigphi(0, 0, 0.0);
  dMuoFindTracksPar->set_candtr_sigphi(1, 0, 0.0);
  dMuoFindTracksPar->set_candtr_sigphi(2, 0, 2.0);
  dMuoFindTracksPar->set_candtr_sigphi(3, 0, 0.0);
  dMuoFindTracksPar->set_candtr_sigphi(4, 0, 0.0);
  dMuoFindTracksPar->set_candtr_sigphi(5, 0, 2.0);

  for (int i = 0; i < 9; i++)
  {
    dMuoFindTracksPar->set_projerr(i, 0, 0.6);
  }
  dMuoFindTracksPar->set_projerr(2, 0, 0.9);

  dMuoFindTracksPar->set_fqcut(0, 0.20);
  dMuoFindTracksPar->set_chifitcut(0, 0.0);
  dMuoFindTracksPar->set_qrescut(0, 0.15);
  dMuoFindTracksPar->set_awirecut(0, 9.00);
  dMuoFindTracksPar->set_muidmask(0, 1);
  //dMuoFindTracksPar->set_MinMuidDepth(0, 4);
  dMuoFindTracksPar->set_MinMuidDepth(0, 2);
  //dMuoFindTracksPar->set_MaxMuidChisqdf(0, 20.);
  dMuoFindTracksPar->set_MaxMuidChisqdf(0, 200.);
  dMuoFindTracksPar->set_MinMuidNhits(0, 5);
  dMuoFindTracksPar->set_MaxMuidPlaHits(0, 10);
  dMuoFindTracksPar->set_MinMuidTheta(0, 0.); //0 deg
                                              //dMuoFindTracksPar->set_MinMuidTheta(0, 0.209); //12 deg
                                              //dMuoFindTracksPar->set_MinMuidTheta(0, 0.349); //20 deg
  dMuoFindTracksPar->set_muidfit(0, 1);

  dMuoFindTracksPar->set_RealVertErr(0, 2.0);
  dMuoFindTracksPar->set_NoVertErr(0, 40.0);
  dMuoFindTracksPar->set_MCVertErr(0, 2.0);
  dMuoFindTracksPar->set_NoVertMCErr(0, 40.0);

  //dMuoFindTracksPar->set_mvdvert(0, 1);
  dMuoFindTracksPar->set_mvdvert(0, 0);
  //dMuoFindTracksPar->set_bbcvert(0, 1);
  dMuoFindTracksPar->set_bbcvert(0, 0);
  //dMuoFindTracksPar->set_globalvert(0, 0); //use global vtx
  dMuoFindTracksPar->set_globalvert(0, 1); //use global vtx

  dMuoFindTracksPar->set_prfit(0, 1);
  dMuoFindTracksPar->set_min_stub_hits(0, 2);
  dMuoFindTracksPar->set_min_track23_hits(0, 6);
  dMuoFindTracksPar->set_min_track_hits(0, 10);
  dMuoFindTracksPar->set_nplskip(0, 2);

  dMuoFindTracksPar->set_ghost_nshare_min(0, 0, 0);
  dMuoFindTracksPar->set_ghost_nshare_min(1, 0, 5);
  dMuoFindTracksPar->set_ghost_nshare_min(2, 0, 0);

  dMuoFindTracksPar->set_max_good_hits(0, 4);

  // set sign of bend plane kicks (revbpkick)
  if(mapFileFlag==0) {
    dMuoFindTracksPar->set_revbpkick(0,1);
  } else {
    if(getMapFileScale() == 0) {
      dMuoFindTracksPar->set_revbpkick(0,0);
    } else if(getMapFileScale() == -1) {
      dMuoFindTracksPar->set_revbpkick(0,1);
    } else {
      dMuoFindTracksPar->set_revbpkick(0,-1);
    }
  }

  dMuoFindTracksPar->set_max_stub_chisq(0, 0, 100.0);
  dMuoFindTracksPar->set_max_stub_chisq(1, 0, 100.0);
  dMuoFindTracksPar->set_max_stub_chisq(2, 0, 50.0);
  dMuoFindTracksPar->set_max_stub_chisq(3, 0, 100.0);
  dMuoFindTracksPar->set_max_stub_chisq(4, 0, 100.0);
  dMuoFindTracksPar->set_max_stub_chisq(5, 0, 50.0);

  dMuoFindTracksPar->set_stub_fit_dwh(0, 0, 0.0);
  dMuoFindTracksPar->set_stub_fit_dwh(1, 0, 0.0);
  dMuoFindTracksPar->set_stub_fit_dwh(2, 0, 0.0);
  dMuoFindTracksPar->set_stub_fit_dwh(3, 0, 0.0);
  dMuoFindTracksPar->set_stub_fit_dwh(4, 0, 0.0);
  dMuoFindTracksPar->set_stub_fit_dwh(5, 0, 0.0);

  dMuoFindTracksPar->set_max_track23_chisq(0, 5000.0);
  dMuoFindTracksPar->set_max_track_chisq(0, 150.0);
  dMuoFindTracksPar->set_mscat_z(0, 85.0);
  dMuoFindTracksPar->set_max_geane_chisqr(0, 10000.0);

  dMuoFindTracksPar->set_ghost_qual_fac(0, 0, 2.0);
  dMuoFindTracksPar->set_ghost_qual_fac(1, 0, 6.0);
  dMuoFindTracksPar->set_ghost_qual_fac(2, 0, 7.5);

  dMuoFindTracksPar->set_ghost_qual_subset_fac(0, 0, 1.2);
  dMuoFindTracksPar->set_ghost_qual_subset_fac(1, 0, 1.2);
  dMuoFindTracksPar->set_ghost_qual_subset_fac(2, 0, 0.2);

  for (int i = 0; i < 3; i++)
  {
    dMuoFindTracksPar->set_ghost_chi_min(i, 0, 0.0);
  }

  for (int i = 0; i < 2; i++)
  {
    dMuoFindTracksPar->set_weed_chisq_bad(i, 0, 10000.0);
    dMuoFindTracksPar->set_weed_chisq_max(i, 0, 0.5);
  }

  dMuoFindTracksPar->set_max_xproj(0, 0, 300.0);
  dMuoFindTracksPar->set_max_yproj(0, 0, 300.0);
  dMuoFindTracksPar->set_max_xproj(1, 0, 250.0);
  dMuoFindTracksPar->set_max_yproj(1, 0, 250.0);
  dMuoFindTracksPar->set_max_xproj(2, 0, 150.0);
  dMuoFindTracksPar->set_max_yproj(2, 0, 150.0);
  dMuoFindTracksPar->set_max_xproj(3, 0, 300.0);
  dMuoFindTracksPar->set_max_yproj(3, 0, 300.0);
  dMuoFindTracksPar->set_max_xproj(4, 0, 250.0);
  dMuoFindTracksPar->set_max_yproj(4, 0, 250.0);
  dMuoFindTracksPar->set_max_xproj(5, 0, 150.0);
  dMuoFindTracksPar->set_max_yproj(5, 0, 150.0);

  dMuoFindTracksPar->set_max_xproj_tr(0, 0, 50.0);
  dMuoFindTracksPar->set_max_yproj_tr(0, 0, 50.0);
  dMuoFindTracksPar->set_max_xproj_tr(1, 0, 200.0);
  dMuoFindTracksPar->set_max_yproj_tr(1, 0, 200.0);
  dMuoFindTracksPar->set_max_xproj_tr(2, 0, 100.0);
  dMuoFindTracksPar->set_max_yproj_tr(2, 0, 100.0);
  dMuoFindTracksPar->set_max_xproj_tr(3, 0, 50.0);
  dMuoFindTracksPar->set_max_yproj_tr(3, 0, 50.0);
  dMuoFindTracksPar->set_max_xproj_tr(4, 0, 200.0);
  dMuoFindTracksPar->set_max_yproj_tr(4, 0, 200.0);
  dMuoFindTracksPar->set_max_xproj_tr(5, 0, 100.0);
  dMuoFindTracksPar->set_max_yproj_tr(5, 0, 100.0);

  dMuoFindTracksPar->set_awirecutchi(0, 0.1);
  dMuoFindTracksPar->set_StubFitVert(0, 0);
  //dMuoFindTracksPar->set_StubFitVert(0, 1);

  dMutGlobalPar->SetRowCount(1);
  dMutGlobalPar->set_MCAnalysis(0, 0);

  dMutHistos->SetRowCount(1);
  dMutHistos->set_Dimuons(0, 1); //all
  dMutHistos->set_Thrown(0, 0);
  dMutHistos->set_Recon(0, 1);
  dMutHistos->set_BPFit(0, 1); // Mike
  dMutHistos->set_Stub(0, 1);  //Yuki
  dMutHistos->set_NCandHits(0, 0); //
  dMutHistos->set_CandTrs(0, 0);  //
  dMutHistos->set_CheckHit(0, 0); //
  dMutHistos->set_CheckMask(0, 1); // Mike
  dMutHistos->set_RawData(0, 0); //
  dMutHistos->set_StripData(0, 1); //
  dMutHistos->set_ClustData(0, 1); //Yuki
  dMutHistos->set_ClustData2(0, 1);

  // Change some flags for evaluation purposes
  if (evaluationFlag) {
    dMuoFindTracksPar->set_globalvert(0, 0);
    dMuoFindTracksPar->set_mcvert(0, 1);
    dMutGlobalPar->set_MCAnalysis(0, 1);
    dMutHistos->set_Thrown(0, 1);
    dMutHistos->set_Recon(0, 1);
    dMutHistos->set_ClustData2(0, 1);
  }

  mumdigipar->SetRowCount(1);

  mumdigipar->set_hit_efficiency(0, 1.0);

  for (int i = 0; i < 3; i++) {
    mumdigipar->set_st_angacc(i, 0, 10.0);
    mumdigipar->set_st_angacc(i + 3, 0, 12.0);
  }

  mumdigipar->set_baselor(0, 0.85);

  for (int i = 0; i < 9; i++) {
    mumdigipar->set_keepgap(i, 0, 1);
  }
  mumdigipar->set_keepgap(8, 0, 0);

  for (int i = 0; i < 10; i++) {
    mumdigipar->set_threshold(i, 0, 6.0);
    mumdigipar->set_noise_level(i, 0, 2.0);
    mumdigipar->set_noise_scale(i, 0, 1.0);
  }
  for (int i = 5; i < 10; i++) {
    mumdigipar->set_noise_scale(i, 0, 0.0);
  }
  mumdigipar->set_threshold(9, 0, 0.0);
  mumdigipar->set_noise_level(9, 0, 0.0);

  mumdigipar->set_GainMin(0, 1.0);

  for (int i = 0; i < 3; i++) {
    mumdigipar->set_wire_spacing(i, 0, 0.5);
  }
  for (int i = 3; i < 5; i++) {
    mumdigipar->set_wire_spacing(i, 0, 0.0);
  }

  mumdigipar->set_CathodeDCMScheme(0, 1111);

  mumdigipar->set_ThreshFactor(0, 0, 3.0);
  mumdigipar->set_ThreshFactor(1, 0, 3.0);
  mumdigipar->set_ThreshFactor(2, 0, 3.0);
  mumdigipar->set_ThreshFactor(3, 0, 3.0);
  mumdigipar->set_ThreshFactor(4, 0, 3.0);
  mumdigipar->set_ThreshFactor(5, 0, 3.0);
  mumdigipar->set_ThreshFactor2(0, 0, -100.0);
  mumdigipar->set_ThreshFactor2(1, 0, -100.0);
  mumdigipar->set_ThreshFactor2(2, 0, -100.0);
  mumdigipar->set_ThreshFactor2(3, 0, -100.0);
  mumdigipar->set_ThreshFactor2(4, 0, -100.0);
  mumdigipar->set_ThreshFactor2(5, 0, -100.0);

  mumdigipar->set_MinClusCharge(0, 2.0);

  dMutCathodePulseParams->setNsamples(4);
  float tsamples[4];
  tsamples[0] = 100.;
  tsamples[1] = 600.;
  tsamples[2] = 700.;
  tsamples[3] = 800.;
  dMutCathodePulseParams->setTsamples(tsamples);

  dMfmPar->SetRowCount(1);
  dMfmPar->set_verbosity(0, 0);
  dMfmPar->set_mapFile(0, mapFileFlag );

  //Get gloabal TimeStamp from preco
#ifdef DEBUG
  cout << "PRECO Global TimeStamp = " << startTime << endl;
#endif
  

  mMuiInit.SetSearchTimeStamp(startTime);

#ifdef DEBUG
  cout << " calling mMuiReadTubeEff " << endl;
#endif
  mMuiReadTubeEff.event(topNode);

  if(simulationFlag>0)
  {
    mMuiPseudoTrig.MapSelect(2);
  }
  else
  {
    mMuiPseudoTrig.MapSelect(0);
  }

#ifdef DEBUG
    cout << "--->MUID: Gloabal startTime for run " << runNumber
	   << " is:  " << startTime << endl;
#endif
  mMuiPseudoTrig.initialize(abs(runNumber));

  mMuiInit.event(topNode);

#ifdef DEBUG
  cout << "murec: Calling mMutdbInit\n";
#endif

#ifdef DEBUG
    cout << "--->MUTR: Global startTime for run " << runNumber
	   << " is:  " << startTime << endl;
#endif
    mMutdbInitM.dbGetAll(topNode, startTime);

#ifdef DEBUG
  cout << "murec: Calling mMfmMT\n";
#endif
  mMfmMT.event(topNode);
#ifdef DEBUG
  cout << "murec: Calling mMutRootInit\n";
#endif
  mMutRootInit.event(topNode);
#ifdef DEBUG
  cout << "murec: Calling mumUser\n";
#endif
  mumUser.event(topNode);

  init_done = 1;
  return 0;
  
}
// Run the part of reconstruction appropriate for a PRDF.
PHBoolean mMuoRecoModule::event_unpack(PHCompositeNode *topNode)
{

#ifdef DEBUG
  cout << "Calling mMuiPseudoTrigger\n";
#endif
  mMuiPseudoTrig.event(topNode);

#ifdef DEBUG
  cout << "Calling MuiGetDCM\n";
#endif
  MuiGetDCM(topNode);

#ifdef DEBUG
  cout << "Calling mMuiDCMUnpack\n";
#endif
  mMuiDCMUnpack.event(topNode);

#ifdef DEBUG
  cout << "murec: Calling mMutZeroSuptoRawData\n";
#endif
  mMutZeroSuptoRawDataM.event(topNode);

#ifdef DEBUG
  cout << "murec: Calling mMutApplyCalib\n";
#endif
  mMutApplyCalibM.event(topNode);

  return 0;
}
  // If embedding enabled combine the hits of secondary dst.
PHBoolean mMuoRecoModule::event_embed(PHCompositeNode *topNode, PHCompositeNode *embedNode)
{
  
  mMuiDSTMixer.event(topNode, embedNode);
  mergeMut(topNode, embedNode);
  
  return 0;
}

// Run the MuTr cluster finding and fitting 

PHBoolean mMuoRecoModule::event_cluster(PHCompositeNode *topNode)
{

  PHIODataNode<dMutCathodeClustersWrapper>::iterator dMutCathodeClustersW(topNode);
  if(dMutCathodeClustersW.find("dMutCathodeClusters")>0)
    {
      (*dMutCathodeClustersW).SetRowCount(0);
    }


  if (evaluationFlag) {
    PHNodeIterator mainIter(topNode);
    //Find EVA node
    PHCompositeNode* evaNode = static_cast<PHCompositeNode*>
    (mainIter.findFirst("PHCompositeNode", "EVA"));
    
    ioEval->read(evaNode);

    KinGetGEA(topNode);  // fill the fkin table
    MutGetGEA(topNode);  // fill the mumhits table
    MuiGetGEA(topNode);  // fill the munhits table
    
#ifdef DEBUG
    cout << "Calling mMutFillRawCathGhitRel\n";
#endif
    mMutFillRawCathGhitRel.event(topNode);

  }

#ifdef DEBUG
  cout << "murec: Calling mMutFindCathodeClustsT\n";
#endif
  mMutFindCathodeClustsTM.event(topNode);
  if (evaluationFlag) {
#ifdef DEBUG
    cout << "murec: Calling mMutFillClusterGhitRel\n";
#endif
    mMutFillClusterGhitRel.event(topNode);
  }
#ifdef DEBUG
  cout << "murec: Calling mMutFitCathodeClustsT\n";
#endif
  mMutFitCathodeClustsT.event(topNode);
	if (evaluationFlag) {
#ifdef DEBUG
    cout << "murec: Calling mMutCathFitEval\n";
#endif
    mMutCathFitEvaluator.event(topNode);
	}
  return 0;
}

// Run the part of reconstruction appropriate
// for a Unpacked PRDF or a DST.
PHBoolean mMuoRecoModule::event_reco(PHCompositeNode *topNode)
{


// Zero the following tables if they are already there.
// We could be refitting or embedding.

  PHIODataNode<dMuoTracksWrapper>::iterator dMuoTracks(topNode);

  if(dMuoTracks.find("dMuoTracks")>0)
    {
      (*dMuoTracks).SetRowCount(0);
    }

  PHIODataNode<dMuoTrackRoadRelWrapper>::iterator dMuoTrackRoadRel(topNode);

  if(dMuoTrackRoadRel.find("dMuoTrackRoadRel")>0)
    {
      (*dMuoTrackRoadRel).SetRowCount(0);
    }

  PHIODataNode<dMuiClustersWrapper>::iterator dMuiClustersW(topNode);

  if(dMuiClustersW.find("dMuiClusters")>0)
  {
    (*dMuiClustersW).SetRowCount(0); //
  }
  PHIODataNode<dMuiClusterRawRelWrapper>::iterator dMuiClusterRawRelW(topNode);

  if(dMuiClusterRawRelW.find("dMuiClusterRawRel")>0)
  {
    (*dMuiClusterRawRelW).SetRowCount(0); //
  }
  
  PHIODataNode<dMuiRoadsWrapper>::iterator dMuiRoads(topNode);

  if(dMuiRoads.find("dMuiRoads")>0)
    {
      (*dMuiRoads).SetRowCount(0); // 
    }

  PHIODataNode<dMuiRoadRawRelWrapper>::iterator dMuiRoadRawRel(topNode);

  if(dMuiRoadRawRel.find("dMuiRoadRawRel")>0)
    {
      (*dMuiRoadRawRel).SetRowCount(0); // 
    }
    
#ifdef DEBUG
  cout << "Calling mMuiClusterFinder\n";
#endif
  mMuiClusterFinder.event(topNode);
#ifdef DEBUG
  cout << "Calling mMuiRoadFinder\n";
#endif
  mMuiRoadFind.event(topNode);
#ifdef DEBUG
  cout << "Calling mMuiFillRoadRawRel\n";
#endif
  mMuiFillRoadRawRel.event(topNode);
  if (evaluationFlag) {
    
#ifdef DEBUG
    cout << "Calling mMuiFillRawFkinRel\n";
#endif
    mMuiFillRawFkinRel.event(topNode);
#ifdef DEBUG
    cout << "Calling mMuiFillClusterFkinRel\n";
#endif
    mMuiFillClusterFkinRel.event(topNode);
#ifdef DEBUG
    cout << "Calling mMuiFillRoadFkinRel\n";
#endif
    mMuiFillRoadFkinRel.event(topNode);
  }

#ifdef DEBUG
  cout << "murec: Calling mMuoFindTracks\n";
#endif
  mMuoFindTracksM.event(topNode);
#ifdef DEBUG
  cout << "murec: Calling mMuiRoadFinder2\n";
#endif
  mMuiRoadFind2.event(topNode);
#ifdef DEBUG
  cout << "murec: Calling mMuiMuonId\n";
#endif
  mMuiMuonId.event(topNode);
#ifdef DEBUG
  cout << "murec: Calling mMuoFillDataMineVars\n";
#endif
  mMuoFillDataMineVars.event(topNode);
#ifdef DEBUG
  cout << "Calling mMuiHistoBase\n";
#endif
  mMuiHistoBase.event(topNode);

#ifdef DEBUG
  PHIODataNode<dMuiRoadsWrapper>::iterator iRoad(topNode);
  if(iRoad.find("dMuiRoads")>0)
  {
    cout<<"NumRoads: "<<(*iRoad).RowCount() << endl;
  }
  PHIODataNode<dMuoTracksWrapper>::iterator iTrack(topNode);
  if(iTrack.find("dMuoTracks")>0)
  {
    cout<<"NumTracks: "<<(*iTrack).RowCount() << endl;
  }
#endif

  return 0;
}

PHBoolean mMuoRecoModule::end(PHCompositeNode *topNode)
{

#ifdef DEBUG
  cout << "murec: Calling mMuiEnd\n";
#endif
  mMuiEnd.event(topNode);

#ifdef DEBUG
  cout << "murec: Calling mMutEnd\n";
#endif
  mMutEnd.event(topNode);

#ifdef DEBUG
  cout << "murec: Calling mMutCloseRootFile\n";
#endif
  mMutCloseRootFile.event(topNode);

  return 0;
}

PHBoolean mMuoRecoModule::mergeMut(PHCompositeNode* mainNode, PHCompositeNode* embedNode)
{
  bool oldst = false;
  PHIODataNode<dMutCalibCathodesOut>::iterator rCalibCathodes1(mainNode);
  if(rCalibCathodes1.find("dMutCalibCathodesOut")==0)
  { cout<<"dMutCalibCathodesOut not found.\n";
    oldst = true;
  }
  
  PHIODataNode<dMutCalibCathodesOut>::iterator rCalibCathodes2(embedNode);
  if(rCalibCathodes2.find("dMutCalibCathodesOut")==0)
  { cout<<"Embedding dMutCalibCathodesOut not found.\n";
    return -1;
  }

  int beforeCount = 0;
  int afterCount  = 0;
  if(!oldst)
  {
    dMutCalibCathodesOut* fCalibCathodes1 = &(*rCalibCathodes1);
    dMutCalibCathodesOut* fCalibCathodes2 = &(*rCalibCathodes2);
  
    beforeCount = fCalibCathodes1->RowCount();
    
    for(int calibid2 = 0; calibid2 < fCalibCathodes2->RowCount(); calibid2++)
    {
      bool calibfound = false;
      for(int calibid1 = 0; calibid1 < fCalibCathodes1->RowCount(); calibid1++)
      {
        if(calibfound) continue;
        
        //Are these the same cathodes
        if(
          fCalibCathodes1->get_arm(calibid1) == fCalibCathodes2->get_arm(calibid2) &&
          fCalibCathodes1->get_station(calibid1) == fCalibCathodes2->get_station(calibid2) &&
          fCalibCathodes1->get_octant(calibid1) == fCalibCathodes2->get_octant(calibid2) &&
          fCalibCathodes1->get_halfoctant(calibid1) == fCalibCathodes2->get_halfoctant(calibid2) &&
          fCalibCathodes1->get_gap(calibid1) == fCalibCathodes2->get_gap(calibid2) &&
          fCalibCathodes1->get_icath(calibid1) == fCalibCathodes2->get_icath(calibid2) &&
          fCalibCathodes1->get_plane(calibid1) == fCalibCathodes2->get_plane(calibid2) &&
          fCalibCathodes1->get_strip(calibid1) ==fCalibCathodes2->get_strip(calibid2)
          )
        {
          //Our signal file contains a hit that overlaps with the real data
          // So lets add the total charge of the hits and for now do nothing with adc values
          calibfound = true;
          fCalibCathodes1->set_qstrip(calibid1,
                                      fCalibCathodes1->get_qstrip(calibid1)
                                      + fCalibCathodes2->get_qstrip(calibid2)
                                      );
          
        }
        
        
      }
  
      //If the cathode was not hit in first file add it from second file
      if(!calibfound)
      {
        fCalibCathodes1->Add();
        int newID = fCalibCathodes1->RowCount() - 1;
        fCalibCathodes1->set_qstrip(newID, fCalibCathodes2->get_qstrip(calibid2));
        fCalibCathodes1->set_qrms(newID, fCalibCathodes2->get_qrms(calibid2));
        fCalibCathodes1->set_tzero(newID, fCalibCathodes2->get_tzero(calibid2));
        for(int adcid = 0 ; adcid < 4; adcid++)
        {
    fCalibCathodes1->set_charge(adcid, newID,
              fCalibCathodes2->get_charge(adcid, calibid2));
        }
        for(int mcid = 0 ; mcid < 10; mcid++)
        {
    fCalibCathodes1->set_MutMCIndex(mcid, newID,
            fCalibCathodes2->get_MutMCIndex(mcid, calibid2));
        }
        fCalibCathodes1->set_arm(newID, fCalibCathodes2->get_arm(calibid2));
        fCalibCathodes1->set_station(newID, fCalibCathodes2->get_station(calibid2));
        fCalibCathodes1->set_octant(newID, fCalibCathodes2->get_octant(calibid2));
        fCalibCathodes1->set_halfoctant(newID, fCalibCathodes2->get_halfoctant(calibid2));
        fCalibCathodes1->set_gap(newID, fCalibCathodes2->get_gap(calibid2));
        fCalibCathodes1->set_icath(newID, fCalibCathodes2->get_icath(calibid2));
        fCalibCathodes1->set_plane(newID, fCalibCathodes2->get_plane(calibid2));
        fCalibCathodes1->set_strip(newID, fCalibCathodes2->get_strip(calibid2));        
        
      }
    }

    afterCount = fCalibCathodes1->RowCount();

  }else
  {
    //Before pro.19 old wrapped staf table was used for Calibrated Cathodes
    PHIODataNode<dMutCalibCathodesWrapper>::iterator rCalibCathodes1(mainNode);
    if(rCalibCathodes1.find("dMutCalibCathodes")==0)
    { cout<<"dMutCalibCathodes not found.\n";
      return -1;
    }
    
    
    dMutCalibCathodesWrapper* fCalibCathodes1 = &(*rCalibCathodes1);
    dMutCalibCathodesOut* fCalibCathodes2 = &(*rCalibCathodes2);

    int beforeCount = fCalibCathodes1->RowCount();

    for(int calibid2 = 0; calibid2 < fCalibCathodes2->RowCount(); calibid2++)
    {
      bool calibfound = false;
      for(int calibid1 = 0; calibid1 < fCalibCathodes1->RowCount(); calibid1++)
      {
        if(calibfound) continue;

        //Are these the same cathodes
        if(
           fCalibCathodes1->get_arm(calibid1) == fCalibCathodes2->get_arm(calibid2) &&
           fCalibCathodes1->get_station(calibid1) == fCalibCathodes2->get_station(calibid2) &&
           fCalibCathodes1->get_octant(calibid1) == fCalibCathodes2->get_octant(calibid2) &&
           fCalibCathodes1->get_halfoctant(calibid1) == fCalibCathodes2->get_halfoctant(calibid2) &&
           fCalibCathodes1->get_gap(calibid1) == fCalibCathodes2->get_gap(calibid2) &&
           fCalibCathodes1->get_icath(calibid1) == fCalibCathodes2->get_icath(calibid2) &&
           fCalibCathodes1->get_plane(calibid1) == fCalibCathodes2->get_plane(calibid2) &&
           fCalibCathodes1->get_strip(calibid1) ==fCalibCathodes2->get_strip(calibid2)
           )
        {
          //Our signal file contains a hit that overlaps with the real data
          // So lets add the total charge of the hits and for now do nothing with adc values
          calibfound = true;
          fCalibCathodes1->set_qstrip(calibid1,
                                      fCalibCathodes1->get_qstrip(calibid1)
                                      + fCalibCathodes2->get_qstrip(calibid2)
                                      );

        }


      }

      //If the cathode was not hit in first file add it from second file
      if(!calibfound)
      {
        fCalibCathodes1->SetRowCount(fCalibCathodes1->RowCount() + 1);
        int newID = fCalibCathodes1->RowCount() - 1;
        fCalibCathodes1->set_qstrip(newID, fCalibCathodes2->get_qstrip(calibid2));
        fCalibCathodes1->set_qrms(newID, fCalibCathodes2->get_qrms(calibid2));
        for(int mcid = 0 ; mcid < 10; mcid++)
        {
          fCalibCathodes1->set_MutMCIndex(mcid, newID,
                                          fCalibCathodes2->get_MutMCIndex(mcid, calibid2));
        }
        fCalibCathodes1->set_arm(newID, fCalibCathodes2->get_arm(calibid2));
        fCalibCathodes1->set_station(newID, fCalibCathodes2->get_station(calibid2));
        fCalibCathodes1->set_octant(newID, fCalibCathodes2->get_octant(calibid2));
        fCalibCathodes1->set_halfoctant(newID, fCalibCathodes2->get_halfoctant(calibid2));
        fCalibCathodes1->set_gap(newID, fCalibCathodes2->get_gap(calibid2));
        fCalibCathodes1->set_icath(newID, fCalibCathodes2->get_icath(calibid2));
        fCalibCathodes1->set_plane(newID, fCalibCathodes2->get_plane(calibid2));
        fCalibCathodes1->set_strip(newID, fCalibCathodes2->get_strip(calibid2));

      }
    }
    afterCount = fCalibCathodes1->RowCount();
  }    
  cout<<"MutMerge: Before/After "<<beforeCount <<"/"<< afterCount<<endl;

  return 0;
}