TApi.cxx

// File: TApi.cxx

#include <iostream>
#include <list>

#include "TApi.h"
#include "autoConfig.h"

// For BOCChannelConfig
#include "sctConf/configRegistry.h"
#include "SctApiException.h"
#include "TriggerImpl.h"
#include "ScanDefImpl.h"
#include "ScanMonitorImpl.h"

#include <boost/bind.hpp>
#include "SctApiDDC.h"
#include "SctApi/Idiosyncrasy.h"

// Template to check for exceptions 
//  ::result_type is implemented by the boost bind stuff

template <class Call> typename Call::result_type checkCall(const Call &call) {
  try {
    return call();
  } catch(SctApi::SctApiException &e) {
    std::cout << "SctApiException " << e.what() << " thrown\n";
  }
}

ClassImp(TApi)
ClassImp(TScanDef)
ClassImp(TTrigger)
ClassImp(TScanMonitor)

// TApi *tapi;

// Constructor
TApi::TApi(std::string plugin){
  SctApi::Idiosyncrasy id(0,0);

  SctConfiguration::FactoryManager::instance().loadPlugin(plugin); 
  SctConfiguration::Factory &f = SctConfiguration::FactoryManager::instance().getFactory(plugin);

  boost::shared_ptr<SctConfiguration::Configuration> config(f.defaultConfig());

  worker = new SctApi::SctApi(id, config);
}

// Destructor
/*
  The destructor.
*/
TApi::~TApi(){
  delete worker;
}

// ROD Diagnostics

void TApi::initialiseAll(int scanNumber) {
  worker->initialiseAll(scanNumber);
  do{
    usleep(100000);
  }while (!this->isInitialised());
}

bool TApi::isInitialised() {
  return worker->isInitialised();
}

void TApi::shutdownAll() {
  worker->shutdownAll();
}

void TApi::setRunNumber(int newRun) {
  worker->setRunNumber(newRun);
}

void TApi::setScanNumber(int newScan) {
  worker->setScanNumber(newScan);
}

void TApi::changeRunMode(SctApi::RunType mode) {
  worker->changeRunMode(mode);
}

void TApi::flashLED(unsigned int rod,
                    long slaveNumber, long period, long flashes) {
  worker->flashLED(rod, slaveNumber, period, flashes);
}

void TApi::echo(unsigned int rod,
                unsigned int length, unsigned long *data) {
  worker->echo(rod, length, data);
}

void TApi::echoAll(unsigned int length, unsigned long *data) {
  worker->echoAll(length, data);
}

void TApi::echoSlave(unsigned int rod,
                     unsigned int slave, unsigned int length, unsigned long *data) {
  worker->echoSlave(rod, slave, length, data);
}

void TApi::awaitResponse(unsigned int rod, int timeout) {
  worker->awaitResponse(rod, timeout);
}

unsigned long *TApi::getResponse(unsigned int rod) {
  unsigned long length;
  unsigned long *result = worker->getResponse(rod, length);
  if(result == 0) {
    std::cout << "No response at TApi\n";
    return 0;
  }
  if(length < 2) result = 0;
  else {
    if(result[0] != length) {
      std::cout << "Result length mismatch!\n";
    }
  }
  return result;
}

unsigned long *TApi::getResponse(unsigned int rod, 
                                 unsigned long *length) {
  unsigned long myLength;
  unsigned long *result = worker->getResponse(rod, myLength);
  *length = myLength;
  return result;
}

// Get a message from a ROD text buffer
bool TApi::getRodMessage(unsigned int rod, 
                         char *buffer, unsigned long &length) {
  return worker->getRodMessage(rod, buffer, length);
}

UINT32 TApi::findModule(const char *sn) {
  return worker->findModule(sn);
}

UINT32 TApi::findModule(INT32 mur, INT32 module) {
  return worker->findModule(mur, module);
}

void TApi::sendABCDModules(UINT32 bank, UINT32 type) {
  try {
    worker->sendAllABCDModules(SctApi::BankType(bank), SctApi::ConfigType(type));
  } catch(SctApi::SctApiException &e) {
    std::cout << "Got exception: " << e.what() << std::endl;
  }
}

void TApi::sendABCDModule(UINT32 mid, UINT32 bank, UINT32 type) {
  try {
    worker->sendABCDModule(mid, SctApi::BankType(bank), SctApi::ConfigType(type));
  } catch(SctApi::SctApiException &e) {
    std::cout << "Got exception: " << e.what() << std::endl;
  }
}

void TApi::getABCDModules(UINT32 bank) {
  worker->getABCDModules(SctApi::BankType(bank));
}

void TApi::getABCDModule(UINT32 mid, UINT32 bank) {
  worker->getABCDModule(mid, SctApi::BankType(bank));
}

void TApi::modifyABCDMask(UINT32 mid, UINT32* mask) {
  worker->modifyABCDMask(mid, mask);
}

void TApi::modifyABCDTrims(UINT32 mid, UINT8* trims) {
  worker->modifyABCDTrims(mid, trims);
}

void TApi::modifyABCDVar(UINT32 typ, FLOAT32 var) {
  worker->modifyABCDVar(typ, var);
}

void TApi::modifyABCDVar(UINT32 mid, UINT32 typ, FLOAT32 var) {
  worker->modifyABCDVar(mid, typ, var);
}

void TApi::modifyABCDVar(UINT32 mid, UINT32 c, UINT32 typ, FLOAT32 var) {
  worker->modifyABCDVar(mid, c, typ, var);
}

void TApi::setAutoUpdateBanks(std::list<UINT32> banks){
  std::list<SctApi::BankType> api_banks;
  for (std::list<UINT32>::const_iterator i=banks.begin(); i!=banks.end(); ++i){ 
    api_banks.push_back(SctApi::BankType(*i));
  }
  worker->setAutoUpdateBanks(api_banks);
}

void TApi::setAutoUpdateBank(UINT32 bank){
  std::list<SctApi::BankType> api_banks;
  api_banks.push_back(SctApi::BankType(bank));
  worker->setAutoUpdateBanks(api_banks);
}

void TApi::modifyABCDVarROD(UINT32 mid, UINT32 chip, UINT32 typ, FLOAT32 var, UINT32 bank) {
  worker->modifyABCDVarROD(mid, chip, typ, var, std::list<SctApi::BankType>(1,SctApi::BankType(bank)));
}

void TApi::modifyABCDVarROD(UINT32 mid, UINT32 chip, UINT32 typ, FLOAT32 var, std::list<UINT32> banks) {
  std::list<SctApi::BankType> api_banks;
  for (std::list<UINT32>::const_iterator i=banks.begin(); i!=banks.end(); ++i){ 
    api_banks.push_back(SctApi::BankType(*i));
  }
  worker->modifyABCDVarROD(mid, chip, typ, var, api_banks);
}

void TApi::modifyABCDVarROD(UINT32 mid, UINT32 typ, FLOAT32 var, UINT32 bank) {
  worker->modifyABCDVarROD(mid, typ, var, std::list<SctApi::BankType>(1,SctApi::BankType(bank)));
}

void TApi::modifyABCDVarROD(UINT32 mid, UINT32 typ, FLOAT32 var, std::list<UINT32> banks) {
  std::list<SctApi::BankType> api_banks;
  for (std::list<UINT32>::const_iterator i=banks.begin(); i!=banks.end(); ++i){ 
    api_banks.push_back(SctApi::BankType(*i));
  }
  worker->modifyABCDVarROD(mid, typ, var, api_banks);
}

void TApi::modifyABCDVarROD(UINT32 typ, FLOAT32 var, UINT32 bank) {
  worker->modifyABCDVarROD(typ, var, std::list<SctApi::BankType>(1,SctApi::BankType(bank)));
}

void TApi::modifyABCDVarROD(UINT32 typ, FLOAT32 var, std::list<UINT32> banks) {
  std::list<SctApi::BankType> api_banks;
  for (std::list<UINT32>::const_iterator i=banks.begin(); i!=banks.end(); ++i){ 
    api_banks.push_back(SctApi::BankType(*i));
  }
  worker->modifyABCDVarROD(typ, var, api_banks);
}

void TApi::modifyBOCParam(unsigned int rod,
                            unsigned int channel, unsigned int type, unsigned int val) {
  checkCall(boost::bind(&SctApi::SctApi::modifyBOCParam, worker, 
                        rod, channel, type, val));
}

void TApi::modifyBOCParam(unsigned int type, unsigned int val) {
  checkCall(boost::bind(&SctApi::SctApi::modifyBOCParam, worker, type, val));
}

void TApi::loadConfiguration() {
  worker->loadConfiguration();
}

void TApi::loadModuleConfigurations() {
  worker->loadModuleConfigurations();
}

void TApi::configureBOC(unsigned int rod) {
  worker->configureBOC(rod);
}

UINT32 TApi::findBarrelModule(INT32 barrel, INT32 row, INT32 number) {
  return worker->findBarrelModule(barrel, row, number);
}

UINT32 TApi::findEndcapModule(INT32 disk, INT32 ring, INT32 number) {
  return worker->findEndcapModule(disk, ring, number);
}

void TApi::addDebugPrimList(unsigned long length, long index, long id, long version,
                            unsigned long * body) {
  worker->addDebugPrimList(length, index, id, version, body);
}

void TApi::sendDebugPrimList(unsigned int rod) {
  worker->sendDebugPrimList(rod);
}

void TApi::sendDebugPrimListAll() {
  worker->sendDebugPrimListAll();
}

void TApi::sendDebugSlavePrimList(unsigned int rod,
                                  unsigned int slave, bool await, bool response) {
  worker->sendDebugSlavePrimList(rod, slave, await, response);
}

void TApi::createDebugPrimList() {
  worker->createDebugPrimList();
}

void TApi::debugPrimListFromFile(const char *fileName) {
  worker->debugPrimListFromFile(fileName);
}

void TApi::dumpDebugPrimList() {
  worker->dumpDebugPrimList();
}

std::list<SctApi::RodLabel> TApi::listRods() {
  return worker->listRods();
}

/*
  Dump contents of a block of DSP memory to cout.
*/
int TApi::dspBlockDump(unsigned int rod,
                       long dspStart, long numWords, long dspNumber, bool usePrimitive){
  return worker->dspBlockDump(rod, dspStart, numWords, dspNumber, usePrimitive);
}

int TApi::dspBlockDumpFile(unsigned int rod,
                           long dspStart, long numWords, long dspNumber, const char *filename, bool usePrimitive)
{
  return worker->dspBlockDumpFile(rod, dspStart, numWords, dspNumber, filename, usePrimitive);
}

/*
  Read contents of a block of DSP memory.
*/
unsigned long *TApi::dspBlockRead(unsigned int rod,
                                  long dspStart, long numWords, long dspNumber, 
                                  unsigned long *length, bool usePrimitive) {
  unsigned long thing;
  unsigned long *result = worker->dspBlockRead(rod, dspStart, numWords, 
                                               dspNumber, thing, usePrimitive);
  *length = thing;
  return result;
}

int TApi::dspBlockWrite(unsigned int rod,
                        unsigned long *buffer, unsigned long dspAddress, long numWords, 
                        long dspNumber, bool usePrimitive) {
  return worker->dspBlockWrite(rod, 
                               buffer, dspAddress, numWords, dspNumber, usePrimitive);
}

unsigned long TApi::dspSingleRead(unsigned int rod,
                                  const unsigned long dspAddr, long dspNumber) {
  return worker->dspSingleRead(rod, dspAddr, dspNumber);
}

void TApi::dspSingleWrite(unsigned int rod,
                   unsigned long dspAddr, unsigned long value, long dspNumber) {
  worker->dspSingleWrite(rod, dspAddr, value, dspNumber);
}

void TApi::defaultScan(int type) {
  worker->defaultScan(type);
}

void TApi::tidyHistogramming() {
  worker->tidyHistogramming();
}

TScanMonitor *TApi::startAsyncScan(TScanDef tScan) {
  TScanMonitor *monitor = 0;
  tScan.update();
  boost::shared_ptr<SctApi::Scan> scan = tScan.getScan();

  try {
    if(scan)
      monitor = ScanMonitorWrapper::createMonitor(worker->startAsyncScan(scan));
    else 
      std::cout << "Bad scan at Root interface level\n";
  } catch(SctApi::SctApiException &s) {
    std::cout << "Exception thrown by startAsyncScan:\n";
    std::cout << s.what() << std::endl;
  } catch(std::exception &s) {
    std::cout << "Exception thrown by startAsyncScan:\n";
    std::cout << s.what() << std::endl;
  }

  return monitor;
}

void TApi::doScan(TScanDef tScan) {
  tScan.update();
  boost::shared_ptr<SctApi::Scan> scan = tScan.getScan();

  try {
    if(scan)
      worker->doScan(scan);
    else 
      std::cout << "Bad scan at Root interface level\n";
  } catch(SctApi::SctApiException &s) {
    std::cout << "Exception thrown by doScan:\n";
    std::cout << s.what() << std::endl;
  } catch(std::exception &s) {
    std::cout << "Exception thrown by doScan:\n";
    std::cout << s.what() << std::endl;
  }
}

void TApi::awaitScan() {
  worker->awaitScan();
}

void TApi::doRawScan(TScanDef tScan, int delay, int width, bool configure, bool clkBy2) {
  tScan.update();
  boost::shared_ptr<SctApi::Scan> scan = tScan.getScan();

  try {
    if(scan)
      worker->doRawScan(scan, delay, width, configure, clkBy2);
    else 
      std::cout << "Bad scan at Root interface level\n";
  } catch(SctApi::SctApiException &s) {
    std::cout << "SctApi Exception thrown by doRawScan:\n";
    std::cout << s.what() << std::endl;
  } catch(...) {
    std::cout << "Unknown Exception thrown by doRawScan:\n";
  }
}

unsigned long TApi::sendTriggers(TTrigger tTrig, unsigned long count) {
  tTrig.update();
  boost::shared_ptr<SctApi::Trigger> trig = tTrig.getTrigger();
  if(trig){
    return worker->sendTriggers(trig.get(), count);
  }else{ 
    std::cout << "Bad trigger at Root interface level\n";
    return 0;
  }
}

void TApi::sendRodTrigger(unsigned int rod, TTrigger tTrig, unsigned long count, int scan_point) {
  tTrig.update();

  boost::shared_ptr<SctApi::Trigger> trig = tTrig.getTrigger();

  if(trig)
    worker->sendRodTrigger(rod, trig.get(), count, scan_point);
  else 
    std::cout << "Bad trigger at Root interface level\n";
}

void TApi::status() {
  std::cout << worker->status() << std::endl;
}

unsigned long TApi::readRodCommandReg(unsigned int rod,
                                      long regNumber) {
  return worker->readRodCommandReg(rod, regNumber);
}

unsigned long TApi::readRodStatusReg(unsigned int rod,
                                     long regNumber) {
  return worker->readRodStatusReg(rod, regNumber);
}

void TApi::setABCDModule(UINT32 mid, UINT32 bank) {
  try {
    worker->setABCDModule(mid, std::list<SctApi::BankType>(1,SctApi::BankType(bank)));
  } catch(SctApi::SctApiException &s) {
    std::cout << "Exception thrown by setABCDModule:\n";
    std::cout << s.what() << std::endl;
  }
}

void TApi::setABCDModules(std::list<UINT32> banks){
  try {
    std::list<SctApi::BankType> api_banks;
    for (std::list<UINT32>::const_iterator i=banks.begin(); i!=banks.end(); ++i){ 
      api_banks.push_back(SctApi::BankType(*i));
    }
    worker->setABCDModules(api_banks);
  } catch(SctApi::SctApiException &s) {
    std::cout << "Exception thrown by setABCDModules:\n";
    std::cout << s.what() << std::endl;
  }
}

void TApi::setABCDModules(UINT32 bank) {
  try {
    worker->setABCDModules(std::list<SctApi::BankType>(1,SctApi::BankType(bank)));
  } catch(SctApi::SctApiException &s) {
    std::cout << "Exception thrown by setABCDModules:\n";
    std::cout << s.what() << std::endl;
  }
}

void TApi::copyABCDModules(UINT32 from, std::list<UINT32> to) {
  try {
    std::list<SctApi::BankType> api_banks;
    for (std::list<UINT32>::const_iterator i=to.begin(); i!=to.end(); ++i){ 
      api_banks.push_back(SctApi::BankType(*i));
    }
    worker->copyABCDModules(SctApi::BankType(from), api_banks);
  } catch(SctApi::SctApiException &s) {
    std::cout << "Exception thrown by setABCDModules:\n";
    std::cout << s.what() << std::endl;
  }
}

void TApi::copyABCDModules(UINT32 mid, UINT32 from, std::list<UINT32> to) {
  try {
    std::list<SctApi::BankType> api_banks;
    for (std::list<UINT32>::const_iterator i=to.begin(); i!=to.end(); ++i){ 
      api_banks.push_back(SctApi::BankType(*i));
    }
    worker->copyABCDModule(mid, SctApi::BankType(from), api_banks);
  } catch(SctApi::SctApiException &s) {
    std::cout << "Exception thrown by setABCDModules:\n";
    std::cout << s.what() << std::endl;
  }
}

unsigned long *TApi::retrieveModule(UINT32 mid) {
  return (unsigned long*)worker->retrieveModule(mid);
}

void TApi::printABCDModule(int mid) {
  worker->printABCDModule(mid);
}

void TApi::printABCDRodModule(int mid, int bank) {
  checkCall(boost::bind(&SctApi::SctApi::printABCDRodModule, worker, 
                        mid, SctApi::BankType(bank)));
}

void TApi::printBOCSetup(unsigned int rod) {
  checkCall(boost::bind(&SctApi::SctApi::printBOCSetup, worker, 
                        rod));
}

void TApi::currentBOCSetup(unsigned int rod) {
  try {
    std::vector<SctConfiguration::BOCChannelConfig> setup = worker->currentBOCSetup(rod);

    std::cout << "Got setup length " << setup.size() << std::endl;

    for(unsigned int i=0; i<setup.size(); i++) {
      SctConfiguration::BOCChannelConfig conf = setup[i];

      std::cout << conf.current << " " << conf.delay << " " << conf.markSpace << std::endl;
      std::cout << conf.threshold0 << " " << conf.delay0 << std::endl;
      std::cout << conf.threshold1 << " " << conf.delay1 << std::endl;
    }
  } catch(SctApi::SctApiException &s) {
    std::cout << "Exception in currentBOCSetup " << s.what() << std::endl;
  }
}

void TApi::printBOCRegisters(unsigned int rod) {
  checkCall(boost::bind(&SctApi::SctApi::printBOCRegisters, worker, rod));
}

// void TApi::currentBOCRegisters(unsigned int rod) {
//   checkCall(boost::bind(&SctApi::SctApi::currentBOCRegisters, worker, rod));
// }

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

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

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

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

void TApi::rawData(unsigned int rod, 
                   int delay, int units, bool setMask, TTrigger tTrig) {
  tTrig.update();

  boost::shared_ptr<SctApi::Trigger> trig = tTrig.getTrigger();

  if(trig)
    worker->rawData(rod, delay, units, setMask, trig.get());
  else 
    std::cout << "Bad trigger to raw data at Root interface level\n";
}

char *TApi::probe(unsigned int rod, signed int harness) {
  std::vector<char> result = worker->probe(rod, harness);
  int length = result.size();
  char *buffer = new char[length + 1];

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

  buffer[length] = 0;

  return buffer;
}

char *TApi::probeWithTrigger(unsigned int rod, 
                             TTrigger tTrig, signed int harness) {
  tTrig.update();

  boost::shared_ptr<SctApi::Trigger> trig = tTrig.getTrigger();

  if(trig) {
    std::vector<char> result = worker->probeWithTrigger(rod, trig.get(), harness);
    int length = result.size();
    char *buffer = new char[length + 1];

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

    buffer[length] = 0;

    return buffer;
  } else {
    std::cout << "Bad trigger to raw data at Root interface level\n";
    return 0;
  }
}

void TApi::probeScan(unsigned int rod, 
                     TScanDef tScan, signed int harness) {
  tScan.update();
  boost::shared_ptr<SctApi::Scan> scan = tScan.getScan();

  if(!scan) {
    std::cout << "Bad scan at Root interface level\n";
    return;
  }

  std::cout << "Summary\n";
  std::vector< std::vector <char> > result = worker->probeScan(rod, scan, harness);
  int outerLength = result.size();
  int innerLength = 0;
  if(outerLength > 0) {
    innerLength = result[0].size();
  }
  for(int i=0; i<innerLength; i++) {
    for(int j=0; j<outerLength; j++) {
      std::cout << result[j][i];
    }
    std::cout << std::endl;
  }
}

bool TApi::checkAllModulesProbe(const char *value) {
  return worker->checkAllModulesProbe(value);
}

void TApi::autoConfigure() {
  ::SctApi::AutoConf::AutoConfigurer configurer(*worker);
  configurer.run();

  std::list< ::SctApi::AutoConf::AutoResult> results = configurer.getResults();

  std::cout << results.size() << " auto-configure results:\n";

  for(std::list< ::SctApi::AutoConf::AutoResult>::const_iterator autoIter = results.begin();
      autoIter != results.end(); autoIter ++) {
    const ::SctApi::AutoConf::AutoResult &autoResult = *autoIter;

    std::cout << "r: " << autoResult.rod << " tx: " << autoResult.tx << " rx: " << autoResult.rx << std::endl;
  }
}

void TApi::rodMode(unsigned int rod,
                   int mode, int flag, int fifoSetup, int nBins, int delay, int message) {
  worker->rodMode(rod, 
                  mode, flag, fifoSetup, nBins, delay, message);
}

void TApi::bocHistogram(unsigned int rod, 
                        unsigned int samples, unsigned int numLoops)
{
  worker->bocHistogram(rod, samples, numLoops);
}

void TApi::testLinkOutSelect(unsigned int rod,
                             unsigned int link) {
  worker->testLinkOutSelect(rod, link);
}

void TApi::setDebugOption(const char *opt) {
  worker->setDebugOption(opt);
}

void TApi::unsetDebugOption(const char *opt) {
  worker->unsetDebugOption(opt);
}

void TApi::listEnabledDebugOptions() {
  std::list<std::string> theList = worker->listEnabledDebugOptions();
  for(std::list<std::string>::const_iterator i = theList.begin();
      i != theList.end();
      i++) {
    std::cout << *i << std::endl;
  }
}

void TApi::listDebugOptions() {
  std::vector<std::string> theList = worker->listDebugOptions();
  for(std::vector<std::string>::const_iterator i = theList.begin();
      i != theList.end();
      i++) {
    std::cout << *i << std::endl;
  }
}

void TApi::debugStepHistogram() 
{
  worker->debugStepHistogram();
}

void TApi::debugContinueHistogram()
{
  worker->debugContinueHistogram();
}

void TApi::debugAbortHistogram()
{
  worker->debugAbortHistogram();
}

void TApi::standardRegisterDump(unsigned int rod) 
{
  worker->standardRegisterDump(rod);
}

void TApi::lasersOff() {
  worker->lasersOff();
}

void TApi::scanEvents(unsigned int rod, int sl, 
                      bool extFlag, bool errorType) {
  worker->scanEvents(rod, sl, extFlag, errorType);
}

void TApi::decodeEvent(unsigned int rod, 
                       int sl, int index, bool extFlag, bool errorType) {
  worker->decodeEvent(rod, sl, index, extFlag, errorType);
}

void TApi::decodeConfig(unsigned int rod, 
                        bool skipTrim, bool bypass) {
  worker->decodeConfig(rod, skipTrim, bypass);
}

void TApi::timSetFrequency(
                           double trigFreq, double rstFreq) {
  worker->timSetFrequency(trigFreq, rstFreq);
}

double TApi::timGetTriggerFrequency(){
  return worker->timGetTriggerFrequency();
}

double TApi::timGetResetFrequency(){
  return worker->timGetResetFrequency();
}

void TApi::freeTriggers() {
  worker->freeTriggers();
}

void TApi::stopTriggers() {
  worker->stopTriggers();
}

void TApi::timL1A() {
  worker->timL1A();
}

void TApi::timCalL1A(int delay) {
  worker->timCalL1A(delay);
}

void TApi::timSoftReset() {
  worker->timSoftReset();
}

void TApi::timBCReset() {
  worker->timBCReset();
}

unsigned long TApi::sendTimBurst(unsigned long count, int random, bool external) {
  return checkCall(boost::bind(&SctApi::SctApi::sendTimBurst, worker, count, random, external));
}

unsigned long TApi::runTimSequence(unsigned long count, int random, bool external) {
  return checkCall(boost::bind(&SctApi::SctApi::timRunSequence, worker, count, random, external));
}

void TApi::timVerbose() {
  worker->timVerbose();
}

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

UINT16 TApi::timReadRegister(int reg) {
  return worker->timReadRegister(reg);
}

void TApi::requestHardReset(UINT32 mid) {
  worker->getSctApiDDC()->requestHardReset(mid);
}

void TApi::resumePolling() {
  worker->resumePolling();
}

void TApi::stopPolling() {
  worker->stopPolling();
}


TScanDef::TScanDef() :
  trigsPerBurst(200),
  scanVariable(1),  scanVariable2(1),
  full(0), bits32(1), loopCalLine(0),
  distSlave(1), debug(0), tim(0), nth(0), nth_rem(0),
  enableDataMode(true), ccode(0), ope(0)
{
  worker.reset(new SctApi::ScanDefImpl);
  // A large threshold scan
  configure(1, 0.0, 400.0, 5.0);

  // With a single L1A trigger
  trigSequence.singleL1A();

  // So the worker has pointers to the TriggerImpl's in the trigsequences
  update();
}

TScanDef::~TScanDef() {
//   delete worker;
}

TScanDef::TScanDef(const TScanDef &other) :
  trigsPerBurst(other.trigsPerBurst),

  scanVariable(other.scanVariable),
  scanVariable2(other.scanVariable2),

  trigSequence(other.trigSequence),
  trigSequence2(other.trigSequence2),

  full(other.full), 
  bits32(other.bits32),
  loopCalLine(other.loopCalLine),

  distSlave(other.distSlave),
  debug(other.debug),
  tim(other.tim),
  nth(other.nth),
  nth_rem(other.nth_rem),
  enableDataMode(other.enableDataMode),
  ccode(other.ccode),
  ope(other.ope)
{
  worker.reset(new SctApi::ScanDefImpl(*other.worker));
}

void TScanDef::update() {
  // Only copy the things which are defined as parameters
  // (ScanPoints are set up in worker by the configure method)
  if(trigsPerBurst != -1)
    worker->setNTrigs(trigsPerBurst);

  worker->setScanVariable1(scanVariable);
  worker->setScanVariable2(scanVariable2);

  // Copy triggers
  trigSequence.update();
  worker->setTrigger1(trigSequence.getTrigger());
  trigSequence2.update();
  worker->setTrigger2(trigSequence2.getTrigger());

  // Set options
  worker->setOption(SctApi::Scan::FULL, full);
  worker->setOption(SctApi::Scan::BITS32, bits32);
  worker->setOption(SctApi::Scan::LOOPCALLINE, loopCalLine);
  worker->setOption(SctApi::Scan::DISTSLAVE, distSlave);
  worker->setOption(SctApi::Scan::DEBUG, debug);
  worker->setOption(SctApi::Scan::TIM, tim);
  worker->setOption(SctApi::Scan::NTH, nth);
  worker->setOption(SctApi::Scan::NTH_REM, nth_rem);
  worker->setOption(SctApi::Scan::ENABLE_DATA_MODE, enableDataMode);
  worker->setOption(SctApi::Scan::USE_CCODE, ccode);
  worker->setOption(SctApi::Scan::OPE, ope);
}

void TScanDef::print() {
  update();
  std::cout << worker->print(); // copyScan(this).print();
}

void TScanDef::configure(UINT16 type, FLOAT32 start, FLOAT32 stop, FLOAT32 step) {
  scanVariable = type;
  worker->configure(type, start, stop, step);
}

void TScanDef::configure2(UINT16 type, FLOAT32 start, FLOAT32 stop, FLOAT32 step) {
  scanVariable2 = type;
  worker->configure2(type, start, stop, step);
}

void TScanDef::setScanPoint(int index, FLOAT32 value) {
  worker->scanPoints[index] = value;
}

void TScanDef::setScanPoint2(int index, FLOAT32 value) {
  worker->scanPoints2[index] = value;
}

void TScanDef::setTriggersPoint(int index, UINT32 nTrigs) {
  if(trigsPerBurst != -1) {
    worker->setNTrigs(trigsPerBurst);
  }
  trigsPerBurst = -1;
  worker->allTrigsSame = false;
  worker->trigPoints[index] = nTrigs;
}

// This is the default for both set 0 and set 1
TTrigger::TTrigger() {
  worker.reset(new SctApi::TriggerImpl);
  incCmd = 0;
  incData = 0;
  source = 0;
  frequency = 40.;
  random=0;
  update();
}

TTrigger::TTrigger(const TTrigger &other) {
  worker.reset(new SctApi::TriggerImpl(*other.worker));
  incCmd = other.incCmd;
  incData = other.incData;
  source = other.source;
  frequency = other.frequency;
  random = other.random;
}

TTrigger::~TTrigger() {
  // This is deleted by ScanDefImpl not via TScanDef
  //  delete worker;
}

void TTrigger::singleL1A() {
  worker->singleL1A();
}

void TTrigger::doubleL1A(int delay) {
  worker->doubleL1A(delay);
}

void TTrigger::delayedL1A(int delay) {
  worker->delayedL1A(delay);
}

void TTrigger::calL1A(int delay) {
  worker->calL1A(delay);
}

void TTrigger::pulseL1A(int delay) {
  worker->pulseL1A(delay);
}

void TTrigger::softL1A(int delay) {
  worker->softL1A(delay);
}

void TTrigger::print() {
  update();
  std::cout << worker->print() << std::endl;
}

void TTrigger::softCalL1A(int delay, int delay2) {
  worker->softCalL1A(delay, delay2);
}

void TTrigger::softPulseL1A(int delay, int delay2) {
  worker->softPulseL1A(delay, delay2);
}

void TTrigger::bcL1A(int delay) {
  worker->bcL1A(delay);
}

void TTrigger::bcCalL1A(int delay, int delay2) {
  worker->bcCalL1A(delay, delay2);
}

void TTrigger::bcPulseL1A(int delay, int delay2) {
  worker->bcPulseL1A(delay, delay2);
}

void TTrigger::update() {
  worker->setCommIncr(incCmd, incData);
  worker->setSource((::SctApi::Trigger::Source)source);
  worker->setFrequency(frequency);
  worker->setRandom(random);
}

TScanMonitor::TScanMonitor() {
}

TScanMonitor::~TScanMonitor() {
  //  delete worker;
}

void TScanMonitor::newBin(int prevTriggers, int newBin) {
  worker->newBin(prevTriggers, newBin);
}

void TScanMonitor::finishScan() {
  worker->finishScan();
}

boost::shared_ptr<SctApi::Trigger> TriggerWrapper::getTrigger() {
  return worker;
}

// Copy TScanDef scan to implementation of Scan interface 
//   update(); must be called on the scan first
boost::shared_ptr<SctApi::Scan> ScanDefWrapper::getScan() {
//   if((tScan.trigSequence.trigCommand.GetSize() != tScan.trigSequence.trigData.GetSize()) ||
//      (tScan.trigSequence2.trigCommand.GetSize() != tScan.trigSequence2.trigData.GetSize()) ||
//      ((tScan.trigSequence.trigCommand.GetSize() != tScan.trigSequence2.trigCommand.GetSize()) && 
//       (tScan.trigSequence2.trigData.GetSize() != 0))) {
//     cout << "Trigger arrays not compatible! Aborting scan...\n";
//     return;
//   }

  return worker;
}

/*
  "Constructor" that root doesn't have to see
 */
TScanMonitor *ScanMonitorWrapper::createMonitor(boost::shared_ptr<SctApi::ScanMonitor> monitor) {
  TScanMonitor *tMonitor = new TScanMonitor;
  tMonitor->worker = monitor;
  return tMonitor;
}

---