---

SctApi.h

Go to the documentation of this file.

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

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

#include <boost/thread.hpp>
#include <boost/shared_ptr.hpp>

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

#include "sctddc/SCTDCSCommand.hxx"
#include "log.h"

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

#warning "Should some of these return smart pointers?"

struct scan_result_ptrs;

namespace SctConfiguration {
  class Configuration;
}

namespace SctApi {
class Crate;

class PrimListWrapper;

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 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;

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

  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 Trigger *getTrigger1() const = 0;
  virtual const Trigger *getTrigger2() const = 0;

  virtual Trigger *getTrigger1() = 0;
  virtual Trigger *getTrigger2() = 0;

  virtual void setTrigger1(Trigger *trigger) = 0;
  virtual void setTrigger2(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 short getNTrigs() const = 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;
};


class ScanEx {
 public:
  // Which ROD we're going to talk to (filled in automatically)
  int partition;
  int crate; 
  int rod;
  UINT32 channels[2];

  UINT32 dspChannels[4][2];

  int slaves;

  char bitFieldDSP;

  unsigned int diagnosticReg;

  int trimScan;

  //    *************** Unused but useful fields

  int timTrigs;
};

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

  static const unsigned int BAD_MODULE;

  SctApi();

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

  SctApi(int initDebug);

  ~SctApi();

 private:
  void setup();

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);


  void configureAllModules();

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


  void loadConfiguration();


  void loadConfiguration(std::string filename);


  void storeModuleConfigurations();


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


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


  void 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, int &length);

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


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


  void echo(unsigned int partition, unsigned int crate, unsigned int rod,
            unsigned int length, const 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);

  int dspBlockDumpFile(unsigned int partition, unsigned int crate, unsigned int rod,
                       long dspStart, long numWords, long dspNumber, string filename);

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


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


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


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


  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 buffer, 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 sendDebugSlavePrimList(unsigned int partition, unsigned int crate, unsigned int rod,
                              unsigned int slave, bool await, bool response);


  /**** Official SCTAPI bit (majority unimplemented) ******/


  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, UINT32 &disk, UINT32 &quadrant, UINT32 &number);


  void getABCDModule(UINT32 bank);


  void getABCDModule(UINT32 mid, UINT32 bank);


  void setABCDModule(UINT32 mid, UINT32 bank);


  void sendAllABCDModules(UINT32 bank, UINT32 type = 2);


  void sendABCDModule(UINT32 mid, UINT32 bank, UINT32 type=2);


  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 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 printBOCSetup(unsigned int partition, unsigned int crate, unsigned int rod);


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


  void lasersOff();

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


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


  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 status();


  void defaultScan(int type);


  void doScan(Scan &scan);

  void abortScan();


  void doRawScan(Scan &scan, int delay, bool configure = false, bool clkBy2 = false);


  void sendTriggerAll(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, int bank);


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

  // Very bad but CINT isn't happy at the moment...
  void printHex(UINT32 num, int width);


  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);


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


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

  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 ddcGetChannelParameter(int crate, int channel, std::string dpeName,
                              int& dpeValue, int timeout);

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

  void changeRunState(int state);

  void tidyHistogramming();

  void setDebugLevel(unsigned int level);

  unsigned int getDebugLevel();

  void debugStepHistogram();

  void debugContinueHistogram();

  void debugAbortHistogram();

  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);

  void sendData(unsigned int partition, unsigned int crate, unsigned int rod);
 private:
  /********** Should these be part of the API? **************/


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


  int initialiseTim(unsigned int partition, unsigned int crate);


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

  void writeSlaveBlock(unsigned int partition, unsigned int crate, unsigned int rod, int s, long sAdd, int words, long *block);

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

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

  void writeRODRegister(int reg, int off, int width, int value, boost::shared_ptr<PrimListWrapper> list);

  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);

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


  int initialiseModule(std::string module);

  /*************************************************************
   *          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 buildSlavePrimList(boost::shared_ptr<PrimListWrapper> primList, boost::shared_ptr<PrimListWrapper> prim, 
                          unsigned int slaveNumber, bool await, bool response);


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


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

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

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

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

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

  void stopHistogramming(ScanEx &ex);

  void calib_init();

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


  void pollHistogramming(ScanEx &ex, int slave, int bins, int events, int timeout = 5);

  scan_result_ptrs readHistogramData(const Scan &scan, const ScanEx &ex, UINT32 mid, int index);

  void readHistogramsToFile(const Scan &scan, const ScanEx &ex);

  void saveHistogramToFile(scan_result_ptrs histo, std::string filename);

#ifdef USE_IS

  void readHistogramsToIS(const Scan &scan, const ScanEx &ex);
#endif

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

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


  void printOutList(unsigned long *outlist, unsigned long length, bool in = false, int level = 0);


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

  ABCDModule *lookupConfig(UINT32 mid);

  void cacheModuleConfig(UINT32 mid);


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

  void initDDC();

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

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

  MRSStream *mrs;
#if USE_IS
  ISInfoDictionary *m_isDict;
#endif

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

  boost::shared_ptr<PrimListWrapper> debugPrimList;

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

  std::map<UINT32, ABCDModule> moduleMap;

  Log log;

  int debugLevel;

  Scan *lastDebugScan;
  ScanEx lastDebugScanEx;

  int responseCode;

  UINT32 scanNumber;

  UINT32 runNumber;

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

---