SctApiHisto.cxx

#include "SctApi.h"
#include "SctApiConsts.h"
#include "SctApiDebug.h"
#include "SctApiHisto.h"
#include "ScanMonitorImpl.h"
#include "crate.h"
#include "primListWrapper.h"
#include "PrimBuilder.h"
#include "ConfigurationUtility.h"

#include "RodCrate/RodModule.h"
#include "RodCrate/TimDefine.h"
#include "CommonWithDsp/primParams.h"
#include "CommonWithDsp/registerIndices.h"

#include "Sct/AbcdScans.h"
#include "Sct/AbcdChip.h"
#include "Sct/StringStreamer.h"

#include "ScanResultWriter/scan.h"
#include "utility.h"

#include "primUtils.h"

#include "VmeDecode.h"

#ifdef USE_IS
#include <is/infoT.h>
#include "Sct/IoExceptions.h"
#include "ScanResultWriter/ScanResultWriter.h"
#endif
#include "Sct/SctNames.h"

#include "Scan.h"
#include "Trigger.h"
#include "SctApiException.h"

#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/lexical_cast.hpp>

#include <algorithm>

#include "Sct/MultiMessageDebugStream.h"
#include "Idiosyncrasy.h"
#include "ScanDefImpl.h"

using namespace std;
using namespace Sct;
using namespace SctPixelRod;
using namespace boost::posix_time;
using boost::shared_ptr;

namespace SctApi {

int useCCode(const SctApi& api, const Scan& scan){
  if (api.checkDebugOption(DEBUG_SCAN_USE_CCODE)) return 1;
  if (scan.getOption(Scan::USE_CCODE)) return 2;
  if (scan.getOption(Scan::FULL)) return 3;
//  if (scan.getOption(Scan::TIM)) return 3;
  if (scan.getOption(Scan::OPE)) return 4;
  return 0;
}

void SctApi::validateScan(boost::shared_ptr<const Scan> scan) {
  // Do checks on scan
  if(scan->getScanPoints2().size() != 0 && 
     scan->getScanPoints2().size() != scan->getScanPoints1().size()) {
    string message("Can't have two different sized scan points! (unless points(2) is empty)");
    cout << message << endl;
    if(mrs) {
      *mrs << "INVALID_SCAN" << MRS_ERROR 
           << MRS_QUALIF("SCTAPI") << MRS_QUALIF("doScan") 
       << MRS_PARAM<int>("ScanPoints(1) size",scan->getScanPoints1().size()) 
       << MRS_PARAM<int>("ScanPoints(2) size",scan->getScanPoints2().size())
           << MRS_TEXT(message)
           << ENDM;
    }
    throw SctApiException(message);
  }
  
  if(scan->getScanPoints1().empty() && scan->getScanPoints1().empty()){
    string message("Scan points are empty!");
    cout << message << endl;
    if(mrs) {
      *mrs << "INVALID_SCAN" << MRS_ERROR 
           << MRS_QUALIF("SCTAPI") << MRS_QUALIF("doScan") 
           << MRS_TEXT(message)
           << ENDM;
    }
    throw SctApiException(message);
  }
  
  if (scan->getTrigger1()->getRODTriggers().empty() 
      && scan->getTrigger2()->getRODTriggers().empty()){
    string message("Both triggers are empty!");
    cout << message << endl;
    if(mrs) {
      *mrs << "INVALID_TRIGGER" << MRS_ERROR 
           << MRS_QUALIF("SCTAPI") << MRS_QUALIF("doScan") 
           << MRS_TEXT(message)
           << ENDM;
    }
    throw SctApiException(message);
  }
  
  if (scan->getOption(Scan::TIM) && 
      !scan->getTrigger2()->getRODTriggers().empty()){
    string message("Can't have second trigger for TIM histogramming");
    cout << message << endl;
    if(mrs) {
      *mrs << "INVALID_TRIGGER" << MRS_ERROR 
           << MRS_QUALIF("SCTAPI") << MRS_QUALIF("doScan") 
       << MRS_PARAM<const char*>("Trigger(2)",scan->getTrigger1()->print().c_str())
       << MRS_TEXT(message)
       << ENDM;
    }
    throw SctApiException(message);
  }
  
  if (scan->getOption(Scan::TIM) && 
      !scan->getTrigger1()->isValidTIMTrigger()){
    string message("Trigger(1) is not a valid TIM trigger");
    if(mrs) {
      *mrs << "INVALID_TRIGGER" << MRS_ERROR 
           << MRS_QUALIF("SCTAPI") << MRS_QUALIF("doScan") 
           << MRS_TEXT(message)
       << MRS_PARAM<const char*>("Trigger(1)",scan->getTrigger1()->print().c_str())
       << ENDM;
    }
    throw SctApiException(message);
  }
  
  if(scan->getOption(Scan::TIM)==0 && 
     !scan->getTrigger1()->isValidRODTrigger()){
    string message("Trigger(1) is not a valid ROD trigger");
    cout << message << endl;
    if(mrs) {
      *mrs << "INVALID_TRIGGER" << MRS_ERROR 
           << MRS_QUALIF("SCTAPI") << MRS_QUALIF("doScan") 
           << MRS_TEXT("Trigger(1) is not a valid ROD trigger")
       << MRS_PARAM<const char*>("Trigger(1)",scan->getTrigger1()->print().c_str())
       << ENDM;
    }
    throw SctApiException(message);
  }

  if(scan->getOption(Scan::TIM)==0 &&
     !scan->getTrigger2()->getRODTriggers().empty() && 
     scan->getTrigger2()->isValidRODTrigger()){
    string message("Trigger(2) is not a valid ROD trigger");
    cout << message << endl;
    if(mrs) {
      *mrs << "INVALID_TRIGGER" << MRS_ERROR 
           << MRS_QUALIF("SCTAPI") << MRS_QUALIF("doScan") 
           << MRS_TEXT("Trigger(2) is not a valid ROD trigger")
       << MRS_PARAM<const char*>("Trigger(2)",scan->getTrigger1()->print().c_str())
       << ENDM;
    }
    throw SctApiException(message);
  }  
}

boost::shared_ptr<ScanMonitor> SctApi::startAsyncScan(boost::shared_ptr<const Scan> scan) {
  return boost::shared_ptr<ScanMonitor> ( new ScanMonitorImpl(startScan(scan, false)));
}

boost::shared_ptr<ScanControl> SctApi::startScan(boost::shared_ptr<const Scan> constScan, bool pollTriggers) {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "startScan\n";
  }
  
#if USE_CONST_SCAN
  boost::shared_ptr<const Scan> scan = constScan;
#else
#warning "Shouldn't do this!!!!"
  // Problem is multiple crates"
  // Move nonconst stuff to ScanEx which isn't broadcast over IPC
  std::cout << "Copying the constScan to a private version we can modify" << std::endl;
  boost::shared_ptr<Scan> scan = ScanDefImpl::clone(constScan);
  std::cout << "Finished copying the constScan to a private version we can modify" << std::endl;
#endif

  // Set up parameters
  boost::shared_ptr<ScanEx> extra(new ScanEx);

#if USE_CONST_SCAN
  extra->setStartTime(second_clock::universal_time());
#else
  scan->setStartTime(second_clock::universal_time());
#endif

  extra->diagnosticReg = 0;

  extra->trimScan = 0;
  if(scan->getScanVariable1() == ST_TRIM) {
    // We need to download the trim configuration
    extra->trimScan = 1;
  }

  cout << "Do scan " << scanNumber << ":\n";
  // Scan extra->
  scan->setRunNumber(runNumber);
  scan->setScanNumber(scanNumber);

  // Increment the scan number before doing anything else
  if(scan->getOption(Scan::FULL)) {
    // A full scan is three consecutive histograms (different time bins)
    scanNumber += 3;
  } else {
    scanNumber += 1;
  }

  if(mrs) {
    const std::string s1 = (Sct::StringStreamer << "SCAN_REQSD_" << ucid());
    const std::string s2 = (Sct::StringStreamer << "Scan requested on " << ucid());
    
    *mrs << s1 << MRS_INFORMATION
         << MRS_PARAM<int>("run", runNumber) << MRS_PARAM<int>("scan", scan->getScanNumber()) << MRS_TEXT(s2) << ENDM;
  }

  std::cout << scan->print() << std::endl;

  validateScan(scan);

  if(!checkModuleListsForScan()) {
    throw SctApiException("Invalid scan. Module lists check failed");
  }

  setupScanMasks(*extra, scan->getOption(Scan::DISTSLAVE), scan->getScanPoints2().size() != 0);

  RodLabel zeroRod = extra->rodInfo.begin()->first;

#if !USE_CONST_SCAN
  // Tell the scan which modules are in which groups (extra already knows)
  for(unsigned int i = 0;
      i<extra->groupLists.size();
      i++) {
    scan->setModuleList(i, extra->groupLists[i]);
  }
  scan->setNGroups(extra->groupLists.size());
#endif

  // Report module masks
  if(checkDebugOption(DEBUG_DIAG)) {
    RodScanEx &rodInfo = extra->rodInfo.find(zeroRod)->second;
    cout << hex << "Channels in use: 0x" << rodInfo.channels.mask0 << " 0x" << rodInfo.channels.mask1 << dec << endl;

    for(int i=0; i<numSlaves * 2; i++) {
      cout << hex << "Group channels: 0x" << rodInfo.groupChannels[i].mask0 << " 0x" << rodInfo.groupChannels[i].mask1 << dec << endl;
    }

    for(int i=0; i<numSlaves; i++) {
      cout << hex << "Slave channels: 0x" << rodInfo.slaveChannels[i].mask0 << " 0x" << rodInfo.slaveChannels[i].mask1 << dec << endl;
    }

    cout << "Slave DSP bit-field: " << hex << (int)rodInfo.bitFieldDSP << dec << " nSlaves: " << rodInfo.slaves << endl;

    hex(cout);
    for(int i=0; i<numSlaves; i++) {
      cout << "Groups on DSP " << i << ": 0x" << (int)extra->groupDspMap[i] << endl;
    }

    for(int i=0; i<2; i++) {
      cout << "Groups to serial port " << i << ": 0x" << (int)extra->groupSpMap[i] << endl;
    }

    for(int i=0; i<2; i++) {
      cout << "Groups using range list " << i << ": 0x" << (int)extra->groupRangeMap[i] << endl;
    }
    dec(cout);
  }

  for(ScanEx::RodInfoMap::const_iterator ri = extra->rodInfo.begin();
      ri != extra->rodInfo.end();
      ri++) {
    if(ri->second.bitFieldDSP & 0xf == 0) {
#warning "Should only abort if no slaves on all RODs?"
      cout << "No slaves have been deemed involved in histogramming aborting\n";
      if(mrs) {
        *mrs << MRS_ERROR 
             << "SCAN_NODSP" 
             << MRS_QUALIF("SCTAPI") << MRS_QUALIF("doScan") 
             << MRS_TEXT("No DSP matched to modules for scan")
             << MRS_PARAM<int>("partition", ri->first.partition)
             << MRS_PARAM<int>("crate", ri->first.crate)
             << MRS_PARAM<int>("rod", ri->first.rod)
             << ENDM;
      }
      // Harshly abort if one ROD doesn't have modules in a scan...
      throw SctApiException("Invalid scan. A ROD doesn't have any modules attached");
    }
  }

  if (mrs){
    ostringstream oss;
    oss << ucid() << " Starting pre scan hardware check";
    *mrs << MRS_INFORMATION << MRS_QUALIF("SCTAPI") << "HARDWARE_CHECK" 
     << MRS_TEXT(oss.str()) << ENDM;
  };  

  if (!preScanHardwareCheck(*scan.get(), *extra)) throw SctApiException("Pre scan hardware check failed");

  std::cout << ucid() << " Starting pre-scan module setup at TIME " << second_clock::universal_time() << std::endl;

  if (mrs){
    ostringstream oss;
    oss << ucid() << " Starting pre scan module setup";
    *mrs << MRS_INFORMATION << MRS_QUALIF("SCTAPI") << "MODULE_SETUP" 
     << MRS_TEXT(oss.str()) << ENDM;
  };  

  preScanModuleSetup(*scan.get());
  
  { 
    // Check for soft reset and update diagnostic reg accordingly.
    Trigger::RODTriggers points = scan->getTrigger1()->getRODTriggers();

    for(unsigned int i=0; i<points.size(); i++) {
      if(points[i].first == SOFT_RESET) {
        cout << "Do extra soft reset before trigger to mask soft reset in trigger\n";
        extra->diagnosticReg |= 1 << DR_SOFT_BC_RESET;
      }
    }
  }

  bool setupGood = true;


  if (mrs){
    ostringstream oss;
    oss << ucid() << " Setting up DSP histogramming tasks";
    *mrs << MRS_INFORMATION << MRS_QUALIF("SCTAPI") << "HISTO_SETUP" 
     << MRS_TEXT(oss.str()) << ENDM;
  };  


  std::cout << ucid() << " Setting up histogramming tasks started at TIME " 
        << second_clock::universal_time()  << std::endl;
  
  try {
    cout << "Setup histogramming tasks ...\n";
    doHistogramSetup(*scan.get(), *extra);
    cout << " ... done setup histogramming tasks\n";
  } catch(SctApiException &s) {
    setupGood = false;
  }

  // Send MRS message first so timing not involved
  if(mrs) {
    const std::string s1 = (Sct::StringStreamer << "SCAN_STARTED_" << ucid());
#if USE_CONST_SCAN
    const std::string s2 = (Sct::StringStreamer << "Scan started on " << ucid() << " with nGroups " << extra->getNGroups() );
#else
    const std::string s2 = (Sct::StringStreamer << "Scan started on " << ucid() << " with nGroups " << scan->getNGroups() );
#endif
    *mrs << s1 << MRS_INFORMATION 
         << MRS_QUALIF("SCTAPI") << MRS_QUALIF("doScan") 
         << MRS_TEXT(s2) 
         << MRS_PARAM<int>("ScanNumber", scan->getScanNumber())
         << MRS_PARAM<int>("ScanType1", scan->getScanVariable1())
         << MRS_PARAM<int>("ScanType2", scan->getScanVariable2())
         << ENDM;
  }

  boost::shared_ptr<ScanControl> newScanController;

  try {
    if(setupGood) {
      // Decide which controller to use
      if(!pollTriggers) {
        newScanController.reset(new ScanControlAsyncHisto(*this, scan, extra));
      } else if(scan->getOption(Scan::TIM)) {
        newScanController.reset(new ScanControlTIMHisto(*this, scan, extra));
      } else {
        newScanController.reset(new ScanControlRODHisto(*this, scan, extra));
      }

      std::cout << ucid() << " Starting histogramming ...  at TIME " << second_clock::universal_time() << std::endl;
      newScanController->startHistogramming();
      std::cout << ucid() << " Histogramming started at TIME " << second_clock::universal_time() << std::endl;
    }
  } catch(SctApiException &s) {
    setupGood = false;
  }

  if(setupGood) {
    // Do polling in separate thread, first 
    // If external triggers then don't do polling loop
    if(pollTriggers) {
      scanController = newScanController;
    }
  }

  std::cout << ucid() << " finished histo setup at TIME " 
        << second_clock::universal_time() << std::endl;

  return newScanController;
}

void SctApi::doScan(boost::shared_ptr<const Scan> scan) {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "doScan\n";
  }

  boost::shared_ptr<ScanControl> monitor = startScan(scan, true);

// if not using a scan thread, need to do the scan loop polling here.
#if ( (USE_SCAN_THREAD) ==0 )
  if(monitor) {
    std::cout << "No scan thread - doing the scan loop polling in same thread!" << std::endl;
    // But not for now
    scanLoop();
  }
#endif
}

void SctApi::awaitScan() {
  while((scanController || m_inScanLoop) || m_inRawScanLoop) {
    sleep(1);
  }
}

/* Called by scanPollingThread */
void SctApi::scanLoop() {
  // Do this before getting the scan out
  m_inScanLoop = true;

  boost::shared_ptr<ScanControl> control;

  // Effectively kills scanController... ie should have a different name
  swap(control, scanController);

  // For the debug methods to talk to
  lastScanController = control;

  if(!control) {
    cout << "Given null scan aborting!\n";
    return;
  }

  control->initialisePolling();

  int pollReturn = pollHistogramming(control, 3);

  cout << "pollHistogramming complete (" << pollReturn << ")\n";

  control->finishHistogram(pollReturn == 0);

  // Do this before getting the scan out
  m_inScanLoop = false;
}

void SctApi::scanPollingThread() {
  cout << "SCAN: Start polling thread\n";
  while(!m_stopPolling) {
    usleep(500000);
    if(scanController) {
      scanLoop();
    }
  }
}

void SctApi::setupEventTrapping(const Scan &scan, const ScanEx &ex, const RodLabel rod, boost::shared_ptr<PrimListWrapper> primList) {
  const RodScanEx &rodInfo = ex.getRodScanInfo(rod);

  // Set up each slave individually
  for(int slaveNumber=0; slaveNumber<numSlaves; slaveNumber++) {
    if((rodInfo.bitFieldDSP & (1<<slaveNumber)) && getCrate()->slavePresent(rod.rod, slaveNumber)) {
      int match;
      int modulus;            // Trap if (count % mod) == rem
      int remainder;

      switch(scan.getOption(Scan::DISTSLAVE)) {
      case 0:
        // Single slave
        match = 0;
        modulus = 1;
        remainder = 0;

        if(scan.getOption(Scan::NTH) > 1) {
          // Only trap every nth trigger
          modulus = scan.getOption(Scan::NTH);
          remainder = scan.getOption(Scan::NTH_REM);
        }
        break;
      case 1:
        // Group distribution
        match = slaveNumber;  // Match number set by histo control to distribute to slaves
        modulus = 1;
        remainder = 0;
        break;
      case 2:
        // Router distribution, between 4 DSPs
        match = 0;
        modulus = rodInfo.slaves;
        remainder = slaveNumber;

        if(scan.getOption(Scan::NTH) > 1) {
          modulus = rodInfo.slaves * scan.getOption(Scan::NTH);
          remainder = slaveNumber * scan.getOption(Scan::NTH) + scan.getOption(Scan::NTH_REM);
        }
        break;
      default:
        match = 0;
        modulus = 1;
        remainder = 0;
        break;
      }

      eventTrapSetup(0x1 << slaveNumber, 
                     match, modulus, remainder,
                     scan.getOption(Scan::TIM), checkDebugOption(DEBUG_SCAN_ERROR_TRAP_ALL), primList);
    }
  }
}

void SctApi::setupEventDump(const Scan &scan, const ScanEx &ex, const RodLabel rod, boost::shared_ptr<PrimListWrapper> primList) {
  if(!(checkDebugOption(DEBUG_SCAN_ERROR_TRAP) && scan.getOption(Scan::DEBUG))) return;

  int slaveNumber = 2;

  // No difference depending where its run...
  {
    // Trap all events as errors
    long *evData = new long[sizeof(EVENT_TRAP_SETUP_IN)/sizeof(long)];

    EVENT_TRAP_SETUP_IN &primData = *(EVENT_TRAP_SETUP_IN*)evData;

#if R_EVENT_TRAP_SETUP == 103
    primData.slvBits = 0x1 << slaveNumber;
    primData.numberOfEvents = COLLECT_FOREVER;
    primData.timeoutInUsec = 0x30000;

    primData.extRouterSetup = 0;

    // This tells the setup code to change the trapRemainder
    //  Only matters if setting up more than one slave
    primData.distribute = TRAP_DISTRIB_NEITHER;

    primData.releaseFrames = 0;
    primData.permitBackPressure = 1;
    primData.dataMode = 0;                        // Data or Event mode
    primData.sLink = 0;                           // Where to pick events (dsp or router)

    primData.format = TRAP_FMT_ERROR;             // Slink format
    primData.trapStray = 1;                       // Trap stray events
    primData.iterLimit = 2;                       // Don't keep them long

    // Trap events from ROD triggers
    primData.trapConfig[0] = TRAP_CFG_ROD_EVT;
    primData.trapExclusionFlag[0] = 0;            // Don't exclude anything
    primData.trapFunction[0] = TRAP_FXN_RESYNCH;

    primData.trapMatch[0] = 0;                    // = slave number??
    primData.trapModulus[0] = 1;                  // Trap if (count % mod) == rem
    primData.trapRemainder[0] = 0;

    // Trap one is idle
    primData.trapConfig[1] = TRAP_CFG_IDLE;
    primData.trapExclusionFlag[1] = 0;
    primData.trapFunction[1] = 0;

    primData.trapMatch[1] = 0; 
    primData.trapModulus[1] = 0;
    primData.trapRemainder[1] = 0;
#else 
#error "Event trapping not compiled (new Primitive definition)!"
#endif
    primList->addPrimitive(RodPrimitive(sizeof(EVENT_TRAP_SETUP_IN)/sizeof(UINT32) + 4, 
                                        0, EVENT_TRAP_SETUP, R_EVENT_TRAP_SETUP, evData),
                           evData);
  }

  // Start event trapping on slave 2
  startEventTrap(slaveNumber, primList);

  // Start a dump to remove the events...
  {
    long *taskData = new long[sizeof(START_TASK_IN)/sizeof(long)];

    for(unsigned int i=0; i<sizeof(START_TASK_IN)/sizeof(long); i++) {
      taskData[i] = 0;
    }

    START_TASK_IN &taskPrim = *(START_TASK_IN *)taskData;

    taskPrim.taskType = RESYNCH_TASK;
    taskPrim.taskRevision = R_RESYNCH_TASK;
    taskPrim.priority = 1; // Top???
    taskPrim.completionFlag = 1; 

    RESYNCH_TASK_IN &resynch = taskPrim.taskStruct.resynchTaskIn;

    resynch.errorType = 0;

    shared_ptr<PrimListWrapper> myList(new PrimListWrapper(4));

    myList->addPrimitive(RodPrimitive(4 + sizeof(START_TASK_IN)/sizeof(UINT32),
                                      3, START_TASK, R_START_TASK, taskData),
                         taskData);

    PrimBuilder::instance().slavePrimList(primList, myList, slaveNumber, true, true);
  }
}

void SctApi::startEventTrapping(const Scan &scan, const ScanEx &ex, const RodLabel rod, shared_ptr<PrimListWrapper> primList) {
  const RodScanEx &rodInfo = ex.getRodScanInfo(rod);

  for(int slaveNumber=0; slaveNumber<numSlaves; slaveNumber++) {
    if((rodInfo.bitFieldDSP & (1<<slaveNumber)) && getCrate()->slavePresent(rod.rod, slaveNumber)) {
      startEventTrap(slaveNumber, primList);
    }
  }
}

void SctApi::setupHistogramming(const Scan &scan, const ScanEx &ex, const RodLabel rod, bool tim, 
                                 boost::shared_ptr<PrimListWrapper> primList) {
  const RodScanEx &rodInfo = ex.getRodScanInfo(rod);

  int nBins = scan.getScanPoints1().size();
  if(!scan.getOption(Scan::BITS32)) {
    if(nBins%2 == 1) {
      nBins += 1;
    }
  }

  for(int slaveNumber = 0; slaveNumber < 4; slaveNumber ++) {
    if((rodInfo.bitFieldDSP & (1<<slaveNumber)) && getCrate()->slavePresent(rod.rod, slaveNumber)) {
      // Primitive
      long *histoData = new long[sizeof(HISTOGRAM_SETUP_IN)/sizeof(UINT32)];

      HISTOGRAM_SETUP_IN &primData = *(HISTOGRAM_SETUP_IN*)histoData;

#if (R_HISTOGRAM_SETUP == 108)
      primData.base = (UINT32 *)0xffffffff;//  HISTOGRAM_DEFAULT_BASE;    // 0x20d2000
      primData.nBins = nBins; 

      primData.dataType[0] = scan.getScanVariable1();
      primData.dataType[1] = scan.getScanVariable2();

      primData.binSize = scan.getOption(Scan::BITS32)?HISTOGRAM_32BIT:HISTOGRAM_16BIT;

      if(useCCode(*this, scan)) {
        primData.routineType = HISTO_ROUTINE_C;
    {
      Sct::MultiMessageDebugStream m(true,false,true);
      m << ucid() << " is using CCODE rather than ASM for histogramming (reason="
        << useCCode(*this,scan) << ")";
    };
      } else {
        primData.routineType = HISTO_ROUTINE_ASM;
      }

      // The meanings of the histogramming options have been unilaterally redefined by Douglas...
      // doChipOcc
      //   supported with both ASM and C histogramming
      primData.opt[0] = scan.getOption(Scan::OPE)?1:0;
      // dataFormat
      //   not supported by either ASM or C histogramming
      primData.opt[1] = scan.getOption(Scan::FULL)?HISTOGRAM_FULL:HISTOGRAM_CONDENSED;          // Get all three data sets
      // verbose
      //   only supported by C histogramming
      primData.opt[2] = 0;
      // unused
      primData.opt[3] = 0;

      UINT8 groupMap = ex.groupDspMap[slaveNumber];

      primData.validModules[0] = 0;
      primData.validModules[1] = 0;

      primData.moduleRangeMap[0][0] = 0;
      primData.moduleRangeMap[0][1] = 0;
      primData.moduleRangeMap[1][0] = 0;
      primData.moduleRangeMap[1][1] = 0;

      for(int i=0; i<8; i++) {
        if(groupMap & (1<<i)) {
          primData.validModules[0] |= rodInfo.groupChannels[i].mask0;          // Modules to this slave
          primData.validModules[1] |= rodInfo.groupChannels[i].mask1;          //    32-47 in low 16 bits

          if(ex.groupSpMap[0] & (1<<i)) {
            primData.moduleRangeMap[0][0] |= rodInfo.groupChannels[i].mask0;
            primData.moduleRangeMap[0][1] |= rodInfo.groupChannels[i].mask1;
          }
          if(ex.groupSpMap[1] & (1<<i)) {
            primData.moduleRangeMap[1][0] |= rodInfo.groupChannels[i].mask0;
            primData.moduleRangeMap[1][1] |= rodInfo.groupChannels[i].mask1;
          }
        }
      }

      primData.xPtr[0] = (FLOAT32 *)0xffffffff; // 0x3f00000;                    // Where the fit data will be stored
      primData.xPtr[1] = (FLOAT32 *)0xffffffff; // 0x3f01000; 
#elif (R_HISTOGRAM_SETUP == 105) || (R_HISTOGRAM_SETUP == 107)
      primData.base = (UINT32 *)0xffffffff;//  HISTOGRAM_DEFAULT_BASE;    // 0x20d2000
      primData.nBins = nBins; 

      primData.padding[0] = 0;
      primData.padding[1] = 0;

      primData.dataType[0] = scan.getScanVariable1();
      primData.dataType[1] = scan.getScanVariable2();

      primData.binSize = scan.getOption(Scan::BITS32)?HISTOGRAM_32BIT:HISTOGRAM_16BIT;

      // arrangement
      primData.opt[0] = HISTOGRAM_SLICE; // scan.getOption(Scan::FORMAT)?HISTOGRAM_SLICE:HISTOGRAM_BLOCK;
      // dataFormat
      primData.opt[1] = scan.getOption(Scan::FULL)?HISTOGRAM_FULL:HISTOGRAM_CONDENSED;          // Get all three data sets
      // unused
      primData.opt[2] = 0;
#if(R_HISTOGRAM_SETUP == 107)
      primData.opt[3] = 0;
#endif

      UINT8 groupMap = ex.groupDspMap[slaveNumber];

      primData.validModules[0] = 0;
      primData.validModules[1] = 0;

      primData.moduleRangeMap[0][0] = 0;
      primData.moduleRangeMap[0][1] = 0;
      primData.moduleRangeMap[1][0] = 0;
      primData.moduleRangeMap[1][1] = 0;

      for(int i=0; i<8; i++) {
        if(groupMap & (1<<i)) {
          primData.validModules[0] |= rodInfo.groupChannels[i].mask0;          // Modules to this slave
          primData.validModules[1] |= rodInfo.groupChannels[i].mask1;          //    32-47 in low 16 bits

          if(ex.groupSpMap[0] & (1<<i)) {
            primData.moduleRangeMap[0][0] |= rodInfo.groupChannels[i].mask0;
            primData.moduleRangeMap[0][1] |= rodInfo.groupChannels[i].mask1;
          }
          if(ex.groupSpMap[1] & (1<<i)) {
            primData.moduleRangeMap[1][0] |= rodInfo.groupChannels[i].mask0;
            primData.moduleRangeMap[1][1] |= rodInfo.groupChannels[i].mask1;
          }
        }
      }

      primData.xPtr[0] = (FLOAT32 *)0xffffffff; // 0x3f00000;                    // Where the fit data will be stored
      primData.xPtr[1] = (FLOAT32 *)0xffffffff; // 0x3f01000; 
#elif R_HISTOGRAM_SETUP == 104
      primData.base = (UINT32 *)0xffffffff; // HISTOGRAM_DEFAULT_BASE;    // 0x20d2000
      primData.rodType = ROD_TYPE_SCT;
      primData.nBins = nBins;

      primData.padding[0] = 0;
      primData.padding[1] = 0;

      primData.dataType[0] = scan.getScanVariable1();
      primData.dataType[1] = scan.getScanVariable2();

      primData.arrangement = HISTOGRAM_SLICE;
      primData.dataFormat = scan.getOption(Scan::FULL)?HISTOGRAM_FULL:HISTOGRAM_CONDENSED;          // Get all three data sets
      primData.binSize = scan.getOption(Scan::BITS32)?HISTOGRAM_32BIT:HISTOGRAM_16BIT;
      primData.unused = 0;

      if(scan.getOption(Scan::DISTSLAVE) == 1) {
        primData.validModules[0] = rodInfo.groupChannels[slaveNumber][0];          // Modules to this slave
        primData.validModules[1] = rodInfo.groupChannels[slaveNumber][1];          //    32-47 in low 16 bits
        primData.moduleRangeMap[0][0] = rodInfo.groupChannels[slaveNumber][0];     // All modules use rangemap 0
        primData.moduleRangeMap[0][1] = rodInfo.groupChannels[slaveNumber][1];
      } else {
        primData.validModules[0] = rodInfo.channels[0];                          // Modules to this slave
        primData.validModules[1] = rodInfo.channels[1];                          //    32-47 in low 16 bits
        primData.moduleRangeMap[0][0] = rodInfo.channels[0];                     // All modules use rangemap 0
        primData.moduleRangeMap[0][1] = rodInfo.channels[1];
      }
      primData.moduleRangeMap[1][0] = 0;                                    // No modules for rangemap 1
      primData.moduleRangeMap[1][1] = 0;

      primData.xPtr[0] = (FLOAT32 *)0x3f00000;                              // Where the fit data will be stored
      primData.xPtr[1] = (FLOAT32 *)0x3f01000; 
#else 
#error "Histogram setup not compiled (new Primitive definition)!"
#endif

      long *taskData = new long[sizeof(START_TASK_IN)/sizeof(UINT32)];

      for(unsigned int i=0; i<sizeof(START_TASK_IN)/sizeof(UINT32); i++) {
        taskData[i] = 0;
      }

      START_TASK_IN &taskPrim = *(START_TASK_IN *)taskData;

      taskPrim.taskType = HISTOGRAM_TASK;
      taskPrim.taskRevision = R_HISTOGRAM_TASK;
      taskPrim.priority = 1; // Top???
      taskPrim.completionFlag = 1; 

      HISTOGRAM_TASK_IN &histoTaskData = taskPrim.taskStruct.histogramTaskIn;

      histoTaskData.nEvents = COLLECT_FOREVER;
      if(tim) {
        histoTaskData.controlFlag = LOCAL_SET_TRIG;
      } else {
        histoTaskData.controlFlag = MASTER_HREG;
      }

      boost::shared_ptr<PrimListWrapper> myList(new PrimListWrapper(4));

      myList->addPrimitive(RodPrimitive(4 + sizeof(HISTOGRAM_SETUP_IN)/sizeof(UINT32), 
                                        2, HISTOGRAM_SETUP, R_HISTOGRAM_SETUP, histoData),
                           histoData);
      myList->addPrimitive(RodPrimitive(4 + sizeof(START_TASK_IN)/sizeof(UINT32),
                                        3, START_TASK, R_START_TASK, taskData),
                           taskData);

      PrimBuilder::instance().slavePrimList(primList, myList, slaveNumber, true, true);
    }
  }
}

void SctApi::startHistogramTask(const Scan &scan, const ScanEx &ex, const RodLabel rod, 
                                unsigned int startBin, unsigned int nBins, unsigned int nTrigs,
                                boost::shared_ptr<PrimListWrapper> primList) {
  const RodScanEx &rodInfo = ex.getRodScanInfo(rod);

  // The number of bins in the variable list has to be nBins...
  unsigned int allBins = nBins;

  long *ctrlData = new long[sizeof(START_TASK_IN)/sizeof(UINT32) + allBins * 2];

  for(unsigned int i=0; i<sizeof(START_TASK_IN)/sizeof(UINT32) + allBins * 2; i++) {
    ctrlData[i] = 0;
  }

  struct START_TASK_IN &primData = *(START_TASK_IN*)ctrlData;
  struct HISTOGRAM_CTRL_TASK_IN &taskData = primData.taskStruct.histoCtrlTaskIn; 

#if (R_HISTOGRAM_CTRL_TASK == 107)
  primData.taskType = HISTOGRAM_CTRL_TASK;
  primData.taskRevision = R_HISTOGRAM_CTRL_TASK;
  primData.priority = 1;
  primData.completionFlag = 1; 

  taskData.slvBits = rodInfo.bitFieldDSP;   // Which DSPs to use

  if(scan.getScanPoints2().size() > 0) {
    taskData.port = SP_BOTH;
  } else {
    //@todo Should this be SP_BOTH??? 
    // The histogramming itself can only use one port...
    // But this may tell the engine to configure modules using both ports?
    // Which would be good to do anyway
    //taskData.port = SP_BOTH;
    taskData.port = SP0;
  }

  taskData.configRegister[0] = scan.getScanVariable1(); // ST_VTHR;
  taskData.configRegister[1] = scan.getScanVariable2(); // ST_VTHR;

  taskData.configSctSet = Utility::translateBank(SCTAPI_BANK_SCAN);

  // Which bit of configuration to send, unless this is a trim scan then basic should be enough
#if (R_RW_MODULE_DATA>=103)
  if(!ex.trimScan) {
    taskData.dataSet = CONFIG_MODULE_BASIC; 
  }else{ 
    taskData.dataSet = CONFIG_MODULE_TRIM;               // Which bit of configuration to send
  }
#else
#warning "Using old dataSet values (pre 11 April 2005 dsp code) AJB wonders if this is actually #defined or typedefed to the same values..."
  if(!ex.trimScan) {
    taskData.dataSet = MODULE_BASIC; 
  }else{ 
    taskData.dataSet = MODULE_TRIM;               // Which bit of configuration to send
  }
#endif

  taskData.groupRangeMap[0] = ex.groupRangeMap[0];
  taskData.groupRangeMap[1] = ex.groupRangeMap[1];

  taskData.groupDSPMap[0] = ex.groupDspMap[0];
  taskData.groupDSPMap[1] = ex.groupDspMap[1];
  taskData.groupDSPMap[2] = ex.groupDspMap[2];
  taskData.groupDSPMap[3] = ex.groupDspMap[3];

  taskData.groupSPMap[0] = ex.groupSpMap[0];
  taskData.groupSPMap[1] = ex.groupSpMap[1];

  taskData.globalCtrl = 0;              // Don't want to take control for internal triggers
  taskData.syncLevel = 0;               //  So don't need synchronisation 

  taskData.histoBase = (UINT32*)0xffffffff; // HISTOGRAM_DEFAULT_BASE;    // 0x20d2000

  taskData.doChipOcc = scan.getOption(Scan::OPE)?1:0;
  taskData.dataFormat = scan.getOption(Scan::FULL)?HISTOGRAM_FULL:HISTOGRAM_CONDENSED;
  taskData.binSize = scan.getOption(Scan::BITS32)?HISTOGRAM_32BIT:HISTOGRAM_16BIT;
  taskData.unused1 = 0;

  taskData.extSetup = 0xff;                    // This is specifies which setup tasks are done externally (to the control task)
  taskData.dataPath = DATA_PATH_NORMAL;        // Other option is INMEM (presumably TestBench based)
  taskData.capture = 0;
  taskData.useRangeList = 0;                   // Major difference from Doug's example!

  taskData.repetitions = nTrigs;
  taskData.nBins = nBins;
  taskData.bin0 = startBin;

  // Ignore range list data 
  for(int i=0; i<5; i++) {
    taskData.rangeList[0].xPair[i].x0 = 0.0;
    taskData.rangeList[1].xPair[i].x0 = 0.0;
    taskData.rangeList[0].xPair[i].delta_x = 0.0;
    taskData.rangeList[1].xPair[i].delta_x = 0.0;
  }

  // X data lists
  taskData.dataPtr[0] = (FLOAT32 *)0xffffffff;   // Data for group 1               Append to end of primitive
  taskData.dataPtr[1] = (FLOAT32 *)0xffffffff;   // Data for group 2

  // Clear trigger sequences
  for(int i=0; i<N_CMD_LIST_CMDS; i++) {            // from primParams.h
    taskData.triggerSequence[0].cmd[i] = NO_CMD;    // Set a trigger sequence
    taskData.triggerSequence[1].cmd[i] = NO_CMD;    // Set a trigger sequence
    taskData.triggerSequence[0].data[i] = 0;        // Set a trigger sequence
    taskData.triggerSequence[1].data[i] = 0;        // Set a trigger sequence
  }


//    // Two L1As (illegal without delay?!)
//    taskData.triggerSequence[0].cmd[0] = L1_TRIGGER;
//    taskData.triggerSequence[1].cmd[0] = L1_TRIGGER;
//    taskData.triggerSequence[0].cmd[1] = L1_TRIGGER;
//    taskData.triggerSequence[1].cmd[1] = L1_TRIGGER;

  Trigger::RODTriggers points = scan.getTrigger1()->getRODTriggers();

  for(unsigned int i=0; i<points.size(); i++) {
    taskData.triggerSequence[0].cmd[i] = points[i].first;        // Set a trigger sequence
    taskData.triggerSequence[0].data[i] = points[i].second;      // Set a trigger sequence
  }

  if(scan.getScanPoints2().size() > 0) {
    points = scan.getTrigger2()->getRODTriggers();

    for(unsigned int i=0; i<points.size(); i++) {
      taskData.triggerSequence[1].cmd[i] = points[i].first;      // Set a trigger sequence 2
      taskData.triggerSequence[1].data[i] = points[i].second;    // Set a trigger sequence 2
    }
  } else {
    // Leave as default
  }

//    taskData.triggerSequence[0].cmd[0] = CALIBRATION_PULSE;
//    taskData.triggerSequence[0].cmd[1] = DELAY;
//    taskData.triggerSequence[0].cmd[2] = L1_TRIGGER;

//    taskData.triggerSequence[0].data[1] = 0x81;

  unsigned short cmd, data;

  scan.getTrigger1()->getCommIncr(cmd, data);
  taskData.incCmd[0] = cmd;
  taskData.incData[0] = data;
  scan.getTrigger2()->getCommIncr(cmd, data);
  taskData.incCmd[1] = cmd;
  taskData.incData[1] = data;

  taskData.calLineLoop = scan.getOption(Scan::LOOPCALLINE);
  if(scan.getOption(Scan::DISTSLAVE) == 2) {
    taskData.distributionToggle = ROUTER_DISTRIB;
  } else {
    taskData.distributionToggle = MODULE_GROUP;
  }

  for(int i=0; i<10; i++) {
    taskData.genData[i] = 0;
  }

  // Defined groups
  taskData.genData[0] = 0xff;

  if(scan.getScanPoints2().size() > 0) {
    taskData.genData[1] = 1;
    taskData.genData[2] = 0x0200; // 0301;
  }

#elif (R_HISTOGRAM_CTRL_TASK == 105)
  primData.taskType = HISTOGRAM_CTRL_TASK;
  primData.taskRevision = R_HISTOGRAM_CTRL_TASK;
  primData.priority = 0; // Top???
  primData.completionFlag = 1; 

  taskData.slvBits = 0xf;             // Use all slaves
  taskData.configSctSet = translateBank(SCTAPI_BANK_PHYSICS);
  // Not an array yet
//    taskData.configRegister[0] = 0;     // V_THR ??
//    taskData.configRegister[1] = 0;     // V_THR ??
  taskData.dataSet = 0;               // ??
  taskData.useRangeList = 0;          // ??
  taskData.groupRangeMap[0] = 0;      // No range map
  taskData.groupRangeMap[1] = 0;      //  ditto
  taskData.cmdBuff = CMD_BUFFER_BOTH;     // Which serial port to use
  taskData.dataPtr[0] = group1Data;   // Data for group 1
  taskData.dataPtr[1] = group2Data;   // Data for group 2
  taskData.repetitions = 10;          // Make it stop quickly 10 events
  taskData.nBins = 10;                // 10 bins
  taskData.bin0 = 0;                  // Start at 0

  taskData.triggerSequence[0];        // Set a trigger sequence
  taskData.triggerSequence[1];        // Set a trigger sequence

  taskData.incCmd[0] = 0;
  taskData.incCmd[1] = 0;
  taskData.calLineLoop = 0;  // Doesn't work yet??

  taskData.distributionToggle = 0;  // ??
  taskData.incData[0] = 1;
  taskData.incData[1] = 1;

  taskData.groupSPMap[0] = 0;
  taskData.groupSPMap[1] = 0;
#else  // Unknown R_HISTOGRAM_CTRL_TASK
#error "Histogram Task not compiled (new Primitive definition)!" 
#endif

  int offset = sizeof(START_TASK_IN)/sizeof(UINT32);

  // Copy real bins
  for(unsigned int i=0; i<allBins; i++) {
    ctrlData[offset + i] = *(UINT32 *)&(scan.getScanPoints1()[i]);
    if(scan.getScanPoints2().size() == 0) {
      ctrlData[offset + allBins + i] = *(UINT32*)&(scan.getScanPoints1()[i]);
    } else {
      ctrlData[offset + allBins + i] = *(UINT32*)&(scan.getScanPoints2()[i]);
    }
  }

  primList->addPrimitive(RodPrimitive(4 + sizeof(START_TASK_IN)/sizeof(UINT32) + allBins * 2, 
                                      0, START_TASK, R_START_TASK, ctrlData),
                         ctrlData);
}

/*
  Stop histogram control in master
  Histogram and event trapping in slaves

  *********** XXX Send them individually as it doesn't seem to work otherwise ***************
*/
void SctApi::stopHistogramming(const ScanEx &ex) {
  for(ScanEx::RodInfoMap::const_iterator ri = ex.rodInfo.begin();
      ri != ex.rodInfo.end();
      ri++) {
    const RodLabel &rod = ri->first;

    {
      boost::mutex::scoped_lock lock(log().mutex());
      log() << "Stop histogramming (controlled)\n";
    }
//  stopEvTrap(0);

//  taskOp(16, 0, 0, -1);   // Stop histogram control task

//  taskOp(32, 0, 0, 0);     // Stop histogram task

    boost::shared_ptr<PrimListWrapper> primList(new PrimListWrapper(2));

    PrimBuilder &builder = PrimBuilder::instance();
    builder.taskOp(primList, HISTOGRAM_CTRL_TASK, TASK_STOP, 0);

    {
      boost::mutex::scoped_lock lock(log().mutex());
      log() << "Stop histo control task\n";
    }
    sendPrimList(rod.rod, primList);

    awaitResponse(rod.rod, 5);
    primList->clear();

    cout << "Done kill control task\n";

    for(int slaveNumber=0; slaveNumber<numSlaves; slaveNumber++) {
      // Kill all tasks!!!!
      boost::shared_ptr<PrimListWrapper> slList(new PrimListWrapper(1));

      // Stop Slave histogramming task

      builder.taskOp(slList, HISTOGRAM_TASK, TASK_STOP, 0);

      PrimBuilder::instance().slavePrimList(primList, slList, slaveNumber, true, true);
      {
        boost::mutex::scoped_lock lock(log().mutex());
        log() << "Stop slave histogram task " << slaveNumber << endl;
      }
      sendPrimList(rod.rod, primList);
      awaitResponse(rod.rod, 5);
      slList->clear();
      primList->clear();

      cout << "Done kill histogram task\n";

      stopEventTrap(slaveNumber, primList);

      // Reset router trapping
      PrimBuilder::instance().writeRegister(primList, RTR_TRAP_RESET(slaveNumber), RTR_TRAP_RESET_O, 1, 1);

      {
        boost::mutex::scoped_lock lock(log().mutex());
        log() << "Stop Event trapping on slave " << slaveNumber << endl;
      }
      sendPrimList(rod.rod, primList);

      awaitResponse(rod.rod, 5);
      primList->clear();

      cout << "Done kill event trapping\n";
    }
  }

  //  sendPrimList(ex.rod, primList);
  //  awaitResponse(ex.rod, 2);
  cout << "Done kill histogramming tasks\n";
}

ScanControl::ScanControl(SctApi &api) : api(api) {}

#if USE_CONST_SCAN
void  ScanControl::setModuleScanCacheToLastPointInScan(SctApi &api, boost::shared_ptr<const Scan> scan,
                               boost::shared_ptr<const ScanEx> scanEx) {
#else
void  ScanControl::setModuleScanCacheToLastPointInScan(SctApi &api, boost::shared_ptr<const Scan> scan) {
#endif
  if (api.checkDebugOption(DEBUG_MODULE_CONFIG)) {
    std::cout << "setModuleScanCacheToLastPointInScan setting the following values:\n"
          << "mid\tsn\tvariable\tvalue\tvar 1/2?" << std::endl;
  }

#if USE_CONST_SCAN
  for(unsigned int group = 0; group < scanEx->getNGroups(); group ++) {
    const ModuleList &groupList = scanEx->getModuleList(group);
#else
  for(unsigned int group = 0; group < scan->getNGroups(); group ++) {
    const ModuleList &groupList = scan->getModuleList(group);
#endif
    for(ModuleList::const_iterator mi = groupList.begin();
    mi!=groupList.end();
    mi ++) {
      
      string sn = *mi;
      UINT32 mid = api.findModule(sn);
      {
    unsigned int partition, crate, rod, channel;
    Utility::getpcrc(mid, partition, crate, rod, channel);
    if (api.idiosyncrasy().ucid() != Sct::UCID(partition, crate)) {
      std::cout << "\nWARNING!!! I didnt think that sn " << sn << " was on this crate!!!\n" 
            << __FILE__ << ":" <<  __LINE__ << std::endl;
      continue;  // next module
    }
      }
      boost::shared_ptr<SctApiConfigCache::ModuleBanks> banks = api.getModuleConfigCache().getFromMid(mid);
      if (!banks.get()){
    if (api.mrs) {
      *api.mrs << "NO_CACHED_CONFIG" << MRS_ERROR
           << MRS_QUALIF("SctApi")
           << MRS_PARAM<int>("mid", mid) 
           << MRS_TEXT("No cache at all available when setting cache at end of scan") << ENDM;
    }else{
      std::cout << "ERROR! No cache at all available when setting cache at end of scan, mid" << mid << std::endl; 
    }
    continue;
      }
      boost::shared_ptr<ABCDModule> config = banks->get(SCTAPI_BANK_SCAN);
      if (!config.get()){
    if (api.mrs) {
      *api.mrs << "NO_CACHED_CONFIG" << MRS_ERROR
           << MRS_QUALIF("SctApi")
           << MRS_PARAM<int>("mid", mid) 
           << MRS_TEXT("No SCAN cache available when setting cache at end of scan") << ENDM;
    }else{
      std::cout << "ERROR! No SCAN cache available when setting cache at end of scan, mid" << mid << std::endl; 
    }
    continue;
      }

      if (group<4){
    const ::SctApi::Scan::ScanPoints points = scan->getScanPoints1();
    if (!points.empty() && scan->getScanVariable1()!=0 ) {
      ConfigUtility::modifyVar(config.get(), scan->getScanVariable1(), points[points.size()-1]);
      if(api.checkDebugOption(DEBUG_MODULE_CONFIG)){
        std::cout << mid << "\t" << sn  << "\t" << scan->getScanVariable1()  << "\t"
              << points[points.size()-1]  << "\t" << "\t[1]" << std::endl;
      }
    }
      }else{
    const ::SctApi::Scan::ScanPoints points = scan->getScanPoints2();
    if (!points.empty() && scan->getScanVariable2()!=0 ) {
      ConfigUtility::modifyVar(config.get(), scan->getScanVariable2(), points[points.size()-1]);
      if(api.checkDebugOption(DEBUG_MODULE_CONFIG)){
        std::cout << mid << "\t" << sn  << "\t" << scan->getScanVariable1()  << "\t"
              << points[points.size()-1]  << "\t" << "\t[2]" << std::endl;
      }
    }
      }
    }
  }
  if(api.checkDebugOption(DEBUG_MODULE_CONFIG)) std::cout << std::endl;
}

void ScanControlRODHisto::readHistograms() {
  time_t saveTime;
  saveTime = time(NULL);

  /* Loop over RODs and release memory at the end to save space
       Makes algorithm slightly inefficient (multiple loops over module list)
       but better than crashing due to OOM!
  */
  list<RodLabel> rodList = api.listRods();

  for(list<RodLabel>::const_iterator rl = rodList.begin();
      rl!=rodList.end();
      rl++){

    cout << "Reading out modules from ROD " << Sct::URID(rl->partition,
                             rl->crate,
                             rl->rod) << " of " << rodList.size() << endl;

    // For each module
#if USE_CONST_SCAN
    const unsigned int nGrOuPs = scanEx->getNGroups();
#else
    const unsigned int nGrOuPs = scan->getNGroups();
#endif
    for(unsigned int group = 0; group < nGrOuPs; group ++) {
#if USE_CONST_SCAN
      const ModuleList &groupList = scanEx->getModuleList(group);
#else
      const ModuleList &groupList = scan->getModuleList(group);
#endif
      cout << "Modules in group " << group << " of " << nGrOuPs << ": count= " << groupList.size() << endl;
      for(ModuleList::const_iterator mi = groupList.begin();
          mi!=groupList.end();
          mi ++) {

        string sn = *mi;
    cout << "Attempting to find mid for ["<<sn<<"]"<<std::endl;
        UINT32 mid = api.findModule(sn);

    cout << "serial number is [" << sn << "] mid = " << mid << std::endl;

        {
          unsigned int partition, crate, rod, channel;
          Utility::getpcrc(mid, partition, crate, rod, channel);
          if(RodLabel(partition, crate, rod) != *rl) {
            // Come back later
        cout << "Skipping " << sn << " (in ROD " << Sct::URID(partition,crate,rod) << " not " << Sct::URID(rl->partition, rl->crate, rl->rod) << ")\n";
            continue;
          }
        }

        cout << "Module:  " << mid << " = " << sn << endl;

        try {
          if(scan->getOption(Scan::FULL)) {
        std::cout << "Readout full mode histograms:" << std::endl;
            for(int f=0; f<3; f++) {
          std::cout << "    (" << f << " of 3)" << std::endl;
              scan_result_ptrs result = readHistogramData(mid, f);

              result.header.scanNumber += f;

              // Files need discriminating because they're all the same time
              if(checkDebugOption(DEBUG_SAVE_HISTOGRAM)) {
                readHistogramToFile(api.ucid(), *scan, *scanEx, mid, api.convertToString(mid), result, saveTime, f);
              }

#ifdef USE_IS
              // IS based on Run/Scan number so nothing more needed
              if(api.mrs) readHistogramToIS(api.ucid(), *scan, *scanEx, mid, result);
#endif

              delete [] (char*)result.data;
              delete [] result.points;
              delete [] result.nEvents;
              delete [] result.nErrorEvents;
            }
          } else {
        std::cout << "Readout non-full mode histogram" << std::endl;
            scan_result_ptrs result = readHistogramData(mid, 0);

            if(checkDebugOption(DEBUG_SAVE_HISTOGRAM)) {
              readHistogramToFile(api.ucid(), *scan, *scanEx, mid, api.convertToString(mid), result, saveTime);
            }
#ifdef USE_IS
            if(api.mrs)readHistogramToIS(api.ucid(), *scan, *scanEx, mid, result);
#endif
            delete [] (char*)result.data;
            delete [] result.points;
            delete [] result.nEvents;
            delete [] result.nErrorEvents;
          }
        } catch(SctApiException &s) {
      std::cout << "Scan readout failed" << std::endl;
          if(api.mrs) {
            *api.mrs << "SCAN_READOUT_FAIL" << MRS_ERROR
                     << MRS_QUALIF("SctApi")
                     << MRS_PARAM<int>("run", scan->getRunNumber()) 
                     << MRS_PARAM<int>("scan", scan->getScanNumber()) 
                     << MRS_PARAM<int>("mid", mid) 
                     << MRS_TEXT("Module readout failed") << ENDM;
          }
        }
      } // Histogram for next module
    } // Next module group

    // Release memory from ROD
    for(std::map<std::pair<RodLabel, int>, 
          Utility::MemoryBlock> :: iterator mapIter = scanEx->histoMap.begin();
        mapIter != scanEx->histoMap.end();
        mapIter++) {

      if(mapIter->first.first == *rl) {
        if(api.mrs) {
          *api.mrs << "SCAN_READOUT" << MRS_DIAGNOSTIC
                   << MRS_PARAM<float>("MWords", mapIter->second.size() / 1e6)
                   << MRS_PARAM<int>("crate", rl->crate)
                   << MRS_PARAM<int>("rod", rl->rod)
                   << MRS_TEXT("Releasing memory after histogram readout") << ENDM;
        }

        mapIter->second = Utility::MemoryBlock();
      }
    }
  } // End ROD loop
}

scan_result_ptrs ScanControlRODHisto::readHistogramData(UINT32 mid, int frame) {
  scan_result_ptrs scanResult;

  //We do this first deliberately.
  //The dummy api will need to mess around with some things
  scanResult.data = readHistogramRawData(mid, frame);

  if(scanResult.data == 0) {
    cout << "readHistogramRawData returned 0 in readHistogramData";
    throw SctApiException("readHistogramRawData returned 0 in readHistogramData");
  }

  int nBins = scan->getScanPoints1().size();

  // Read the module configuration from the end of the scan...

  /* Modifyed 2/6/2005 AJB to use the SCAN bank _directly_
   * api.getABCDModule(mid, SCTAPI_BANK_SCAN);

  // Save copy of configuration from end of scan
   */
 
  ABCDModule moduleConfig; // no initial value - SHOULD always be set below or there is an error.
  boost::shared_ptr<SctApiConfigCache::ModuleBanks> the_banks=api.getModuleConfigCache().getFromMid(mid);
  if (!the_banks.get()) {
    if(api.mrs) {
      *api.mrs << "ROD_BANK_CONFIG_CACHE" << MRS_ERROR << MRS_QUALIF("SCTAPI")
           << MRS_PARAM<int>("mid", mid)
           << MRS_TEXT("Cant return cache for non-existant MID at end of scan") << ENDM;
    }else{
      cerr << "Non-existant module mid=" << mid << std::endl;
    }
  } else {
    boost::shared_ptr<ABCDModule> scan_config = the_banks->get(SCTAPI_BANK_SCAN);
    if (!scan_config.get()){
      if(api.mrs) {
    *api.mrs << "ROD_BANK_CONFIG_CACHE" << MRS_ERROR << MRS_QUALIF("SCTAPI")
         << MRS_PARAM<int>("mid", mid)
         << MRS_TEXT("Cant return cache for non-existant SCAN BANK at end of scan") << ENDM;
      }else{
    cerr << "Non-existant scan bank at end of scan ! mid=" << mid << std::endl;
      }
    } else {
      moduleConfig = *scan_config;
    }
  }

  if(checkDebugOption(DEBUG_MODULE_CONFIG)) {
    cout << "Configuration after scan temporarily not available \n";
    //cout << api.config->printABCDModule(moduleConfig); // private
  }

  ScanHeader &header = scanResult.header;

  header.version = CURRENT_SCANHEADER_VERSION;
  header.length = sizeof(ScanHeader);
  header.runNumber = scan->getRunNumber();
  header.scanNumber = scan->getScanNumber();
  
  strncpy(header.moduleName, api.convertToString(mid).c_str(), 16);
#if USE_CONST_SCAN
  strncpy(header.startTime, to_iso_string(scanEx->getStartTime()).c_str(), 16);
  strncpy(header.endTime, to_iso_string(scanEx->getEndTime()).c_str(), 16);
#else
  strncpy(header.startTime, to_iso_string(scan->getStartTime()).c_str(), 16);
  strncpy(header.endTime, to_iso_string(scan->getEndTime()).c_str(), 16);
#endif
  header.moduleName[15] = 0;    // Null terminate the string
  header.startTime[15] = 0;
  header.endTime[15] = 0;
  
//   snprintf(header.moduleName, 16, "%s", convertToString(mid).c_str());
//   cout << "Module name in Scan Results (" << header.moduleName << ")\n" ;
  header.scanType = scan->getScanVariable1();
  header.npoints = nBins;
  header.size = nBins * 2 * 1024 * (scan->getOption(Scan::BITS32)?2:1);
  header.dataType = SR_DT_SLICE;

  header.width = scan->getOption(Scan::BITS32)?SR_WD_32:SR_WD_16;

  header.config = moduleConfig;

  header.pntPoints = sizeof(ScanHeader);
  header.pntEvents = header.pntPoints + nBins * sizeof(FLOAT32);
  header.pntErrors = header.pntEvents + nBins * sizeof(UINT32);
  header.pntData = header.pntErrors + nBins * sizeof(UINT32);

  // The points
  FLOAT32 *points = new FLOAT32[nBins];
  for(int i=0; i<nBins; i++) {
    points[i] = scan->getScanPoints1()[i];
  }
  scanResult.points = points;

  // The event counts
  UINT32 *events = new UINT32[nBins];

  std::pair<RodLabel, unsigned int> moduleSlave = findModuleSlave(mid);

  // This is the better way of counting (especially when there are errors)
  unsigned long *countChunk = getEventCountChunk(moduleSlave.first, moduleSlave.second);

  for(int i=0; i<nBins; i++) {
    events[i] = countChunk[i];

    // Unfortunately it counts * 4 for cal line loop
    if(scan->getOption(Scan::LOOPCALLINE)) {
      events[i] >>= 2; 
    }
  }

#if 0
  // But this way does get the count right with the callineloop on!
  Scan::TrigPoints trigs = scan->getVariableTrigs();
 
  for(int i=0; i<nBins; i++) {
    if(i<lastBin[moduleSlave.first]) {
      events[i] = trigs[i];
    } else if(i == lastBin[moduleSlave.first]) {
      events[i] = lastEvent[moduleSlave.first];
    } else {
      events[i] = 0;
    }
  }
#endif

  scanResult.nEvents = events;

  // The error counts
  UINT32 *errors = new UINT32[nBins];
  UINT32 correctedTrigPoint;
  Scan::TrigPoints trigPoints = scan->getVariableTrigs();
  for(int i=0; i<nBins; i++) {
    // An error is when a requested event doesn't get to be histogrammed
    // The requested number of triggers is first corrected for cases
    // where the trap modulus is > 1.
    if(scan->getOption(Scan::NTH) > 1) {
      correctedTrigPoint = ((UINT32) trigPoints[i] / (UINT32)scan->getOption(Scan::NTH));
    }else{
      correctedTrigPoint = trigPoints[i];
    }
    if (correctedTrigPoint >= events[i]){
       errors[i] = correctedTrigPoint - events[i];
    }else{
       errors[i] = 0;
    }
  }
  scanResult.nErrorEvents = errors;

  return scanResult;
}

char* ScanControlRODHisto::readHistogramRawData(UINT32 mid, int frame) {
  int nBins = scan->getScanPoints1().size();

  // The number of bins the ROD thinks there are...
  int rodBins = nBins;
  if(!scan->getOption(Scan::BITS32))
    if(rodBins%2 == 1) rodBins++;

  // The data!
  int binSize = 0x800*(scan->getOption(Scan::BITS32)?4:2);   // In bytes, so works for 16bit histograms

  char *data = new char[nBins * binSize];

  bool moduleBlock = false;
//    int baseAddress = index*(binSize*nBins);

  unsigned int slaveNumber = 4;

  RodLabel rodLabel;
  unsigned int channel;
  {
    unsigned int partition, crate, rod;
    Utility::getpcrc(mid, partition, crate, rod, channel);
    RodLabel temp(partition, crate, rod);
    rodLabel = temp;
  }

  const RodScanEx &rodInfo = scanEx->getRodScanInfo(rodLabel);

  for(int slave=0; slave<4; slave++) {
    if((channel<32 && (rodInfo.slaveChannels[slave].mask0 & 1<<channel))
       || (channel >= 32 && (rodInfo.slaveChannels[slave].mask1 & 1<<(channel-32)))) {
      if(slaveNumber == 4) {
        slaveNumber = slave;
      } else {
        cerr << " ****** Module found on multiple slaves this is an unsupported configuration, the first one will be downloaded??? *****\n";
        cerr << " ****** Well you don't expect me to add them all together do you??? *****\n";
#warning "But maybe I should any way"
      }
    }
  }

  if(slaveNumber == 4) {
    cerr << " ****** Current module not found on any slave, skipping histogram read out *****\n";

    throw SctApiException("No mapping from module to DSP found");
  }

  // Find the module index on this slave
  int index = 0;
  int nModules = 0; // moduleMap.size();

  for(unsigned int ch=0; ch<48; ch++) {
    if(channel == ch) {
      index = nModules;
    }
    if(ch<32) {
      if(rodInfo.slaveChannels[slaveNumber].mask0 & 1<<ch) {
        nModules ++;
      }
    } else {
      if(rodInfo.slaveChannels[slaveNumber].mask1 & 1<<(ch-32)) {
        nModules ++;
      }
    }
  }

  // Get data from place defined by DSP
  unsigned long slaveOffset = 0;

  if(moduleBlock) {
    slaveOffset += binSize * rodBins;
  } else {
    slaveOffset += binSize * index;
  }

  // For reading expanded data, skip to next block of histograms...
  slaveOffset += ((binSize * rodBins * nModules) + binSize) * frame;

  bool error = false;

  for(int i=0; i<nBins; i++) {
    unsigned long *chunk = getHistogramChunk(rodLabel, slaveNumber, slaveOffset, binSize/sizeof(UINT32));
    unsigned long *buffer = (unsigned long *)&(data[i*binSize]);

    if(chunk) {
      for(int b=0; b<binSize/sizeof(UINT32); b++) {
        buffer[b] = chunk[b];
      }

      // Check End of bin xx Module xx
      int bin, module;
      int count = sscanf(&((char*)buffer)[binSize-32], "End of bin %d Module %d", &bin, &module);
      if(count == 2) {
//          printf("Found End of bin %d module %d\n", bin, module);
      } else {
        if(!error)
          printf("Found bad end of histogram bin (%25s)\n", &((char*)buffer)[binSize-32]);
        error = true;
      }

#warning "Memory leak if sendData didn't work"
//       delete [] chunk;
    } else {
      for(int b=0; b<binSize/sizeof(UINT32); b++) {
        buffer[b] = 0;
      }
    }

    if(moduleBlock) {
      slaveOffset += binSize;
    } else {
      slaveOffset += binSize * nModules;
    }
  }

  return data;
}

pair<RodLabel, unsigned int> ScanControlRODHisto::findModuleSlave(unsigned int mid) {
  RodLabel rodLabel;
  unsigned int channel;
  {
    unsigned int partition, crate, rod;
    Utility::getpcrc(mid, partition, crate, rod, channel);
    RodLabel temp(partition, crate, rod);
    rodLabel = temp;
  }

  unsigned int slaveNumber = 4;

  const RodScanEx &rodInfo = scanEx->getRodScanInfo(rodLabel);

  for(int slave=0; slave<4; slave++) {
    if((channel<32 && (rodInfo.slaveChannels[slave].mask0 & 1<<channel))
       || (channel >= 32 && (rodInfo.slaveChannels[slave].mask1 & 1<<(channel-32)))) {
      if(slaveNumber == 4) {
        slaveNumber = slave;
      } else {
        cerr << " ****** Module found on multiple slaves this is an unsupported configuration, the first one will be downloaded??? *****\n";
        cerr << " ****** Well you don't expect me to add them all together do you??? *****\n";
#warning "But maybe I should any way"
      }
    }
  }

  if(slaveNumber == 4) {
    cerr << " ****** Current module not found on any slave, skipping histogram read out *****\n";

    throw SctApiException("No mapping from module to DSP found");
  }

  return make_pair(rodLabel, slaveNumber);
}

void readHistogramToFile(const Sct::UCID & ucid, const Scan &scan, const ScanEx &ex, 
                         UINT32 mid, std::string sn, scan_result_ptrs scanData, time_t saveTime, int frame) {
  const int BUFF_SIZE = 50;

  struct tm broke;
  broke = *(gmtime(&saveTime));

  string tempDir = SctNames::getTempDir() + "/";
  int bufferLength = BUFF_SIZE + tempDir.length();
  char *filename = new char[bufferLength];
  strcpy(filename, tempDir.c_str());

  cout << "Module:  " << mid << " = " << sn << endl;

  int written = tempDir.length();
  if(scan.getOption(Scan::FULL)) {
    written += snprintf(filename + written, bufferLength - written, "Histogram%d_%s", frame, sn.c_str());
    //                                                                    20021112143712
    strftime(filename + written, bufferLength - written, "_%Y%m%d%H%M%S.bin", &broke);
  } else {
    written += snprintf(filename + written, bufferLength - written, "Histogram_%s", sn.c_str());
    //                                                                    20021112143712
    strftime(filename + written, bufferLength - written, "_%Y%m%d%H%M%S.bin", &broke);
  }

  {
    Sct::MultiMessageDebugStream m(true,false,true);
    m << ucid << " is writing histogram data to " << filename;
  };

  saveHistogramToFile(scanData, filename);
    
  cout << "done.\n";

  delete [] filename;
}

void saveHistogramToFile(scan_result_ptrs histo, std::string filename) {
  ofstream histoout(filename.c_str(), ios::binary);

  //    assert(histo.header.length == sizeof(ScanHeader));
  histoout.write((char*)&histo.header, histo.header.length);

  //    assert(histo.header.pntEvents - histo.header.pntPoints == nBins * sizeof(FLOAT32));
  histoout.write((char*)histo.points, histo.header.pntEvents-histo.header.pntPoints);

  //    assert(histo.header.pntErrors - histo.header.pntEvents == nBins * sizeof(FLOAT32));
  histoout.write((char*)histo.nEvents, histo.header.pntErrors-histo.header.pntEvents);

  //    assert(histo.header.pntData - histo.header.pntErrors == nBins * sizeof(FLOAT32));
  histoout.write((char*)histo.nErrorEvents, histo.header.pntData-histo.header.pntErrors);

  //    assert(histo.header.size*2 == (nBins * 0x800 * 4));

  // header.size is a count in 16bit words!
  histoout.write((char*)histo.data, histo.header.size*2);
}

#ifdef USE_IS

void readHistogramToIS(const Sct::UCID & ucid, const Scan &scan, const ScanEx &ex, UINT32 mid, scan_result_ptrs scanData) {
//   {
//     boost::mutex::scoped_lock lock(log().mutex());
//     log() << "Read Histogram for " << mid << " to IS\n";
//   }

  cout << "Writing histogram data to IS\n";

//   string sn = convertToString(mid);

  cout << "Module:  " << mid << /* " " << sn << */ endl;
  {
    Sct::MultiMessageDebugStream m(true,false,true);
    m << ucid << " is writing histogram data to IS for mid " << mid;
  };

  try {
    SctData::ScanResultWriter::publish(scanData);
  } catch(Sct::IoException &e) {
    cout << "ScanResult publish failed:\n" << e.what() << endl;
    e.sendToMrs(MRS_ERROR);
  }
}

#endif

int SctApi::pollHistogramming(boost::shared_ptr<ScanControl> controller, int timeout) {
  int returnVal = 0;

  bool timedout = false;

  time_t start_time = time(0);

  while(!timedout) {
    bool progressMade = false;
    bool newBin = false;
    if(controller->checkScanComplete(progressMade, newBin)) {
      // Finished, exit while
      break;
    }

    if(progressMade) {
      start_time = time(0);
    }

    if(newBin) {
      cout << "Controller going to next bin\n";

      controller->nextBin();
    } else {
      // Check text buffers (no longer a side effect of polling)
#if USE_THREADS
      // Text buffers already checked by primThread
      sleep(1);
#else
      awaitResponseAll(0);
#endif

      if((time(0) - start_time) > timeout) {
        timedout = true;
        returnVal = -1;

        controller->reportTimeout();

        if(checkDebugOption(DEBUG_EXTRA_DUMPS)) {
          standardRegisterDumpAll();
        }

        controller->reportEventErrors();

        break;
      }
    }
  }

#if USE_IS
  if(m_isDict) {
    m_isDict->remove("SCTAPIServer.currentBin");
    m_isDict->remove("SCTAPIServer.maxBin");
  }
#endif

  return returnVal;
}

void SctApi::doHistogramSetup(const Scan &scan, const ScanEx &extra) {
  for(ScanEx::RodInfoMap::const_iterator ri = extra.rodInfo.begin();
      ri != extra.rodInfo.end();
      ri++) {
    //    const RodScanEx &rodInfo = ri->second;
    const RodLabel &rod = ri->first;

    // Clear event memory on all slaves
    // 8192 words from what was 0x80008000
    for(int slaveNumber=0; slaveNumber<numSlaves; slaveNumber++) {
      if(getCrate()->slavePresent(rod.rod, slaveNumber)) {
        if(getCrate()->getRodRevision(rod.rod) >= 0xe) {
#warning "Hard-coded address of incoming event buffer"
          setSlaveBlock(rod.rod, slaveNumber, 0x18000, 0x2000, 0);
        } else {
          setSlaveBlock(rod.rod, slaveNumber, 0x80008000, 0x2000, 0);
        }
      }
    }

    boost::shared_ptr<PrimListWrapper> primList(new PrimListWrapper(1));

    setupEventTrapping(scan, extra, rod, primList);
    startEventTrapping(scan, extra, rod, primList);
    setupEventDump(scan, extra, rod, primList);

    /*    if(checkDebugOption(DEBUG_EXTRA_DUMPS)) {
      sendPrimList(rod.rod, primList);
      awaitResponse(rod.rod, 5);
      primList->clear(); // .reset(new PrimListWrapper(2));

      // Do the dump after setting up trapping
      standardRegisterDump(rod.rod);
      }*/

    setupHistogramming(scan, extra, rod, scan.getOption(Scan::TIM), primList);

    // Wait for things to settle before starting histogramming
    sendPrimList(rod.rod, primList);
  }
  
  
  for(ScanEx::RodInfoMap::const_iterator ri = extra.rodInfo.begin();
      ri != extra.rodInfo.end();
      ri++) {
    const RodLabel &rod = ri->first;
    int responseCode = awaitResponse(rod.rod, 5);
    if(responseCode != 0) {
      cout << "Histogram setup list failed! (ROD " << rod.rod << ")\n";
      throw SctApiException("Histogram setup list failed! (ROD " + boost::lexical_cast<string>(rod.rod) + ")");
    } else {
      unsigned long length;
      unsigned long *result = getResponse(rod.rod, length);

      if(result) {
    if(result[6] == EVENT_TRAP_SETUP && result[7] == R_EVENT_TRAP_SETUP) {
      // First is ETS, so decode as if all are...
      int numPrims = result[2];
      cout << numPrims << " replies from setup primitive list\n";

      int offset = 4;
      for(int prim = 0; prim<numPrims; prim++) {
        cout << prim << ": ";
        if(result[offset+2] == EVENT_TRAP_SETUP && result[offset+3] == R_EVENT_TRAP_SETUP) {
          cout << "ETS Error code " << result[offset+4] << endl;
        } else {
          cout << "Unexpected (not ETS) reply from setup primitive list\n";
        }
        offset += result[offset+0];
      }
    } else {
      cout << "Unexpected output list from histogram setup primitive list\n";
      ::SctApi::printOutList(result, length, true, 0, cout, 
                 checkDebugOption(DEBUG_PRINT_UNKNOWN), checkDebugOption(DEBUG_PRINT_RAW));
    }
    delete [] result;
      } else {
    cout << "No response to ETS\n";
      }
    }
  }
}

void ScanControlRODHisto::startHistogramming() {
  for(ScanEx::RodInfoMap::const_iterator ri = scanEx->rodInfo.begin();
      ri != scanEx->rodInfo.end();
      ri++) {
    const RodLabel &rod = ri->first;

    // Setup debug register
    if(scan->getOption(Scan::DEBUG)) {
      if(checkDebugOption(DEBUG_SCAN_AUTO_STALL)) {
        cout << "** Debug mode setting AUTO_STALL\n"; 
        scanEx->diagnosticReg |= (1<<DR_AUTO_STALL);
      }

      if(checkDebugOption(DEBUG_SCAN_STEP_MODE)) {
        cout << "** Debug mode setting STEP_CTRL\n"; 
        scanEx->diagnosticReg |= (1<<DR_STEP_CTRL);
      }

      if(checkDebugOption(DEBUG_SCAN_PAUSE_PULSE)) {
#ifdef DR_PULSE_PAUSE
        cout << "** Debug mode setting PAUSE_PULSE\n"; 
        scanEx->diagnosticReg |= (1<<DR_PULSE_PAUSE);
#else
    cout << "ERROR : Debug mode PAUSE_PAUSE no longer available\n";
#endif
      }
    }

    if(checkDebugOption(DEBUG_SCAN_ROD_MODE_BITS)) {
      cout << "Setting up to use ROD mode bits\n"; 
#ifdef DR_USE_ROD_MASK_LUT
      scanEx->diagnosticReg |= (1<<DR_USE_ROD_MASK_LUT);
#else
      cout << "ERROR : Cannot set up to use ROD mode bits - USE_ROD_MASK_LUT no longer available!\n"; 
#endif
    }

    if(scanEx->diagnosticReg != 0x0) {
      cout << "Writing master diag reg: 0x" << hex << scanEx->diagnosticReg << dec << endl;
      api.dspSingleWrite(rod.rod, 0x80000010, scanEx->diagnosticReg, -1);
    } else {
      cout << "Clearing master diag reg\n";
      api.dspSingleWrite(rod.rod, 0x80000010, scanEx->diagnosticReg, -1);
    }

    if(!useCCode(api, *scan)) {
      
      unsigned long SDSP_IDRAM_BASE;
      if(api.getRodRevision(rod) >= 0xe) {
        SDSP_IDRAM_BASE = 0x10000;        // Rev E or F
      } else {
        SDSP_IDRAM_BASE = 0x80000000;     // Rev C
      }

      for(int s=0; s<numSlaves; s++) {
        if(ri->second.bitFieldDSP & (1<<s)) {
          try {
            unsigned long val = api.dspSingleBlockRead(rod.rod, 
                                                       SDSP_IDRAM_BASE + 0x10, s);
            cout << "Read from slave " << s << " diag register: 0x" << hex << val 
                 << " which should be 0x" << (0) << dec << endl;

            // Toggle cache on
            unsigned long newVal = val | (1<<19);
            api.dspSingleBlockWrite(rod.rod, SDSP_IDRAM_BASE + 0x10, newVal, s);

            val = api.dspSingleBlockRead(rod.rod, SDSP_IDRAM_BASE + 0x10, s);
            cout << "Read from slave " << s << " diag register: 0x" << hex << val 
                 << " which should be 0x" << (1<<19) << dec << endl;
          } catch(VmeException &v) {
            Utility::decodeVme(v);
            cerr << "VmeException turning on slave " << s << " cache\n";
          }
        }
      }
    }

    cout << "Histogram starting...\n";

    boost::shared_ptr<PrimListWrapper> primList(new PrimListWrapper(1));
    api.startHistogramTask(*scan, *scanEx, rod, 
                           sectionStartBin, 1 + sectionEndBin - sectionStartBin, sectionEndTrigger, 
                           primList);

//     {
//       boost::mutex::scoped_lock lock(log().mutex());
//       log() << "Send start histogram task list\n";
//     }
    api.sendPrimList(rod.rod, primList);

  }

  for(ScanEx::RodInfoMap::const_iterator ri = scanEx->rodInfo.begin();
      ri != scanEx->rodInfo.end();
      ri++) {
    const RodLabel &rod = ri->first;
    int responseCode = api.awaitResponse(rod.rod, 5);
    if(responseCode != 0) {
      cout << "Histogram primitive failed! (ROD " << rod.rod << ")\n";
      throw SctApiException("Histogram primitive failed! (ROD " + boost::lexical_cast<string>(rod.rod) + ")");
    }
  }
}

void SctApi::eventTrapSetup(int slaveMask, int trapMatch, int trapMod, int trapRemain, bool tim, bool error,
                            boost::shared_ptr<PrimListWrapper> primList) {
  long *evData = new long[sizeof(EVENT_TRAP_SETUP_IN)/sizeof(UINT32)];

  EVENT_TRAP_SETUP_IN &primData = *(EVENT_TRAP_SETUP_IN*)evData;

#if R_EVENT_TRAP_SETUP == 103
  primData.slvBits = slaveMask;
  primData.numberOfEvents = COLLECT_FOREVER;
  primData.timeoutInUsec = 0x30000;

  primData.extRouterSetup = 0;

  // This tells the setup code to change the trapRemainder
  //  Only matters if setting up more than one slave
  primData.distribute = TRAP_DISTRIB_NEITHER;

  primData.releaseFrames = 0;
  if(tim) {
    primData.permitBackPressure = 0;
  } else {
    primData.permitBackPressure = 1;
  }
  primData.dataMode = 0;                        // Data or Event mode
  if(tim) {                           // Where to pick events (dsp or router)
    primData.sLink = 1;
  } else {
    primData.sLink = 0;
  }

  primData.format = error?TRAP_FMT_ERROR:TRAP_FMT_NORMAL; // Slink format
  primData.trapStray = 1;                       // Trap stray events
  primData.iterLimit = 2;                       // Don't keep them long

  if(tim) {
    // Trap events from the SLINK
    primData.trapConfig[0] = TRAP_CFG_SLINK_EVT;
  } else {
    // Trap events from ROD triggers
    primData.trapConfig[0] = TRAP_CFG_ROD_EVT;
  }
  primData.trapExclusionFlag[0] = 0;            // Don't exclude anything
  primData.trapFunction[0] = TRAP_FXN_HISTOGRAM;

  primData.trapMatch[0] = trapMatch;
  primData.trapModulus[0] = trapMod;
  primData.trapRemainder[0] = trapRemain;

  // Trap one is idle
  primData.trapConfig[1] = TRAP_CFG_IDLE;
  primData.trapExclusionFlag[1] = 0;
  primData.trapFunction[1] = 0;

  primData.trapMatch[1] = 0; 
  primData.trapModulus[1] = 0;
  primData.trapRemainder[1] = 0;
#else 
#error "Event trapping not compiled (new Primitive definition)!"
#endif
  primList->addPrimitive(RodPrimitive(sizeof(EVENT_TRAP_SETUP_IN)/sizeof(UINT32) + 4, 
                                      0, EVENT_TRAP_SETUP, R_EVENT_TRAP_SETUP, evData),
                         evData);
}

void SctApi::startEventTrap(int slaveNumber, boost::shared_ptr<PrimListWrapper> primList) {
  shared_ptr<PrimListWrapper> startList(new PrimListWrapper(1));

  PrimBuilder::instance().startEvTrap(startList);

  PrimBuilder::instance().slavePrimList(primList, startList, slaveNumber, true, true);
}

void SctApi::stopEventTrap(int slaveNumber, boost::shared_ptr<PrimListWrapper> primList) {
  shared_ptr<PrimListWrapper> stopList(new PrimListWrapper(1));

  PrimBuilder::instance().stopEvTrap(stopList);

  PrimBuilder::instance().slavePrimList(primList, stopList, slaveNumber, true, true);
}

ScanMonitorImpl::ScanMonitorImpl(boost::shared_ptr<ScanControl> control) : controller(control) {
}

ScanMonitorImpl::~ScanMonitorImpl() {
}

void ScanMonitorImpl::newBin(int prevTriggers, int newBin) {
  controller->nextBin();
}

void ScanMonitorImpl::finishScan() {
  controller->finishHistogram(true);
}

// If this uses sendData then memory is stored internally so isn't leaked, otherwise it is!
unsigned long *ScanControlRODHisto::getHistogramChunk(RodLabel rodLabel, int slaveNumber,
                                                      unsigned long offset, unsigned long size) {
  try {
    pair<RodLabel, int> key = make_pair(rodLabel, slaveNumber);

    Utility::MemoryBlock chunk;
    chunk = scanEx->histoMap[key];
    if(!chunk) {
      pair<UINT32, UINT32> chunkPos = api.sendData(rodLabel.rod, HISTOGRAM_DATA, slaveNumber);

      cout << "SendData returned " << chunkPos.first << " " << chunkPos.second << endl;
      cout << " need offset " << offset << " length " << size << endl;

      if(api.mrs) {
        // Something about getting lots of data
        *api.mrs << "SCAN_READOUT" << MRS_DIAGNOSTIC
                 << MRS_PARAM<float>("MWords", chunkPos.second/4e6)
                 << MRS_PARAM<int>("crate", rodLabel.crate)
                 << MRS_PARAM<int>("rod", rodLabel.rod)
                 << MRS_TEXT("Scan requested histogram readout") << ENDM;
      }

      unsigned long *block = api.primReadSlaveDsp(rodLabel.rod, 
                          slaveNumber, chunkPos.first, chunkPos.second/sizeof(UINT32));

      if(block == 0) {
    throw SctApiException("Read of histogram from slave failed");
      }

      chunk = Utility::MemoryBlock(chunkPos.second/sizeof(UINT32), block);

      scanEx->histoMap[key] = chunk;
    }

    if((offset + size*4) > (chunk.size() * 4)) {
      cout << "Asked for chunk +" << offset << " length " << size << " in " << chunk.size() << "words (continuing)\n";
    }

    // Offset is in bytes
    return chunk.address() + (offset / 4);
  } catch(SctApiException &e) {
    cout << "Caught exception in getHistogramChunk: " << e.what() << "\n\ttrying old histogram address\n";
    unsigned long slaveAddress;

    if(api.getRodRevision(rodLabel) >= 0xe) {
      slaveAddress = 0xa00e2000;
    } else {
      throw SctApiException("Slave histogram read not possible with old (pre-rev-E) rod");
    }
    return api.primReadSlaveDsp(rodLabel.rod, 
                                slaveNumber, slaveAddress + offset, size);
  }
}

unsigned long *ScanControlRODHisto::getEventCountChunk(RodLabel rodLabel, int slaveNumber) {
  try {
    pair<RodLabel, int> key = make_pair(rodLabel, slaveNumber);

    Utility::MemoryBlock chunk = scanEx->evCountMap[key];
    if(!chunk) {
      pair<UINT32, UINT32> chunkPos = api.sendData(rodLabel.rod, BIN_DATA, slaveNumber);

      cout << "SendData bin returned " << chunkPos.first << " " << chunkPos.second << endl;

      unsigned long *block = api.primReadSlaveDsp(rodLabel.rod, 
                                                  slaveNumber, chunkPos.first, chunkPos.second);
      chunk = Utility::MemoryBlock(chunkPos.second, block);

      scanEx->evCountMap[key] = chunk;
    }

    return chunk.address();
  } catch(SctApiException &e) {
    return 0;
  }
}


ScanControlRODHisto::ScanControlRODHisto(SctApi &api, boost::shared_ptr<Scan> aScan, boost::shared_ptr<ScanEx> aScanEx) : ScanControl(api), scan(aScan), scanEx(aScanEx), aborting(false) {
  int nBins = scan->getScanPoints1().size();

  Scan::TrigPoints trigPoints = scan->getVariableTrigs();

  finalTrigger = trigPoints[nBins-1];

  finalBin = nBins - 1;

  UINT32 initialNTrigs = trigPoints[0];

  unsigned int i = 0;
  while(i<trigPoints.size() && trigPoints[i] >= initialNTrigs) 
    i++;

  // i is now the index of the first different point
  sectionStartBin = 0;
  sectionEndBin = i - 1;
  if(i==trigPoints.size()) {
    sectionEndTrigger = trigPoints[i-1];
  } else {
    sectionEndTrigger = trigPoints[i-1] - trigPoints[i];
  }
  cout << "Final bin = " << finalBin << " trigger = " << finalTrigger << endl;

  cout << "Initial sectionEndBin = " << sectionEndBin << " sectionEndTrigger = " << sectionEndTrigger << endl;

  // no rods 
  for(ScanEx::RodInfoMap::const_iterator ri = scanEx->rodInfo.begin();
      ri != scanEx->rodInfo.end();
      ri++) {
    const RodLabel &rodLabel = ri->first;
    reportedFinished[rodLabel]=false;
  }
}

void ScanControlRODHisto::initialisePolling() { 
  scanStart = time(0);

  cout << "Histogram polling started\n";
  // Let it get going so the bin counter gets reset
  sleep(1);

  cout << "Polling histogramming task\n";
  cout << "scan point count " << scan->getScanPoints1().size() << endl;

  for(ScanEx::RodInfoMap::const_iterator ri = scanEx->rodInfo.begin();
      ri != scanEx->rodInfo.end();
      ri++) {
    const RodLabel &rodLabel = ri->first;

    if(api.mrs) {
      const std::string m1 = (Sct::StringStreamer << "POLL_ROD_" << api.ucid());      const std::string m2 = (Sct::StringStreamer << "ROD polling started on " << api.ucid());
      
      *api.mrs << m1 << MRS_DIAGNOSTIC << MRS_QUALIF("SCTAPI") 
               << MRS_PARAM<int>("partition", rodLabel.partition)
               << MRS_PARAM<int>("crate", rodLabel.crate)
               << MRS_PARAM<int>("rod", rodLabel.rod)
               << MRS_PARAM<int>("run", scan->getRunNumber())
               << MRS_PARAM<int>("scan", scan->getScanNumber())
               << MRS_PARAM<int>("firstSlave", ri->second.firstSlave)
               << MRS_TEXT(m2)
               << ENDM;
    }
  }

#if USE_IS
  if(api.m_isDict) {
    ISInfoInt binNumber(0);
    api.m_isDict->insert("SCTAPIServer.currentBin", binNumber);

    ISInfoInt maxNumber(finalBin);
    api.m_isDict->insert("SCTAPIServer.maxBin", maxNumber);
  }
#endif
}

void ScanControlRODHisto::reportTimeout() {
  Sct::MultiMessageDebugStream m(true,false,true);

  m << "You are about to get the 'Scan aborted (histogramming stalled)' "
    <<"message.  Histogram polling timeout being reported in ["
    <<__FILE__<<"] at line ["<<__LINE__<<"]. This means that SctApi got bored waiting more than about 5 (search for the second argument of pollHistogramming in SctApiHisto.cxx) seconds for the event counter to be incremented in the rod. ";

  RodLabel minROD;
  if(scanEx->rodInfo.size() > 0) {
    minROD = scanEx->rodInfo.begin()->first;
  }

  m << "Was expecting: finalBin=" << finalBin << ", finalTrigger=" << finalTrigger;

  // Find the ROD that stopped everything
  for(ScanEx::RodInfoMap::const_iterator ri = scanEx->rodInfo.begin();
      ri != scanEx->rodInfo.end();
      ri++) {
    const RodLabel &rodLabel = ri->first;
    cout << "   ROD (" << rodLabel.partition << ", " << rodLabel.crate << ", " << rodLabel.rod << "): ";
    cout << " Event " << lastEvent[rodLabel] << "    Bin " << lastBin[rodLabel] << "\n";

    if(lastEvent[rodLabel] < lastEvent[minROD]) {
      minROD = rodLabel;
    } else if(lastEvent[rodLabel] == lastEvent[minROD] && lastBin[rodLabel] < lastBin[minROD]) {
      minROD = rodLabel;
    }
  }


  m << ".  Problem was perhaps localised to"
    << " partition " << minROD.partition
    << " crate" << minROD.crate
    << " rod" << minROD.rod
    << " run" << scan->getRunNumber()
    << " scan"<< scan->getScanNumber()
    << " bin"<< lastBin[minROD]
    << " event"<< lastEvent[minROD];

  m.flush();

  if(api.mrs) {
    *api.mrs << "SCAN_ABORTED" << MRS_ERROR
             << MRS_PARAM<int>("partition", minROD.partition)
             << MRS_PARAM<int>("crate", minROD.crate)
             << MRS_PARAM<int>("rod", minROD.rod)
             << MRS_PARAM<int>("run", scan->getRunNumber())
             << MRS_PARAM<int>("scan", scan->getScanNumber())
             << MRS_PARAM<int>("bin", lastBin[minROD]) << MRS_PARAM<int>("event", lastEvent[minROD]) 
             << MRS_TEXT("Scan aborted (histogramming stalled)") << ENDM;
  }
}

void ScanControlRODHisto::nextBin() {
  // Fix ending variables if reached the end
  if(findNextSection()) {
    finalTrigger = sectionEndTrigger;
    finalBin = sectionEndBin;
    return;
  }

  for(ScanEx::RodInfoMap::const_iterator ri = scanEx->rodInfo.begin();
      ri != scanEx->rodInfo.end();
      ri++) {
    const RodLabel &rod = ri->first;

    cout << "New histogram control task...\n";

    boost::shared_ptr<PrimListWrapper> primList(new PrimListWrapper(1));
    api.startHistogramTask(*scan, *scanEx, rod, 
                           sectionStartBin, 1 + sectionEndBin - sectionStartBin, sectionEndTrigger, 
                           primList);

    api.sendPrimList(rod.rod, primList);
    int responseCode = api.awaitResponse(rod.rod, 5);

    if(responseCode != 0) {
      cout << "Histogram primitive failed! (ROD " << rod.rod << ")\n";
      throw SctApiException("Histogram primitive failed! (ROD " + boost::lexical_cast<string>(rod.rod) + ")");
    }
  }  
}

bool ScanControlRODHisto::findNextSection() {
  // Find next section to do
  Scan::TrigPoints trigPoints = scan->getVariableTrigs();

  unsigned int i = sectionEndBin + 1; // StartBin + 1;

  if(i==trigPoints.size()) {
    // Nothing more to do
    // If we're done, the previous section was last so don't overwrite the parameters
    return true;
  }

  UINT32 initialNTrigs = trigPoints[i];

  while(i<trigPoints.size() && trigPoints[i] >= initialNTrigs)
    i ++; 

  bool done = false;

  sectionStartBin = 0;
  sectionEndBin = i - 1;

  if(i == trigPoints.size()) {
    sectionEndTrigger = trigPoints[i-1];
  } else {
    sectionEndTrigger = trigPoints[i-1] - trigPoints[i];

//     sectionStartBin = i;
//     sectionEndBin = trigPoints.size() - 1;
//     sectionEndTrigger = scan->getVariableTrigs()[i] - completedTriggers[i];
  }

#if 0 
  // The old way
  unsigned int i = sectionEndBin + 1;
  UINT32 initialNTrigs = trigPoints[i];
  while(i<trigPoints.size() && trigPoints[i] == initialNTrigs) 
    i++;

  sectionStartBin = sectionEndBin + 1;
  sectionEndBin = i - 1;
  sectionEndTrigger = scan->getVariableTrigs()[i-1];

  done = false;
#endif

  cout << "Next sectionStartBin = " << sectionStartBin << " sectionEndBin = " << sectionEndBin << " sectionEndTrigger = " << sectionEndTrigger << endl;

  return done;
}

bool ScanControlRODHisto::checkScanComplete(bool &progressMade, bool &newBin) {
  if(aborting) {
    return true;
  }

  progressMade = false;
  newBin = false;

  bool result = true;

  int totalBin = 0;

  map<RodLabel, bool> rodNewBinMap;

  for(ScanEx::RodInfoMap::const_iterator ri = scanEx->rodInfo.begin();
      ri != scanEx->rodInfo.end();
      ri++) {
    const RodLabel &rodLabel = ri->first;

    bool rodNewBin = false;

    if(!checkScanCompleteROD(rodLabel, progressMade, rodNewBin, totalBin)) {
      result = false;
    }

    rodNewBinMap[rodLabel] = rodNewBin;
  }

  // Only do a "newBin" if all RODs agree
  newBin = true;  
  for(map<RodLabel, bool>::const_iterator mapIter = rodNewBinMap.begin();
      mapIter != rodNewBinMap.end();
      mapIter++) {
    if(mapIter->second == false) {
      newBin = false;
    } else {
      cout << "New bin requested by ROD (" << mapIter->first.partition << ", " << mapIter->first.crate << ", " << mapIter->first.rod << ")\n";
    }
  }

  if(progressMade) {
    int progressBin = totalBin / scanEx->rodInfo.size();

#if USE_IS
    if(api.m_isDict) {
      ISInfoInt binNumber(progressBin);
      api.m_isDict->update("SCTAPIServer.currentBin", binNumber);
    }
#endif
  }

  return result;
}

void ScanControlRODHisto::abort() {
  aborting = true;
}

unsigned int ScanControlRODHisto::getEventCounter(const RodLabel &rodLabel, int slave, bool fromMaster) {
  // Now then, now then, now then!
  // With dsp code version 1.20 and above, things have changed as follows:
  // o mdsp maintains one 32 bit event count for each module group (slave)
  // o sdsp maintains one 32 bit event count

  if(fromMaster) {
  // Read 32 bit counter from mdsp
    unsigned long address=0;
#if defined(HSSTAT_REG_0)
    switch (slave){
    case 0: address=HSSTAT_REG_0; break;
    case 1: address=HSSTAT_REG_1; break;
    case 2: address=HSSTAT_REG_2; break;
    case 3: address=HSSTAT_REG_3; break;
    default: cerr << "get event counter for bad slave number : " << slave << std::endl; return 0;
    }
#else
#warning "PWP Hard-coded memory address for checking MDSP event counters"
    switch (slave){
    case 0: address=0x80000028; break;
    case 1: address=0x8000002c; break;
    case 2: address=0x80000030; break;
    case 3: address=0x80000034; break;
    default: cerr << "get event counter for bad slave number : " << slave << std::endl; return 0;
    }
#endif

    unsigned long reg = api.dspSingleRead(rodLabel.rod, address, -1);
    return (unsigned int) reg;
  } else {
    // Read 32 bit counter from sdsp
    // Uses RW_SLAVE_MEMORY primitive rather than direct read of slave (which would be unpredictable!)
    unsigned long SDSP_IDRAM_BASE;
    if(api.getRodRevision(rodLabel) >= 0xe) {
      SDSP_IDRAM_BASE = 0x10000;        // Rev E or F
    } else {
      SDSP_IDRAM_BASE = 0x80000000;     // Rev C
    }
    unsigned long reg = api.dspSingleBlockRead(rodLabel.rod, SDSP_IDRAM_BASE+0x2c, slave);
    return (unsigned int) reg;
  }
}

bool ScanControlRODHisto::checkScanCompleteROD(const RodLabel &rodLabel, bool &progressMade, bool &newBin, int &totalBin) {
  int partition = rodLabel.partition;
  int crate = rodLabel.crate;
  int rod = rodLabel.rod;

  int currBin = 0;
  int currEvent = 0;

  // Read bin number from master dsp
#warning "AJB does not like the look of this hard-coded memory address for the bin number - not one little bit!"
  // See Sct/comRegDfns_11x.h for placement of regs
  long reg = api.dspSingleRead(rod, 0x80000020, -1);
  currBin = (reg & 0xff);

  RodScanEx &rodInfo = scanEx->rodInfo[rodLabel];

  // Use the event count copied from the master for the lowest slave with a module
  // This counter should now be 32 bit
  currEvent = getEventCounter(rodLabel, rodInfo.firstSlave, true);

  if(currBin != lastBin[rodLabel]) {
    lastBin[rodLabel] = currBin;
    lastEvent[rodLabel] = currEvent;
    cout << "Next bin " << currBin << "+" << currEvent << " on ROD (" << partition << ", " << crate << ", " << rod << ")\n";

    progressMade = true;
  } else if(currEvent != lastEvent[rodLabel]) { 
    lastEvent[rodLabel] = currEvent;
    cout << "Next event " << currEvent << " (bin " << currBin << ") on ROD (" << partition << ", " << crate << ", " << rod << ")\n";

    progressMade = true;
  }

  totalBin += currBin;

  // End of current section
  if(currBin == sectionEndBin && currEvent == sectionEndTrigger) {
    // Probably got to the end...
    newBin = true;

    // Check all the DSPs involved
    for(int s=0; s<4; s++) {
      if(rodInfo.bitFieldDSP & (1<<s)) {
        int slaveEvent = getEventCounter(rodLabel, s, true);
        // Actually this one not finished yet
        if(slaveEvent != sectionEndTrigger) {
          cout << " Slave " << s << " completed only " << slaveEvent << "/" << sectionEndTrigger << " triggers\n";
          newBin = false;
        }
      }
    }
  } else if(currBin == sectionEndBin && currEvent == (sectionEndTrigger%65536)) {
    // Should check trigger count on slave (not 16bit?)

    // If progress was made we'll wait for the next iteration
    if(!progressMade) {
      // Otherwise its most likely finished properly...
      newBin = true;

      // Check all the DSPs involved
      for(int s=0; s<4; s++) {
    if(rodInfo.bitFieldDSP & (1<<s)) {
          int slaveEvent = getEventCounter(rodLabel, s, true);
      // Actually this one not finished yet
      if(slaveEvent != sectionEndTrigger) {
        cout << " Slave " << s << " completed only " << slaveEvent << "/" << sectionEndTrigger << " triggers\n";
        newBin = false;
      }
    }
      }
    }
  }

  // Could this be if(newBin && currBin == finalBin) ???
#warning "Actually, this is wrong if the last section is one bin"
  //  (finalTrigger is the complete count, which may not be the 
  //   same as the number of triggers sent in last section)
  if(((currBin == finalBin) && (currEvent == finalTrigger))
     || ((currBin == finalBin) && (currEvent == (finalTrigger%65536)) && !progressMade)) {

    // Fix lastEvent in the case it's incorrect due to 16bitness
    lastEvent[rodLabel] = finalTrigger;

    if(api.mrs && !reportedFinished[rodLabel]) {
      reportedFinished[rodLabel]=true;
      *api.mrs << "HISTO_SUCCESS" << MRS_DIAGNOSTIC << MRS_QUALIF("SCTAPI") 
               << MRS_PARAM<int>("partition", rodLabel.partition)
               << MRS_PARAM<int>("crate", rodLabel.crate)
               << MRS_PARAM<int>("rod", rodLabel.rod)
               << MRS_TEXT("Histogramming successfully complete")
               << ENDM;
    }

    cout << "Histogramming completed successfully on rod " << rod << "\n";

    return true;
  }

  return false;
}

void ScanControlTIMHisto::finishHistogram(bool success) { 
  printVetoStatus();
  this->ScanControlRODHisto::finishHistogram(success);  
}

void ScanControlAsyncHisto::finishHistogram(bool success) { 
  printVetoStatus();
  this->ScanControlRODHisto::finishHistogram(success);  
}

void ScanControl::printVetoStatus(){
  // Total count of clocks spent with FFTVeto on
  long long loCount = api.timReadRegister(0x74);
  long long hiCount = api.timReadRegister(0x76);
  long long extCount = api.timReadRegister(0x78);
  long long count = loCount + (hiCount << 16) + ((extCount << 16) << 16);
  
  // Number Triggers Veto'd
  long loVeto = api.timReadRegister(0x7c);
  long hiVeto = api.timReadRegister(0x7e);
  long veto = loVeto + (hiVeto << 16);
  
  // Count of number of times the veto is asserted.
  long loVetos = api.timReadRegister(0x84);
  long hiVetos = api.timReadRegister(0x86);
  long vetos = loVetos + (hiVetos << 16);

  std::ostringstream vetostatus;
  vetostatus << "TIM FFTV Software disable:" << (bool)(api.timReadRegister(0x9c) & 0x100);
  vetostatus << "; Hardware disable:" << (bool)(api.timReadRegister(0x5a) & 0x8000);
  vetostatus << "; Veto on:" << (bool)(api.timReadRegister(0x5a) & 0x4000) << std::endl;
  
  std::ostringstream oss; 
  oss << std::hex << count << std::dec;
  
  std::cout << vetostatus.str();
  printf("TIM FFTV: Clocks spent vetoed %lld  Vetoed triggers %ld  Veto applications %ld\n", count, veto, vetos);
  
  if (api.mrs) {
    *api.mrs << MRS_INFORMATION << MRS_QUALIF("SCTAPI") << "TIM_FFTV_STATUS"
         << MRS_TEXT("TIM module fixed-frequency veto status")
         << MRS_PARAM<const char*>("Number of clocks with veto applied",oss.str().c_str())
         << MRS_PARAM<long>("Number of triggers vetoed",veto)
         << MRS_PARAM<long>("Number of times veto applied",vetos)
         << MRS_PARAM<const char*>("Status",vetostatus.str().c_str())
         << ENDM;
  }
} 

void ScanControlRODHisto::finishHistogram(bool success) { 
  time_t scanEnd = time(0);

#if USE_CONST_SCAN
  scanEx->setEndTime(second_clock::universal_time());
#else
  scan->setEndTime(second_clock::universal_time());
#endif

  std::cout << api.ucid() << " finished histogramming at TIME " << second_clock::universal_time() << std::endl;

  if(!useCCode(api, *scan)) {
    for(ScanEx::RodInfoMap::const_iterator ri = scanEx->rodInfo.begin();
        ri != scanEx->rodInfo.end();
        ri++) {
      const RodLabel &rod = ri->first;
      const RodScanEx &rodInfo = ri->second;

      unsigned long SDSP_IDRAM_BASE;
      if(api.getRodRevision(rod) >= 0xe) {
        SDSP_IDRAM_BASE = 0x10000;        // Rev E or F
      } else {
        SDSP_IDRAM_BASE = 0x80000000;     // Rev C
      }

      for(int s=0; s<numSlaves; s++) {
        if(rodInfo.bitFieldDSP & (1<<s)) {
          try {
#warning "Hard coded reads of diagnostic register"
            unsigned long val = api.dspSingleBlockRead(rod.rod, 
                                                       SDSP_IDRAM_BASE + 0x10, s);
            cout << "Read from slave " << s << " diag register: 0x" << hex << val 
                 << " which should be 0x" << (1<<19) << dec << endl;

            // Flush cache
            unsigned long newVal = val | 1<<17;
            api.dspSingleBlockWrite(rod.rod, SDSP_IDRAM_BASE + 0x10, newVal, s);
            val = api.dspSingleBlockRead(rod.rod, SDSP_IDRAM_BASE + 0x10, s);
            cout << "Read from slave " << s << " diag register: 0x" << hex << val 
                 << " which should be 0x" << (1<<17) << dec << endl;

            // Turn off flush and cache
            newVal = val | 1<<19;
            api.dspSingleBlockWrite(rod.rod, SDSP_IDRAM_BASE + 0x10, newVal, s);
            val = api.dspSingleBlockRead(rod.rod, SDSP_IDRAM_BASE + 0x10, s);
            cout << "Read from slave " << s << " diag register: 0x" << hex << val 
                 << " which should be 0x" << (0) << dec << endl;
          } catch(VmeException &v) {
            Utility::decodeVme(v);
            cerr << "VmeException turning off slave " << s << " cache\n";
          }
        }
      }
    }
  }

#if USE_CONST_SCAN
  setModuleScanCacheToLastPointInScan(api, scan, scanEx);
#else
  setModuleScanCacheToLastPointInScan(api, scan);
#endif
  
  std::cout << api.ucid() << " Done setModuleScanCacheToLastPointInScan at TIME " << second_clock::universal_time() << std::endl;

  // Read out if successful (even in debug mode!)
  //  but don't readout in debug mode if polling failed
  if(!scan->getOption(Scan::DEBUG) || success == true) {
    if(api.mrs) {
      *api.mrs << "SCAN_FINISHED" << MRS_INFORMATION 
               << MRS_QUALIF("SCTAPI") << MRS_QUALIF("doScan") 
               << MRS_TEXT("Scan finished") 
               << MRS_PARAM<int>("ScanNumber", scan->getScanNumber())
               << MRS_PARAM<int>("ScanType1", scan->getScanVariable1())
               << MRS_PARAM<int>("ScanType2", scan->getScanVariable2())
               << MRS_PARAM<int>("ScanTime", scanEnd - scanStart)
               << ENDM;
    }

    cout << api.ucid() << " Histogramming complete, " << (scanEnd - scanStart) << " seconds, tidying up...\n";
//     {
//       boost::mutex::scoped_lock lock(log().mutex());
//       log() << "Histogramming complete, " << (scanEnd - scanStart) << " seconds\n";
//     }

    cout << api.ucid() << " Starting to read histograms at TIME " << second_clock::universal_time() << std::endl;

    readHistograms();

    cout << api.ucid() << " Histograms read finished at TIME " << second_clock::universal_time() << std::endl;
  } else {
    if(!scan->getOption(Scan::DEBUG)) {
      cout << "Histogram polling failed\n";

      if(api.mrs) {
        *api.mrs << "SCAN_FAILED" << MRS_INFORMATION 
                 << MRS_QUALIF("SCTAPI") << MRS_QUALIF("doScan") 
                 << MRS_TEXT("Scan polling failed") 
                 << MRS_PARAM<int>("ScanNumber", scan->getScanNumber())
                 << MRS_PARAM<int>("ScanTime", scanEnd - scanStart)
                 << ENDM;
      }
    }
  }

  if(checkDebugOption(DEBUG_PRINT_CALIB)) {
    RodLabel zeroRod = scanEx->rodInfo.begin()->first;

    api.print_calib(zeroRod.rod);
  }
  
  if(!scan->getOption(Scan::DEBUG)) {
    api.stopHistogramming(*scanEx);

    // Only restore module config if not debug mode
    postScanModuleSetup();
  } else {
    if(api.mrs) {
      *api.mrs << "SCAN_DEBUG" << MRS_INFORMATION 
               << MRS_QUALIF("SCTAPI") << MRS_QUALIF("doScan") 
               << MRS_TEXT("Scan done in debug mode, probably best to be at the command line to sort it out!") 
               << ENDM;
    }

    cout << "** In debug mode, you're responsible for terminating histogram and for readout\n";
  }

  if(checkDebugOption(DEBUG_PRINT_CALIB)) {
    RodLabel zeroRod = scanEx->rodInfo.begin()->first;

    api.print_calib(zeroRod.rod);
  }

  // This should now have been updated with the modules in the scan
  std::cout << scan->print();
  
#if USE_IS
  if(api.m_isDict) 
    api.m_isDict->remove(api.idiosyncrasy().infoServiceNameOfScanStatusObject());
#endif

  if(api.mrs)
    *api.mrs << "SCAN_COMPLETE" << MRS_INFORMATION << MRS_QUALIF("SctApi") << MRS_TEXT("Scan has completed") << ENDM;
}

void ScanControlRODHisto::postScanModuleSetup() {
  api.setErrorMasks();
}

bool ScanControlRODHisto::checkDebugOption(int opt) {
  return Debug::getInstance()->checkDebugOption((DebugOptions)opt);
}

void ScanControlRODHisto::reportEventErrors() {
  api.reportEventErrors();
}

unsigned int ScanControlRODHisto::getProcTime(const RodLabel rlabel, int dsp) {
  if(dsp == -1) {
    throw SctApiException("Can't getProcTime on MDSP");
  } else {
    int procTime;

    unsigned long SDSP_IDRAM_BASE;
    if(api.getRodRevision(rlabel) >= 0xe) {
      SDSP_IDRAM_BASE = 0x10000;        // Rev E or F
    } else {
      SDSP_IDRAM_BASE = 0x80000000;     // Rev C
    }

    unsigned long length;

#warning "Hard-coded address, sdsp histogram status block"
    unsigned long *regs = api.dspBlockRead(rlabel.rod, 
                                           SDSP_IDRAM_BASE + 0x10, 20, dsp, length);

    if(regs) {
      long reg;

      // H stat reg 0
      reg = regs[6];
      procTime = ((reg >> 16) & 0xffff);
    } else {
      throw SctApiException("Failed to read getProcTime from DSP");
    }

    return procTime;
  }
}

ScanControlRODHisto::TrapBuffers ScanControlRODHisto::getTrapBuffers(const RodLabel rlabel, int dsp) {
  if(dsp == -1) {
    throw SctApiException("Invaled dsp passed to getTrapBuffers");
  } else {
    int ihead, itail, xhead, xtail;

    unsigned long SDSP_IDRAM_BASE;
    if(api.getRodRevision(rlabel) >= 0xe) {
      SDSP_IDRAM_BASE = 0x10000;        // Rev E or F
    } else {
      SDSP_IDRAM_BASE = 0x80000000;     // Rev C
    }

    unsigned long length;
#warning "Hard coded address of sdsp trap block"
    unsigned long *regs = api.dspBlockRead(rlabel.rod, 
                                           SDSP_IDRAM_BASE + 0x10, 20, dsp, length);

    if(regs) {
      long reg;

      // Trap stat 1
      reg = regs[1];
      itail = ((reg & 0xff0000) >> 16);
      xtail = ((reg & 0xff000000) >> 24);

      // Trap stat 1
      reg = regs[2];
      ihead = ((reg & 0xff0000) >> 16);
      xhead = ((reg & 0xff000000) >> 24);
    } else {
      throw SctApiException("Failed to read DSP for getTrapBuffers");
    }

    return make_pair(make_pair(ihead, itail), make_pair(xhead, xtail));
  }
}

void ScanControlRODHisto::dumpHistoStatus(const RodLabel rlabel, int dsp) {
  if(dsp == -1) {
    const unsigned long MDSP_IDRAM_BASE = 0x80000000;

    // Histogram command stat 0
#ifndef HCMD_STAT_REG_0 
#warning "Reading hard-coded HCMD_STAT_REG_0"
    long reg = api.dspSingleRead(0, MDSP_IDRAM_BASE + 0x20, -1);
#else
    long reg = api.dspSingleRead(0, HCMD_STAT_REG_0, -1);
#endif
    cout << "Bin: " << (reg & 0xff) 
         << " Cal: " << ((reg & 0xff00) >> 8) 
         << " Errs: " << ((reg & 0xffff0000) >> 16) << endl;

    // Histogram command stat 1
#ifndef HCMD_STAT_REG_1 
#warning "Reading hard-coded HCMD_STAT_REG_1"
    reg = api.dspSingleRead(0, MDSP_IDRAM_BASE + 0x24, -1);
#else
    reg = api.dspSingleRead(0, HCMD_STAT_REG_1, -1);
#endif
    cout << "avg. trans " << (reg & 0xff)
         << " avg. len " << ((reg & 0xff00) >> 8)
         << " avg. proc. " << ((reg & 0xffff0000) >> 16) << endl;

    // Histogram status 1
#ifndef HSSTAT_REG_1 
#warning "Reading hard-coded HSSTAT_REG_1"
    reg = api.dspSingleRead(0, MDSP_IDRAM_BASE + 0x2c, -1);
#else
    reg = api.dspSingleRead(0, HSSTAT_REG_1, -1);
#endif
    cout << "Slave 0: " << (reg & 0xffff)
         << " Slave 1: " << ((reg & 0xffff0000) >> 16) << endl;

    // Histogram status 0
#ifndef HSSTAT_REG_0 
#warning "Reading hard-coded HSSTAT_REG_0"
    reg = api.dspSingleRead(0, MDSP_IDRAM_BASE + 0x28, -1);
#else
    reg = api.dspSingleRead(0, HSSTAT_REG_0, -1);
#endif
    cout << "Slave 2: " << (reg & 0xffff)
         << " Slave 3: " << ((reg & 0xffff0000) >> 16) << endl;
  } else {
    unsigned long SDSP_IDRAM_BASE;
    if(api.getRodRevision(rlabel) >= 0xe) {
      SDSP_IDRAM_BASE = 0x10000;        // Rev E or F
    } else {
      SDSP_IDRAM_BASE = 0x80000000;     // Rev C
    }

    unsigned long length;
#warning "Hard coded block of trap status registers"
    unsigned long *regs = api.dspBlockRead(rlabel.rod, 
                                           SDSP_IDRAM_BASE + 0x10, 20, dsp, length);

    if(regs) {
      long reg;

      cout << "TrapStatus: \n";


      // Trap stat 0
      reg = regs[1];
      int words = ((reg &0xffff) >> 0);
      int itail = ((reg & 0xff0000) >> 16);
      int xtail = ((reg & 0xff000000) >> 24);

      cout << "Event word count: " << words;
      cout << " IFrame tail: " << itail;
      cout << " XFrame tail: " << xtail << endl;

      // Trap stat 1
      reg = regs[2];
      int ihead = ((reg & 0xff0000) >> 16);
      int xhead = ((reg & 0xff000000) >> 24);
      cout << " IFrame head: " << ihead;
      cout << " XFrame head: " << xhead << endl;

      // Trap cmd stat
      reg = regs[17];
      cout << "Trap Command/Status: " 
           << ((reg & 0x1)?"Trailer ":"")            // TCSR_TRAILER
           << ((reg & 0x2)?"Transmit ":"")
           << ((reg & 0x4)?"Header ":"")
           << ((reg & 0x4)?"ISR active ":"");
      cout << ((reg & 0x10)?"\"Data Error\" ":"")
           << ((reg & 0x20)?"\"Header Error\" ":"")
           << ((reg & 0x40)?"\"Trailer Error\" ":"")
           << ((reg & 0x80)?"\"Link Error\" ":"");
      cout << ((reg & 0x100)?"\"Error\" ":"")
           << ((reg & 0x200)?"\"Overflow(old)\" ":"")
           << ((reg & 0x800)?"\"ISR pending\" ":"");
      cout << ((reg & 0x4000)?"\"Overflow error\" ":"")
           << ((reg & 0x8000)?"\"Overflow\" ":"");
      cout << endl;

      int errCount = ((reg >> 16) & 0xff);
      cout << "\"Error count\": " << errCount << endl;
      int evCount = ((reg >> 24) & 0xff);
      cout << "\"Event count\": " << evCount << endl;

      // Hcmd stat reg 0
      reg = regs[4];
      int currentBin = (reg & 0xff);
      cout << "Bin: " << currentBin
           << " Cal: " << ((reg & 0x1f00) >> 8) 
           << ((reg & 0x800)?" Cal enabled":"")
           << ((reg & 0x1000)?" New bin":"")
           << ((reg & 0x20000)?" New cal":"") << endl;

      // Hcmd stat reg 1
      reg = regs[5];
      int numEvents = reg;
      cout << "Num events: " << numEvents << endl;

      // H stat reg 0
      reg = regs[6];
      cout << "Histogram status: 0x" << hex << (reg & 0xffff) << dec << " " << ((reg & 0x1)?"Ready ":"")
           << ((reg & 0x2)?"Expecting ":"")
           << ((reg & 0x4)?"Processing ":"")
           << ((reg & 0x8)?"Done ":"") << endl;

      int procTime = ((reg >> 16) & 0xffff);
      cout << "Bin err: " << ((reg >> 8) & 0xff) 
           << " proc time: " << ((reg >> 16) & 0xffff) << endl;

      // H stat reg 1
      reg = regs[7];
      int evRecvd = reg;
      cout << "Events recvd: " << evRecvd << endl;

      ofstream statusOut("TIMStatus.txt", ios_base::out | ios_base::app);
      statusOut << currentBin << "\t" 
                << ihead  << "\t" << itail << "\t" 
                << xhead << "\t" << xtail << "\t"
                << errCount << "\t" << evCount << "\t" 
                << evRecvd << "\t" << words << "\t" << procTime << endl;
    }
  }
}

ScanControlTIMHisto::ScanControlTIMHisto(SctApi &api, boost::shared_ptr<Scan> aScan, boost::shared_ptr<ScanEx> aScanEx) : ScanControlRODHisto(api, aScan, aScanEx), binCount(0) {
}

void ScanControlTIMHisto::startHistogramming() {
  // Set BCID offset to 3
  api.timWriteRegister(0x14, 0x3000);

  // reset TIM FFT veto counters
  for (unsigned reg=0x74; reg<=0x86; reg+=2){
    api.timWriteRegister(reg,0x0);
  }

  shared_ptr<PrimListWrapper> preTimList(new PrimListWrapper(4));
// next two lines unnecessary - done at newBin PWP
//  PrimBuilder::instance().rodMode(preTimList, DATA_TAKING_MODE, 0, 1, 0, 0, 1); 
//  PrimBuilder::instance().writeRegister(preTimList, RTR_CMND_STAT, RTR_SLINK_DOWN_OVERRIDE_O, 1, 1);   // Mask LDown#

  for(int f=0; f<8; f++) {
//     PrimBuilder::instance().writeRegister(preTimList, DM_DFLT_LUT(f), 0, 16, 0xaaaa);   // Decrement L1 for check
//     PrimBuilder::instance().writeRegister(preTimList, DM_DFLT_LUT(f), 0, 16, 0x5555);   // Increment L1 for check
    PrimBuilder::instance().writeRegister(preTimList, DM_DFLT_LUT(f), 0, 16, 0x0);   // Clear L1 inc
  }

   //for(int ch=0; ch<48; ch++) {
   //  PrimBuilder::instance().writeRegister(preTimList, Utility::EfbErrorMask(0, ch), 5, 1, 1);  // Mask L1ID check
   //  PrimBuilder::instance().writeRegister(preTimList, Utility::EfbErrorMask(1, ch), 5, 1, 1);  // Mask L1ID check
   //}

  cout << "Sending pre TIM setup list\n";
  api.synchSendPrimListAll(preTimList);
  cout << " done sending pre TIM setup list\n";

  hex(cout);
  cout << "0x" << RTR_CMND_STAT << ": 0x" << api.readRODRegister(0, RTR_CMND_STAT) << endl;
  cout << "0x" << Utility::EfbErrorMask(0, 0) << ": 0x" << api.readRODRegister(0, Utility::EfbErrorMask(0, 0)) << endl;
  cout << "0x" << Utility::EfbErrorMask(1, 0) << ": 0x" << api.readRODRegister(0, Utility::EfbErrorMask(1, 0)) << endl;
  cout << "0x" << DM_DFLT_LUT(0) << ": 0x" << api.readRODRegister(0, DM_DFLT_LUT(0)) << endl;
  cout << "0x" << DM_DFLT_LUT(1) << ": 0x" << api.readRODRegister(0, DM_DFLT_LUT(1)) << endl;
  dec(cout);

  if(checkDebugOption(DEBUG_TIM_SCAN_STATUS)) {
    // This is added to by dumpHistoStatus
    ofstream statusOut("TIMStatus.txt");
    statusOut << "bin\tihead\titail\txhead\txtail\terrCnt\tevCount\tevRecvd\twords\tprocTime\n";
  }

  std::cout << "Wait for slave 0 of all RODs to be ready\n";

/*
  bool ready;
  unsigned long loop = 0;
  do{
    ready = true;
    for(ScanEx::RodInfoMap::const_iterator ri = scanEx->rodInfo.begin();
        ri != scanEx->rodInfo.end();
        ri++) {
      const RodLabel &rodLabel = ri->first;

      unsigned long SDSP_IDRAM_BASE;
      if(api.getRodRevision(rodLabel) >= 0xe) {
        SDSP_IDRAM_BASE = 0x10000;
      } else {
        SDSP_IDRAM_BASE = 0x80000000;
      }
      unsigned long reg = api.dspSingleBlockRead(rodLabel.rod, SDSP_IDRAM_BASE+0x28, 0);
      if((reg & 0x01) == 0) ready = false;
    }
    loop ++;
    usleep(1000); //1mS
  }while((ready == false) && (loop < 1000));

  if(loop > 999){
    std::cout << "timeout waiting for slaves to be ready\n";
  }else{
    std::cout << "Slaves ready in " << loop << " loops\n";
  }
*/
}

void ScanControlTIMHisto::nextBin() {
  cout << "TIM histo, next bin\n";

  unsigned scanvariable1 = scan->getScanVariable1();
  if (scanvariable1!=0){
    double value = scan->getScanPoints1()[binCount];
    
    if (ConfigUtility::isModuleRegister(scanvariable1)){
      std::list<BankType> banks;
      banks.push_back(SCTAPI_BANK_SCAN);
      api.modifyABCDVarROD(scanvariable1, value, banks);
    } else if (ConfigUtility::isTimRegister(scanvariable1) ) {
      api.modifyTIMParam(scanvariable1, (int)(value+0.5));
    } else if (ConfigUtility::isBocRegister(scanvariable1) ){
      api.modifyBOCParam(scanvariable1, (int)(value+0.5));
    } else if (ConfigUtility::variableType(scanvariable1)==ConfigUtility::TRIGGER_VAR) {
      ; // done later
    } else {
      if (api.mrs) {
    *api.mrs << "BAD_SCAN_VARIABLE" << MRS_TEXT("Unknown scan variable in TIM scan")
         << MRS_PARAM<int>("Variable number",scanvariable1) << MRS_WARNING << ENDM;
      } else{
    std::cout << "Warning - bad scan variable : " << scanvariable1 
          << " type " << ConfigUtility::variableType(scanvariable1) << std::endl;
      }
    }
  }

  // AJB add this?
  //if (!ConfigUtility::isBOCRegister(scan->getScanVariable1())) 
  api.sendAllABCDModules(SCTAPI_BANK_SCAN);
  
  // SET_TRIGGER (ie tell histograms about next bin)
  shared_ptr<PrimListWrapper> setTriggerList(new PrimListWrapper(4));
  PrimBuilder::instance().setTrigger(setTriggerList, binCount, Utility::translateBank(SCTAPI_BANK_SCAN));

  shared_ptr<PrimListWrapper> binTimList(new PrimListWrapper(4));

  // Send to all slaves
  for(int s=0; s<4; s++) {
    PrimBuilder::instance().slavePrimList(binTimList, setTriggerList, s, 1, 0);
  }

  PrimBuilder::instance().rodMode(binTimList, DATA_TAKING_MODE, 0, 1, 0, 0, 1);
  PrimBuilder::instance().writeRegister(binTimList, RTR_CMND_STAT, RTR_SLINK_DOWN_OVERRIDE_O, 1, 1);   // Mask LDown#

  cout << "Sending TIM setup list\n";
  api.synchSendPrimListAll(binTimList);
  cout << " done sending TIM setup list\n";

  if(checkDebugOption(DEBUG_TIM_SCAN_STATUS)) {
    cout << "******************* Pre triggers status ********************\n";
    dumpHistoStatus(RodLabel(), 0);
  }

  cout << "Sending soft/bc resets to crate: " << api.ucid() << endl;
  api.timSoftReset();
  api.timBCReset();

  Scan::TrigPoints trigs = scan->getVariableTrigs();

  cout << "Want " << trigs[binCount] << " triggers to crate: " << api.ucid() << endl;

  const Trigger& trig1 = *scan->getTrigger1();
  
  if(1) {
    switch(scan->getOption(Scan::TIM)) {
    case 1:
      // Just send lots of triggers, relies on user to set up frequency/nth appropriately
      {
    api.sendTriggers(&trig1, trigs[binCount], binCount);
      }
      break;
    case 2:
#warning "Assumes ROD 0!!!"
      // Send one trigger at a time, then wait maximum of 1 second for trap buffers to equalize
      for(unsigned int i=0; i<trigs[binCount]; i++) {
    api.timL1A();
    
    TrapBuffers tb = getTrapBuffers(RodLabel(), 0);
    
    if (!(tb.first.first == tb.first.second && tb.second.first == tb.second.second))
      sleep(1);
      }
      break;
    case 3:
#warning "Assumes ROD 0!!!"
      // Send in bursts of triggers, wait for them to finish
      // Designed to be run at 100kHz
      {
    unsigned int sentTriggers = 0;
    const unsigned int trigsPerBurst = 20;
    
    while(sentTriggers < trigs[binCount]) {
      if(sentTriggers % 1000 < trigsPerBurst) {
        cout << "Done " << sentTriggers << " triggers\n";
        if(checkDebugOption(DEBUG_TIM_SCAN_STATUS))
          dumpHistoStatus(RodLabel(), 0);
      }
      int ntrigs = min(trigs[binCount]-sentTriggers, trigsPerBurst);
      api.sendTimBurst(ntrigs,false);
      sentTriggers += ntrigs;
      
      // Have they been processed yet?
      TrapBuffers tb = getTrapBuffers(RodLabel(), 0);
      
      TrapBuffers oldtb;
      if (!(tb.first.first == tb.first.second && tb.second.first == tb.second.second))
        do {
          oldtb = tb;
          usleep(trigsPerBurst * 10);  // 7 * 10us at 100kHz 
          tb = getTrapBuffers(RodLabel(), 0);
          
          if(tb.first.first == tb.first.second && tb.second.first == tb.second.second) break;
          if(tb == oldtb) break;
        } while(1); 
    }
      }
      break;
    case 4:
#warning "Assumes ROD 0!!!"
      // Adjust frequency depending on how long the previous set of triggers 
      //  takes to histogram, first 1 then 10 then the rest.
      {
    unsigned int sentTriggers = 0;
    
    api.timL1A();
    sentTriggers ++;
    
    //   // Set 100kHz triggers
    //   api.timSetFrequency(100, 0);
    
    unsigned int procTime = getProcTime(RodLabel(), 0);
    double timFrequency = 0.25 * 1e6/procTime;
    // Don't go faster than 6kHz
    api.timSetFrequency(min(6.0, timFrequency/1000), 0);
    
    cout << "*** Proc Time for 1 trigger was " << procTime << " setting frequency to " << timFrequency << "Hz\n";
    
    procTime = getProcTime(RodLabel(), 0);
    timFrequency = 0.25 * 1e6/procTime;
    api.timSetFrequency(min(6.0, timFrequency/1000), 0);
    
    cout << "*** Proc Time after 10 trigs was " << procTime << " setting frequency to " << timFrequency << "Hz\n";
    
    if(trigs[binCount] > sentTriggers)
      api.sendTimBurst(trigs[binCount]-sentTriggers,false);
    
    if(checkDebugOption(DEBUG_TIM_SCAN_STATUS)) {
      cout << "******************* Post triggers status ********************\n";
      dumpHistoStatus(RodLabel(), 0);
    }
    
    TrapBuffers tb = getTrapBuffers(RodLabel(), 0);
    
    TrapBuffers oldtb;
    if (!(tb.first.first == tb.first.second && tb.second.first == tb.second.second))
      do {
        oldtb = tb;
        sleep(1);
        tb = getTrapBuffers(RodLabel(), 0);
        
        if(tb.first.first == tb.first.second && tb.second.first == tb.second.second) break;
        if(tb == oldtb) break;
      } while(1); 
    break;
      }
    default:
      {
    std::cout << "ERROR - unknown TIM option : " 
          << (scan->getOption(Scan::TIM)) << std::endl;
    break;
      }
    } // End switch on TIM histogramming types
  }
  if(checkDebugOption(DEBUG_TIM_SCAN_STATUS)) {
    cout << "******************* Post triggers status 2 ******************\n";
    dumpHistoStatus(RodLabel(), 0);
  }

  //  TTrigger soft;
  //soft.softL1A(30);

  //  api.timL1A();
  binCount ++;
}

// TIM histos don't run Histo Control so event counters not mirrored to master
// A sort of dummy function at the moment...
bool ScanControlTIMHisto::checkScanCompleteROD(const RodLabel &rodLabel, bool &progressMade, bool &newBin, int &totalBin) {

  unsigned long slvEvtCnt1 = getEventCounter(rodLabel, 0, false);
  usleep(10000); // 10mS??
  unsigned long slvEvtCnt2 = getEventCounter(rodLabel, 0, false);
  
  if(slvEvtCnt1 != slvEvtCnt2){
    // progress was made if this changed
    progressMade = true;
    newBin = false;
  }else if((binCount>0) && (slvEvtCnt2 == 0)){
    // Not the first bin, but no events were seen: nothing happened!
    // (Necessary because polling starts before first TIM trigger is issued)
    progressMade == false;
    newBin = false;
  }else{
    // neither count changed and at least one of them is not zero:
    // assume this bin has been completed
    progressMade = true;
    newBin = true;
  }

  std::cout << "Checking TIM scan complete: slvCount1 " <<  slvEvtCnt1 << " slvCount2 " << slvEvtCnt2 << endl;

  totalBin += binCount-1;

  //  cout << "Are we at the end: " << (binCount-1) << " " << finalBin << endl;

  if((binCount-1 >= finalBin)) {
    return true;
  }

  return false;
}

// bool ScanControlTIMHisto::checkScanComplete(bool &progressMade) {
//   return false;
// }

ScanControlAsyncHisto::ScanControlAsyncHisto(SctApi &api, boost::shared_ptr<Scan> aScan, boost::shared_ptr<ScanEx> aScanEx) : ScanControlRODHisto(api, aScan, aScanEx), binCount(0) {
}

void ScanControlAsyncHisto::startHistogramming() {
#warning "Should we check we're in physics mode?"
  if(checkDebugOption(DEBUG_TIM_SCAN_STATUS)) {
    // This is added to by dumpHistoStatus
    ofstream statusOut("TIMStatus.txt");
    statusOut << "bin\tihead\titail\txhead\txtail\terrCnt\tevCount\tevRecvd\twords\tprocTime\n";
  }
}

void ScanControlAsyncHisto::nextBin() {
  cout << "Asynchronous histo, next bin\n";

  if (scan->getScanVariable1()!=0){
    std::list<BankType> banks;
    banks.push_back(SCTAPI_BANK_SCAN);
    
    api.modifyABCDVarROD(scan->getScanVariable1(), scan->getScanPoints1()[binCount], banks);
  }

  if(0) {
    // AJB add this?
    //if (!ConfigUtility::isBOCRegister(scan->getScanVariable1())) 
    api.sendAllABCDModules(SCTAPI_BANK_SCAN);
  }

  // SET_TRIGGER (ie tell histograms about next bin)
  shared_ptr<PrimListWrapper> setTriggerList(new PrimListWrapper(4));
  PrimBuilder::instance().setTrigger(setTriggerList, binCount, Utility::translateBank(SCTAPI_BANK_SCAN));

  shared_ptr<PrimListWrapper> binTimList(new PrimListWrapper(4));

  // Send to all slaves
  for(int s=0; s<4; s++) {
    PrimBuilder::instance().slavePrimList(binTimList, setTriggerList, s, 1, 0);
  }

  // Do this if configuring modules, otherwise, we're already in physics mode
//   PrimBuilder::instance().rodMode(binTimList, DATA_TAKING_MODE, 0, 1, 0, 0, 1);
//   PrimBuilder::instance().writeRegister(binTimList, RTR_CMND_STAT, RTR_SLINK_DOWN_OVERRIDE_O, 1, 1);   // Mask LDown#

  cout << "Sending async TIM set trigger list\n";
  api.synchSendPrimListAll(binTimList);
  cout << " done sending async TIM set trigger list\n";

  if(checkDebugOption(DEBUG_TIM_SCAN_STATUS)) {
    cout << "******************* Next bin triggers status ********************\n";
    dumpHistoStatus(RodLabel(), 0);
  }

//   cout << "Sending soft/bc resets to crate: " << api.ucid() << endl;
//   api.timSoftReset();
//   api.timBCReset();

  binCount ++;
}

}

---