api.h

#ifndef PXAR_API_H
#define PXAR_API_H

#include "pxardllexport.h"

#if ((defined WIN32) && (defined __CINT__))
typedef int int32_t;
typedef short int int16_t;
typedef unsigned int uint32_t;
typedef unsigned short int uint16_t;
typedef unsigned char uint8_t;
#else
#include <stdint.h>
#endif


#include <string>
#include <vector>
#include <map>
#include "datatypes.h"
#include "exceptions.h"

// PXAR Flags

#define FLAG_FORCE_SERIAL  0x0001

#define FLAG_CALS          0x0002

#define FLAG_XTALK         0x0004

#define FLAG_RISING_EDGE   0x0008

#define FLAG_FORCE_MASKED   0x0010

#define FLAG_DISABLE_DACCAL 0x0020

#define FLAG_NOSORT 0x0040

#define FLAG_CHECK_ORDER 0x0080

#define FLAG_FORCE_UNMASKED   0x0100


#define CALL_MEMBER_FN(object,ptrToMember)  ((object).*(ptrToMember))

namespace pxar {

  class dut;

  class hal;


  typedef  std::vector<Event*> (hal::*HalMemFnRocParallel)(std::vector<uint8_t> rocids, std::vector<int32_t> parameter);
  typedef  std::vector<Event*> (hal::*HalMemFnPixelParallel)(std::vector<uint8_t> rocids, uint8_t column, uint8_t row, std::vector<int32_t> parameter);
  typedef  std::vector<Event*> (hal::*HalMemFnRocSerial)(uint8_t rocid, std::vector<int32_t> parameter);
  typedef  std::vector<Event*> (hal::*HalMemFnPixelSerial)(uint8_t rocid, uint8_t column, uint8_t row, std::vector<int32_t> parameter);



  class DLLEXPORT pxarCore {

  public:

    pxarCore(std::string usbId = "*", std::string logLevel = "WARNING");

    ~pxarCore();

    std::string getVersion();

    bool initTestboard(std::vector<std::pair<std::string,uint8_t> > sig_delays,
                       std::vector<std::pair<std::string,double> > power_settings,
                       std::vector<std::pair<std::string, uint8_t> > pg_setup);
  
    void setTestboardPower(std::vector<std::pair<std::string,double> > power_settings);

    void setTestboardDelays(std::vector<std::pair<std::string,uint8_t> > sig_delays);

    void setPatternGenerator(std::vector<std::pair<std::string, uint8_t> > pg_setup);

    bool initDUT(uint8_t hubId,
         std::string tbmtype, 
         std::vector<std::vector<std::pair<std::string,uint8_t> > > tbmDACs,
         std::string roctype,
         std::vector<std::vector<std::pair<std::string,uint8_t> > > rocDACs,
         std::vector<std::vector<pixelConfig> > rocPixels,
         std::vector<uint8_t> rocI2Cs);

    bool initDUT(uint8_t hubid,
         std::string tbmtype, 
         std::vector<std::vector<std::pair<std::string,uint8_t> > > tbmDACs,
         std::string roctype,
         std::vector<std::vector<std::pair<std::string,uint8_t> > > rocDACs,
         std::vector<std::vector<pixelConfig> > rocPixels);

    bool programDUT(); 
  

    // DTB functions

    bool flashTB(std::string filename);

    double getTBia();

    double getTBva();

    double getTBid();

    double getTBvd();

    void HVoff();

    void HVon();

    void Pon();

    void Poff();

    bool SignalProbe(std::string probe, std::string name);
    
    std::vector<uint16_t> daqADC(std::string signal, uint8_t gain, uint16_t nSample, uint8_t source, uint8_t start);
 
    // TEST functions

    bool setDAC(std::string dacName, uint8_t dacValue, uint8_t rocI2C);

    bool setDAC(std::string dacName, uint8_t dacValue);

    uint8_t getDACRange(std::string dacName);

    bool setTbmReg(std::string regName, uint8_t regValue, uint8_t tbmid);

    bool setTbmReg(std::string regName, uint8_t regValue);

    std::vector< std::pair<uint8_t, std::vector<pixel> > > getPulseheightVsDAC(std::string dacName, uint8_t dacMin, uint8_t dacMax, uint16_t flags, uint16_t nTriggers);

    std::vector< std::pair<uint8_t, std::vector<pixel> > > getPulseheightVsDAC(std::string dacName, uint8_t dacStep, uint8_t dacMin, uint8_t dacMax, uint16_t flags, uint16_t nTrigger);

    std::vector< std::pair<uint8_t, std::vector<pixel> > > getEfficiencyVsDAC(std::string dacName, uint8_t dacMin, uint8_t dacMax, uint16_t flags, uint16_t nTriggers);

    std::vector< std::pair<uint8_t, std::vector<pixel> > > getEfficiencyVsDAC(std::string dacName, uint8_t dacStep, uint8_t dacMin, uint8_t dacMax, uint16_t flags, uint16_t nTriggers);

    std::vector< std::pair<uint8_t, std::vector<pixel> > > getThresholdVsDAC(std::string dacName, std::string dac2name, uint8_t dac2min, uint8_t dac2max, uint16_t flags, uint16_t nTriggers);

    std::vector< std::pair<uint8_t, std::vector<pixel> > > getThresholdVsDAC(std::string dac1name, uint8_t dac1step, uint8_t dac1min, uint8_t dac1max, std::string dac2name, uint8_t dac2step, uint8_t dac2min, uint8_t dac2max, uint16_t flags, uint16_t nTriggers);

    std::vector< std::pair<uint8_t, std::vector<pixel> > > getThresholdVsDAC(std::string dac1name, uint8_t dac1step, uint8_t dac1min, uint8_t dac1max, std::string dac2name, uint8_t dac2step, uint8_t dac2min, uint8_t dac2max, uint8_t threshold, uint16_t flags, uint16_t nTriggers);

    std::vector< std::pair<uint8_t, std::pair<uint8_t, std::vector<pixel> > > > getPulseheightVsDACDAC(std::string dac1name, uint8_t dac1min, uint8_t dac1max, std::string dac2name, uint8_t dac2min, uint8_t dac2max, uint16_t flags, uint16_t nTriggers);

    std::vector< std::pair<uint8_t, std::pair<uint8_t, std::vector<pixel> > > > getPulseheightVsDACDAC(std::string dac1name, uint8_t dac1step, uint8_t dac1min, uint8_t dac1max, std::string dac2name, uint8_t dac2step, uint8_t dac2min, uint8_t dac2max, uint16_t flags, uint16_t nTriggers);

    std::vector< std::pair<uint8_t, std::pair<uint8_t, std::vector<pixel> > > > getEfficiencyVsDACDAC(std::string dac1name, uint8_t dac1min, uint8_t dac1max, std::string dac2name, uint8_t dac2min, uint8_t dac2max, uint16_t flags, uint16_t nTriggers);

    std::vector< std::pair<uint8_t, std::pair<uint8_t, std::vector<pixel> > > > getEfficiencyVsDACDAC(std::string dac1name, uint8_t dac1step, uint8_t dac1min, uint8_t dac1max, std::string dac2name, uint8_t dac2step, uint8_t dac2min, uint8_t dac2max, uint16_t flags, uint16_t nTriggers);

    std::vector<pixel> getPulseheightMap(uint16_t flags, uint16_t nTriggers);

    std::vector<pixel> getEfficiencyMap(uint16_t flags, uint16_t nTriggers);

    std::vector<pixel> getThresholdMap(std::string dacName, uint8_t dacStep, uint8_t dacMin, uint8_t dacMax, uint16_t flags, uint16_t nTriggers);

    std::vector<pixel> getThresholdMap(std::string dacName, uint8_t dacStep, uint8_t dacMin, uint8_t dacMax, uint8_t threshold, uint16_t flags, uint16_t nTriggers);

    std::vector<pixel> getThresholdMap(std::string dacName, uint16_t flags, uint16_t nTriggers);

    bool setExternalClock(bool enable); 

    void setClockStretch(uint8_t src, uint16_t delay, uint16_t width);

    void setSignalMode(std::string signal, uint8_t mode);


    // DAQ functions

    bool daqStart();
    bool daqStart(const int bufsize, const bool init);

    bool daqStatus();

    bool daqStatus(uint8_t & perFull);
    
    Event daqGetEvent();

    rawEvent daqGetRawEvent();

    uint16_t daqTrigger(uint32_t nTrig = 1, uint16_t period = 0);

    uint16_t daqTriggerLoop(uint16_t period = 1000);

    void daqTriggerLoopHalt();

    bool daqStop();
    bool daqStop(const bool init);

    std::vector<rawEvent> daqGetRawEventBuffer();

    std::vector<uint16_t> daqGetBuffer();

    std::vector<Event> daqGetEventBuffer();

    std::vector<std::vector<uint16_t> > daqGetReadback();

    statistics getStatistics();

    dut * _dut;

    bool status();

    uint16_t GetADC( uint8_t rpc_par1 ) ;

  private:

    hal * _hal;

    std::vector<Event*> expandLoop(HalMemFnPixelSerial pixelfn, HalMemFnPixelParallel multipixelfn, HalMemFnRocSerial rocfn, HalMemFnRocParallel multirocfn, std::vector<int32_t> param, uint16_t flags = 0);

    std::vector<Event*> condenseTriggers(std::vector<Event*> data, uint16_t nTriggers, bool efficiency);
    
    std::vector<pixel> repackMapData (std::vector<Event*> data, uint16_t nTriggers, uint16_t flags, bool efficiency);

    std::vector<pixel> repackThresholdMapData (std::vector<Event*> data, uint8_t dacStep, uint8_t dacMin, uint8_t dacMax, uint8_t thresholdlevel, uint16_t nTriggers, uint16_t flags);

    std::vector< std::pair<uint8_t, std::vector<pixel> > > repackDacScanData (std::vector<Event*> data, uint8_t dacStep, uint8_t dacMin, uint8_t dacMax, uint16_t nTriggers, uint16_t flags, bool efficiency);

    std::vector<std::pair<uint8_t,std::vector<pixel> > > repackThresholdDacScanData (std::vector<Event*> data, uint8_t dac1step, uint8_t dac1min, uint8_t dac1max, uint8_t dac2step, uint8_t dac2min, uint8_t dac2max, uint8_t thresholdlevel, uint16_t nTriggers, uint16_t flags);

    std::vector< std::pair<uint8_t, std::pair<uint8_t, std::vector<pixel> > > > repackDacDacScanData (std::vector<Event*> data, uint8_t dac1step, uint8_t dac1min, uint8_t dac1max, uint8_t dac2step, uint8_t dac2min, uint8_t dac2max, uint16_t nTriggers, uint16_t flags, bool efficiency);

    bool verifyRegister(std::string name, uint8_t &id, uint8_t &value, uint8_t type);

    uint8_t stringToDeviceCode(std::string name);

    void MaskAndTrimNIOS();

    void MaskAndTrim(bool trim);

    void MaskAndTrim(bool trim, std::vector<rocConfig>::iterator rocit);

  public:
  
    void SetCalibrateBits(bool enable);
    
   private:
   
    void verifyPatternGenerator(std::vector<std::pair<std::string,uint8_t> > &pg_setup);

    void checkTestboardPower(std::vector<std::pair<std::string,double> > power_settings);

    void checkTestboardDelays(std::vector<std::pair<std::string,uint8_t> > sig_delays);

    uint32_t getPatternGeneratorDelaySum(std::vector<std::pair<uint16_t,uint8_t> > &pg_setup);

    bool _daq_running;

    uint32_t _daq_buffersize;

    bool _daq_startstop_warning;
    
  }; // class pxarCore


  class DLLEXPORT dut {
    
    friend class pxarCore;
    
  public:

    dut() : _initialized(false), _programmed(false), roc(), tbm(), sig_delays(),
      va(0), vd(0), ia(0), id(0), pg_setup(), pg_sum(0) {}

    // GET functions to read information

    void info();

    size_t getNEnabledPixels(uint8_t rocid);

    size_t getNEnabledPixels();

    size_t getNMaskedPixels(uint8_t rocid);

    size_t getNMaskedPixels();

    size_t getNEnabledTbms();

    size_t getNTbms();

    std::string getTbmType();

    size_t getNEnabledRocs();

    size_t getNRocs();

    std::string getRocType();

    std::vector< pixelConfig > getEnabledPixels(size_t rocid);

    std::vector< pixelConfig > getEnabledPixels();

    std::vector< pixelConfig > getMaskedPixels(size_t rocid);

    std::vector< pixelConfig > getMaskedPixels();

    std::vector< rocConfig > getEnabledRocs();

    std::vector< uint8_t > getEnabledRocIDs();

    std::vector< uint8_t > getEnabledRocI2Caddr();

    std::vector< uint8_t > getRocI2Caddr();

    std::vector< tbmConfig > getEnabledTbms();

    bool getPixelEnabled(uint8_t column, uint8_t row);

    bool getAllPixelEnable();

    bool getModuleEnable();

    pixelConfig getPixelConfig(size_t rocid, uint8_t column, uint8_t row);

    uint8_t getDAC(size_t rocId, std::string dacName);

    std::vector<std::pair<std::string,uint8_t> > getDACs(size_t rocId);

    std::vector< std::pair<std::string,uint8_t> > getTbmDACs(size_t tbmId);

    void printDACs(size_t rocId);

    void setROCEnable(size_t rocId, bool enable);

    void setTBMEnable(size_t tbmId, bool enable);

    void testPixel(uint8_t column, uint8_t row, bool enable);

    void testPixel(uint8_t column, uint8_t row, bool enable, uint8_t rocid);

    void maskPixel(uint8_t column, uint8_t row, bool mask);

    void maskPixel(uint8_t column, uint8_t row, bool mask, uint8_t rocid);

    void testAllPixels(bool enable);

    void testAllPixels(bool enable, uint8_t rocid);

    void maskAllPixels(bool mask, uint8_t rocid);

    void maskAllPixels(bool mask);

    bool updateTrimBits(std::vector<pixelConfig> trimming, uint8_t rocid);

    bool updateTrimBits(uint8_t column, uint8_t row, uint8_t trim, uint8_t rocid);

    bool updateTrimBits(pixelConfig trim, uint8_t rocid);
   
    bool status();

  private:

    bool _initialized;

    bool _programmed;

    std::vector< bool > getEnabledColumns(size_t roci2c);

    uint8_t hubId;

    std::vector< rocConfig > roc;

    std::vector< tbmConfig > tbm;

    std::map<uint8_t,uint8_t> sig_delays;

    double va, vd, ia, id;

    std::vector<std::pair<uint16_t,uint8_t> > pg_setup;

    uint32_t pg_sum;

  }; //class DUT

} //namespace pxar

#endif /* PXAR_API_H */