SctApi.h

#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 <mrs/message.h>
#if USE_IS
//#include <is/isinfotmpl.h>
#include <is/infodictionary.h>
#endif

class SCTDCSCommand;
#include "log.h"

#include "SctApiConfigCache.h"
#include "Sct/Addressing.h"

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

struct scan_result_ptrs;

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

#include "SctApiFwd.h"

// includes
#include "ModuleList.h"

namespace SctApi {

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

  static const unsigned int BAD_MODULE;

  SctApi(const Idiosyncrasy &); // copies the idiosyncrasy

  SctApi(const Idiosyncrasy &, boost::shared_ptr<SctConfiguration::Configuration> newConf); // copies the idiosyncrasy

  virtual ~SctApi();

 private:
  void setup();

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

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

public:
  const Idiosyncrasy & idiosyncrasy();
  const Sct::UCID & ucid() const; // shortcut to m_id->ucid();

  const std::string getHostName() const;

  void setMrsStream(MRSStream *stream);

#if USE_IS

  void setIsDictionary();
#endif

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


  void initialiseAll(int run);

  bool isInitialised();
  

  void shutdownAll();


  void setRunNumber(UINT32 newRun);


  void setScanNumber(UINT32 newScan);


  UINT32 getRunNumber();


  UINT32 getScanNumber();


  bool isRODPresent(unsigned int rod);

  bool changeRunMode(enum RunType mode);

  bool changeEventFormat(enum EventFormatType format);


  void startupModules();

  ModuleList getModuleList();

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


  void loadConfiguration();


  void loadConfiguration(std::string filename);


  int loadModuleConfigurations();


  void storeModuleConfigurations(BankType bank);


  void storeBOCConfigurations();


  void configureBOC(unsigned int rod);


  std::vector<double> getBOCMonitorArray(unsigned int rod);


  int awaitResponse(unsigned int rod, int timeout);


  int awaitResponseAll(int timeout);


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

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

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


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


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


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


  void echoSlave(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 rod,
                   long dspStart, long numWords, long dspNumber, bool usePrim = true);


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


  void standardRegisterDump(RodLabel rl);


  void standardRegisterDump(unsigned int rod);


  void standardRegisterDumpAll();


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


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


  unsigned long dspSingleBlockRead(unsigned int rod,
                                   long dspStart, long dspNumber);


  void dspSingleBlockWrite(unsigned int rod,
                           unsigned long dspAddress, unsigned long val, long dspNumber);


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


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

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

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

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


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


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


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


  void dspSingleWrite(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 rod);


  void sendDebugPrimListAll();


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


  void debugPrimListFromFile(std::string fileName);

  void dumpDebugPrimList();

  const std::list<RodLabel> listRods() const;

  //const std::list<CrateLabel> listCrates() const;

  /**** 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 rod, 
                                                         UINT32 slot, BankType bank);
  

  virtual void setABCDModules(std::list<BankType> bank);


  virtual void setABCDModule(UINT32 mid, std::list<BankType> banks);

  virtual void copyABCDModule(UINT32 mid, BankType from, std::list<BankType> to);

  virtual void copyABCDModules(BankType from, std::list<BankType> to);


  virtual void sendAllABCDModules(BankType bank,
                                  ConfigType type = SCTAPI_CONFIG_ALL,
                                  const bool enableDataMode=true /* enableDataMode should have default value true to ensure compatibility with old code*/);


  virtual void sendABCDModule(UINT32 mid,
                              BankType bank,
                              ConfigType type = SCTAPI_CONFIG_ALL,
                              const bool enableDataMode=true /* enableDataMode should have default value true to ensure compatibility with old code*/);


  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 setAutoUpdateBanks(std::list<BankType> banks);


  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 modifyABCDVarAllModulesOneChip(UINT32 chip, UINT32 typ, FLOAT32 var);


  void modifyABCDVarROD(UINT32 mid, UINT32 chip, UINT32 typ, FLOAT32 var, std::list<BankType> banks);


  void modifyABCDVarROD(UINT32 mid, UINT32 typ, FLOAT32 var, std::list<BankType> banks);


  void modifyABCDVarROD(UINT32 type, FLOAT32 value, std::list<BankType> banks);

/*    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 modifyTIMParam(unsigned int param, unsigned int value);



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


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


  void printBOCSetup(unsigned int rod);


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


  void printBOCRegisters(unsigned int rod);


  SctConfiguration::BOCGlobalConfig currentBOCRegisters(unsigned int rod);

  void saveBOCSetup(unsigned int rod, BankType bank);

  void saveBOCRegisters(unsigned int rod, BankType bank);

  void restoreBOCSetup(unsigned int rod, BankType bank);

  void restoreBOCRegisters(unsigned int rod, BankType bank);


  void lasersOff();

  void setErrorMasks();

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


  void timSetFrequency(double trigFreq, double rstFreq);

  double timGetTriggerFrequency();

  double timGetResetFrequency();


  void freeTriggers();


  void stopTriggers();


  void timL1A();


  void timCalL1A(int delay);


  void timSoftReset();


  void timBCReset();

  void timLoadSequence(const std::vector<unsigned>& seq);
  
  unsigned long timRunSequence(unsigned long ntrigs, int random, bool external=false);
  
  unsigned long sendTimBurst(unsigned long count, int random, bool external=false);

  void timVerbose();


  void timWriteRegister(int reg, UINT16 val);


  UINT16 timReadRegister(int reg);


  std::string status();


  void defaultScan(int type);


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


  boost::shared_ptr<ScanMonitor> startAsyncScan(boost::shared_ptr<const Scan> scan);


  boost::shared_ptr<ScanControl> startScan(boost::shared_ptr<const Scan> scan, bool pollTriggers);

  void SctApi::validateScan(boost::shared_ptr<const Scan> scan);

  bool hasFinishedScanning();

  const std::string & nameOfScanStatusObject();

  void awaitScan();

  void abortScan();


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


  void sendRodTrigger(unsigned int rod, const Trigger *trig, long unsigned count, int scan_point=0);

  unsigned long sendTriggers(const Trigger* trig, unsigned long count, int scan_point=0);


  void printABCDModule(int mid);


  void printABCDRodModule(int mid, BankType bank);


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


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

  void reportEventErrors();

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


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


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


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


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

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

  bool checkAllModulesProbe(std::string value);

  void autoConfigure();

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


  /************ Direct DDC (no translations) ****************/
  SctApiDDC * getSctApiDDC() const;

  void tidyHistogramming();

  long getRodSlot(unsigned int rod);

  int getRodRevision(unsigned int rod);

  int getRodRevision(const RodLabel &label);

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

  unsigned int testLinkOutRetrieve(unsigned int rod);

  void unsetDebugOption(std::string opt);

  void setDebugOption(std::string opt);

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

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

#warning "Call this unset scan busy?"
  void unsetBusy();

  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 rod,
               int mode, int flag, int fifoSetup, int nBins, int delay, int message);

  void setupModuleMask(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 rod, int type, int dsp);

  void resumePolling();

  void stopPolling();

  void print_calib(unsigned int rod);


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

  void stopHistogramming(const ScanEx &ex);

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

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

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

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

  virtual unsigned long *readFifo(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 rod,
                    boost::shared_ptr<PrimListWrapper> prim);


  int synchSendPrimList(unsigned int rod, boost::shared_ptr<PrimListWrapper> primList, int timeout = 10);

  MRSStream *mrs;

  SctApiConfigCache& getModuleConfigCache();
#if USE_IS
  boost::shared_ptr<ISInfoDictionary> m_isDict;
#endif

  unsigned preloadModuleConfigurations();
  volatile bool m_preloadModuleConfigurationsStop;
 protected:
  virtual void really_setABCDModule(UINT32 mid, std::list<BankType> banks, UINT32 api_cfg_bits);
  
  virtual void really_getABCDModule(UINT32 mid, BankType bank);

  /********** Should these be part of the API? **************/
  


  virtual int initialiseRod(unsigned int rod);


  virtual int initialiseModule(std::string module, bool toRod=true);

  ABCDModule *lookupConfig(UINT32 mid);


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

  int getLastEventFrame(unsigned int rod, int slave);


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

  void scanPollingThread();

  void initialisationThread();

  void addRodToList(RodLabel newRod);

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

  std::list<RodLabel> rodList;

  std::map<RodLabel, RodInfo> rodInfoList;
  boost::recursive_mutex rodInfoListAccess;

  std::map<UINT32, ABCDModule> moduleMap;
 
  boost::mutex moduleMapAccess;
 
  // 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 )         *
   *************************************************************/

  unsigned int prt() const; // shortcut to ucid().partition();
  unsigned int crt() const; // shortcut to ucid().crate();
  Sct::URID localRod(const Sct::RodIdentifier rod) const; // returns the URID of the supplied rod assuming that it lies within this crate.


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

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

  

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


  void sendPrimListAll(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 rod, 
                   int delay, bool setMask);

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


  Crate *getCrate() const;

  void cacheModuleConfig(UINT32 mid, std::string name="");


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

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

  bool checkModuleListsForScan();


  void preScanModuleSetup(const Scan &scan);

  void insertISStats();

  void updateISStats();

  // AJB needed to make this public for ScanControl to use
 public:
  bool checkDebugOption(std::string opt) const;
  // This should be DebugOptions but that would mean including SctApiDebug.h here
  bool checkDebugOption(int opt) const;
 private:

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

  boost::shared_ptr<Idiosyncrasy> m_id; // NB this is shared to hide the implementaton, not because we share the ownership with anyone.  The same is true for most of the private members below:

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

  boost::shared_ptr<DCSAccess> m_dcsAccess;
  boost::shared_ptr<SctApiDDC> m_sctApiDDC;

  boost::shared_ptr<PrimListWrapper> debugPrimList;

  //std::map<std::pair<unsigned int, unsigned int>, Crate* > crateMap;
  boost::shared_ptr<Crate> crateObject;

  boost::shared_ptr<Log> m_log;
  Log & log() { return *m_log; };

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

  UINT32 scanNumber;

  UINT32 runNumber;

  RunType currentRunMode;
  
  std::list<BankType> m_autoUpdateBanks;

#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;
  bool m_inRawScanLoop;

  std::auto_ptr<boost::thread> m_initialisationThread;
  bool m_is_initialised;
  
#endif

  SctApiConfigCache module_cache;

  /* **********  Mutexes  ********** */
};
}  // End of namespace SctApi
#endif

---