SctApi.h

// File: SctApi.h
// Library interface to SCTAPI
#ifndef SCTROD_SCTAPI_H
#define SCTROD_SCTAPI_H

// Make sure all compilations have same SctApi structure!
#include "config.h"

#include <list>
#include <map>
#include <string>
#include <vector>

#include <boost/thread.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/shared_array.hpp>
#include <boost/date_time/posix_time/posix_time_types.hpp>

#include <mrs/message.h>
#if USE_IS
#include <is/isinfotmpl.h>
#endif

class SCTDCSCommand;
#include "log.h"

#include "DCSAccess.h"

// This defines ABCDModule (a typedef)
#include <CommonWithDsp/sctStructure.h>
// Unfortunately this is necessary
#include <CommonWithDsp/processor.h>

struct scan_result_ptrs;

namespace SctConfiguration {
  class Configuration;
  struct BOCChannelConfig;
  struct BOCGlobalConfig;
}

#include "SctApiFwd.h"

namespace SctApi {

class CrateException;

class SctApiException : public std::exception {
  std::string desc;
 public:
  SctApiException(const std::string &str) throw() : desc(str) {}

  SctApiException(const CrateException &c) throw();

  ~SctApiException() throw() {}

  virtual const char* what () const throw() { return desc.c_str(); }
};

class Crate;

class PrimListWrapper;

class ScanEx;

class Trigger {
 public:
  virtual ~Trigger();

  typedef std::vector<std::pair<UINT16, UINT32> > RODTriggers;

  virtual void singleL1A() = 0;
  virtual void doubleL1A(unsigned short delay) = 0;
  virtual void delayedL1A(unsigned short delay) = 0;
  virtual void calL1A(unsigned short delay) = 0;
  virtual void pulseL1A(unsigned short delay) = 0;
  virtual void softL1A(unsigned short delay) = 0;
  virtual void softCalL1A(unsigned short delay, unsigned short delay2) = 0;
  virtual void softPulseL1A(unsigned short delay, unsigned short delay2) = 0;
  virtual void bcL1A(unsigned short delay) = 0;
  virtual void bcCalL1A(unsigned short delay, unsigned short delay2) = 0;
  virtual void bcPulseL1A(unsigned short delay, unsigned short delay2) = 0;

  virtual void setCommIncr(unsigned short command, unsigned short incr) = 0;
  virtual void getCommIncr(unsigned short &command, unsigned short &incr) const = 0;

  virtual const RODTriggers getRODTriggers() const = 0; 

  virtual void print() const = 0;
};

class Scan {
 public:
  virtual ~Scan();

  typedef std::vector<FLOAT32> ScanPoints;

  typedef std::vector<UINT32> TrigPoints;

  enum ScanOptions {FULL, BITS32, LOOPCALLINE, DISTSLAVE, DEBUG, TIM};

  virtual void configure(unsigned short type, float start, float stop, float step) = 0;
  virtual void configure2(unsigned short type, float start, float stop, float step) = 0;

  virtual const boost::shared_ptr<Trigger> getTrigger1() const = 0;
  virtual const boost::shared_ptr<Trigger> getTrigger2() const = 0;

  virtual boost::shared_ptr<Trigger> getTrigger1() = 0;
  virtual boost::shared_ptr<Trigger> getTrigger2() = 0;

  virtual void setTrigger1(boost::shared_ptr<Trigger> trigger) = 0;
  virtual void setTrigger2(boost::shared_ptr<Trigger> trigger) = 0;

  virtual void setScanVariable1(unsigned short var) = 0;
  virtual void setScanVariable2(unsigned short var) = 0;

  virtual unsigned short getScanVariable1() const = 0;
  virtual unsigned short getScanVariable2() const = 0;

  virtual void setNTrigs(unsigned long nTrigs) = 0;
  virtual unsigned long getNTrigs() const = 0;

  virtual const TrigPoints getVariableTrigs() const = 0;
  virtual void setVariableTrigs(const TrigPoints &scans) = 0;
  virtual void setVariableTrigRange(unsigned short start, unsigned short end, unsigned long value) = 0;

  virtual const ScanPoints getScanPoints1() const = 0;
  virtual const ScanPoints getScanPoints2() const = 0;
  virtual void setScanPoints1(const ScanPoints &scans) = 0;
  virtual void setScanPoints2(const ScanPoints &scans) = 0;

  virtual int getOption(enum ScanOptions) const = 0;
  virtual void setOption(enum ScanOptions, int option) = 0;

  virtual void print() const = 0;

  virtual void setScanNumber(unsigned int scan) = 0;
  virtual unsigned int getScanNumber() const = 0;
  virtual void setRunNumber(unsigned int scan) = 0;
  virtual unsigned int getRunNumber() const = 0;

  virtual std::list<std::string> getModuleList(unsigned int group) const = 0;
  virtual void setModuleList(unsigned int group, std::list<std::string> newList) = 0;
  virtual unsigned int getNGroups() const = 0;
  virtual void setNGroups(unsigned int val) = 0;
  
  virtual boost::posix_time::ptime getStartTime() const = 0;
  virtual void setStartTime(boost::posix_time::ptime t) = 0;
  
  virtual boost::posix_time::ptime getEndTime() const = 0;
  virtual void setEndTime(boost::posix_time::ptime t) = 0;
};

class SctApi {
  SctApi(const SctApi &);
  SctApi &operator=(const SctApi&);
 public:

  static const unsigned int BAD_MODULE;

  SctApi();

  SctApi(boost::shared_ptr<SctConfiguration::Configuration> newConf);

  virtual ~SctApi();

 private:
  void setup();

  void dumpPrimList(boost::shared_ptr<PrimListWrapper> prim);

  void dumpRawEvent(unsigned int partition, unsigned int crate, unsigned int rod, int units, unsigned long *bufferA, unsigned long *bufferB);

public:
  void setMrsStream(MRSStream *stream);

#if USE_IS

  void setIsDictionary(ISInfoDictionary *dict);
#endif

  /***************** Global configuration functions ***********************/


  void initialiseAll(int run);


  void shutdownAll();


  void setRunNumber(UINT32 newRun);


  void setScanNumber(UINT32 newScan);


  UINT32 getRunNumber();


  UINT32 getScanNumber();


  bool isRODPresent(unsigned int partition, unsigned int crate, unsigned int rod);


  void startupModules();

  std::list<std::string> getModuleList();

  /*********************** Module configuration **********************/


  void loadConfiguration();


  void loadConfiguration(std::string filename);


  int loadModuleConfigurations();


  void storeModuleConfigurations();


  void configureBOC(unsigned int partition, unsigned int crate, unsigned int rod);


  int awaitResponse(unsigned int partition, unsigned int crate, unsigned int rod, int timeout);


  int awaitResponseAll(unsigned int partition, unsigned int crate, int timeout);


  unsigned long *getResponse(unsigned int partition, unsigned int crate, unsigned int rod, 
                             unsigned long &length);

  bool getRodMessage(unsigned int partition, unsigned int crate, unsigned int rod,
                     char *buffer, unsigned long &length);

  /*************** ROD Diagnostics ********************/


  void flashLED(unsigned int partition, unsigned int crate, unsigned int rod,
                long slaveNumber, long period = 1000, long flashes = 10);


  void echo(unsigned int partition, unsigned int crate, unsigned int rod,
            unsigned int length, const unsigned long *data);


  void echoAll(unsigned int length, const unsigned long *data);


  void echoSlave(unsigned int partition, unsigned int crate, unsigned int rod,
                 unsigned int slave, unsigned int length, const unsigned long *data);


  /***************** Direct ROD access (Debug only) ********************/
  /* Should be able to do anything with these commands */


  int dspBlockDump(unsigned int partition, unsigned int crate, unsigned int rod,
                   long dspStart, long numWords, long dspNumber, bool usePrim = true);


  int dspBlockDumpFile(unsigned int partition, unsigned int crate, unsigned int rod,
                       long dspStart, long numWords, long dspNumber, std::string filename, bool usePrim = true);


  void standardRegisterDump(RodLabel rl);


  void standardRegisterDump(unsigned int partition, unsigned int crate, unsigned int rod);


  void standardRegisterDumpAll();


  unsigned long *dspBlockRead(unsigned int partition, unsigned int crate, unsigned int rod,
                              long dspStart, long numWords, long dspNumber, unsigned long &length, bool usePrim = true);


  int dspBlockWrite(unsigned int partition, unsigned int crate, unsigned int rod,
                    unsigned long *buffer, unsigned long dspAddress, long numWords, long dspNumber, bool usePrim = true);


  unsigned long *primReadSlaveDsp(unsigned int partition, unsigned int crate, unsigned int rod,
                                  int s, int add, int words);


  void primWriteSlaveDsp(unsigned int partition, unsigned int crate, unsigned int rod,
                         int s, int add, int numWords, unsigned long *data);

  void writeSlaveFile(unsigned int partition, unsigned int crate, unsigned int rod, unsigned int slave, 
                      std::string fileName, unsigned long address, bool usePrim = true);

  void startSlave(unsigned int partition, unsigned int crate, unsigned int rod, unsigned int slave);

  boost::shared_array<unsigned long> loadFile(std::string filename, unsigned long & length);


  unsigned long readRodStatusReg(unsigned int partition, unsigned int crate, unsigned int rod,
                                 long regNumber);


  unsigned long readRodCommandReg(unsigned int partition, unsigned int crate, unsigned int rod,
                                  long regNumber);


  unsigned long dspSingleRead(unsigned int partition, unsigned int crate, unsigned int rod,
                              const unsigned long dspAddr, long dspNumber);


  void dspSingleWrite(unsigned int partition, unsigned int crate, unsigned int rod,
                      unsigned long dspAddr, unsigned long value, long dspNumber);


  ABCDModule *retrieveModule(UINT32 mid);


  void createDebugPrimList();


  void addDebugPrimList(unsigned long length, long index, long id, long version,
                        unsigned long * body);


  void sendDebugPrimList(unsigned int partition, unsigned int crate, unsigned int rod);


  void sendDebugPrimListAll();


  void sendDebugSlavePrimList(unsigned int partition, unsigned int crate, unsigned int rod,
                              unsigned int slave, bool await, bool response);


  void debugPrimListFromFile(std::string fileName);

  void dumpDebugPrimList();

  std::list<RodLabel> listRods();

  /**** Official SCTAPI bit ******/


  UINT32 findModule(std::string sn);


  std::string convertToString(UINT32 mid);


  UINT32 findModule(INT32 mur, INT32 module);


  std::pair<INT32, INT32> convertToMUR(UINT32 mid);


  UINT32 findBarrelModule(INT32 barrel, INT32 row, INT32 number);


  void convertToBarrelModule(UINT32 mid, UINT32 &barrel, UINT32 &row, int &number);


  UINT32 findEndcapModule(INT32 disk, INT32 quadrant, INT32 number);


  void convertToEndcapModule(UINT32 mid, INT32 &disk, UINT32 &quadrant, UINT32 &number);


  void getABCDModules(BankType bank);


  virtual void getABCDModule(UINT32 mid, BankType bank);


  virtual boost::shared_ptr<ABCDModule> getABCDModuleRaw(unsigned int partition, unsigned int crate, unsigned int rod, 
                                                         UINT32 slot, BankType bank);
  

  virtual void setABCDModules(BankType bank);


  virtual void setABCDModule(UINT32 mid, BankType bank);


  virtual void sendAllABCDModules(BankType bank, ConfigType type = SCTAPI_CONFIG_ALL);


  virtual void sendABCDModule(UINT32 mid, BankType bank, ConfigType type = SCTAPI_CONFIG_ALL);


  void modifyABCDMask(UINT32 mid, UINT32* mask);

/*    void modifyABCDListMask(mList* mlist, UINT32* mask); */

  void modifyABCDTrims(UINT32 mid, UINT8* trims);

/*    void modifyABCDTrims(mList* mlist, UINT8* trims); */


  void modifyABCDVar(UINT32 typ, FLOAT32 var);


  void modifyABCDVar(UINT32 mid, UINT32 typ, FLOAT32 var);

/*    void modifyABCDVar(mList* mlist, UINT32 typ, FLOAT32 var); */


  void modifyABCDVar(UINT32 mid, UINT32 chip, UINT32 typ, FLOAT32 var);


  void modifyABCDVarROD(UINT32 mid, UINT32 chip, UINT32 typ, FLOAT32 var, BankType bank);


  void modifyABCDVarROD(UINT32 mid, UINT32 typ, FLOAT32 var, BankType bank);


  void modifyABCDVarROD(UINT32 type, FLOAT32 value, BankType bank);

/*    void modifyABCDVar(mList* mlist, UINT32 chip, UINT32 typ, FLOAT32 var); */


  void modifyABCDRC(UINT32 mid, UINT32 chip, UINT16 function, FLOAT32 p0, FLOAT32 p1, FLOAT32 p2);


  void modifyBOCParam(unsigned int partition, unsigned int crate, unsigned int rod,
                      unsigned int channel, unsigned int type, unsigned int val);


  void modifyBOCParam(unsigned int type, unsigned int val);


  void printBOCSetup(unsigned int partition, unsigned int crate, unsigned int rod);


  std::vector<SctConfiguration::BOCChannelConfig> currentBOCSetup(unsigned int partition, unsigned int crate, unsigned int rod);


  void printBOCRegisters(unsigned int partition, unsigned int crate, unsigned int rod);


  SctConfiguration::BOCGlobalConfig currentBOCRegisters(unsigned int partition, unsigned int crate, unsigned int rod);

  void saveBOCSetup(unsigned int partition, unsigned int crate, unsigned int rod);

  void saveBOCRegisters(unsigned int partition, unsigned int crate, unsigned int rod);

  void restoreBOCSetup(unsigned int partition, unsigned int crate, unsigned int rod);

  void restoreBOCRegisters(unsigned int partition, unsigned int crate, unsigned int rod);


  void lasersOff();

  /* *************  TIM functs **************/


  void timSetFrequency(unsigned int partition, unsigned int crate, double trigFreq, double rstFreq);


  void freeTriggers(unsigned int partition, unsigned int crate);


  void stopTriggers(unsigned int partition, unsigned int crate);


  void timL1A(unsigned int partition, unsigned int crate);


  void timCalL1A(unsigned int partition, unsigned int crate, int delay);


  void timSoftReset(unsigned int partition, unsigned int crate);


  void timBCReset(unsigned int partition, unsigned int crate);

  void sendTimBurst(unsigned int partition, unsigned int crate, unsigned int count);

  void timVerbose(unsigned int partition, unsigned int crate);


  void timWriteRegister(unsigned int partition, unsigned int crate, int reg, UINT16 val);


  UINT16 timReadRegister(unsigned int partition, unsigned int crate, int reg);


  void status();


  void defaultScan(int type);


  void doScan(boost::shared_ptr<Scan> scan);

  void awaitScan();

  void abortScan();


  void doRawScan(boost::shared_ptr<Scan> scan, int delay, int width, 
                 bool configureModules = false, bool clkBy2 = false);


  void sendTimTrigger(unsigned int partition, unsigned int crate, const Trigger *trig);


  void sendTrigger(unsigned int partition, unsigned int crate, unsigned int rod, const Trigger *trig);


  void printABCDModule(int mid);


  void printABCDRodModule(int mid, BankType bank);


  void decodeEvent(unsigned int partition, unsigned int crate, unsigned int rod, 
                   int sl, int index, bool extFlag = false, bool errorType = false);


  void scanEvents(unsigned int partition, unsigned int crate, unsigned int rod, int sl, bool extFlag, bool errorType);

  void reportEventErrors();

  void decodeConfig(unsigned int partition, unsigned int crate, unsigned int rod, 
                    bool skipTrim = false, bool bypass = false);


  void rawData(unsigned int partition, unsigned int crate, unsigned int rod, int delay, int units, bool setMask = true, const Trigger *trig = 0);


  void sendL1A(unsigned int partition, unsigned int crate, unsigned int rod, bool capture = false);


  std::vector<char> probe(unsigned int partition, unsigned int crate, unsigned int rod, 
                          signed int harness = -1);


  std::vector<char> probeWithTrigger(unsigned int partition, unsigned int crate, unsigned int rod, 
                                     const Trigger *trigger, signed int harness = -1);

  std::vector<std::vector<char> > SctApi::probeScan(unsigned int partition, unsigned int crate, unsigned int rod, 
                                                    boost::shared_ptr<Scan> scan, signed int harness = -1);

  bool checkAllModulesProbe(std::string value);

  void autoConfigure();

  void bocHistogram(unsigned int partition, unsigned int crate, unsigned int rod, 
                    unsigned int samples, unsigned int numLoops);

  /*** DCS functionality */

  void requestHardResetAll();

  void requestHardReset(UINT32 mid);

  void requestIVCurve(UINT32 mid, FLOAT32 start, FLOAT32 stop, FLOAT32 step, UINT16 delay, FLOAT32 currentLim);

  void requestIVCurveAll(FLOAT32 start, FLOAT32 stop, FLOAT32 step, UINT16 delay, FLOAT32 currentLim);

  void setSelectAllInCrate(int crate, bool value, int timeout = 5);

  // #warning "Should this just change DCS?"
  void setSelect(UINT32 mid, bool value); 

  void changeRunState(int state);

  /************ Direct DDC (no translations) ****************/

/*   /\** Get a channel parameter from DDC *\/ */
/*   void ddcGetChannelParameter(int crate, int channel, std::string dpeName, */
/*                               int& dpeValue, int timeout); */

  void ddcChangeState (int crate, int channel, short state, int timeout = 2);
  void ddcChangeStateAll (int crate, short state, int timeout = 2);
  void ddcLoadConfiguration (int crate, short state, int timeout = 2);
  void ddcHardReset (int crate, int channel, int timeout = 2);
  void ddcHardResetAll (int crate, int timeout = 2);

  int ddcGetChannelParameterInt (int crate, int channel, std::string name, int timeout = 2);
  float ddcGetChannelParameterFloat (int crate, int channel, std::string name, int timeout = 2);
  std::string ddcGetChannelParameterString (int crate, int channel, std::string name, int timeout = 2);
  int ddcGetCardParameterInt (int crate, int card, std::string name, int timeout = 2);
  float ddcGetCardParameterFloat (int crate, int card, std::string name, int timeout = 2);
  std::string ddcGetCardParameterString (int crate, int card, std::string name, int timeout = 2);
  int ddcGetCrateParameterInt (int crate, std::string name, int timeout = 2);
  float ddcGetCrateParameterFloat (int crate, std::string name, int timeout = 2);
  std::string ddcGetCrateParameterString (int crate, std::string name, int timeout = 2);


  void ddcGetCrateParameters(int crate, std::vector<std::string> names, 
                             std::map<std::string, float>& dpeValues, int timeout);

  void ddcSetChannelParameter (int crate, int channel, std::string name, float value, int timeout = 2);
  void ddcSetCardParameter (int crate, int card, std::string name, float value, int timeout = 2);
  void ddcSetCrateParameter (int crate, std::string name, float value, int timeout = 2);



  void tidyHistogramming();

  long getRodSlot(unsigned int partition, unsigned int crate, unsigned int rod);

  int getRodRevision(unsigned int partition, unsigned int crate, unsigned int rod);

  int getRodRevision(const RodLabel &label);

  void testLinkOutSelect(unsigned int partition, unsigned int crate, unsigned int rod,
                         unsigned int link);

  unsigned int testLinkOutRetrieve(unsigned int partition, unsigned int crate, unsigned int rod);

  void unsetDebugOption(std::string opt);

  void setDebugOption(std::string opt);

  std::list<std::string> listEnabledDebugOptions();

  std::vector<std::string> listDebugOptions();

  void debugStepHistogram();

  void debugContinueHistogram();

  void debugAbortHistogram();

  void eventTrapSetup(int slaveMask, int trapMatch, int trapMod, int trapRemain, bool tim, bool error, 
                      boost::shared_ptr<PrimListWrapper> primList);

  void startEventTrap(int slave, boost::shared_ptr<PrimListWrapper> primList);

  void stopEventTrap(int slave, boost::shared_ptr<PrimListWrapper> primList);

  void rodMode(unsigned int partition, unsigned int crate, unsigned int rod,
               int mode, int flag, int fifoSetup, int nBins, int delay, int message);

  void setupModuleMask(unsigned int partition, unsigned int crate, unsigned int rod,
                       int port, int slvs);

  void setupModuleMask(int port, int slvs, boost::shared_ptr<PrimListWrapper> list);

  std::pair<UINT32, UINT32> sendData(unsigned int partition, unsigned int crate, unsigned int rod, int type, int dsp);

  void resumePolling();

  void stopPolling();

  void print_calib(unsigned int partition, unsigned int crate, unsigned int rod);


  int synchSendPrimListAllCrates(boost::shared_ptr<PrimListWrapper> primList, int timeout = 10);

  void stopHistogramming(const ScanEx &ex);

  void setSlaveBlock(unsigned int partition, unsigned int crate, unsigned int rod, 
                     int s, long sAdd, int words, long value = 0, bool usePrim = true);

  void writeRODRegister(unsigned int partition, unsigned int crate, unsigned int rod,
                        int reg, int off, int width, int value);

  unsigned int readRODRegister(unsigned int partition, unsigned int crate, unsigned int rod, int r);

  int pollRegister(unsigned int partition, unsigned int crate, unsigned int rod, int r, int off, int width, int val, int timeout = 1000000);

  virtual unsigned long *readFifo(unsigned int partition, unsigned int crate, unsigned int rod, int id, int bank, int elems);

  void startHistogramTask(const Scan &scan, const ScanEx &ex, const RodLabel, 
                          unsigned int startBin, unsigned int nBins, unsigned int nTrigs,
                          boost::shared_ptr<PrimListWrapper> list);


  void sendPrimList(unsigned int partition, unsigned int crate, unsigned int rod,
                    boost::shared_ptr<PrimListWrapper> prim);

  MRSStream *mrs;
#if USE_IS
  ISInfoDictionary *m_isDict;
#endif
 protected:
  
  /********** Should these be part of the API? **************/


  virtual int initialiseRod(unsigned int partition, unsigned int crate, unsigned int rod);


  virtual int initialiseModule(std::string module);

  ABCDModule *lookupConfig(UINT32 mid);


  virtual bool preScanHardwareCheck(Scan& scan, ScanEx& extra);
  
  virtual void doHistogramSetup(const Scan &scan, const ScanEx &extra);
  
  UINT32 *readEventBuffer(unsigned int partition, unsigned int crate, unsigned int rod, 
                        int sl, bool extFlag, bool errorType);

  int getLastEventFrame(unsigned int partition, unsigned int crate, unsigned int rod, int slave);


  virtual int pollHistogramming(boost::shared_ptr<ScanControl> controller, int timeout = 5);
 
  void scanLoop();

  void scanPollingThread();

  void addRodToList(RodLabel newRod);

  RodInfo &SctApi::getRodInfo(const RodLabel &l);

  std::list<RodLabel> rodList;

  std::map<RodLabel, RodInfo> rodInfoList;
  
  std::map<UINT32, ABCDModule> moduleMap;
  
  // Controller for current scan
  boost::shared_ptr<ScanControl> scanController;

  // Possibly to be used for continuing a scan
  boost::shared_ptr<ScanControl> lastScanController;

 private:

  /*************************************************************
   *          Internal functions (shouldn't be exported,       *
   *              probably able to keep them private )         *
   *************************************************************/


  void sendSlavePrimList(unsigned int partition, unsigned int crate, unsigned int rod,
                         boost::shared_ptr<PrimListWrapper> prim, unsigned int slave, bool await, bool response);


  void sendPrimListAll(unsigned int partition, unsigned int crate,
                       boost::shared_ptr<PrimListWrapper> prim);

  void setupEventTrapping(const Scan &scan, const ScanEx &ex, const RodLabel, boost::shared_ptr<PrimListWrapper> list);

  void startEventTrapping(const Scan &scan, const ScanEx &ex, const RodLabel, boost::shared_ptr<PrimListWrapper> primList);

  void setupEventDump(const Scan &scan, const ScanEx &ex, const RodLabel, boost::shared_ptr<PrimListWrapper> list);

  void setupHistogramming(const Scan &scan, const ScanEx &ex, const RodLabel, bool tim, 
                          boost::shared_ptr<PrimListWrapper> list);

  void calib_init();

  void readRawData(unsigned int partition, unsigned int crate, unsigned int rod, 
                   int delay, bool setMask);

  virtual int setupRawData(unsigned int partition, unsigned int crate, unsigned int rod, 
               int delay, int units, bool setMask, const Trigger *trig = 0);


  Crate *getCrate(unsigned int partition, unsigned int crate) const;

  void cacheModuleConfig(UINT32 mid);


  void getrpcrc(UINT32 mid, unsigned int &rpartition, unsigned int &rcrate, unsigned int &rrod, unsigned &rchannel);

  void initDDC();

  void setupScanMasks(ScanEx &extra, int distSlave, bool dual);

  bool checkModuleListsForScan();


  void preScanModuleSetup(Scan &scan);

  bool checkDebugOption(std::string opt);
  // This should be DebugOptions but that would mean including SctApiDebug.h here
  bool checkDebugOption(int opt);

  /*********** Internal variables *************/

  boost::shared_ptr<SctConfiguration::Configuration> config;

  IPCPartition *ddcPartition;
  std::string *ddcCtrls[2];
  SCTDCSCommand *ddcCmd;

  boost::shared_ptr<DCSAccess> dcsAccess;

  boost::shared_ptr<PrimListWrapper> debugPrimList;

  std::map<std::pair<unsigned int, unsigned int>, Crate* > crateMap;

  Log log;

  boost::shared_ptr<const Scan> lastDebugScan;
  boost::shared_ptr<const ScanEx> lastDebugScanEx;

  UINT32 scanNumber;

  UINT32 runNumber;

#if USE_SCAN_THREAD
  boost::condition scanQueue_notEmpty;
  boost::mutex scanQueue_mutex;

  /* ******* Threads ******/
  std::auto_ptr<boost::thread> scanPollThread;

  bool m_stopPolling;
  bool m_inScanLoop;
#endif

  /* **********  Mutexes  ********** */
  boost::mutex logMutex;
};
}  // End of namespace SctApi
#endif

---