SctApi.cxx

#include <iostream>
#include <stdexcept>
#include <cmath>
#include <cstdio>  // For tempnam (and ScanResultWriter)
#include <unistd.h>

#include <sys/stat.h>   // mkdir etc
#include <sys/types.h>

#include <boost/bind.hpp>
#include <boost/format.hpp>

#include "SctApi.h"
#include "SctApiConsts.h"
#include "SctApiDebug.h"
#include "SctApiHisto.h"
#include "sctConf/configRegistry.h"
#include "ScanDefImpl.h" // was SctApiImpl.h
#include "TriggerImpl.h" // was SctApiImpl.h
#include "crateImpl.h"
#include "autoConfig.h"

#include "primUtils.h"
#include "primListWrapper.h"
#include "PrimBuilder.h"

#include "extraScans.h"
#include "SctApiRodInfo.h"
#include "SctApiCounters.h"

#include "ScanResultWriter/scan.h"
#include "Sct/SctNames.h"
#include "Sct/FibreNumberConverters.h"

#include "registerIndices.h"

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

#include "CommonWithDsp/primParams.h"

#include "RodCrate/RodModule.h"

#include "VmeDecode.h"
#include "RodCrate/TimDefine.h"

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

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

#include "utility.h"
#include "SctApiException.h"
#include "ModuleList.h"
#include "DCSAccess.h"
#include "SctApiDDC.h"
#include "Idiosyncrasy.h"
#include "Sct/MultiMessageDebugStream.h"

using namespace std;
using namespace SctPixelRod;
using namespace SctConfiguration;
using namespace SctApi::Utility;
using namespace boost::posix_time;
using boost::shared_ptr;
using SctApi::ModuleList;

// Some static methods
static void handle_unexpected(void);

namespace SctApi {

const unsigned int SctApi::BAD_MODULE = 0xffffffff;

/*
  // This version of the constructor is only called by TApi .. and so is the abnormal constructor

  The default constructor.
  This sets the unexpected handler to interpret all sorts of exceptions
*/
SctApi::SctApi(const Idiosyncrasy & id) 
  : mrs(0),
#if USE_IS
    m_isDict(), 
#endif
    rodList(), rodInfoList(), moduleMap(), scanController(), lastScanController(),
    m_id(new Idiosyncrasy(id)),
    config(), 
    m_dcsAccess(new DCSAccessDummy), m_sctApiDDC(),
    debugPrimList(), crateObject(), 
    m_log(new Log(id.ucid())), lastDebugScan(), lastDebugScanEx(),
    scanNumber(0), runNumber(0)
#if USE_SCAN_THREAD
    ,
    scanQueue_notEmpty(), scanQueue_mutex(), scanPollThread(),
    m_stopPolling(false), m_inScanLoop(false), m_inRawScanLoop(false),  m_initialisationThread(), m_is_initialised(false)
#endif
{
  cout << "Load configuration\n";
  std::string backend = "xml";
  SctConfiguration::FactoryManager::instance().loadPlugin(backend); 
  SctConfiguration::Factory &f = SctConfiguration::FactoryManager::instance().getFactory(backend);
  config.reset(f.defaultConfig());
  config->loadConfiguration("");
  m_sctApiDDC = boost::shared_ptr<SctApiDDC>(new SctApiDDC(config, m_log));
  setup();
}

SctApi::SctApi(const Idiosyncrasy & id, boost::shared_ptr<Configuration> newConf) 
  : mrs(0),
#if USE_IS
    m_isDict(), 
#endif
    rodList(), rodInfoList(), moduleMap(), scanController(), lastScanController(),
    m_id(new Idiosyncrasy(id)),
    config(), 
    m_dcsAccess(new DCSAccessDummy), m_sctApiDDC(),
    debugPrimList(), crateObject(), 
    m_log(new Log(id.ucid())), lastDebugScan(), lastDebugScanEx(),
    scanNumber(0), runNumber(0)
#if USE_SCAN_THREAD
    ,
    scanQueue_notEmpty(), scanQueue_mutex(), scanPollThread(),
    m_stopPolling(false), m_inScanLoop(false), m_inRawScanLoop(false), m_initialisationThread(), m_is_initialised(false)
#endif
{
  config = newConf;
  m_sctApiDDC = boost::shared_ptr<SctApiDDC>(new SctApiDDC(config, m_log));
  setup();
}

/* The destructor. */
SctApi::~SctApi() {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "SctApi destructor\n";
    log() << "\t TIME " << second_clock::universal_time() << endl;
  }

#if USE_SCAN_THREAD
  m_stopPolling = true;
  scanPollThread->join();
#endif

}

bool SctApi::isInitialised(){
  return m_is_initialised;
}

SctApiConfigCache& SctApi::getModuleConfigCache(){
  return module_cache;
}

const Idiosyncrasy & SctApi::idiosyncrasy() {
  return *m_id;
}

const std::string SctApi::getHostName() const {
  char buffer[100];
  gethostname(buffer, 100);
  return std::string(buffer);
}

bool SctApi::hasFinishedScanning() {
  const std::string name 
    = this->idiosyncrasy().infoServiceNameOfScanStatusObject();
  
  const ISInfo::Status badlyTypedReturnValue 
    = m_isDict->contains(name);

  switch (badlyTypedReturnValue) {
  case ISInfo::NotFound:
    // so the IS server existed, but it doesn't contain the "scanning" remark, so probably scanning has stopped
    return true;
  case ISInfo::Success:
    // so the IS server existed, and it does contain the "scanning" remark, so scanning has not yet finished (it is still going on).
    return false;
  default:
    // Something else happened, which should worry us, because this suggests that the method is being called out of context.  Complain to the user, and do not change the state of the cache!  Most likely scanning is not taking place, so return true;
    {
      Sct::MultiMessageDebugStream m(true,false,true);
      m << "SctApi tried to figure out whether scanning had finished by looking for [" 
    << name
    << "] but there was a problem: an unusual ISInfo::Status (value "
    << badlyTypedReturnValue
    << ") was returned while querying IS.  Possible causes might include (but be limited to) running the sw without starting the appropriate is_servers, a software bug, or high network load causing poor CORBA connections, eg timeouts.  Making a guess that scanning is not taking place at the moment ...";
      m.flush();
    };
    return true;
  };
};

void SctApi::setup() 
{
  Debug::getInstance(); // Make sure setupDebugOptions() is called early

  debugPrimList.reset(new PrimListWrapper);

  // Examine exceptions on the way to a crash...
  set_unexpected(handle_unexpected);
  cout << "Installed unexpected handler\n";

  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "Initial setup complete\n";
  }

#if USE_SCAN_THREAD
  scanPollThread.reset(new boost::thread(boost::bind(&SctApi::scanPollingThread, this)));
#endif
}

void SctApi::setMrsStream(MRSStream *stream) 
{
  mrs = stream;
}

#if USE_IS
void SctApi::setIsDictionary()
{
  m_isDict = 
    boost::shared_ptr<ISInfoDictionary>
    (new ISInfoDictionary(Sct::SctNames::getPartition()));
}
#endif

// ROD Diagnostics

// Read one ROD Status Register via HPI
unsigned long SctApi::readRodStatusReg(unsigned int rod,
                                       long regNumber) {
  unsigned long result = 0;

  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "readRodStatusReg " << regNumber << endl;
  }

  Crate *myCrate = getCrate();
  if(myCrate) {
    result = myCrate->readRodStatusReg(rod, regNumber);
  }

  return result;
}
  
// Read one ROD Command Register via HPI
unsigned long SctApi::readRodCommandReg(unsigned int rod,
                                        long regNumber) {
  unsigned long result = 0;

  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "readRodCommandReg\n";
  }

  Crate *myCrate = getCrate();
  if(myCrate) {
    result = myCrate->readRodCommandReg(rod, regNumber);
  }

  return result;
}

// Read a single 32b word from MasterDSP SDRAM via HPI
unsigned long SctApi::dspSingleRead(unsigned int rod,
                                    const unsigned long dspAddr, long dspNumber) {
  unsigned long result = 0;

  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "dspSingleRead 0x" << hex << dspAddr << dec << endl;
  }
  Crate *myCrate = getCrate();
  if(myCrate) {
    result = myCrate->dspSingleRead(rod, dspAddr, dspNumber);
  }

  return result;
}

// Write a single 32b word to MasterDSP SDRAM via HPI
void SctApi::dspSingleWrite(unsigned int rod,
                            unsigned long dspAddr, unsigned long value, long dspNumber) {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "dspSingleWrite 0x" << hex << dspAddr << " 0x" << value << dec << endl;
  }
  Crate *myCrate = getCrate();
  if(myCrate) {
    myCrate->dspSingleWrite(rod, dspAddr, value, dspNumber);
  }
}

ABCDModule *SctApi::lookupConfig(UINT32 mid) {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "lookupconfig " << mid << endl;
  }

  if(moduleMap.find(mid) == moduleMap.end()) {
     std::cout << "AJB lookup config " << mid << " requests cache " << std::endl;
     cacheModuleConfig(mid);
  }

  ABCDModule *result = 0;

  if(moduleMap.find(mid) != moduleMap.end()) {
    result = &(moduleMap.find(mid)->second);
  }

  return result;
}

// This should be a nice and simple method, but lots of fixing up and checking goes on
/*
  1) Given mid, find the serial number for lookup in configuration
  2) Check redundancy mappings and put into ROD information
  3) Get the module configuration from the database
   a) Fix up address for select
   b) If redundant off ROD assign OFF_ROD_TTC
   c) Formatters use different base for rx parameter
   d) Insert module group into configuration structure
  4) Retrieve and put into cache the module error mask
  5) Put configuration into moduleMap
  6) Report on current settings
 */
void SctApi::cacheModuleConfig(UINT32 mid, std::string moduleName) {
  unsigned int partition, crate, rod, channel;
  getpcrc(mid, partition, crate, rod, channel);

  RodLabel label(partition, crate, rod);

  unsigned int mur, module;

  // First find out what this module is called
  try {
    if(checkDebugOption(DEBUG_DIAG))
      cout << "Looking for partition " << partition << " crate " << crate << " rod " << rod << " channel " << channel << endl;
    config->translateFromROD(partition, crate, rod, channel, 
                             mur, module);

    if(checkDebugOption(DEBUG_DIAG2))
      cout << "Found MUR " << mur << " module number " << module << endl;
  } catch(ConfigurationException &c) {
    cout << "Can't find module in MUR map: \n";
    cout << c.what() << endl;

    {
      boost::mutex::scoped_lock lock(log().mutex());
      log() << "  (Not found)\n";
    }

    throw;
  }

  if (moduleName=="") try {
    config->translateToSN(mur, module, moduleName);

    if(checkDebugOption(DEBUG_DIAG2))
      cout << "Found module name " << moduleName << endl;
    //        config->getModuleRodPosition(moduleName, partition, crate, rod, channel);
  } catch(ConfigurationException &c) {
    cout << "Module name not found: \n";
    cout << c.what() << endl;

    {
      boost::mutex::scoped_lock lock(log().mutex());
      log() << "  (Not found)\n";
    }

    throw;
  }

  // Got name, look at redundancy
  bool redundantOnROD = false;

  // If redundancy off-ROD then this is > 48
  unsigned int rchannel;
  unsigned int rpartition, rcrate, rrod;

  // Only valid for off-ROD redundancy
  unsigned long rmid;

  bool redundantValid;

  try {
    config->translateToRROD(mur, module, 
                            rpartition, rcrate, rrod, rchannel);

    if(partition == rpartition && crate == rcrate && rod == rrod) {
      redundantOnROD = true;
    } else {
      RodLabel label(partition, crate, rod);
      RodLabel rlabel(rpartition, rcrate, rrod);

      RodInfo & info(getRodInfo(label));
      RodInfo & rinfo(getRodInfo(rlabel));
      
      cout << "Off ROD module found for mid " << mid << " !!! rchannel was  = " << rchannel << endl;

      unsigned int newRchannel = 48 + rinfo.offRODTTC.size();
#warning BRUCE HAS REALISED THAT SOME OF WHAT FOLLOWS EXPECTS THE UNMODIFIED VALUE OF rchannel, AND SOME OF WHAT FOLLOWS EXPECTS THE ABOE "VIRTUAL+48" rchannel SO THERE ARE ALMOST DEFINITELY BUGS IN THIS ROUTINE THAT WILL PREVENT REDUNDANT LINKS BEING HANDLED CORRECTLY! (Chris on behalf of Bruce)
#warning "Bruce has had an attempt at fixing this problem, but nobody has tested it with a real system"
      rmid = Utility::packpcrc(rpartition, rcrate, rrod, newRchannel);

      info.offRODTTC[mid] = rmid;
      rinfo.offRODRX[rmid] = mid;
      cout << "    rchannel now = " << newRchannel << " rmid = " << rmid << endl;
    }

    redundantValid = true;
  } catch(ConfigurationException &c) {
    redundantValid = false;
    cout << "Module redundancy not found: \n";
    cout << c.what() << endl;

    {
      boost::mutex::scoped_lock lock(log().mutex());
      log() << "  (Not found)\n";
    }

    // We can live with this (as long as select not set...?)
  }

  // Got the module serial number, now get the configuration
  ABCDModule configuration; 
  try {
    configuration = config->getModuleConfig(moduleName);

    // Fix up chip address for select

    // Only modules with sn like 20220nn0200nnn are guaranteed to have select line connected correctly
    // Others like 20220nn0100nnn may not
//     if(moduleName[8] == '2') {
      if(configuration.select) {
        for(int c=0; c<12; c++) {
          configuration.chip[c].address |= 0x10;
        }
    configuration.mid=rmid; // Added AJB 19/4/2005 - is this right?
      } else {
       for(int c=0; c<12; c++) {
          configuration.chip[c].address &= ~0x10;
        }
    configuration.mid=mid; // Added AJB 19/4/2005
      } 
      // } // Otherwise select line on module might be hard-wired

    RodInfo & info(getRodInfo(label));
    // Fix up for off ROD redundancy
    {
      boost::recursive_mutex::scoped_lock lock(rodInfoListAccess);
      
      if (!info.fibreMappings.get()) {
    std::cout << "getting fibre mappings for rod " << rod << std::endl;
    info.fibreMappings.reset(config->getFibreMappings(partition, crate, rod));
      }
    }
    configuration.pTTC  = info.fibreMappings[channel * 3 + 0];
    if(redundantOnROD) {
      configuration.rTTC = info.fibreMappings[rchannel * 3 + 0];
    } else {
      configuration.rTTC = OFF_ROD_TTC;
    };

    // Fix formatter addressing
    unsigned char rx0 = info.fibreMappings[channel * 3 + 1];
   if(rx0 != DATA_LINK_OFF) {
     configuration.rx[0] = (rx0/12)*16 + rx0%12;

     if(rx0 < getRodInfo(label).minLink) {
       getRodInfo(label).minLink = rx0;
     }
   } else {
     configuration.rx[0] = DATA_LINK_OFF;
    }

    // Fix formatter addressing (receive 1)
    unsigned char rx1 = info.fibreMappings[channel * 3 + 2];
    if(rx1 != DATA_LINK_OFF) {
      configuration.rx[1] = (rx1/12)*16 + rx1%12;

      if(rx1 < getRodInfo(label).minLink) {
        getRodInfo(label).minLink = rx1;
      }
    } else {
      configuration.rx[1] = DATA_LINK_OFF;
    }

    // Get Module group
    configuration.groupId = config->getModuleGroup(moduleName);


    if(redundantValid && configuration.select) {
      // Get Module group of redundant partner

      try {
        string redModuleName;

        unsigned int newMur, newModule;
        config->translateFromROD(rpartition, rcrate, rrod, rchannel, 
                         newMur, newModule);

        config->translateToSN(newMur, newModule, redModuleName);

        if(checkDebugOption(DEBUG_DIAG2))
          cout << "Found redundant module name " << redModuleName << endl;

        int redGroup = config->getModuleGroup(redModuleName);

        if(redGroup != configuration.groupId) {
          configuration.groupId = redGroup;

          cout << "Module group changed, should be identical to redundant partner\n";

          if(mrs)
            *mrs << "MODULE_GROUP_CHANGED" << MRS_WARNING << MRS_QUALIF("SCTAPI") 
                 << MRS_PARAM<const char *>("sn", moduleName.c_str())
                 << MRS_PARAM<const char *>("redSn", redModuleName.c_str())
                 << MRS_PARAM<int>("group", configuration.groupId)
                 << MRS_TEXT("Module group changed, should be identical to redundant partner")
                 << ENDM;
        }
      } catch(ConfigurationException &c) {
        cout << "Module name not found: \n";
        cout << c.what() << endl;

        {
          boost::mutex::scoped_lock lock(log().mutex());
          log() << "  (Not found)\n";
        }
      }

    }

    // Put error mask into ROD cache
    for(int l=0; l<2; l++) {
      const unsigned int zeroTo123Pos = configuration.rx[l];
      // We check the values before using it, doing this here makes the next bit less confusing
      const unsigned int zeroTo95Pos = Sct::FibreNumberConverters::from124FormatTo96Format(zeroTo123Pos);
      if (zeroTo123Pos==DATA_LINK_OFF) {
        // Don't put it in the map! 
        //  but otherwise this is valid ... no problem
      } else if(zeroTo123Pos <= 123 && zeroTo95Pos < 96) {
        // Good value, put in map
        unsigned int val = config->getModuleErrorMask(partition, crate, rod, channel, l);
        getRodInfo(label).linkErrorMasks[zeroTo95Pos] = val;
      } else {
        std::ostringstream os;
        os << "Bad fibre numbers for error mask values! Line " << __LINE__ << " of " << __FILE__ << " when 123pos = " << zeroTo123Pos << " and 95pos = " << zeroTo95Pos;
        if (mrs) {
          *mrs << "SctApi" << MRS_ERROR << MRS_TEXT(os.str()) << ENDM;
        } else {
          std::cout << "SctApi: ERROR " << os.str() << std::endl;
        }
      }
    }

    // Put fixed configuration into cache
    moduleMap.insert(make_pair(mid, configuration));

    if(redundantValid == true && redundantOnROD == false) {
      // Modify slightly for off-ROD configuration, and also put into cache
      configuration.rx[0] = DATA_LINK_OFF;
      configuration.rx[1] = DATA_LINK_OFF;

      // Only rTTC will get used, but overwrite pTTC with something valid
      configuration.pTTC = configuration.rTTC = rchannel;

      moduleMap.insert(make_pair(rmid, configuration));
      
      cout << "Off-ROD module configuration loaded " << rmid << " put in slot " << (int)configuration.pTTC << endl;

      if(mrs) {
        *mrs << "MODULE_LOADED" << MRS_INFORMATION << MRS_QUALIF("SCTAPI") 
             << MRS_TEXT("Off-ROD module configuration loaded")
             << MRS_PARAM<int>("rmid", rmid)
             << MRS_PARAM<int>("moduleSlot", configuration.pTTC)
             << ENDM;
      }
    }

    // Now what did we end up with?
    cout << "\tpTTC = " << (int)configuration.pTTC << " rTTC = " << (int)configuration.rTTC 
         << " rx[0] = " << (int)configuration.rx[0] << " rx[1] = " << (int)configuration.rx[1] 
         << " group = " << (int)configuration.groupId;

    for(int l=0; l<2; l++) {
      const unsigned char link = l?rx1:rx0;
      if(link < 96) {
        int mask = getRodInfo(label).linkErrorMasks[link];
        cout << (l?" errorMask1 = 0x":" errorMask0 = 0x") << hex << mask << dec;
      }
    }
    cout << endl;

    if(mrs) {
      int link0 = configuration.rx[0];
      int link1 = configuration.rx[1];

      // Reverse translate formatter encoding
      if(link0 != DATA_LINK_OFF) 
        link0 = (link0/16) * 12 + link0%16;
      if(link1 != DATA_LINK_OFF) 
        link1 = (link1/16) * 12 + link1%16;

      *mrs << "MODULE_LOADED" << MRS_INFORMATION << MRS_QUALIF("SCTAPI") 
           << MRS_PARAM<const char *>("sn", moduleName.c_str())
           << MRS_PARAM<int>("group", configuration.groupId)
           << MRS_PARAM<int>("select", configuration.select)
           << MRS_PARAM<int>("pTTC", configuration.pTTC)
           << MRS_PARAM<int>("rTTC", configuration.rTTC)
           << MRS_PARAM<int>("rx0", link0)
           << MRS_PARAM<int>("rx1", link1);

      for(int l=0; l<2; l++) {
        const unsigned char link = l?rx1:rx0;
        if(link < 96) {
          int mask = getRodInfo(label).linkErrorMasks[link];
          if(mask) {
            *mrs << MRS_PARAM<int>(l?"errorMask1":"errorMask0", mask);
          }
        }
      }

      *mrs << MRS_TEXT("Module configuration loaded")
           << ENDM;
    }
    
  } catch(ConfigurationException &c) {
    cout << "Module not initialised: \n";
    cout << c.what() << endl;

    {
      boost::mutex::scoped_lock lock(log().mutex());
      log() << "  (Not found)\n";
    }

    throw;
  }
}

ABCDModule *SctApi::retrieveModule(UINT32 mid) {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "retrieveModule " << mid << endl;
  }
  return lookupConfig(mid);
}

// Create a prim list
void SctApi::createDebugPrimList() {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "createDebugPrimList\n";
  }
  debugPrimList->clear();
}

// Append a primitive to the prim list
void SctApi::addDebugPrimList(unsigned long length, long index, long id, long version,
                              unsigned long * body) {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "addDebugPrimList ID: " << id << " length: " << length << endl;
  }
  // Don't pass the body because we don't know where it came from...
  debugPrimList->addPrimitive(RodPrimitive((long)length, index, id, version, (long *)body));
}

// Send primlist
void SctApi::sendDebugPrimList(unsigned int rod) {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "sendDebugPrimList " << m_id->ucid() << " " << rod << endl;
  }
  sendPrimList(rod, debugPrimList);
}

// Send primlist to all rods
void SctApi::sendDebugPrimListAll() {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "sendDebugPrimListAll\n";
  }

  sendPrimListAll(debugPrimList);
}

void SctApi::sendDebugSlavePrimList(unsigned int rod,
                                    unsigned int slave, bool await, bool response) {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "sendDebugSlavePrimList \n";
  }
  sendSlavePrimList(rod, debugPrimList, slave, await, response);
}

void SctApi::debugPrimListFromFile(string fileName) {
  ifstream fin(fileName.c_str(), ios::binary);

  unsigned long fileSize;

  // Get size of file
  fin.seekg(0, std::ios::end);  // go to end of file
  fileSize = fin.tellg();  // file size is current location
  fin.seekg(0, std::ios::beg);  // go back to beginning of file

  cout << "Loading file size: " << fileSize << endl;

  long *buffer = new long[fileSize];

  fin.read((char *)(buffer), fileSize);

  long listLength = buffer[0];
//   long listIndex = buffer[1];
  long listNumPrims = buffer[2];
//   long listPrimVersion = buffer[3];

  int offset = 4;

  debugPrimList->clear();

  for(int i=0; i<listNumPrims; i++) {
    long primLength = buffer[offset + 0];
    long primIndex = buffer[offset + 1];
    long primId = buffer[offset + 2];
    long primVersion = buffer[offset + 3];

    // Copy data to primitive
    debugPrimList->addPrimitive(primLength - 4, primIndex, primId, primVersion, buffer + offset + 4);

    offset += primLength;
    if(offset > listLength) {
      cout << "offset too big\n";
      return;
    }
  }
}

void SctApi::dumpDebugPrimList() {
  dumpPrimList(debugPrimList);
}

/*
  Initialise a module:
  Load configuration from database
  Send configuration to ROD

  return 0 for success
*/
int SctApi::initialiseModule(string modulename, bool toRod) {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "InitialiseModule " << modulename << endl << flush;
  }
  
  unsigned int partition, crate, rod, channel;

  // First find out where this module is
  try {
    unsigned int MUR, module;
    config->translateFromSN(modulename, MUR, module);
    config->translateToROD(MUR, module, partition, crate, rod, channel);
  } catch(ConfigurationException &c) {
    cout << "Module not initialised: \n";
    cout << c.what() << endl;
    return -1;
  }

  unsigned long mid=packpcrc(partition, crate, rod, channel);

  try {
    boost::mutex::scoped_lock lock(moduleMapAccess);
    //cache the module config from the config_service to the Crate Controller if necessary
    if (moduleMap.find(mid) == moduleMap.end()){
      cout << "Cache " << (toRod?"and Load ":"") << "module " << modulename << " at " <<
    partition << ", " << crate << ", " << rod << ", " << channel << " \n";
      
      cacheModuleConfig(mid, modulename);
    }
  } catch(ConfigurationException &c) {
    cout << "Module not initialised: \n";
    cout << c.what() << endl;
    return -2;
  }

  // Install configuration in ROD
  if(toRod){
    std::list<BankType> banks;
    banks.push_back(SCTAPI_BANK_PHYSICS);
    banks.push_back(SCTAPI_BANK_CALIBRATION);
    banks.push_back(SCTAPI_BANK_SCAN);
    setABCDModule(mid, banks);
  }
  return 0;
}

/*
   Initialise a rod from the configuration
 */
int SctApi::initialiseRod(unsigned int rod) {
  cout << "Hopefully will later get config for " << Sct::URID(prt(),crt(), rod) << " at " << __FILE__ << " " << __LINE__ << endl;
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "InitialiseRod\n";
  }
  Crate *myCrate = getCrate();
  if(!myCrate) {
    cout << "Request for non-existent crate " << ucid() << endl;
    return -1;
  } else if(!getCrate()->RODPresent(rod)) {
    cout << "ROD can't be initialised further: " << ucid() << " " << rod << endl;
    return -2;
  } else {
    // Set up and start slaves
    SctConfiguration::RodConfig rodConf;
    try {
      cout << "Getting config for " << Sct::URID(prt(),crt(), rod) << " at " << __FILE__ << " " << __LINE__ << endl;
      rodConf = config->getRodConfig(prt(), crt(), rod);
    } catch(ConfigurationException &c) {
      cout << "No configuration for rod " << rod << endl;
      return -3;
    }

    { 
      // Set source id register
      shared_ptr<PrimListWrapper> srcIdList(new PrimListWrapper(1));

      PrimBuilder &builder = PrimBuilder::instance();
      int regId = 0x1a1;
#ifdef SOURCE_ID
      regId = SOURCE_ID;
#endif
      builder.writeRegister(srcIdList, regId, 0, 16, (crt() << 8) | rod);

      sendPrimList(rod, srcIdList);
      if(awaitResponse(rod, 1) != 0) {
    cout << "Setting source ID on ROD failed!\n";
      }
    }

    int startedSlaves = 0;
    int configuredSlaves = 0;
    for(int slave=0;  slave < numSlaves; slave++) {
      try {
        string ip;
        string id;
        string ext;

        if(rodConf.slaves[slave].ipramFile != "") {
          ip = rodConf.slaves[slave].ipramFile;
          id = rodConf.slaves[slave].idramFile;
          ext = rodConf.slaves[slave].extFile;
        } else {
          cout << " Trying defaults\n";

          int rev = getCrate()->getRodRevision(rod);

          char revChar = (char)(rev-0xa) + 'A';

          // Just load rev E DSP code?
          //   if(rev == 0xf) revChar = 'E';

          cout << " Slave config for Rev" << revChar << endl;

          SlaveConfig slaveConfig = config->getDefaultSlaveConfig(revChar);
          ip = slaveConfig.ipramFile;
          id = slaveConfig.idramFile;
          ext = slaveConfig.extFile;
#warning "Assumes there are valid defaults..."
        }

        std::cerr << "Starting slave " << slave << std::endl;
        std::cerr << "(" << ip << ", " << id << ", " << ext << ")\n";

        configuredSlaves ++;

        // These changed for Rev E!
        if(getCrate()->getRodRevision(rod) >= 0xe) {
          writeSlaveFile(rod, slave, ip, 0);
          writeSlaveFile(rod, slave, id, 0x10000);
          writeSlaveFile(rod, slave, ext, 0xa0000000);
        } else {
          writeSlaveFile(rod, slave, ip, 0);
          writeSlaveFile(rod, slave, id, 0x80000000);
          writeSlaveFile(rod, slave, ext, 0x2000000);
        }
 
        startSlave(rod, slave);

        myCrate->slaveStarted(rod, slave);

        startedSlaves ++;

        cout << "Slave " << slave << " on rod " << rod << " configured at TIME " << second_clock::universal_time() << endl;
      } catch(ConfigurationException &c) {
        cout << "No configuration for slave " << slave << ": " << c.what() << endl;

        if(mrs) {
          *mrs << "ROD_SLAVE_INIT" << MRS_ERROR
               << MRS_TEXT((string("ROD slave configuration not found: ") + c.what()).c_str())
               << MRS_PARAM<int>("partition", prt())
               << MRS_PARAM<int>("crate", crt())
               << MRS_PARAM<int>("rod", rod)
               << MRS_PARAM<int>("slave", slave) 
               << ENDM;
        }
      } catch(SctApiException &s) {
        cout << "Slave start failed: " << s.what() << endl;

        if(mrs) {
          *mrs << "ROD_SLAVE_INIT" << MRS_ERROR
               << MRS_TEXT((string("ROD slave initialisation failed: ") + s.what()).c_str())
               << MRS_PARAM<int>("partition", prt())
               << MRS_PARAM<int>("crate", crt())
               << MRS_PARAM<int>("rod", rod)
               << MRS_PARAM<int>("slave", slave) 
               << ENDM;
        }
      }
    }

    if(mrs) {
      *mrs << "ROD_SLAVE_INIT";
      if(startedSlaves != configuredSlaves) {
        *mrs << MRS_ERROR
             << MRS_TEXT("ROD slave initialisation incomplete");
      } else {
        *mrs << MRS_INFORMATION
             << MRS_TEXT("All ROD slaves initialised");
      }
      *mrs << MRS_QUALIF("SCTAPI") 
           << MRS_PARAM<int>("partition", prt())
           << MRS_PARAM<int>("crate", crt())
           << MRS_PARAM<int>("rod", rod)
           << MRS_PARAM<int>("started", startedSlaves)
           << MRS_PARAM<int>("configuration", configuredSlaves)
           << ENDM;
    }

    cout << "Started " << startedSlaves << " slave DSPs\n";

    RodLabel currRod(prt(), crt(), rod);

    std::cout << "Not Reading out modules from ROD but actually adding rod << " << Sct::URID(prt(),crt(),rod) << " to rod list!" << std::endl;

    addRodToList(currRod);
    {
      const RodLabel & l = this->rodList.back(); //moo Moo
      std::cout << "Last rod added was " << Sct::URID(l.partition, l.crate, l.rod) << std::endl;
    }
  }
  return 0;
}


class PreLoadConfigurations{
public:
  PreLoadConfigurations(SctApi* api) : api(api){}
  ~PreLoadConfigurations(){}
  void operator() (){
    bool success=false;
    try{
      ptime start_time(second_clock::universal_time());
      std::cout << "Started preloading module configurations at TIME " 
        << start_time << std::endl;
      api->m_preloadModuleConfigurationsStop=false;
      unsigned modules = api->preloadModuleConfigurations();
      ptime end_time(second_clock::universal_time());
      time_duration load_time=(end_time-start_time);
      std::cout << "Preloaded " << modules << " module configurations at TIME "
        << end_time << ". Took " << load_time.seconds() << " seconds" << std::endl;
      success=true;
    }catch(std::exception& e){
      std::cerr << e.what() << std::endl;
    }catch(...){
    }
    if (!success){
      std::cerr << api->ucid() << " Pre-load of module configurations FAILED!" << std::endl;
    }
  }
  SctApi* api;
private:
  PreLoadConfigurations(){}
};


/*
   Initialise everything from the configuration.
   Uses initialiseRod and initialiseModule to do actual configuration
 */
#define PRELOAD_MODULE_CONFIGURATIONS 1
void SctApi::initialiseAll(int run) {
  //setDebugOption("diag");
  //setDebugOption("diag2");
  //setDebugOption("print_in_prim");
  //setDebugOption("module_config");
  m_is_initialised=false;

  runNumber = run;

#if USE_SCAN_THREAD
  std::cout << "Initialisation using thread" << std::endl;
  scanPollThread.reset(new boost::thread(boost::bind(&SctApi::initialisationThread, this)));
#else
  std::cout << "Initialisation without using thread" << std::endl;
  initialisationThread();
#endif
}

void SctApi::initialisationThread(){
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "InitialiseAll " << runNumber << " foe " << m_id->ucid() << "\n";
  }
  cout << "********** SCT API initialisation started for " << m_id->ucid() <<" **********\n";
  {
    time_t startTime = time(NULL);
    struct tm broke = *(gmtime(&startTime));

    char buffer[25];
    strftime(buffer, 25, "%H:%M:%S %Y/%m/%d", &broke);

    cout << "***************** " << buffer << " **************\n";
  }

  unsigned int totalPartitions = 0;
  unsigned int totalCrates = 0;
  unsigned int totalRods = 0;
  unsigned int totalModules = 0;

  // Clear up from previous time if necessary

  crateObject.reset();
  moduleMap.clear();
  debugPrimList->clear();
  rodList.clear();
  module_cache.clearAll();

  // start pre-loading module configurations
#if PRELOAD_MODULE_CONFIGURATIONS
    boost::thread initialisation_thread(PreLoadConfigurations(this));
#endif

  // Read in configuration and act accordingly
  list<unsigned int> partitions; 
  try {
    partitions = config->listPartitions();
  } catch(ConfigurationException &c) {
    cout << "No partitions to initialise\n";
    cout << c.what() << endl;
    return;
  }

  cout << "Found configuration for " << partitions.size() << " partitions\n";

  for(list<unsigned int>::const_iterator p=partitions.begin();
      p!=partitions.end(); 
      p++) {

    list<unsigned int> crates; 

    try {
      crates = config->listCratesInPartition(*p);
    } catch(ConfigurationException &c) {
      cout << "No crates in this partition\n";
      cout << c.what() << endl;
      continue;
    }

    cout << "Found configuration for " << crates.size() << " crates\n";

    for(list<unsigned int>::const_iterator c=crates.begin(); 
        c!=crates.end(); 
        c++) {

      if (Sct::UCID(*p, *c)==ucid()) {

    cout << "Found a config for our own dear crate " << ucid() << endl;
    try {
      crateObject = boost::shared_ptr<Crate>(new CrateImpl(ucid(), config));
      
      if(mrs)
        getCrate()->setMrsStream(mrs);
      
      cout << ucid() << " Initialise crate at TIME " << boost::posix_time::second_clock::universal_time() << std::endl;
      // Setup VME and say HI to the TIM and all the RODs and BOCs (includes reset of the RODs)
      totalRods += getCrate()->initialiseCrate();

#warning 'AJB WHAT ABOUT TIM2??'
      unsigned tim_debug_status = timReadRegister(TIM_REG_DEBUG_CTL);
      bool sw_disable = tim_debug_status & (1<<12);
      unsigned tim_busy_stat3 = timReadRegister(0x5A);
      bool hw_disable = tim_busy_stat3 & (1<<15);

      if (sw_disable || hw_disable){
        if (mrs) {
          *mrs << MRS_WARNING << "TIM_FFT_VETO_DISABLED" << MRS_QUALIF("SCTAPI")
           << MRS_PARAM<int>("partition",ucid().partition())
           << MRS_PARAM<int>("crate",ucid().crate())
           << MRS_PARAM<int>("hardware disable",hw_disable)
           << MRS_PARAM<int>("software disable",sw_disable)
           << MRS_PARAM<int>("overall disable",(sw_disable&&hw_disable))
           << MRS_TEXT("Tim Fixed Frequency Veto has been DISABLED! If the magnetic field is on this could be DANGEROUS TO MODULES!") << ENDM;
          
        }else{
          std::cout << "TIM FFTV disable : h/w disable=" << hw_disable 
            << " s/w disable=" << sw_disable << std::endl;
        }
      }

      list<unsigned int> rods;
      try {
        rods = config->listRodsInCrate(*p, *c);
      } catch(ConfigurationException &cex) {
        cout << "No RODs in this crate\n";
        cout << cex.what() << endl;

        if(mrs) {
          *mrs << "CRATE_WARNING" << MRS_WARNING << MRS_QUALIF("SCTAPI") 
           << MRS_TEXT("No configuration for RODs while initialising crate")
           << MRS_PARAM<int>("partition", *p)
           << MRS_PARAM<int>("crate", *c)
           << ENDM;
        }

        continue;
      }
      
      //set flag to stop preloading module configurations.
          m_preloadModuleConfigurationsStop=true; 

            for(list<unsigned int>::const_iterator r=rods.begin(); 
          r!=rods.end(); 
          r++) {
        RodLabel label(*p, *c, *r);
        
        // This also does the slave setup
            cout << ucid() << " Start rod " << *r << " initialisation at TIME " << boost::posix_time::second_clock::universal_time() << std::endl;
      
        if(initialiseRod(*r) != 0) {
          cout << "Initialisation of rod  " << *r << " failed!\n";
          // Don't load modules...
          continue;
        }
        
        cout << ucid() << " Start rod " << *r << " module initialisation at TIME " << boost::posix_time::second_clock::universal_time() << std::endl;

        list<unsigned int> MURs;
        try {
          MURs = config->listMURSInRod(*p, *c, *r);
        } catch(ConfigurationException &cex) {
          cout << "No MURs for this ROD\n";
          cout << cex.what() << endl;
          if(mrs) {
        *mrs << "CRATE_WARNING" << MRS_WARNING << MRS_QUALIF("SCTAPI") 
             << MRS_TEXT("Configuration for no modules while initialising ROD")
             << MRS_PARAM<int>("partition", *p)
             << MRS_PARAM<int>("crate", *c)
             << MRS_PARAM<int>("ROD", *r)
             << ENDM;
          }
          continue;
        }
        for(list<unsigned int>::const_iterator mur=MURs.begin(); 
        mur!=MURs.end(); 
        mur++) {
          
          list<string> modules;
          try {
        modules = config->listModulesInMUR(*p, *mur);
          } catch(ConfigurationException &c) {
        cout << "No modules for this MUR\n";
        cout << c.what() << endl;
        continue;
          }
          
          for(list<string>::const_iterator m=modules.begin(); 
          m!=modules.end(); 
          m++) {
        // do module initialiseation if necessary
        if(!initialiseModule(*m, true)) {
          totalModules ++;
        }
          }
        }
        cout << totalModules << " modules initialised at TIME " << boost::posix_time::second_clock::universal_time() << std::endl;

            testLinkOutSelect(*r, getRodInfo(label).minLink);
      }
      
      std::cout << getCrate()->status();
      totalCrates++;
      {
        Sct::MultiMessageDebugStream m(true,true);
        m << "Crate server for " << ucid() << " finished setting up VME and saying HI to the TIM and all the RODs and BOCs (includes reset of the RODs).";
      }
    } catch(...) {
      // Most likely VME initialisation failed (and crate already told MRS)
      cout << "Unexpected failure in crate initialisation\n";
      
      if(mrs) {
        *mrs << "CRATE_FAILED" << MRS_ERROR << MRS_QUALIF("SCTAPI") 
         << MRS_TEXT("Unexpected failure initialising crate")
         << MRS_PARAM<int>("partition", *p)
         << MRS_PARAM<int>("crate", *c)
         << ENDM;
      }
    }
      } else {
    // *p and *c correspond to some other crate we are not interested in.
      };
    }
    totalPartitions ++;
  }

#if PRELOAD_MODULE_CONFIGURATIONS
  initialisation_thread.join();
#endif

  setErrorMasks();
  
  // Load modules first so we know which channels to unmask
  cout << "Setup for calibration...\n";
  calib_init();

  currentRunMode = SCTAPI_RUN_CALIBRATION;
  cout << "... Done\n";

  cout << "Initialisation counts:\n";
  cout << "\ttotalPartitions: " << totalPartitions << endl;
  cout << "\ttotalCrates: " << totalCrates << endl;
  cout << "\ttotalRods: " << totalRods << endl;
  cout << "\ttotalModules: " << totalModules << endl;

  if (totalCrates!=1) {
    Sct::MultiMessageDebugStream m(true,true,true);
    m.severity(MRS_ERROR);
    m << "CrateController for " << ucid() << " found not one but " << totalCrates << " configurations in the config database while attempting to initialiseAll.";
  };

  if(mrs) {
    *mrs << "SCTAPIINIT_COMPLETE" << MRS_INFORMATION << MRS_QUALIF("SCTAPI") 
         << MRS_TEXT("SCTAPI Initialisation counts")
         << MRS_PARAM<int>("partitions", totalPartitions)
         << MRS_PARAM<int>("crates", totalCrates)
         << MRS_PARAM<int>("rods", totalRods)
         << MRS_PARAM<int>("modules", totalModules)
         << ENDM;
  }

  m_is_initialised=true;

  cout << "************** SCT API initialised ****************\n";
  {
    time_t endTime = time(NULL);
    struct tm broke = *(gmtime(&endTime));

    char buffer[25];
    strftime(buffer, 25, "%H:%M:%S %Y/%m/%d", &broke);

    cout << "************** " << buffer << " ****************\n";
  }
}

void SctApi::startSlave(unsigned int rod, unsigned int slave)
{
  cout << "Starting slave on " << slave << endl;

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

  PrimBuilder::instance().startSlave(primList, slave);

  sendPrimList(rod, primList);
  awaitResponse(rod, 5);

  unsigned long length;
  unsigned long *result = getResponse(rod, length);

  if(result) {
    unsigned int slaveRet = result[8];
    delete [] result;
    if(slaveRet != slave) {
      cout << "Bad return (" << slaveRet << ") from start slave " << slave << " \n";
      throw SctApiException("Bad return value from start slave");
    }
  } else {
    cout << "Bad response from start slave\n";
    throw SctApiException("Missing return primitive from start slave");
  }
}

void SctApi::setRunNumber(UINT32 newRun) {
  bool needsUpdate = false;
  if(newRun < runNumber) {
    if(mrs) {
      *mrs << "SCTAPI_RUNNUMBER" << MRS_WARNING << MRS_QUALIF("SCTAPI") 
           << MRS_TEXT("SCTAPI runnumber decrease")
           << MRS_PARAM<int>("oldRunNumber", runNumber)
           << MRS_PARAM<int>("newRunNumber", newRun)
           << MRS_PARAM<int>("newScanNumber", 0)
           << ENDM;
    }
    cout << "****  Run number has been decreased!!\n";
    runNumber = newRun;
    needsUpdate = true;
    scanNumber = 0;
  } else if(newRun == runNumber) {
    if(mrs) {
      *mrs << "SCTAPI_RUNNUMBER" << MRS_INFORMATION << MRS_QUALIF("SCTAPI") 
           << MRS_TEXT("SCTAPI runnumber unchanged")
           << MRS_PARAM<int>("oldRunNumber", runNumber)
           << MRS_PARAM<int>("newRunNumber", newRun)
           << MRS_PARAM<int>("newScanNumber", scanNumber)
           << ENDM;
    }
    cout << "**** Run number is unchanged scan number not reset!!!\n";
  } else {
    if(mrs) {
      *mrs << "SCTAPI_RUNNUMBER" << MRS_INFORMATION << MRS_QUALIF("SCTAPI") 
           << MRS_TEXT("SCTAPI runnumber changed")
           << MRS_PARAM<int>("oldRunNumber", runNumber)
           << MRS_PARAM<int>("newRunNumber", newRun)
           << MRS_PARAM<int>("newScanNumber", 0)
           << ENDM;
    }
    runNumber = newRun;
    needsUpdate = true;
    scanNumber = 0;
  }

  if(needsUpdate) {
    shared_ptr<PrimListWrapper> runNumberList(new PrimListWrapper(1));

    PrimBuilder &builder = PrimBuilder::instance();
    int regId = 0x1a2;
#ifdef RUN_NUMBER
    regId = RUN_NUMBER;
#endif
    builder.writeRegister(runNumberList, regId, 0, 32, runNumber);

    if(synchSendPrimListAll(runNumberList) != 0) {
      cout << "Update of run number on RODs failed!\n";
    }
  }
}

void SctApi::setScanNumber(UINT32 newScan) {
  if(mrs) {
    *mrs << "SCTAPI_SCANNUMBER" << MRS_INFORMATION << MRS_QUALIF("SCTAPI");
  }

  if(newScan < scanNumber) {
    cout << "**** Scan number has been decreased!!\n";
    if(mrs) {
      *mrs << MRS_TEXT("SCTAPI scannumber decreased");
    }
  } else {
    if(mrs) {
      *mrs << MRS_TEXT("SCTAPI scannumber changed");
    }
  }

  if(mrs) {
    *mrs << MRS_PARAM<int>("oldScanNumber", scanNumber)
         << MRS_PARAM<int>("newScanNumber", newScan)
         << ENDM;
  }

  scanNumber = newScan;
}

UINT32 SctApi::getRunNumber() {
  return runNumber;
}

UINT32 SctApi::getScanNumber() {
  return scanNumber;
}

ModuleList SctApi::getModuleList()  
{
  ModuleList result;

  // Set up masks for modules
  for(map<UINT32, ABCDModule>::const_iterator mi = moduleMap.begin();
      mi!=moduleMap.end();
      mi ++) {
    
    UINT32 currMid = mi->first;
    result.push_back(convertToString(currMid));
  }

  return result;
}

bool SctApi::isRODPresent(unsigned int rod) {
  bool result = false;
  if(getCrate()) {
    if(getCrate()->RODPresent(rod)) {
      result = true;
    }
  }

  return result;
}

void SctApi::startupModules() {
  // Turn power to standby1
  m_dcsAccess->toStandby1();

  // Check for clk/2 or event (its still running from last time)
  checkAllModulesProbe("2E");

  // Send configs
  sendAllABCDModules(SCTAPI_BANK_PHYSICS);

  // Check for event headers
  checkAllModulesProbe("E");

  // Power to standby2
  m_dcsAccess->toStandby2();
}

void SctApi::autoConfigure() {
  ::SctApi::AutoConf::AutoConfigurer configurer(*this);
  configurer.run();
}

/*
   Send a PrimList to a ROD

   This function exposes RodPrimList so make it private.
   Therefore to be used internally to this class.
*/
void SctApi::sendPrimList(unsigned int rod,
                          shared_ptr<PrimListWrapper> prim) {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "SendPrimList (" << m_id->ucid() << " " << rod << ")\n" << flush;
  }

  // This calls RodPrimList->bufferBuild
  dumpPrimList(prim);

  currentStats.primitiveLengthCounter += prim->list->getBufferLength();
  currentStats.primitiveCounter ++;

  updateISStats();

  if(getCrate()) {
    getCrate()->sendPrimList(rod, prim);
  } else {
    cout << "Request for non-existent crate " << m_id->ucid() << endl;
  }
}

int SctApi::synchSendPrimList(unsigned int rod, shared_ptr<PrimListWrapper> primList, int timeout) {
  // Send list
  sendPrimList(rod, primList);
 
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "synchSendPrimList sent" << endl;
  }
  int result = 0;

  // Wait for list, with no threads the awaitResponse starts the primitive...
  int responseCode = awaitResponse(rod, timeout);
  
  if(responseCode != 0) {
    cout << "Synchronous primitive list failed on crate "<< ucid()<<"\n";
    cout << " code = " << responseCode << endl;
    
    result = 1;
  }
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "synchSendPrimList returned " << result << endl;
  }
  
  return result;
}

/*
   Send a PrimList to all RODs in a crate

   This function exposes RodPrimList so make it private.
   Therefore to be used internally to this class.
*/
void SctApi::sendPrimListAll(shared_ptr<PrimListWrapper> prim) {
  if(checkDebugOption(DEBUG_DIAG)){
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "SendPrimListAll (" << m_id->ucid() << ")\n" << flush;
  }

  dumpPrimList(prim);

  if(getCrate()) {
    getCrate()->sendPrimListAll(prim);
  } else {
    cout << "Request for non-existent crate " << m_id->ucid() << endl;
  }
}

int SctApi::synchSendPrimListAll(shared_ptr<PrimListWrapper> primList, int timeout) {
  // Send list
  sendPrimListAll(primList);
 
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "synchSendPrimList sent" << endl;
  }
  int result = 0;

  // Wait for list, with no threads the awaitResponse starts the primitive...
  int responseCode = awaitResponseAll(timeout);
  
  if(responseCode != 0) {
    cout << "Synchronous primitive list failed on crate "<< ucid()<<"\n";
    cout << " code = " << responseCode << endl;
    
    result = 1;
  }
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "synchSendPrimList returned " << result << endl;
  }
  
  return result;
}

void SctApi::dumpPrimList(shared_ptr<PrimListWrapper> prim) {
  prim->list->bufferBuild();

  long buffLength = prim->list->getBufferLength();
  unsigned long* bufferStart = prim->list->getBuffer();

  if(checkDebugOption(DEBUG_DUMP_PRIM_BINARY))
    printMemoryBlock(log(), bufferStart, buffLength, 8);

  if(checkDebugOption(DEBUG_SAVE_PRIM)) {
    static int primCount = 0;

    string dirName = Sct::SctNames::getTempDir() + "/PrimLists";

    // Ignore success (0) or failure
    int mkRet = mkdir(dirName.c_str(), S_IRUSR|S_IWUSR|S_IXUSR);
    if(mkRet != 0) {
      // It's OK if it already exists
      if(errno != EEXIST) {
    perror(("Failed to create PrimLists directory in " + Sct::SctNames::getTempDir()).c_str());
      }
    }

    char *saveDir = getcwd(NULL, 0);

    int chRet = chdir(dirName.c_str());
    if(chRet != 0) {
      perror("Failed to change to PrimLists directory");
    }

    char fileName[100];
    sprintf(fileName, "PrimLists_%05d.bin", primCount++);
    ofstream fout(fileName, ios::binary | ios::trunc);
    fout.write((char*)&bufferStart[0], buffLength*4);

    int chRet2 = chdir(saveDir);
    if(chRet2 != 0) {
      perror("Failed to return to saved directory");
    }

    free(saveDir);
  }

  if(checkDebugOption(DEBUG_PRINT_IN_PRIM)) {
    // Pick between log and cout
    if(checkDebugOption(DEBUG_LOG_PRINT_PRIM)) {
      ::SctApi::printOutList(bufferStart, buffLength, true, 0, log(), 
                             checkDebugOption(DEBUG_PRINT_UNKNOWN), checkDebugOption(DEBUG_PRINT_RAW));
    } else {
      ::SctApi::printOutList(bufferStart, buffLength, true, 0, cout, 
                             checkDebugOption(DEBUG_PRINT_UNKNOWN), checkDebugOption(DEBUG_PRINT_RAW));
    }
  }
}

/*
   Shutdown anything that needs shutting down
   Send DCS to standby message
 */
void SctApi::shutdownAll() {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "SctApi told to shutdown\n";
    log() << "\t TIME " << second_clock::universal_time() << endl;
  }
  m_is_initialised=false;

  // What does shutdown involve?
  lasersOff(); //   ????

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

  if(mrs) {
    *mrs << "SCTAPI_SHUTDOWN" << MRS_INFORMATION << MRS_QUALIF("SCTAPI") << MRS_TEXT("First ROD shut down") << ENDM;
  }

  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "Shutdown sequence complete\n";
  }
}

/*
   Create a RodPrimList to send to the Master DSP which contains the RodPrimList which is passed as an argument
 */
void SctApi::sendSlavePrimList(unsigned int rod,
                               shared_ptr<PrimListWrapper> prim, unsigned int slaveNumber, bool await, bool response) {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "SendSlavePrimlist (" << m_id->ucid() << " " << rod << ")\n" << flush;
  }

  if((!getCrate())
     || (!getCrate()->slavePresent(rod, slaveNumber))) {
    cout << "***** Slave DSP (" << slaveNumber << ") was not initialised, please check the configuration and the Slave Image files\n";
    return;
  }

  shared_ptr<PrimListWrapper> container(new PrimListWrapper(1));

  PrimBuilder::instance().slavePrimList(container, prim, slaveNumber, await, response);

  try {
    container->list->bufferBuild();
  }
  catch (PrimListException &p) {
    cout << p.getDescriptor() << " ";
    cout << p.getData1() << ", " << p.getData2() << "\n";
  }

  sendPrimList(rod, container); 
}

/*
    Lookup the Crate object to send instructions to.
    Return 0 if not found.
 */
Crate *SctApi::getCrate() const {
  return crateObject.get();
  /*
  map<pair<unsigned int, unsigned int>, Crate* >::const_iterator found;

  found = crateMap.find(make_pair(partition, crate));
  if(found == crateMap.end()) {
    cerr << "Crate not found in getCrate " << partition << ", " << crate << endl;
    throw SctApiException("Missing crate");
  }
  else return found->second;
  */
}

int SctApi::awaitResponse(unsigned int rod, int timeout) {
  int retVal = 0;
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "AwaitResponse\n";
  }

  if(getCrate()) {
    try {
      retVal = getCrate()->awaitResponse(rod, timeout);
    } catch(CrateException &c) {
      cout << "Crate exception in await response\n" << c.what() << endl;
      retVal = -1;
    } catch(BaseException &b) {
      cout << "Base exception in await response\n" << b << endl;
      retVal = -1;
    } catch(...) {
      cout << "Exception in await response\n";
      retVal = -1;
    }

    if(retVal != 0) {
      if(config->isDummyCrate(prt(), crt())) {
        //We can't wait if there is nothing there so don't signal an error
        //We only check here to prevent doing potentially a lot of unnecessary IPC calls...
        retVal = 0;
      } else {
        cout << "Problem during await response\n";
        cout << "Crate status " << ucid() << endl;
        try {
          cout << getCrate()->status();
        } catch(VmeException &v) {
          cout << "Exception getting crate status\n";
          ::SctApi::Utility::decodeVme(v);
        }
      }
    }
  } else {
    cout << "Request for non-existent crate " << m_id->ucid() << endl;
  }

  if(checkDebugOption(DEBUG_DIAG)){
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "\tAwaitResponse: " << retVal << endl;
  }

  return retVal;
}

int SctApi::awaitResponseAll(int timeout) {
  int retVal = 0;

  if(checkDebugOption(DEBUG_DIAG)){
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "AwaitResponse\n";
  }

  if(getCrate()) {
    try {
      retVal = getCrate()->awaitResponseAll(timeout);
    } catch(CrateException &c) {
      cout << "Crate exception in await response all\n" << c.what() << endl;
      retVal = -1;
    } catch(BaseException &b) {
      cout << "Base exception in await response all\n" << b << endl;
      retVal = -1;
    } catch(...) {
      cout << "Exception in await response all\n";
      retVal = -1;
    }

    if(retVal != 0) {
      cout << "Problem during await response all\n";
    }
  } else {
    cout << "Request for non-existent crate " << m_id->ucid() << endl;
  }

  return retVal;
}

unsigned long *SctApi::getResponse(unsigned int rod, 
                                   unsigned long &length) {
  unsigned long *result;

  if(checkDebugOption(DEBUG_DIAG_RESPONSE)){
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "GetResponse\n";
  }
  if(getCrate()) {
    boost::shared_ptr<RodOutList> output = getCrate()->getResponse(rod);

    if(!output) {
      cout << "No response from crate\n";
      return NULL;
    }

    length = (unsigned long) output->getLength();

    currentStats.primitiveOutLengthCounter += length;

    updateISStats();

    if(checkDebugOption(DEBUG_DIAG_RESPONSE))
      cout << "Got response from crate length = " << length << endl;

    unsigned long *body = output->getBody();

    result = new unsigned long[length];

    for(unsigned int i=0; i<length; i++) {
      result[i] = body[i];
    }

    if(body[0] != length) {
      cout << "Bad outlist/outlength mismatch in returned outlist (" << m_id->ucid() << " " << rod << "): " << body[0] << " != " << length << endl;
      return NULL;
    }

    if(checkDebugOption(DEBUG_SAVE_PRIM)) {
      static int primCount = 0;

      string dirName = Sct::SctNames::getTempDir() + "/PrimLists";

      // Ignore success (0) or failure
      int mkRet = mkdir(dirName.c_str(), S_IRUSR|S_IWUSR|S_IXUSR);
      if(mkRet != 0) {
    // It's OK if it already exists
    if(errno != EEXIST) {
      perror(("Failed to create PrimLists directory for OutList: " + dirName).c_str());
    }
      }

      char *saveDir = getcwd(NULL, 0);

      int chRet = chdir(dirName.c_str());
      if(chRet != 0) {
    perror("Failed to create PrimLists directory for OutList");
      }

      char fileName[100];
      sprintf(fileName, "OutLists_%05d.bin", primCount++);
      ofstream fout(fileName, ios::binary | ios::trunc);
      fout.write((char*)result, length*4);

      int chRet2 = chdir(saveDir);
      if(chRet2 != 0) {
    perror("Failed to change back to saved directory");
      }

      free(saveDir);
    }

    if(checkDebugOption(DEBUG_PRINT_OUT_PRIM)) {
    // Pick between log and cout
      if(checkDebugOption(DEBUG_LOG_PRINT_PRIM)) {
        ::SctApi::printOutList(result, length, false, 0, log(), 
                               checkDebugOption(DEBUG_PRINT_UNKNOWN), checkDebugOption(DEBUG_PRINT_RAW));
      } else {
        ::SctApi::printOutList(result, length, false, 0, cout, 
                               checkDebugOption(DEBUG_PRINT_UNKNOWN), checkDebugOption(DEBUG_PRINT_RAW));
      }
    }
  } else {
    cout << "Request for non-existent crate " << m_id->ucid() << endl;
    return NULL;
  }

  return result;
}

/* Get a message from a ROD text buffer
   Returns whether the action was completed
*/
bool SctApi::getRodMessage(unsigned int rod,
                           char *buffer, unsigned long &length) {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "Get message\n";
  }
  if(getCrate()) {
    return getCrate()->getRodMessage(rod, buffer, length);
  } else {
    buffer[0] = 0;
    length = 0;
    return false;
  }
}

// Get ID number of module
UINT32 SctApi::findModule(string sn) { 
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "findModule " << sn << endl;
  }

  unsigned int partition, crate, rod, channel;

  try {
    unsigned int mur, module;
    config->translateFromSN(sn, mur, module);
    config->translateToROD(mur, module, partition, crate, rod, channel);
  } catch(ConfigurationException &c) {
    cout << "Module not found\n";
    return BAD_MODULE;
  }

  return packpcrc(partition, crate, rod, channel);
}

string SctApi::convertToString(UINT32 mid) {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "convertToString " << mid << endl;
  }

  unsigned int partition, crate, rod, channel;
  getpcrc(mid, partition, crate, rod, channel);

  if(channel >= 48) {
    return "Off-ROD       ";
  }

  string sn;

  try {
    unsigned int mur, module;
    config->translateFromROD(partition, crate, rod, channel, mur, module);
    config->translateToSN(mur, module, sn);
  } catch(ConfigurationException &c) {
    cout << "Module not found\n";
    return "BAD_MODULE    ";
  }

  return sn;
}

UINT32 SctApi::findModule(INT32 mur, INT32 module) {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "findModule " << mur << " " << module << endl;
  }

  unsigned int partition, crate, rod, channel;

  try {
    config->translateToROD(mur, module,
                           partition, crate, rod, channel);
  } catch(ConfigurationException &c) {
    cout << "Module not found\n";
    return BAD_MODULE;
  }

  return packpcrc(partition, crate, rod, channel);
}

pair<INT32, INT32> SctApi::convertToMUR(UINT32 mid) {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "convertToMUR " << mid << endl;
  }

  unsigned int partition, crate, rod, channel;
  getpcrc(mid, partition, crate, rod, channel);

  UINT32 mur;
  UINT32 module;

  try {
    config->translateFromROD(partition, crate, rod, channel, mur, module);
  } catch(ConfigurationException &c) {
    cout << "Module not found\n";
    return make_pair(BAD_MODULE, 0);
  }

  return make_pair(mur, module);
}

UINT32 SctApi::findBarrelModule(INT32 barrel, INT32 row, INT32 number) {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "findBarrelModule " << barrel << " " << row << " " << number << endl;
  }

  unsigned int partition, crate, rod, channel;

  try {
    unsigned int mur, module;
    config->translateFromBarrel(barrel, row, number, mur, module);
    config->translateToROD(mur, module,
                           partition, crate, rod, channel);
  } catch(ConfigurationException &c) {
    cout << "Module not found\n";
    return BAD_MODULE;
  }

  return packpcrc(partition, crate, rod, channel); 
}

void SctApi::convertToBarrelModule(UINT32 mid, UINT32 &barrel, UINT32 &row, int &number) { 
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "convertToBarrelModule " << mid << endl;
  }

  unsigned int partition, crate, rod, channel;
  getpcrc(mid, partition, crate, rod, channel);

  try {
    unsigned int mur, module;
    config->translateFromROD(partition, crate, rod, channel, mur, module);
    config->translateToBarrel(mur, module, barrel, row, number);
  } catch(ConfigurationException &c) {
    cout << "Module not found\n";

    barrel = BAD_MODULE;
    return;
  }
}

UINT32 SctApi::findEndcapModule(INT32 disk, INT32 ring, INT32 number) {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "findEndcapModule " << disk << " " << ring << " " << number << endl;
  }
  unsigned int partition, crate, rod, channel;

  try {
    unsigned int mur, module;
    config->translateFromEndcap(disk, ring, number, mur, module);
    config->translateToROD(mur, module,
                           partition, crate, rod, channel);
  } catch(ConfigurationException &c) {
    cout << "Module not found\n";
    return BAD_MODULE;
  }

  return packpcrc(partition, crate, rod, channel);
}

void SctApi::convertToEndcapModule(UINT32 mid, INT32 &disk, UINT32 &ring, UINT32 &number) {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "convertToEndcapModule " << mid << endl;
  }

  unsigned int partition, crate, rod, channel;
  getpcrc(mid, partition, crate, rod, channel);

  try {
    unsigned int mur, module;
    config->translateFromROD(partition, crate, rod, channel, mur, module);
    config->translateToEndcap(mur, module, disk, ring, number);
  } catch(ConfigurationException &c) {
    cout << "Module not found\n";
    disk = BAD_MODULE;
    return;
  }
}

#warning "These should be due to notifications from the configuration???"

void SctApi::loadConfiguration() {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "loadConfiguration (default)\n";
  }

  cout << "Load configuration\n";
#warning "Using feature of ConfigurationXmlImpl"
  loadConfiguration("");
}

void SctApi::loadConfiguration(string filename) {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "loadConfiguration (" << filename << ")\n";
  }

  m_is_initialised=false;
  
  try {
    cout << "Load configuration\n";
    config->loadConfiguration(filename); 
  } catch(ConfigurationException &c) {
    cout << "Problem loading new configuration, check configuration service\n";
  }

  cout << "Remove module configuration cache\n";

  {
    boost::mutex::scoped_lock lock(moduleMapAccess);
    moduleMap.clear();
  }

  loadModuleConfigurations();
}

unsigned SctApi::preloadModuleConfigurations(){
  unsigned modulecount=0;
  unsigned partition = ucid().partition();
  unsigned crate = ucid().crate();
  list<unsigned int> rods;
  try {
    rods = config->listRodsInCrate(partition, crate);
  } catch(ConfigurationException &c) {
    cout << "No RODs in this crate\n";
    cout << c.what() << endl;
    return 0;
  }
  
  for(list<unsigned int>::const_iterator r=rods.begin(); 
      r!=rods.end(); 
      r++) {
    RodLabel rl(partition, crate, *r);
    {
      boost::recursive_mutex::scoped_lock lock(rodInfoListAccess);
      if (rodInfoList.find(rl)==rodInfoList.end()){
    RodInfo newInfo;
    rodInfoList.insert(make_pair(rl, newInfo));
      }
    }

    list<unsigned int> MURs;
    try {
      MURs = config->listMURSInRod(partition, crate, *r);
    } catch(ConfigurationException &c) {
      cout << "No MURs for this ROD\n";
      cout << c.what() << endl;
      continue;
    }
    
    for(list<unsigned int>::const_iterator mur=MURs.begin(); 
        mur!=MURs.end(); 
        mur++) {

      list<string> modules;
      try {
        modules = config->listModulesInMUR(partition, *mur);
      } catch(ConfigurationException &c) {
        cout << "No modules for this MUR\n";
        cout << c.what() << endl;
        continue;
      }

      for(list<string>::const_iterator m=modules.begin(); 
          m!=modules.end(); 
          m++) {
          if (m_preloadModuleConfigurationsStop) return modulecount;
          if (!initialiseModule(*m, false))++modulecount;
      }
    } 
  }
  return modulecount;
}

int SctApi::loadModuleConfigurations() {
  int moduleConfigurations = 0;

  // For each ROD
  for(list<RodLabel>::const_iterator rl = rodList.begin();
      rl!=rodList.end();
      rl++){
    list<unsigned int> MURs;
    try {
      MURs = config->listMURSInRod(rl->partition, rl->crate, rl->rod);
    } catch(ConfigurationException &c) {
      cout << "No MURs for this ROD\n";
      cout << c.what() << endl;
      continue;
    }

    for(list<unsigned int>::const_iterator mur=MURs.begin(); 
        mur!=MURs.end(); 
        mur++) {

      list<string> modules;
      try {
        modules = config->listModulesInMUR(rl->partition, *mur);
      } catch(ConfigurationException &c) {
        cout << "No modules for this MUR\n";
        cout << c.what() << endl;
        continue;
      }

      for(list<string>::const_iterator m=modules.begin(); 
          m!=modules.end(); 
          m++) {
        if(!initialiseModule(*m)) {
          moduleConfigurations ++;
        }
      }
    }
  }

  cout << "Setup for calibration...\n";
  calib_init();

  return moduleConfigurations;
}

void SctApi::storeModuleConfigurations(BankType bank) {
  for(std::map<UINT32, ABCDModule>::const_iterator i = moduleMap.begin(); 
      i != moduleMap.end(); 
      i++) {
    UINT32 mid=i->first;
    std::string sn = "unknown";
    try{
      sn = convertToString(mid);
      boost::shared_ptr<const SctApiConfigCache::ModuleBanks> banks = module_cache.getFromMid(mid);
      if (!banks.get()) throw SctApiException("Cant save - no banks for this module");
      boost::shared_ptr<const ABCDModule> module = banks->get(bank);
      if (!module.get()) throw SctApiException("Cant save - this bank dosent exist for this module");
      config->configureModuleFromStructure(sn, *module);
    }catch(std::exception& e){
      if (mrs){
    *mrs << "CONFIG_SAVE_ERROR" << MRS_TEXT(e.what()) << MRS_QUALIF("SCTAPI")
         << MRS_PARAM<int>("mid", mid) << MRS_PARAM<int>("bank", bank) 
         << MRS_PARAM<const char*>("sn",sn.c_str()) << ENDM;
      }
    }
  }
}

void SctApi::storeBOCConfigurations()
{
  log() << "Storing BOC configurations" << endl;
  try{
    // This could use SctApi's own rodList instead?
    Crate* the_crate = getCrate();
    const list<unsigned> rods = the_crate->getListOfRods();
    
    for (list<unsigned>::const_iterator ri=rods.begin(); ri!=rods.end(); ++ri){
      const unsigned rod=*ri;
      BOCGlobalConfig global = the_crate->currentBOCRegisters(rod);
      config->configureBOC(prt(), crt(), rod, global);      
      
      vector<BOCChannelConfig> channels = currentBOCSetup(rod); 
      for(int ich=0; ich<48; ich++){
    try {
      unsigned MUR=0, position=0;
      config->translateFromROD(prt(), crt(), rod, ich, MUR, position);
      config->configureBOCChannel(MUR, position, channels[ich]);
    } catch(ConfigurationException &c) {
      // No module mapped to BOC channel
    }
      }
    }
  }catch(std::exception& e){
    log() << e.what() << endl;
    if(mrs) {
      *mrs << "STORE_BOC_ERROR" << MRS_WARNING << MRS_QUALIF("SCTAPI") 
       << MRS_TEXT(e.what()) << ENDM;
    }
  }
}

void SctApi::configureBOC(unsigned int rod) {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "ConfigureBOC called\n";
    log() << "\t TIME " << second_clock::universal_time() << endl;
  }

  try {
    if(getCrate())
      getCrate()->configureBOC(rod);
  } catch(CrateException &c) {
    throw SctApiException(c);
  }
}

std::vector<double> SctApi::getBOCMonitorArray(unsigned int rod) {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "getBOCMonitorArray called\n";
  }

  if(getCrate()) 
    return getCrate()->getBOCMonitorArray(rod);
  else
    throw SctApiException("Failed to getBOCMonitorArray");
}

std::string SctApi::status() {
  std::ostringstream oss;
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "print all status\n";
  }

  oss << "SCTAPI status:\n";
  oss << "Run " << runNumber << " Scan " << scanNumber << endl;

#if USE_THREADS
  oss << "Primitive thread engine enabled\n";
#else
  oss << "Primitive thread engine disabed (dangerous in IPC)\n";
#endif
#if USE_SCAN_THREAD
  oss << "Scan polling thread enabled\n";
  oss << "Initialisation complete? " << (m_is_initialised ? "Y" : "N" ) << " \n";
#else
  oss << "Scan polling thread disabled (doScan can timeout with IPC)\n";
#endif
  if(mrs) {
    *mrs << "SCTAPI_STATUS" << MRS_INFORMATION << MRS_QUALIF("SCTAPI") 
         << MRS_PARAM<int>("run", runNumber) << MRS_PARAM<int>("scan", scanNumber) 
         << MRS_TEXT("Run numbers") << ENDM;
  }

  if(!getCrate()) {
    if(mrs) {
      *mrs << "SCTAPI_STATUS" << MRS_INFORMATION << MRS_QUALIF("SCTAPI") 
           << MRS_TEXT("No crates loaded") << ENDM;
    }
  }
  
  //  for(map<pair<unsigned int, unsigned int>, Crate* >::const_iterator crate = crateMap.begin();
  //   crate != crateMap.end();
  //   crate++)
  {
    oss << "Crate: " << ucid() << " to std::out...\n";
    oss << getCrate()->status();
  }

  oss << "Module configuration for " << moduleMap.size() << " modules:\n";
  for(map<UINT32, ABCDModule>::const_iterator mi = moduleMap.begin();
      mi!=moduleMap.end();
      mi ++) {
    UINT32 mid = mi->first;

    string sn = convertToString(mid);
    ABCDModule *moduleConf = lookupConfig(mid);
    int group = moduleConf->groupId;
    int select = moduleConf->select;
    int prim = moduleConf->pTTC;
    int redun = moduleConf->rTTC;
    int link0 = moduleConf->rx[0];
    int link1 = moduleConf->rx[1];

    // Reverse translate formatter encoding
    if(link0 != DATA_LINK_OFF) 
      link0 = (link0/16) * 12 + link0%16;
    if(link1 != DATA_LINK_OFF) 
      link1 = (link1/16) * 12 + link1%16;

    oss.width(8);
    oss << mid << " " << sn << " Group: " << group << " Select: " << select;
    oss << "\t Pr: ";
    oss.width(2);
    oss << prim << " Red: ";
    oss.width(3);
    oss << redun << " Link 0/1: ";
    oss.width(3);
    oss << link0 << " ";
    oss.width(3);
    oss << link1 << endl;

    if(mrs) {
      *mrs << "MODULE_INFO" << MRS_INFORMATION << MRS_QUALIF("SCTAPI") 
           << MRS_PARAM<const char *>("sn",sn.c_str()) << MRS_PARAM<int>("internalId",mid) 
           << MRS_PARAM<int>("group",group) << MRS_PARAM<int>("select",select)  
           << MRS_PARAM<int>("primary",prim) << MRS_PARAM<int>("redundancy",redun) 
           << MRS_PARAM<int>("link0rx",link0) << MRS_PARAM<int>("link1rx",link1) 
           << MRS_TEXT("Module status ")
           << ENDM;
    }
  }

  if(mrs) {
    *mrs << "SCTAPI_STATUS" << MRS_INFORMATION << MRS_QUALIF("SCTAPI") 
         << MRS_PARAM<int>("run", runNumber) << MRS_PARAM<int>("scan", scanNumber) 
         << MRS_TEXT("Run numbers") << ENDM;
  }
  
  std::list<std::string> enabledDebug = listEnabledDebugOptions();
  if (enabledDebug.empty()){
    oss << "No debug options currently enabled\n";
  }else{
    oss << "Debug options currently enabled:" << endl;
    for (std::list<std::string>::const_iterator i=enabledDebug.begin(); i!=enabledDebug.end(); ++i){
      oss << "\t"<< *i << "\n"; 
    }
  }
  return oss.str();
}

// ****  Histogramming  ****
void SctApi::defaultScan(int type) {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "Send default scan number " << type << endl;
  }
  ScanDefImpl scan;

  long *evSetup;
  long *histSetup;
  long *histStart;

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

  int histStartLength;

  switch(type) {
  default:
  case 0:
    {
      // Event Trap Setup
      long setup[24] = {0x1,   0, 0x2000, 0, 
                        0x3, 0x1,      0, 0,
                          0,   0,      0, 0,
                        0x3,   0,      0, 1,               // Config, exclusion
                        0x1,   0,      0, 1,               // function, match
                          1,   0,      0, 0};              // modulus, remainder

      evSetup = new long[24];
      for(int i=0; i<24; i++) evSetup[i] = setup[i];

      // Setup histogram
      long setupH[] = {
        0x20d2000, 0, 0x60, 0x01010000, 0x20200101, 1, 0, 1, 
        0,         0,    0, 0x03f00000, 0x30f01000};

      histSetup = new long[13];
      for(int i=0; i<13; i++) histSetup[i] = setupH[i];

      // Start histogram
      long startHist[4 + 63] = {
        16, 107, 1, 1,

        // Task params
        // 
        0x01010001, 0x000f0001, 0x08040201,        0xf, 0x020d2000, 0x00200101, 0x0100000f,       1000, 
                50,        0x0, 0x40a00000, 0x40a00000, 0x41200000, 0x40a00000, 0x42c80000, 0x40200000, 
        0x43160000, 0x40a00000, 0x43480000, 0x40a00000, 0x40a00000, 0x40a00000, 0x41200000, 0x40a00000,

        0x42c80000, 0x40200000, 0x43160000, 0x40a00000, 0x43480000, 0x40a00000,        0x0,        0x0,
        0x0070006a, 0x00640065, 0x00640064, 0x00000000, 0x81,              0x0,        0x0,        0x0,
        0x0,      // End of trigger sequence (1)
        0x00640064, 0x00640064, 0x00640064, 0, 0, 0, 0, 
        0, 0,      // End of trigger sequence (2)
        0,         // incCmd (2 bytes) etc 
        0, 0,      // incData
        0, 0, 0,
        0, 0, 0, 0, 0,      // End of control data (rest is up to max task structure size)
      };

      histStart = new long[4+63];
      for(int i=0; i<4+63; i++) histStart[i] = startHist[i];

      histStartLength = 67;
    }
    break;
  case 1:
    // A short nmask scan on module 0
    {
      // Event Trap Setup
      long setup[24] = {
        0x00000001, 0x00000000, 0x00002000, 0x00000000, 0x00000003, 0x00000000, 0x00000001, 0x00000000,
        0x00000000, 0x00000000, 0x00000001, 0x00000002, 0x00000003, 0x00000000, 0x00000000, 0x00000001, 
        0x00000001, 0x00000000, 0x00000000, 0x00000000, 0x00000001, 0x00000000, 0x00000000, 0x00000000};

      evSetup = new long[24];
      for(int i=0; i<24; i++) evSetup[i] = setup[i];

      // Setup histogram
      long setupH[] = {
        0x020d2000, 0x00000000, 0x00000008, 0x18090000, 0x00200101, 0x00000001, 0x00000000, 0x00000001, 
        0x00000000, 0x00000000, 0x00000000, 0x03f00000, 0x03f01000};

      histSetup = new long[13];
      for(int i=0; i<13; i++) histSetup[i] = setupH[i];

      // Start histogram
      long startHist[79] = {
        0x18090001, 0x000f0001, 
        0x000000ff, 0x0000f00f, 0x020d2000, 0x00200101, 0x0000000f, 0x0000040a, 0x00000008, 0x00000000, 
        0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 
        0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 
        0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff, 0xffffffff, 0x0070006a, 0x00640065, 
        0x00640064, 0x00000000, 0x00000082, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00640064, 
        0x00640064, 0x00640064, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 
        0x00000000, 0x00000000, 0x00000000, 0x0000000f, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 
        0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x41800000, 0x42000000, 
        0x42400000, 0x42800000, 0x42a00000, 0x42c00000, 0x42e00000, 0x00000000, 0x41800000, 0x42000000, 
        0x42400000, 0x42800000, 0x42a00000, 0x42c00000, 0x42e00000 
      };

      histStart = new long[79];
      for(int i=0; i<79; i++) histStart[i] = startHist[i];

      histStartLength = 79;


      /* 000000ff 00000001 00000006 0000006f 0000001c 00000000 00000003 00000067 

         00000001 00000000 00002000 00000000 00000003 00000000 00000001 00000000 
         00000000 00000000 00000001 00000002 00000003 00000000 00000000 00000001 
         00000001 00000000 00000000 00000000 00000001 00000000 00000000 00000000 

         00000012 00000001 00002007 00000067 00000000 0000000a ffffffff ffffffff 
         0000000a 00000001 00000001 0000006f 00000004 00000000 00001000 00000065 
         0000000a 0000100e 00000007 00000002 00002008 00000067 00000000 00000001 
         00000001 00000066 00000001 00002007 00000067 00000000 0000005e ffffffff 
         ffffffff 0000005e 00000004 00000002 0000006f 00000011 00000002 00001002 
         00000068 020d2000 00000000 00000008 18090000 00200101 00000001 00000000 
         00000001 00000000 00000000 00000000 03f00000 03f01000 

         00000047 00000003 
         0000000c 00000065 00000020 00000064 00000001 00000001 00000000 00000000 
         00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 
         00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 
         00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 
         00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 
         00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 
         00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 
         00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 
         00000000 00000000 00000000 00000000 00000000 0000005e 1a242170 00000007 
         00000002 00002008 00000067 00000000 00000001 00000001 00000057 00000000 
         0000000c 00000065 00000010 0000006b 00000001 00000001 18090001 000f0001 
         000000ff 0000f00f 020d2000 00200101 0000000f 0000040a 00000008 00000000 
         00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 
         00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 
         00000000 00000000 00000000 00000000 ffffffff ffffffff 0070006a 00640065 
         00640064 00000000 00000082 00000000 00000000 00000000 00000000 00640064 
         00640064 00640064 00000000 00000000 00000000 00000000 00000000 00000000 
         00000000 00000000 00000000 0000000f 00000000 00000000 00000000 00000000 
         00000000 00000000 00000000 00000000 00000000 00000000 41800000 42000000 
         42400000 42800000 42a00000 42c00000 42e00000 00000000 41800000 42000000 
         42400000 42800000 42a00000 42c00000 42e00000 000000ff 1a3ff509 
      */
      break;
    }
  }

  if(!getCrate() || !getCrate()->RODPresent(0)) {
    cout << "No configured ROD ! Aborting default scan\n";
    if(mrs) {
      *mrs << "ROD_NONEXIST" << MRS_ERROR << MRS_QUALIF("SCTAPI") 
           << MRS_PARAM<int>("crate", 0) 
           << MRS_PARAM<int>("rod", 0)
           << MRS_TEXT("Aborting default scan (ROD not configured)") << ENDM;
    }

    return;
  }

  if(!getCrate()->checkBOCLasersOn(0)) {
    cout << "Trying to send default scan using BOC that has its lasers cut out (continuing)\n";
    if(mrs) {
      *mrs << "BOC_INTERLOCKED" << MRS_WARNING << MRS_QUALIF("SCTAPI") 
           << MRS_PARAM<int>("crate", 0) 
           << MRS_PARAM<int>("rod", 0)
           << MRS_TEXT("Default scan continuing even though BOC interlocked") << ENDM;
    }
  }

  primList->addPrimitive(RodPrimitive(4+24, 1, 3, 103, evSetup),
                         evSetup);

  // Start event trap
  long trap[0] = {};
  shared_ptr<PrimListWrapper> sPrimList(new PrimListWrapper(2));
  sPrimList->addPrimitive(RodPrimitive(4, 0, 4096, 101, trap),
                          trap);

  PrimBuilder &builder = PrimBuilder::instance();

  builder.slavePrimList(primList, sPrimList, 0, true, true);

  // Can clear slave list because its fully built!
  sPrimList->clear();
  sPrimList->addPrimitive(RodPrimitive(4 + 13 /* + 2*3 */ , 3, 4098, 104, histSetup),
                          histSetup);
  builder.slavePrimList(primList, sPrimList, 0, true, true);
  
  long task[] = {32, 100, 1, 1, 0, 0};
  sPrimList->clear();
  sPrimList->addPrimitive(RodPrimitive(4 + 6, 4, 12, 101, task),
                          task);
  builder.slavePrimList(primList, sPrimList, 0, true, true);

  primList->addPrimitive(RodPrimitive(histStartLength + 4, 3, 12, 101, histStart),
                         histStart);

  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "Send default scan list\n";
  }
  sendPrimList(0, primList);
  awaitResponse(0, 2);


  // Get result
  unsigned long length;

  unsigned long *result = getResponse(0, length);

  if(result) {
    cout << "Got response from default scan setup\n";
    // Pick between log and cout
    if(checkDebugOption(DEBUG_LOG_PRINT_PRIM)) {
      ::SctApi::printOutList(result, length, true, 0, log(), 
                   checkDebugOption(DEBUG_PRINT_UNKNOWN), checkDebugOption(DEBUG_PRINT_RAW));
    } else {
      ::SctApi::printOutList(result, length, true, 0, cout, 
                   checkDebugOption(DEBUG_PRINT_UNKNOWN), checkDebugOption(DEBUG_PRINT_RAW));
    }

    delete [] result;
  } else {
    cout << "No response from default scan setup\n";
  }

  // Poll histogram
//    pollHistogramming(extra, scan.getScanPoints1().size(), scan.getNTrigs(), 5);

//    // Read histogram
//  #ifdef USE_IS
//    readHistogramsToIS(scan, extra);
//  #endif
//    readHistogramsToFile(scan, extra);
}

void SctApi::tidyHistogramming() {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "Brutal histogram stopping\n";
  }

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

  PrimBuilder &builder = PrimBuilder::instance();

  builder.taskOp(primList, HISTOGRAM_CTRL_TASK, TASK_STOP, 0);

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

    unsigned int rod = rl->rod;

    {
      boost::mutex::scoped_lock lock(log().mutex());
      log() << "Tidy histogram on (" << ucid() << ", " << rod << ")\n";
      log() << "Stop HCT\n";
    }
    sendPrimList(rod, primList);

    awaitResponse(rod, 2);
    primList->clear();

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

    for(int slaveNumber=0; slaveNumber<4; slaveNumber++) {
      shared_ptr<PrimListWrapper> slList(new PrimListWrapper(1));

      // Stop Slave histogramming task

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

      builder.slavePrimList(primList, slList, slaveNumber, true, true);
      {
        boost::mutex::scoped_lock lock(log().mutex());
        log() << "Stop histo task (" << slaveNumber << ")\n";
      }
      sendPrimList(rod, primList);
      awaitResponse(rod, 2);
      slList->clear();
      primList->clear();

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

      builder.stopEvTrap(slList);

      builder.slavePrimList(primList, slList, slaveNumber, true, true);
      {
        boost::mutex::scoped_lock lock(log().mutex());
        log() << "Stop ETS (" << slaveNumber << ")\n";
      }
      sendPrimList(rod, primList);

      awaitResponse(rod, 2);
      primList->clear();

      cout << "Done kill event trapping\n";
    }
//     sendPrimList(rod, primList);
//    awaitResponse(rod, 2);
  }
}

void SctApi::abortScan() {
  if(scanController) 
    scanController->abort();
}

void SctApi::rodMode(unsigned int rod,
                     int mode, int flag, int fifoSetup, int nBits, int delay, int message) {
  shared_ptr<PrimListWrapper> rodModeList(new PrimListWrapper(2));

  PrimBuilder::instance().rodMode(rodModeList, mode, flag, fifoSetup, nBits, delay, message);

  sendPrimList(rod, rodModeList);

  int responseCode = awaitResponse(rod, 1);

  if(responseCode != 0) {
    cout << "Set ROD mode failed!\n";
  }
}

void SctApi::setupModuleMask(unsigned int rod,
                             int port, int slvs) {
  shared_ptr<PrimListWrapper> maskList(new PrimListWrapper(1));

  setupModuleMask(port, slvs, maskList);

  sendPrimList(0, maskList);
  int responseCode = awaitResponse(0, 10);

  if(responseCode != 0) {
    cout << "Module mask setup unsuccessful\n";
  }
}

void SctApi::setupModuleMask(int port, int slvs, boost::shared_ptr<PrimListWrapper> primList) { 
  PrimBuilder::instance().masksFromConfig(primList, port);
  PrimBuilder::instance().masksToSlaves(primList, slvs);
}

void SctApi::calib_init() {
  // Put ROD in useful mode for running calibrations 
#if (R_MODULE_MASK < 101)
  #error "Unsupported old MODULE_MASK version"
#else 
  shared_ptr<PrimListWrapper> calibList(new PrimListWrapper(1));

#if USE_DUAL_PORTS
  // Set up module masks for both ports
  setupModuleMask(SP_BOTH, 0xf, calibList);
#else
  setupModuleMask(SP0, 0xf, calibList);
#endif

  PrimBuilder &builder = PrimBuilder::instance();
  builder.writeRegister(calibList, RRIF_CMND_0, 0, 8, 0xff);    // Reset everything
  builder.writeRegister(calibList, RRIF_CMND_0, 0, 8, 0x78);

  if(synchSendPrimListAll(calibList) != 0) {
    cout << "Calib list moduleMask failed!\n";
  }

  shared_ptr<PrimListWrapper> rodModeList(new PrimListWrapper(1));
  PrimBuilder::instance().rodMode(rodModeList, CALIBRATION_MODE + CALIBRATION_SLINK_OVERRIDE_MODE, 
                                  0, 1, 1, 1, 1);

  if(synchSendPrimListAll(rodModeList) != 0) {
    cout << "Calib list Rod mode on failed!\n";
  }


  // Allow user to turn off slink in calibration mode
  shared_ptr<PrimListWrapper> postRodModeList(new PrimListWrapper(1));
  if(checkDebugOption(DEBUG_CALIB_NO_SLINK)) {
    builder.writeRegister(postRodModeList, RTR_CMND_STAT, RTR_INHIBIT_SLNK_WE_O, 1, 1);
  } else {
    builder.writeRegister(postRodModeList, RTR_CMND_STAT, RTR_INHIBIT_SLNK_WE_O, 1, 0);
  }
//   if(checkDebugOption(DEBUG_CALIB_RTR_STOP_OUTPUT)) {
//     builder.writeRegister(postRodModeList, RTR_CMND_STAT, RTR_STOP_OUTPUT_O, 1, 1);
//   } else {
//     builder.writeRegister(postRodModeList, RTR_CMND_STAT, RTR_STOP_OUTPUT_O, 1, 0);
//   }
  if(synchSendPrimListAll(postRodModeList) != 0) {
    cout << "Calib init post rod mode failed!\n";
  }
#endif  
}

void SctApi::print_calib(unsigned int rod) {
#ifndef FMT_LINK_EN
  cout << "Register ids not known\n";
#else
  cout << "Formatters\n";

  cout << hex;

  cout << " Enables\n";

  for(int a=0; a<8; a++) {
    int data = readRODRegister(rod, FMT_LINK_EN(a)) & 0xffff;
    cout.width(4);
    cout << data << " ";
  }
  cout << endl;

  cout << " Expanded\n";
  for(int a=0; a<8; a++) {
    int data = readRODRegister(rod, FMT_EXP_MODE_EN(a)) & 0xffff;
    cout.width(4);
    cout << hex;
    cout << data << " ";
  }
  cout << endl;

//   cout << " Config mode\n";
//   for(int a=0; a<8; a++) {
//     int data = readRegister(a+0x10) & 0xffff;
//     cout.width(4);
//     cout << hex;
//     cout << data << " ";
//   }
//   cout << endl;

//   cout << " Edge mode\n";
//   for(int a=0; a<8; a++) {
//     int data = readRegister(a+0x18) & 0xffff;
//     cout.width(4);
//     cout << hex;
//     cout << data << " ";
//   }
//   cout << endl;

//   cout << " Time out\n";
//   for(int a=0; a<8; a++) {
//     int data = readRegister(a+0x20, false) & 0xff;
//     cout.width(4);
//     cout << hex;
//     cout << data << " ";
//   }
//   cout << endl;

//   cout << " Overflow limit\n";
//   for(int a=0; a<8; a++) {
//     int data = readRegister(a+0x28, false) & 0x7ff;
//     cout.width(4);
//     cout << hex;
//     cout << data << " ";
//   }
//   cout << endl;

//   cout << " H/T limit\n";
//   for(int a=0; a<8; a++) {
//     int data = readRegister(a+0x30, false) & 0x3ff;
//     cout.width(4);
//     cout << hex;
//     cout << data << " ";
//   }
//   cout << endl;

//   cout << " ROD busy limit\n";
//   for(int a=0; a<8; a++) {
//     int data = readRegister(a+0x38, false) & 0x3ff;
//     cout.width(4);
//     cout << hex;
//     cout << data << " ";
//   }
//   cout << endl;

//   cout << " Diagnostic link to LEMO\n";
//   for(int a=0; a<8; a++) {
//     int data = readRegister(a+0x70, false) & 0xf;
//     cout.width(4);
//     cout << hex;
//     cout << data << " ";
//   }
//   cout << endl;

//   cout << " Diagnostic mode bits read enable\n";
//   for(int a=0; a<8; a++) {
//     int data = readRegister(a+0x78, false) & 0x1;
//     cout.width(4);
//     cout << hex;
//     cout << data << " ";
//   }
//   cout << endl;

  cout << "Link oocupancies\n";
  for(int fmt=0; fmt<8; fmt++) {
    for(int link=0; link<12; link++) {
      int val = readRODRegister(rod, FMT_LINK_OCC_CNT(fmt, link)) & 0x7ff;
      cout << " ";
      Utility::printHex(val, 3);
    }
    cout << endl;
  }

  cout << " Timeout error\n";
  for(int a=0; a<8; a++) {
    int data = readRODRegister(rod, FMT_TIMEOUT_ERR(a)) & 0xfff;
    cout.width(4);
    cout << hex;
    cout << data << " ";
  }
  cout << endl;

  cout << " Overflow error\n";
  for(int a=0; a<8; a++) {
    int data = readRODRegister(rod, FMT_DATA_OVERFLOW_ERR(a)) & 0xfff;
    cout.width(4);
    cout << hex;
    cout << data << " ";
  }
  cout << endl;

  cout << " H/T error\n";
  for(int a=0; a<8; a++) {
    int data = readRODRegister(rod, FMT_HEADER_TRAILER_ERR(a)) & 0xfff;
    cout.width(4);
    cout << hex;
    cout << data << " ";
  }
  cout << endl;

  cout << " ROD busy error\n";
  for(int a=0; a<8; a++) {
    int data = readRODRegister(rod, FMT_ROD_BUSY_ERR(a)) & 0xfff;
    cout.width(4);
    cout << hex;
    cout << data << " ";
  }
  cout << endl;

//   cout << " Parsing mode (1 = Raw, 0 = normal) \n";
//   for(int a=0; a<8; a++) {
//     int data = readRegister(a+0x100, false) & 0xfff;
//     cout.width(4);
//     cout << hex;
//     cout << data << " ";
//   }
//   cout << endl;

//   cout << " Formatter status\n";
//   for(int a=0; a<8; a++) {
//     int data = readRegister(a+0x108, false) & 0xffff;
//     tapi.printHex(data, 4);
//     cout << " ";
// //     cout.width(4);
// //     cout << hex;
// //     cout << data << " ";
//   }
//   cout << endl;

//   cout << " Formatter version\n";
//   for(int a=0; a<8; a++) {
//     int data = readRegister(a+0x110, false) & 0xffff;
//     cout.width(4);
//     cout << hex;
//     cout << data << " ";
//   }
//   cout << endl;

//   cout << "EFB version\n";
//   readRegister(0x1b2);

//   cout << "RTR version\n";
//   readRegister(0x205);

  cout << "RRIF version\n";
  cout << readRODRegister(rod, RRIF_CODE_VERSION) << endl;
  cout << "RRIF status 0\n";
  cout << readRODRegister(rod, RRIF_STATUS_0) << endl;
  cout << "RRIF status 1\n";
  cout << readRODRegister(rod, RRIF_STATUS_1) << endl;

  cout << "RRIF command 0\n";
  cout << readRODRegister(rod, RRIF_CMND_0) << endl;
  cout << "RRIF command 1\n";
  cout << readRODRegister(rod, RRIF_CMND_1) << endl;

  cout << "Output masks\n";
  cout << " ";
  Utility::printHex(readRODRegister(rod, FE_CMND_MASK_0_LO), 8);
  cout << endl;
  cout << " ";
  Utility::printHex(readRODRegister(rod, FE_CMND_MASK_0_HI), 8);
  cout << endl;
  cout << " ";
  Utility::printHex(readRODRegister(rod, FE_CMND_MASK_1_LO), 8);
  cout << endl;
  cout << " ";
  Utility::printHex(readRODRegister(rod, FE_CMND_MASK_1_HI), 8);
  cout << endl;

  cout << "L1ID for ports 0 and 1\n";
  Utility::printHex(readRODRegister(rod, CAL_L1_ID_0), 8);
  Utility::printHex(readRODRegister(rod, CAL_L1_ID_1), 8);
  cout << "BCID for ports 0 and 1\n";
  Utility::printHex(readRODRegister(rod, CAL_BCID), 8);

  cout << dec;
#endif
}

unsigned long SctApi::sendTimBurst(unsigned long count, int random, bool external) {
  return getCrate()->sendTimBurst(count, random, external);
}

unsigned long SctApi::sendTriggers(const Trigger* trig, unsigned long count, int scan_point){
  int random = trig->getRandom();
  double freq = trig->getFrequency();
  Trigger::Source source = trig->getSource();
  switch (source){
  case Trigger::SOURCE_TIM_INTERNAL:
  case Trigger::SOURCE_TIM_EXTERNAL:
    {
      bool use_sequencer = trig->timNeedsSequencer();
      bool external = (source==Trigger::SOURCE_TIM_EXTERNAL);

      // std::ios_base& std::internal(std::ios_base&)
      if (!external) {
    // set up frequencies
    timSetFrequency(trig->getFrequency(), timGetResetFrequency());
      }

      if (use_sequencer) {
    printf("Sending %d triggers using the sequencer, random=%d, external=%d\n",count,random,external);
    Trigger::TIMTriggers timTrigs = Trigger::convertToTIMTriggers(trig->getRODTriggers(scan_point));
    vector<unsigned> seq(timTrigs.size());
    for (unsigned i=0; i<timTrigs.size(); ++i){
      seq[i]=timTrigs[i];
    }
    timLoadSequence(seq);
    return timRunSequence(count, random, external);
      } else {
    printf("Sending %d triggers, random=%d, external=%d\n",count,random,external);
    return sendTimBurst(count, random, external);
      }
      break;
    }
  case Trigger::SOURCE_ROD:
    for(list<RodLabel>::const_iterator rl = rodList.begin();
    rl!=rodList.end();
    rl++){
#warning "No parallelisation here yet AJB 2005-11-25"
      sendRodTrigger(rl->rod, trig, count, scan_point);
    }
    break;
  default:
    if (mrs) {
      *mrs << "TRIG_SOURCE_UNKNOWN" << MRS_TEXT("Trigger source may not be implimented yet") 
       << MRS_PARAM<int>("source",source) 
       << MRS_ERROR << ENDM;
    }else{
      std::cout << "Dont yet know how to send triggers from source : " << source 
        << " " << __FILE__ << ":" << __LINE__ << std::endl;
    }
    throw SctApiException("BadTrigger");
    break;
  }
}

void SctApi::sendRodTrigger(unsigned int rod, const Trigger *trig, unsigned long count, int scan_point) {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "Send Trigger\n";
  }

  // Do we want to build and send on both streams?
  //  There's only one trigger, so not quite sure what this will do
  //  But we already send on both ports and that seems to work... ? (this method not used much)
  //  Should probably make the two consistent, so choose "BOTH"
#if USE_DUAL_PORTS
  int serialPorts = SP_BOTH;
#else
  int serialPorts = SP0;
#endif

  long *data = new long[sizeof(BUILD_STREAM_IN)/4];

  BUILD_STREAM_IN &buildPrim = *(BUILD_STREAM_IN*)data;

#if (R_BUILD_STREAM == 102)
  Trigger::RODTriggers points = trig->getRODTriggers(scan_point);

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

  buildPrim.port = serialPorts;
  buildPrim.reset = 1;
  buildPrim.chip = 63;
  buildPrim.fibre = 3;
  buildPrim.dataLen = 0;
  buildPrim.data = 0;    // Should be ignored?
 
  shared_ptr<PrimListWrapper> sendList(new PrimListWrapper(3));

  sendList->addPrimitive(RodPrimitive(4 + sizeof(BUILD_STREAM_IN)/4, 
                                      2, BUILD_STREAM, R_BUILD_STREAM, data),
                         data);
#elif R_BUILD_STREAM == 101
#error "Build stream not compiled (unsupported old version)" 
#else   // Unknown R_BUILD_STREAM
#error "Build stream not compiled (unknown primitive version, check primParams.h)" 
#endif

#if USE_DUAL_PORTS
  // Send both ports stream
  PrimBuilder::instance().sendStream(sendList, serialPorts, 0);
#else
  // Confusingly this was already like this, much simpler to use serialPorts and 
  //  make it the same as the buildStream above though!
  PrimBuilder::instance().sendStream(sendList, SP_BOTH, 0);
#endif

  for (unsigned i=0; i<count; ++i){
    sendPrimList(rod, sendList);
    
    int responseCode = awaitResponse(rod, 2);
    
    if(responseCode != 0) {
      cout << "Send trigger " << i << " failed on rod " << rod << "!\n";
      break;
    }
  }
}

void SctApi::sendL1A(unsigned int rod, bool capture) {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "Send L1A\n";
  }

  long *data = new long[sizeof(BUILD_STREAM_IN)/4];

  BUILD_STREAM_IN &buildPrim = *(BUILD_STREAM_IN*)data;

#if (R_BUILD_STREAM == 102)
  for(int i=0; i<6; i++) {
    buildPrim.cmdList.cmd[i] = 0x64;
    buildPrim.cmdList.data[i] = 0;
  }

  buildPrim.cmdList.cmd[0] = 0x65;

  buildPrim.port = SP0;
  buildPrim.reset = 1;
  buildPrim.chip = 63;
  buildPrim.fibre = 3;
  buildPrim.dataLen = 0;
  buildPrim.data = 0;    // Should be ignored?
 
  shared_ptr<PrimListWrapper> sendList(new PrimListWrapper(3));

  sendList->addPrimitive(RodPrimitive(4 + sizeof(BUILD_STREAM_IN)/4, 
                                      2, BUILD_STREAM, R_BUILD_STREAM, data),
                         data);
#elif R_BUILD_STREAM == 101
#error "Build stream not compiled (unsupported old version)" 
#else   // Unknown R_BUILD_STREAM
#error "Build stream not compiled (unknown primitive version, check primParams.h)" 
#endif

#ifdef CMD_BUFFER_BOTH
  PrimBuilder::instance().sendStream(sendList, CMD_BUFFER_BOTH, capture);
#else
  PrimBuilder::instance().sendStream(sendList, SP_BOTH, capture);
#endif

  sendPrimList(rod, sendList);

  awaitResponse(rod, 2);
}

void SctApi::bocHistogram(unsigned int rod, 
                          unsigned int samples, unsigned int numLoops) {
  std::cout << "BOC histogram unsupported\n";
  throw SctApiException("BOC histogram unsupported");
}

void SctApi::printABCDModule(int mid) {
  ABCDModule *mConf = lookupConfig(mid);

  if(mConf) {
    std::cout << config->printModuleConfig(*mConf);
  } else {
    cout << "Invalid module id " << mid << endl;
  }
}

void SctApi::printABCDRodModule(int mid, BankType bank) {
  getABCDModule(mid, bank);

  ABCDModule *mConf = lookupConfig(mid);
  if (mConf) std::cout << config->printModuleConfig(*mConf);
}

void SctApi::modifyTIMParam(unsigned int type, unsigned int val) {
  getCrate()->modifyTIMParam(type, val);
}

void SctApi::modifyBOCParam(unsigned int type, unsigned int val) {
  getCrate()->modifyBOCParam(type, val, true);
}

void SctApi::modifyBOCParam(unsigned int rod,
                            unsigned int channel, unsigned int type, unsigned int val) {
  getCrate()->modifyBOCParam(rod, channel, type, val, true);
}

void SctApi::printBOCSetup(unsigned int rod) {
  getCrate()->printBOCSetup(rod);
}

vector<BOCChannelConfig> SctApi::currentBOCSetup(unsigned int rod) {
  return getCrate()->currentBOCSetup(rod);
}

void SctApi::printBOCRegisters(unsigned int rod) {
  getCrate()->printBOCRegisters(rod);
}

BOCGlobalConfig SctApi::currentBOCRegisters(unsigned int rod) {
  return getCrate()->currentBOCRegisters(rod);
}

void SctApi::saveBOCSetup(unsigned int rod, BankType bank) {
  getCrate()->saveBOCSetup(rod, bank);
}

void SctApi::saveBOCRegisters(unsigned int rod, BankType bank) {
  getCrate()->saveBOCRegisters(rod, bank);
}

void SctApi::restoreBOCSetup(unsigned int rod, BankType bank) {
  getCrate()->restoreBOCSetup(rod, bank);
}

void SctApi::restoreBOCRegisters(unsigned int rod, BankType bank) {
  getCrate()->restoreBOCRegisters(rod, bank);
}

void SctApi::lasersOff() {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "Lasers off called\n";
    log() << "\t TIME " << second_clock::universal_time() << endl;
  }

  std::cout << " *** Trying to turn lasers off  ***\n";
  getCrate()->lasersOff();
}

void SctApi::timSetFrequency(double trigFreq, double rstFreq) {
  getCrate()->timSetFrequency(trigFreq, rstFreq);
}

double SctApi::timGetTriggerFrequency() {
  return getCrate()->timGetTriggerFrequency();
}

double SctApi::timGetResetFrequency() {
  return getCrate()->timGetResetFrequency();
}

void SctApi::freeTriggers() {
  shared_ptr<PrimListWrapper> timList(new PrimListWrapper(1));

#ifdef RRIF_CMND_1
  PrimBuilder &builder = PrimBuilder::instance();
  // Use TIM triggers
  builder.writeRegister(timList, RRIF_CMND_1, 1, 1, 1);
  // Enable TIM trigger event ID decoding
  builder.writeRegister(timList, RRIF_CMND_1, 8, 1, 1);
#else
#error "Unsupported no registers"
#endif

  sendPrimListAll(timList);

  awaitResponseAll(2);

  getCrate()->freeTriggers();
}

void SctApi::stopTriggers() {
  shared_ptr<PrimListWrapper> timList(new PrimListWrapper(1));

#ifdef RRIF_CMND_1
  PrimBuilder &builder = PrimBuilder::instance();
  // Use TIM triggers
  builder.writeRegister(timList, RRIF_CMND_1, 1, 1, 0);
  // Enable TIM trigger event ID decoding
  builder.writeRegister(timList, RRIF_CMND_1, 8, 1, 0);
#else
#error "Unsupported no registers"
#endif

  sendPrimListAll(timList);

  awaitResponseAll(2);

  getCrate()->stopTriggers();
}

void SctApi::timL1A() {
  getCrate()->timL1A();
}

void SctApi::timCalL1A(int delay) {
  getCrate()->timCalL1A(delay);
}

void SctApi::timSoftReset() {
  // FER doesn't reset TIM L1 count
  getCrate()->timECR();
}

void SctApi::timBCReset() {
  getCrate()->timBCR();
}

void SctApi::timLoadSequence(const vector<unsigned>& seq){
  getCrate()->timLoadSequence(seq);
}

unsigned long SctApi::timRunSequence(unsigned long trigs, int random, bool external){
  return getCrate()->timRunSequence(trigs, random, external);
}

void SctApi::timVerbose() {
  getCrate()->timVerbose();
}

void SctApi::timWriteRegister(int reg, UINT16 val) {
  getCrate()->timRegLoad(reg, val);
}

UINT16 SctApi::timReadRegister(int reg) {
  return getCrate()->timRegRead(reg);
}

void SctApi::decodeConfig(unsigned int rod, 
                          bool skipTrim, bool bypass) {
  unsigned long readlength;
#warning "Hard-coded address, this is the serial port output buffer"
  unsigned long *config = dspBlockRead(rod, 0x2102000, 270 * 12, -1, readlength);

  unsigned int pos = 0;
  while(pos < readlength) {
    if((config[pos] & 0x5760000) != 0x5700000) {
      cout << "Strange data: ";
      cout << hex << " " << pos << " " << config[pos] << dec << endl;
      break;
    } 

    unsigned int f3 = (config[pos] & 0xff000) >> 12;
    unsigned int f4 = (config[pos] & 0x00fc0) >> 6;
    unsigned int f5 = (config[pos] & 0x0003f) >> 0;

    pos ++;

    cout << "Chip address " << f4 << ": ";
    if(!bypass) {
      cout << hex << f3 << "/" << f5 << dec << ": ";
    }

    switch(f3) {
    case 0x1c:
      {
        unsigned short data = (0xffff0000 & config[pos]) >> 16;
        switch(f5) {
        case 0:
          // Configuration reg
          if(!bypass) {
            cout << "Config: " << hex << data << dec;
            cout << " comp " << (data & 3) 
                 << " cal "  << ((data & 0xc) >> 2)
                 << " trim "  << ((data & 0x30) >> 4)
                 << " edge "  << ((data & 0x40) >> 6)
                 << " mask "  << ((data & 0x80) >> 7)
                 << " acc "  << ((data & 0x100) >> 8)
                 << " in_b " << ((data & 0x200) >> 9)
                 << " out_b " << ((data & 0x400) >> 10)
                 << " mast " << ((data & 0x800) >> 11)
                 << " end " << ((data & 0x1000) >> 12)
                 << " feed " << ((data & 0x2000) >> 13)
                 << endl;
          } else {
            cout << " in_b " << ((data & 0x200) >> 9)
                 << " out_b " << ((data & 0x400) >> 10)
                 << " mast " << ((data & 0x800) >> 11)
                 << " end " << ((data & 0x1000) >> 12)
                 << " feed " << ((data & 0x2000) >> 13)
                 << endl;
          }
          break;
        case 0x10:
          if(!bypass) {
            cout << "Strobe delay: " << hex 
                 << (data & 0x3f) << dec << endl;
          }
          break;
        case 0x18:
          if(!bypass) {
            cout << "Threshold/Cal: " << hex
                 << ((data & 0xff00) >> 8) << "/" 
                 << (data & 0xff) << dec << endl;
          }
          break;
        case 0x38:
          if(!bypass) {
            cout << "preamp/shaper: " << hex
                 << ((data & 0xff00) >> 8) << "/" 
                 << (data & 0xff) << dec << endl;
          }
          break;
        case 0x04:
          if(skipTrim || bypass) {
            cout << "\r                   \r";
          } else {
            cout << "TRIM DAC: " << hex
                 << (data & 0xf) << " " 
                 << ((data & 0x7f0) >> 4) << dec << endl;
          }
          break;
        }
        pos ++;
        break;
      }
    case 0x8c:
      if(!bypass) {
        // Mask reg
        cout << "Mask ";
        cout << hex;
        for(int i=0; i<4; i++) {
          cout << config[pos++] << " ";
        }
        cout << dec;
        cout << endl;
        pos++;
      } else {
        pos += 5;
      }
      break;
    case 0x0c:
      cout << "Something else\n";
      break;
    }
  }
}

void SctApi::getrpcrc(UINT32 mid, unsigned int &rpartition, unsigned int &rcrate, unsigned int &rrod, unsigned int &rchannel) {
  unsigned int partition, crate, rod, channel;

  getpcrc(mid, partition, crate, rod, channel);

  unsigned int mur, module;

  try {
    if(checkDebugOption(DEBUG_DIAG))
      cout << "Looking for module in partition " << partition << " crate " << crate << " rod " << rod << " channel " << channel << endl;
    config->translateFromROD(partition, crate, rod, channel, 
                             mur, module);

    if(checkDebugOption(DEBUG_DIAG2))
      cout << "Found MUR " << mur << " module number " << module << endl;
  } catch(ConfigurationException &c) {
    cout << "Can't find module in MUR map: \n";
    cout << c.what() << endl;

    {
      boost::mutex::scoped_lock lock(log().mutex());
      log() << "  (Not found)\n";
    }
    throw;
  }

  try {
    config->translateToRROD(mur, module, 
                            rpartition, rcrate, rrod, rchannel);
  } catch(ConfigurationException &c) {
    cout << "Module redundancy not found: \n";
    cout << c.what() << endl;

    {
      boost::mutex::scoped_lock lock(log().mutex());
      log() << "  (Not found)\n";
    }
    throw;
  }
}

long SctApi::getRodSlot(unsigned int rod) 
{
  if(getCrate()) {
    return getCrate()->getRodSlot(rod);
  } else {
    return -1;
  }
}

int SctApi::getRodRevision(unsigned int rod) 
{
  if(getCrate()) {
    return getCrate()->getRodRevision(rod);
  } else {
    return -1;
  }
}

int SctApi::getRodRevision(const RodLabel &label) 
{
  if(getCrate()) {
    return getCrate()->getRodRevision(label.rod);
  } else {
    return -1;
  }
}

void SctApi::testLinkOutSelect(unsigned int rod,
                               unsigned int link) 
{
#ifdef FMT_LINK_DATA_TEST_MUX
  int formatter = link/12;
  int intLink = link%12;

  if(formatter > 8 || formatter < 0) {
    cout << "formatter out of range: " << formatter << endl;
    return;
  }

  if(intLink > 12 || intLink < 0) {
    cout << "link out of range: " << intLink << endl;
    return;
  }

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

  PrimBuilder &builder = PrimBuilder::instance();
  builder.writeRegister(primList, FMT_LINK_DATA_TEST_MUX(formatter), 0, 4, intLink);   // 0x070 + formatter
  builder.writeRegister(primList, EFB_CMND_0, 4, 4, formatter & 0x7);                  // 0x1a4

  sendPrimList(rod, primList);
  awaitResponse(rod, 2);
#else 
#error "Link out select not compiled"
#endif
}

unsigned int SctApi::testLinkOutRetrieve(unsigned int rod) 
{
#ifdef FMT_LINK_DATA_TEST_MUX
  int fReg = readRODRegister(rod, EFB_CMND_0);
  int formatter = (fReg >> 4) & 0x7;

  int lReg = readRODRegister(rod, FMT_LINK_DATA_TEST_MUX(formatter));
  int intLink = lReg & 0xf;

  return formatter * 12 + intLink;
#else 
#error "Link out select not compiled"
#endif
}

void SctApi::setDebugOption(std::string opt) {
  Debug::getInstance()->setDebugOption(opt);
}

void SctApi::unsetDebugOption(std::string opt) {
  Debug::getInstance()->unsetDebugOption(opt);
}

std::list<std::string> SctApi::listEnabledDebugOptions() const{
  return Debug::getInstance()->listEnabledDebugOptions();
}

std::vector<std::string> SctApi::listDebugOptions() const{
  return Debug::getInstance()->listDebugOptions();
}

void SctApi::unsetBusy() {
  if(m_isDict) {
    m_isDict->remove(idiosyncrasy().infoServiceNameOfScanStatusObject());
  }
}

bool SctApi::checkDebugOption(std::string opt) const{
  return Debug::getInstance()->checkDebugOption(opt);
}

bool SctApi::checkDebugOption(int intOpt) const{
  return Debug::getInstance()->checkDebugOption((DebugOptions)intOpt);
}

void SctApi::debugStepHistogram()
{
  if(!lastDebugScanEx) {
    cout << "No last scan stored\n";
    return;
  }

  // This can only work as a single ROD method!
  RodLabel zeroRod = lastDebugScanEx->rodInfo.begin()->first;

  // Do step
#warning "Hard coded access to diagnostic register with STEP_CTRL and STEP_TRIGGER bits"
  dspSingleWrite(zeroRod.rod, 
                 0x80000010, lastDebugScanEx->diagnosticReg | (1<<7) | (1<<6), -1); 

#if USE_THREADS
  sleep(1);
#else
  // Read the text buffers
  awaitResponse(zeroRod.rod, 1);
#endif

  if(checkDebugOption(DEBUG_EXTRA_DUMPS)) {
    standardRegisterDump(zeroRod.rod);
  }
}

void SctApi::debugContinueHistogram()
{
  // This can only work as a single ROD method!
  RodLabel zeroRod = lastDebugScanEx->rodInfo.begin()->first;

#warning "Hard-coded diagnostic register with STEP_TRIGGER bit"
  dspSingleWrite(zeroRod.rod, 
                 0x80000010, lastDebugScanEx->diagnosticReg | (1<<7), -1); 

#if USE_THREADS
  sleep(1);
#else
  // Read the text buffers
  awaitResponse(zeroRod.rod, 
                1);
#endif

  if(checkDebugOption(DEBUG_EXTRA_DUMPS)) {
    standardRegisterDump(zeroRod.rod);
  }
}

void SctApi::debugAbortHistogram()
{
#warning "How to do this... tidyHistogramming? (not when in stalled mode!) AUTO_STALL ends at next bin!"
  // killing histogram task then step?
  time_t start_time = time(0);

  // This can only work as a single ROD method!
  RodLabel zeroRod = lastDebugScanEx->rodInfo.begin()->first;

  while(1) {
    cout << "** Loop\n";

#warning "Hard coded address (Diagnostic register (STEP_TRIGGER))"
    dspSingleWrite(zeroRod.rod, 
                   0x80000010, (1<<7), -1);
    while(dspSingleRead(zeroRod.rod, 
                        0x80000010, -1) & (1<<7)) {
      if((time(0) - start_time) > 2) {
        goto breakOut;
      }
    }
  }

 breakOut:
  tidyHistogramming();
}

void SctApi::standardRegisterDump(RodLabel rl) {
  standardRegisterDump(rl.rod);
}

void SctApi::standardRegisterDump(unsigned int rod) {
  static int dumpCount = 0;

  if(!getCrate() 
     || !getCrate()->RODPresent(rod)) {
    cout << "Invalid crate or ROD in standardRegisterDump\n";
    return;
  }

  cout << "Making dump number " << dumpCount << endl;

  string baseDir(Sct::SctNames::getTempDir());

  // Awkward to do %05d with strings...
  boost::format dirFormat("%s/Dump_%05d_%05d");
  dirFormat % baseDir % getpid() % (dumpCount ++);

  string dirName(dirFormat.str());
  
  cout << " in " << dirName << endl;

  int dirRet = mkdir(dirName.c_str(), S_IRUSR|S_IWUSR|S_IXUSR);
  if(dirRet != 0) {
    // It's OK if it already exists
    if(errno != EEXIST) {
      perror(("Failed to create Dump directory in '" + baseDir + "', aborting dump").c_str());
      return;
    }
  }

  char *saveDir = getcwd(NULL, 0);
  int chRet = chdir(dirName.c_str());
  if(chRet != 0) {
    perror("Failed to change to Dump directory, aborting dump");
    return;
  }

  dspBlockDumpFile(rod, 0x02400000, 0x80000, -1, "BigMDSPDump.bin");

  dspBlockDumpFile(rod, 0x00400000, 0x800, -1, "StandardDumpFRM.bin");
  dspBlockDumpFile(rod, 0x00402000, 0x100, -1, "StandardDumpEFB.bin");
  dspBlockDumpFile(rod, 0x00402400, 0x060, -1, "StandardDumpRTR.bin");
  dspBlockDumpFile(rod, 0x00404400, 0x300, -1, "StandardDumpRCF.bin");

  dspBlockDumpFile(rod, 0x02000000, 0x40000, -1, "StandardDumpMDSP_XPROG.bin");
  dspBlockDumpFile(rod, 0x80000000, 0x02000, -1, "StandardDumpMDSP_IDRAM.bin");

  ofstream moduleList("StandardModuleList.txt");

  moduleList << "Module configuration for " << moduleMap.size() << " modules:\n";
  for(map<UINT32, ABCDModule>::const_iterator mi = moduleMap.begin();
      mi!=moduleMap.end();
      mi ++) {
    UINT32 mid = mi->first;

    string sn = convertToString(mid);
    ABCDModule *moduleConf = lookupConfig(mid);
    int group = moduleConf->groupId;
    int select = moduleConf->select;
    int prim = moduleConf->pTTC;
    int redun = moduleConf->rTTC;
    int link0 = moduleConf->rx[0];
    int link1 = moduleConf->rx[1];

    // Reverse translate formatter encoding
    if(link0 != DATA_LINK_OFF) 
      link0 = (link0/16) * 12 + link0%16;
    if(link1 != DATA_LINK_OFF) 
      link1 = (link1/16) * 12 + link1%16;

    moduleList.width(8);
    moduleList << mid << " " << sn << " Group: " << group << " Select: " << select;
    moduleList << "\t Pr: ";
    moduleList.width(2);
    moduleList << prim << " Red: ";
    moduleList.width(3);
    moduleList << redun << " Link 0/1: ";
    moduleList.width(3);
    moduleList << link0 << " ";
    moduleList.width(3);
    moduleList << link1 << endl;
  }

  // Rev E or rev F
  if(getCrate()->getRodRevision(rod) >= 0xE) {
    for(int s=0; s<4; s++) {
      // Event data in slave
      string idramFile = "StandardDumpSDSP0_IDRAM.bin";
      idramFile[16] = s + '0';
      dspBlockDumpFile(rod, 0x00010000, 0x2000, s, idramFile);
      string burstFile = "StandardDumpSDSP0_BURST.bin";
      burstFile[16] = s + '0';
      dspBlockDumpFile(rod, 0x00018000, 0x2000, s, burstFile);
      string sdramFile = "StandardDumpSDSP0_SDRAM.bin";
      sdramFile[16] = s + '0';
      dspBlockDumpFile(rod, 0xa0040000, 0x28800, s, sdramFile);
    }
  } else {  // Rev C
    for(int s=0; s<4; s++) {
      // Event data in slave
      string idramFile = "StandardDumpSDSP0_IDRAM.bin";
      idramFile[16] = s + '0';
      dspBlockDumpFile(rod, 0x80000000, 0x2000, s, idramFile);
      string burstFile = "StandardDumpSDSP0_BURST.bin";
      burstFile[16] = s + '0';
      dspBlockDumpFile(rod, 0x80008000, 0x2000, s, burstFile);
      string sdramFile = "StandardDumpSDSP0_SDRAM.bin";
      sdramFile[16] = s + '0';
      dspBlockDumpFile(rod, 0x02040000, 0x28800, s, sdramFile);
    }
  }

  int chSaveRet = chdir(saveDir);
  if(chSaveRet != 0) {
    perror("Failed to return to saved directory after Dump");
  }
}

void SctApi::standardRegisterDumpAll() {
  for(list<RodLabel>::const_iterator rl = rodList.begin();
      rl!=rodList.end();
      rl++){
    standardRegisterDump(*rl);
  }
}

void SctApi::setupScanMasks(ScanEx &extra, int distSlave, bool dual) {
  RodScanEx defaultInfo;

  if(distSlave == 0) {
    defaultInfo.slaves = 1;
    defaultInfo.bitFieldDSP = 0x1;
  } else if(distSlave == 1) {
    defaultInfo.slaves = 0;
    defaultInfo.bitFieldDSP = 0x0; // Fill in which slaves are used later
  } else if(distSlave == 2) {
    defaultInfo.slaves = 4;
    defaultInfo.bitFieldDSP = 0xf;
  }

  ModuleMask zeroMask = {0, 0};

  defaultInfo.channels = zeroMask;

  for(int i=0; i<8; i++) {
    defaultInfo.groupChannels[i] = zeroMask;
  }
  for(int i=0; i<4; i++) {
    defaultInfo.slaveChannels[i] = zeroMask;
  }

  // Group to DSP mappings
  if(distSlave == 0) {               // Which groups for each DSP to use
    // All groups to slave 0
    extra.groupDspMap[0] = 0xff;
    extra.groupDspMap[1] = 0x0;
    extra.groupDspMap[2] = 0x0;
    extra.groupDspMap[3] = 0x0;
  } else if(distSlave == 2) {
    // All groups to all slaves
    extra.groupDspMap[0] = 0xff;
    extra.groupDspMap[1] = 0xff;
    extra.groupDspMap[2] = 0xff;
    extra.groupDspMap[3] = 0xff;
  } else {
    if(!dual) {
      // Each group to a separate DSP
      extra.groupDspMap[0] = 0x11;
      extra.groupDspMap[1] = 0x22;
      extra.groupDspMap[2] = 0x44;
      extra.groupDspMap[3] = 0x88;
    } else {
      // Each Dsp has to service one trigger
      extra.groupDspMap[0] = 0x03;
      extra.groupDspMap[1] = 0x0c;
      extra.groupDspMap[2] = 0x30;
      extra.groupDspMap[3] = 0xc0;
    }
  }

  if(!dual) {
    extra.groupSpMap[0] = 0xff;        // All groups use port 0
    extra.groupSpMap[1] = 0x00;
  } else {
    extra.groupSpMap[0] = 0xf;         // Groups 0-3 use port 0
    extra.groupSpMap[1] = 0xf0;        // Groups 4-7 use port 1
  }

  if(!dual) {
    extra.groupRangeMap[0] = 0xff;         // All groups use range list 0
    extra.groupRangeMap[1] = 0x0;
  } else {
    extra.groupRangeMap[0] = 0x0f;         // Groups 0-3 -> range list 0
    extra.groupRangeMap[1] = 0xf0;         // Groups 4-7 -> range list 1
  }

  // Set up masks for modules
  for(map<UINT32, ABCDModule>::const_iterator mi = moduleMap.begin();
      mi!=moduleMap.end();
      mi ++) {
    UINT32 currMid = mi->first;

    ABCDModule *moduleConfig = lookupConfig(currMid);
    unsigned int group = moduleConfig->groupId;

    unsigned int newPartition, newCrate, newRod, newChannel;
    getpcrc(currMid, newPartition, newCrate, newRod, newChannel);

    RodLabel thisRod(newPartition, newCrate, newRod);

    RodScanEx &thisInfo = extra.getOrNewRod(thisRod, defaultInfo);

    // Check if redundancy in use
    if(moduleConfig->select) {
      // does clk/cmd go from same ROD
      try {
        unsigned int rpartition, rcrate, rrod, rchannel;
        getrpcrc(currMid, rpartition, rcrate, rrod, rchannel);

        if(newPartition != rpartition || newCrate != rcrate || newRod != rrod) {
          // Nothing to do as mask are rx
        }
      } catch(ConfigurationException &c) {
        // Redundant conversion failed, this should have been picked up in the checks
      }
    }

    if(newChannel<32) {
      if(thisInfo.channels.mask0 & 1<<newChannel) {
        cout << "Module already using this channel in this group\n";
      }
      thisInfo.channels.mask0 |= 1<<newChannel;

      if(distSlave == 1) {
        thisInfo.groupChannels[group].mask0 |= 1<<newChannel;
      } else if(distSlave == 0) {
        thisInfo.groupChannels[0].mask0 |= 1<<newChannel;
      } else {
        // Same as distSlave == 1...
        thisInfo.groupChannels[group].mask0 |= 1<<newChannel;
      }
    } else {
      if(thisInfo.channels.mask1 & 1<<(newChannel-32)) {
        cout << "Module already using this channel in this group\n";
      }
      thisInfo.channels.mask1 |= 1<<(newChannel-32);

      if(distSlave == 1) {
        thisInfo.groupChannels[group].mask1 |= 1<<(newChannel-32);
      } else if(distSlave == 0) {
        thisInfo.groupChannels[0].mask1 |= 1<<(newChannel-32);
      } else {
        // Same as distSlave == 1...
        thisInfo.groupChannels[group].mask1 |= 1<<(newChannel-32);
      }
    }

    if(group+1 > extra.groupLists.size()) {
      extra.groupLists.resize(group + 1);
    }
    extra.groupLists[group].push_back(convertToString(currMid));
  }

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

    RodScanEx &thisInfo = extra.getRodScanInfo(*rl);

    thisInfo.slaves = 0;
    thisInfo.firstSlave = numSlaves;

    for(int slave=0; slave<numSlaves; slave++) {
      for(int group=0; group<8; group++) {
        if(extra.groupDspMap[slave] & (1<<group)) {
          if(thisInfo.groupChannels[group].mask0 || thisInfo.groupChannels[group].mask1) {
            thisInfo.bitFieldDSP |= 1<<slave;
          }

          thisInfo.slaveChannels[slave].mask0 |= thisInfo.groupChannels[group].mask0;
          thisInfo.slaveChannels[slave].mask1 |= thisInfo.groupChannels[group].mask1;
        }
      }

      if(thisInfo.bitFieldDSP & (1<<slave)) {
        thisInfo.slaves++; 

        if(thisInfo.firstSlave > 3) {
          thisInfo.firstSlave = slave;
        }
      }
    }
  }
}

// Check lists are valid
bool SctApi::checkModuleListsForScan() {
  if(moduleMap.begin() == moduleMap.end()) {
    cout << "No modules to scan!\n";
    if(mrs) {
      *mrs << "SCAN_NO_MODULES" << MRS_ERROR 
           << MRS_QUALIF("SCTAPI") << MRS_QUALIF("doScan") 
           << MRS_TEXT("No modules to scan")
           << ENDM;
    }
    return false;
  }

  // Initialise with first module
  UINT32 mid = moduleMap.begin()->first;
  unsigned int firstPartition, firstCrate, firstRod, firstChannel;
  getpcrc(mid, firstPartition, firstCrate, firstRod, firstChannel);

  for(map<UINT32, ABCDModule>::const_iterator mi = moduleMap.begin();
      mi!=moduleMap.end();
      mi ++) {
    UINT32 currMid = mi->first;

    unsigned int newPartition, newCrate, newRod, newChannel;

    getpcrc(currMid, newPartition, newCrate, newRod, newChannel);

    // Check first module against current one
    if(newPartition != firstPartition) {
      cout << "Can't do scans on modules in different partitions (ever?)\n";
      if(mrs) {
        *mrs << "SCAN_MISMATCH" << MRS_ERROR 
             << MRS_QUALIF("SCTAPI") << MRS_QUALIF("doScan") 
             << MRS_TEXT("Mismatch partitions. Can't do scans on modules in different partitions (ever?)")
             << ENDM;
      }
      return false;
    }

    // Check first module against current one
    if(newCrate != firstCrate) {
      cout << "Can't do scans on modules in different crates (yet)\n";
      if(mrs) {
        *mrs << "SCAN_MISMATCH" << MRS_ERROR 
             << MRS_QUALIF("SCTAPI") << MRS_QUALIF("doScan") 
             << MRS_TEXT("Crate mismatch, can't do scans on modules in different crates (yet)")
             << ENDM;
      }
      return false;
    }

    ABCDModule *config = lookupConfig(currMid);

    if(!config) {
      cout << "Trying to do a scan on a module with no configuration FAILED!\n";
      if(mrs) {
        *mrs << "SCAN_NOCONFIG" << MRS_ERROR 
             << MRS_QUALIF("SCTAPI") << MRS_QUALIF("doScan") 
             << MRS_TEXT("Trying to do a scan on a module with no configuration FAILED!")
             << ENDM;
      }
      return false;
    }

    // Check if redundancy in use
    if(config->select) {
      // does clk/cmd go from same ROD
      try {
        unsigned int rpartition, rcrate, rrod, rchannel;
        getrpcrc(currMid, rpartition, rcrate, rrod, rchannel);

        if(newPartition != rpartition || newCrate != rcrate || newRod != rrod) {
          cout << "Can't do redundant stuff on split RODs at the moment, SCAN CANCELLED\n";
          return false;
        }
      } catch(ConfigurationException &c) {
        cout << "No mapping to redundant channel for module with select, SCAN CANCELLED\n";
        return false;
      }
    }
  }

  return true;
}

bool SctApi::preScanHardwareCheck(const Scan& scan, ScanEx& extra) {
  std::cout << "preScanHardwareCheck started at TIME " << boost::posix_time::second_clock::universal_time() << std::endl;
  // Check that the appropriate slaves were initialised 
  for(ScanEx::RodInfoMap::const_iterator ri = extra.rodInfo.begin();
      ri != extra.rodInfo.end();
      ri++) {
    const RodLabel rod = ri->first;
    for(int i=0; i<4; i++) {
      if(ri->second.bitFieldDSP & (1<<i) 
         && getCrate()
         && !getCrate()->slavePresent(rod.rod, i)) {
        cout << "***** A slave DSP necessary for the requested scan was not initialised\n";
        cout << "*****  please check the configuration and the Slave Image files\n";
        if(mrs) {
          *mrs << MRS_ERROR 
               << "SCAN_NODSP" 
               << MRS_QUALIF("SCTAPI") << MRS_QUALIF("doScan") 
               << MRS_PARAM<int>("slavesNeeded", ri->second.bitFieldDSP)
               << MRS_PARAM<int>("slaveNotStarted", i)
               << MRS_TEXT("Required DSPs not initialised for the requested scan")
               << ENDM;
        }
        return false;
      }
    }

    // Don't bother checking if in debug mode
    if(!getCrate()->checkBOCLasersOn(rod.rod)) {
      if(!scan.getOption(Scan::DEBUG)) {
        cout << "Trying to do scan using BOC that has its lasers cut out (aborting)\n";
        if(mrs) {
          *mrs << "BOC_INTERLOCKED" << MRS_ERROR << MRS_QUALIF("SCTAPI") 
               << MRS_PARAM<int>("crate", rod.crate) 
               << MRS_PARAM<int>("rod", rod.rod)
               << MRS_TEXT("Scan aborting (BOC interlocked)") << ENDM;
        }

        return false;
      } else {
        cout << "Trying to do scan using BOC that has its lasers cut out (continuing for debug)\n";
      }
    }
  }
  if(!checkAllModulesProbe("E")) {
#warning "Possibly disable the ones that aren't returning events? (with warnings!)"
    if(!scan.getOption(Scan::DEBUG)) {
      cout << "Check all modules in scan are returning events! (aborting)\n";
      if(mrs) {
    *mrs << "SCAN_ABORTED" << MRS_ERROR << MRS_QUALIF("SCTAPI") 
         << MRS_TEXT("Scan aborting (Modules not returning events)") 
         << MRS_PARAM<const char*>("ucid",static_cast<string>(ucid()).c_str()) << ENDM;
      }
      return false;
    } else {
      cout << "All modules in scan are not returning events! (continuing for DEBUG)\n";
      if(mrs) {
    *mrs << "SCAN_WARNING" << MRS_WARNING << MRS_QUALIF("SCTAPI") 
         << MRS_TEXT("Modules not all returning events (Scan continuing anyway (DEBUG))")
         << MRS_PARAM<const char*>("ucid",static_cast<string>(ucid()).c_str()) << ENDM;
      }
    }
  }
  
  return true;
}

/* This probably should be in ScanControlRODHisto, but 
   it has to be done before the main scan and so doesn't 
   fit into the current plan...
 */
void SctApi::preScanModuleSetup(const Scan &scan) {
  std::cout << "preScanModuleSetup started at TIME " << boost::posix_time::second_clock::universal_time() << std::endl;
  {
    std::list<BankType> banks;
    banks.push_back(SCTAPI_BANK_SCAN);
    setABCDModules(banks);
    cout << "Configuration for all modules has been uploaded to SCAN at TIME " << boost::posix_time::second_clock::universal_time() << std::endl;
  }

  cout << "Do ROD configuration (masks etc)\n"; 
  calib_init();

  if(checkDebugOption(DEBUG_PRINT_CALIB)) {
    UINT32 mid = moduleMap.begin()->first;
    unsigned int partition, crate, rod, channel;
    getpcrc(mid, partition, crate, rod, channel);

    print_calib(rod);
  }
  // Send configuration to the module (this should be redundant as it the first thing the histogramming does)
  std::cout << "send all modules at TIME " << second_clock::universal_time() << std::endl;
  sendAllABCDModules(SCTAPI_BANK_SCAN);

  cout << "Module Configurations for scan uploaded to RODs at time " << second_clock::universal_time() << std::endl;

  PrimBuilder &builder = PrimBuilder::instance();
  
  // For full histograms the formatters need to be told to produce expanded events
  shared_ptr<PrimListWrapper> expandFormatList(new PrimListWrapper(1));
  for(int i=0; i<8; i++) {
    if(scan.getOption(Scan::FULL)) { 
      builder.writeRegister(expandFormatList, FMT_EXP_MODE_EN(i), 0, 12, 0xfff);
    } else {
      builder.writeRegister(expandFormatList, FMT_EXP_MODE_EN(i), 0, 12, 0x0);
    }
  }

  if(synchSendPrimListAll(expandFormatList) != 0) {
    cout << "Expand mode list failed!\n";
  }

  if(scan.getOption(Scan::FULL)) {
    cout << "Formatters set for expanded mode\n";
  } else {
    cout << "Formatters set for condensed mode\n";
  }


  if(scan.getScanVariable1() == ST_TOKEN
     || scan.getScanVariable1() == ST_BYPASS) {
    PrimBuilder &builder = PrimBuilder::instance();

    shared_ptr<PrimListWrapper> chipSeqList(new PrimListWrapper(1));
    for(int i=0; i<48; i++) {
      builder.writeRegister(chipSeqList, Utility::EfbErrorMask(0, i), 10, 1, 1);
      builder.writeRegister(chipSeqList, Utility::EfbErrorMask(1, i), 10, 1, 1);
    }
    
    if(synchSendPrimListAll(chipSeqList) != 0) {
      cout << "Chip sequence error list failed!\n";
    }

    cout << "EFB chip sequence detection turned off\n";
  }

  // Check for double triggers which aren't supported by DSP code
  {
    Trigger::RODTriggers points = scan.getTrigger1()->getRODTriggers();

    int triggerCount = 0;

    for(unsigned int i=0; i<points.size(); i++) {
      // Count triggers
      if(points[i].first == L1_TRIGGER) {
        triggerCount++;
      }
    }

    // Double triggers... none of current options will cope...
    if(triggerCount > 1 && scan.getOption(Scan::DISTSLAVE) < 3) {
      shared_ptr<PrimListWrapper> dblTrigFixList(new PrimListWrapper(1));

      // Mask L1 and BCID checks
      for(int f=0; f<48; f++) {
    // L1ID
    builder.writeRegister(dblTrigFixList, Utility::EfbErrorMask(0, f), 5, 1, 1);
        builder.writeRegister(dblTrigFixList, Utility::EfbErrorMask(1, f), 5, 1, 1);

        // BCID
        builder.writeRegister(dblTrigFixList, Utility::EfbErrorMask(0, f), 6, 1, 1);
        builder.writeRegister(dblTrigFixList, Utility::EfbErrorMask(1, f), 6, 1, 1);
      }

      if(synchSendPrimListAll(dblTrigFixList)) {
        cout << "Double trigger BC check list failed!\n";
      }
      cout << "L1 and BCID checks masked for double triggers\n";
    }
  }

  cout << "Done module set-up at time " << second_clock::universal_time() << std::endl;;

  if(checkDebugOption(DEBUG_PRINT_CALIB)) {
    // A bit over the top just to find 0, 0, 0!
    UINT32 mid = moduleMap.begin()->first;
    unsigned int partition, crate, rod, channel;
    getpcrc(mid, partition, crate, rod, channel);

    print_calib(rod);
  }
}

void SctApi::resumePolling() {
  getCrate()->resumePolling();
}

void SctApi::stopPolling() {
  getCrate()->stopPolling();
}

SctApiDDC * SctApi::getSctApiDDC() const {
  return m_sctApiDDC.get();
}

SctApiCounters publishedStats;
SctApiCounters currentStats;

void SctApi::updateISStats() {
  if(!m_isDict) return;
  if(publishedStats.primitiveCounter != currentStats.primitiveCounter) {
    ISInfoInt isInt(currentStats.primitiveCounter);
    m_isDict->update("SCTAPIServer." + idiosyncrasy().uniqueName() + "_primitiveCounter", isInt);
    publishedStats.primitiveCounter = currentStats.primitiveCounter;
  }
  if(publishedStats.primitiveLengthCounter != currentStats.primitiveLengthCounter) {
    ISInfoInt isInt(currentStats.primitiveLengthCounter);
    m_isDict->update("SCTAPIServer." + idiosyncrasy().uniqueName() + "_primitiveLengthCounter", isInt);
    publishedStats.primitiveLengthCounter = currentStats.primitiveLengthCounter;
  }
  if(publishedStats.primitiveOutLengthCounter != currentStats.primitiveOutLengthCounter) {
    ISInfoInt isInt(currentStats.primitiveOutLengthCounter);
    m_isDict->update("SCTAPIServer." + idiosyncrasy().uniqueName() + "_primitiveOutLengthCounter", isInt);
    publishedStats.primitiveOutLengthCounter = currentStats.primitiveOutLengthCounter;
  }
  if(publishedStats.mdspMemoryBlockCounter != currentStats.mdspMemoryBlockCounter) {
    ISInfoInt isInt(currentStats.mdspMemoryBlockCounter);
    m_isDict->update("SCTAPIServer." + idiosyncrasy().uniqueName() + "_mdspMemoryBlockCounter", isInt);
    publishedStats.mdspMemoryBlockCounter = currentStats.mdspMemoryBlockCounter;
  }
  if(publishedStats.mdspMemoryBlockLengthCounter != currentStats.mdspMemoryBlockLengthCounter) {
    ISInfoInt isInt(currentStats.mdspMemoryBlockLengthCounter);
    m_isDict->update("SCTAPIServer." + idiosyncrasy().uniqueName() + "_mdspMemoryBlockLengthCounter", isInt);
    publishedStats.mdspMemoryBlockLengthCounter = currentStats.mdspMemoryBlockLengthCounter;
  }
  if(publishedStats.sdspMemoryBlockCounter != currentStats.sdspMemoryBlockCounter) {
    ISInfoInt isInt(currentStats.sdspMemoryBlockCounter);
    m_isDict->update("SCTAPIServer." + idiosyncrasy().uniqueName() + "_sdspMemoryBlockCounter", isInt);
    publishedStats.sdspMemoryBlockCounter = currentStats.sdspMemoryBlockCounter;
  }
  if(publishedStats.sdspMemoryBlockLengthCounter != currentStats.sdspMemoryBlockLengthCounter) {
    ISInfoInt isInt(currentStats.sdspMemoryBlockLengthCounter);
    m_isDict->update("SCTAPIServer." + idiosyncrasy().uniqueName() + "_sdspMemoryBlockLengthCounter", isInt);
    publishedStats.sdspMemoryBlockLengthCounter = currentStats.sdspMemoryBlockLengthCounter;
  }
}

void SctApi::insertISStats() {
  if(!m_isDict) return;
  ISInfoInt isInt(0);
  m_isDict->insert("SCTAPIServer." + idiosyncrasy().uniqueName() + "_primitiveCounter", isInt);
  m_isDict->insert("SCTAPIServer." + idiosyncrasy().uniqueName() + "_primitiveLengthCounter", isInt);
  m_isDict->insert("SCTAPIServer." + idiosyncrasy().uniqueName() + "_primitiveOutLengthCounter", isInt);
  m_isDict->insert("SCTAPIServer." + idiosyncrasy().uniqueName() + "_mdspMemoryBlockCounter", isInt);
  m_isDict->insert("SCTAPIServer." + idiosyncrasy().uniqueName() + "_mdspMemoryBlockLengthCounter", isInt);
  m_isDict->insert("SCTAPIServer." + idiosyncrasy().uniqueName() + "_sdspMemoryBlockCounter", isInt);
  m_isDict->insert("SCTAPIServer." + idiosyncrasy().uniqueName() + "_sdspMemoryBlockLengthCounter", isInt);
}
}  // End of namespace SctApi

// Some static exception handlers documented only in this file
static void handle_unexpected(void) {
  cerr << "Unexpected exception thrown in unknown place\n";

  try {
    throw;
  } catch (RodException &r) {
    cerr << "Rod Exception\n";
    cerr << r.getDescriptor() << ", " << r.getData1() << ", " << r.getData2() << endl;
  } catch (NoImageFile &f) {
    cerr << "No image file exception " << f.getFileName() << endl;
  } catch (VmeException &v) {
    SctApi::Utility::decodeVme(v);
  } catch (HpiException &h) {
    cerr << "HpiException:\n";
    hex(cerr);
    cerr << h.getDescriptor() << '\n';
    cerr << "calcAddr: " << h.getCalcAddr() << ", readAddr: " <<
      h.getReadAddr() << '\n';
    dec(cerr);
  } catch (PrimListException &p) {
    cerr << "Primlist Exception:\n";
    cerr << p.getDescriptor() << " " << p.getData1() << ", " << p.getData2() << endl;
  } catch(std::exception &e) {
    cerr << "std::exception with what: " << e.what() << endl;
  } catch(...) {
    cerr << "Unknown exception type\n";
  }

  // New version of VmeInterface should cope and shutdown RCC interface properly
  exit(1);

  //  Rethrow exception, function _must_ catch (and therefore method with specification, 
  //   if no exceptions specified then no problem in the first place...) std::bad_exception to recover.
// throw;
}

#if 0

void buildChannelMasks() {
  UINT32 txchannels[2];
  UINT32 rxchannels[4];

  txchannels[0] = 0;
  txchannels[1] = 0;
  rxchannels[0] = 0;
  rxchannels[1] = 0;
  rxchannels[2] = 0;
  rxchannels[3] = 0;

  // Build channel map for modules
  for(map<UINT32, ABCDModule>::const_iterator mi = moduleMap.begin();
      mi!=moduleMap.end();
      mi ++) {
    UINT32 currMid = mi->first;

    cout << "Set up module " << currMid << endl;

    unsigned int newPartition, newCrate, newRod;
    // If requires look up redundant channel instead
#warning "How is off-ROD redundancy handled?... (old calib_init)"

    unsigned int rcvChannel, sndChannel;
    getpcrc(currMid, newPartition, newCrate, newRod, rcvChannel);

    if(lookupConfig(currMid)->select == 1) {
      try {
        unsigned int redPartition, redCrate, redRod;
        getrpcrc(currMid, redPartition, redCrate, redRod, sndChannel);
#warning "Check same ROD? (old calib_init)"
      } catch(ConfigurationException &c) {
        sndChannel = rcvChannel;
      }
    } else {
      sndChannel = rcvChannel;
    }

    char *mappings = config->getFibreMappings(newPartition, newCrate, newRod);

    int txChannel = mappings[sndChannel * 3 + 0];
    int rx0Channel = mappings[rcvChannel * 3 + 1];
    int rx1Channel = mappings[rcvChannel * 3 + 2];

    int txi, txval, rx0i, rx0val, rx1i, rx1val;

    if(txChannel<32) { txi = 0; txval = 1<<txChannel; }
    else { txi = 1; txval = 1<<(txChannel-32); }

    if(rx0Channel<32) { rx0i = 0; rx0val = 1<<rx0Channel; }
    else if(rx0Channel<64) { rx0i = 1; rx0val = 1<<(rx0Channel-32); }
    else if(rx0Channel<96) { rx0i = 2; rx0val = 1<<(rx0Channel-64); }
    else { rx0i = 3; rx0val = 1<<(rx0Channel-96); }

    if(rx1Channel<16) { rx1i = 0; rx1val = 1<<rx1Channel; }
    else if(rx1Channel<32) { rx1i = 1; rx1val = 1<<(rx1Channel-32); }
    else if(rx1Channel<64) { rx1i = 2; rx1val = 1<<(rx1Channel-64); }
    else { rx1i = 3; rx1val = 1<<(rx1Channel-96); }

    if(txchannels[txi] & txval) {
      cout << "Module already using this channel in this group\n";
    } else {
      txchannels[txi] |= txval;
    }

    if(rxchannels[rx0i] & rx0val) {
      cout << "Module already using this channel in this group\n";
    } else {
      rxchannels[rx0i] |= rx0val;
    }

    if(rxchannels[rx1i] & rx1val) {
      cout << "Module already using this channel in this group\n";
    } else {
      rxchannels[rx1i] |= rx1val;
    }

    delete [] mappings;
  }

  cout << "Calculated channel masks:\n";
  cout << hex;
  cout << "tx: 0x" << txchannels[0] << " 0x" << txchannels[1] << endl;
  cout << "rx: 0x" << rxchannels[0] << " 0x" << rxchannels[1] << " 0x" << rxchannels[2] << " 0x" << rxchannels[3] << endl;
  cout << dec;
}

#endif

---