PixTest.hh

#ifndef PIXTEST_H
#define PIXTEST_H
 
#include "pxardllexport.h"

#ifdef __CINT__
#undef __GNUC__
typedef char __signed;
typedef char int8_t; 
#endif

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

#include <TQObject.h> 
#include <TH1.h> 
#include <TH2.h> 
#include <TProfile2D.h> 
#include <TTree.h> 
#include <TDirectory.h> 
#include <TFile.h>
#include <TSystem.h>
#include <TTimeStamp.h>

#include "api.h"
#include "log.h"

#include "PixInitFunc.hh"
#include "PixSetup.hh"
#include "PixTestParameters.hh"
#include "shist256.hh"

typedef struct { 
  uint16_t dac;
  uint16_t header; 
  uint16_t trailer; 
  uint16_t numDecoderErrors;
  uint16_t npix;
  uint8_t  proc[20000];
  uint8_t  pcol[20000];
  uint8_t  prow[20000];
  double   pval[20000];
  double   pq[20000];
} TreeEvent;


class DLLEXPORT PixTest: public TQObject {
public:
  PixTest(PixSetup *a, std::string name);
  PixTest();
  virtual ~PixTest();
  void init();
  void bookHist(std::string name);
  void bookTree();
  virtual void doAnalysis();
  virtual void doTest(); 
  virtual void fullTest(); 
  virtual void runCommand(std::string command); 
  void saveDacs(); 
  void saveTrimBits(); 
  void saveTbParameters(); 
  std::vector<std::vector<std::pair<int, int> > > deadPixels(int ntrig, bool scanCalDel = false);
  void maskPixels();     
  bool testProblem() {return fProblem;}

  virtual void setToolTips();
  virtual std::string getStopTip() {return fStopTip;}
  virtual std::string getSummaryTip() {return fSummaryTip;}
  virtual std::string getTestTip() {return fTestTip;}
  virtual std::string getHistOption(TH1*);

  int pixelThreshold(std::string dac, int ntrig, int dacmin, int dacmax);
  void dacScan(std::string dac, int ntrig, int dacmin, int dacmax, std::vector<shist256*> maps, int ihit, int flag = 0);
  void preScan(std::string dac, std::vector<shist256*> maps, int &dacmin, int &dacmax);
  void scurveAna(std::string dac, std::string name, std::vector<shist256*> maps, std::vector<TH1*> &resultMaps, int result);
  void getPhError(std::string dac, int dacmin, int dacmax, int FLAGS, int ntrig);
  std::vector<TH2D*> phMaps(std::string name, uint16_t ntrig = 10, uint16_t FLAGS = FLAG_FORCE_MASKED); 
  std::vector<TH2D*> efficiencyMaps(std::string name, uint16_t ntrig = 10, uint16_t FLAGS = FLAG_FORCE_MASKED); 
  std::vector<TH1*> scurveMaps(std::string dac, std::string name, int ntrig = 10, int daclo = 0, int dachi = 255, int dacsperstep = -1, 
                   int result = 15, int ihit = 1, int flag = FLAG_FORCE_MASKED); 
  std::vector<TH1*> thrMaps(std::string dac, std::string name, uint8_t dacmin, uint8_t dachi, int ntrig, uint16_t flag = 0);
  std::vector<TH1*> thrMaps(std::string dac, std::string name, int ntrig, uint16_t flag = 0);


  std::vector<std::pair<int,int> > checkHotPixels(TH2D* h);

  std::pair<std::vector<TH2D*>,std::vector<TH2D*> > xEfficiencyMaps(std::string name, uint16_t ntrig, 
                                    uint16_t FLAGS = FLAG_CHECK_ORDER | FLAG_FORCE_UNMASKED);

  void maskHotPixels(std::vector<TH2D*>); 
  void resetROC();
  void resetTBM();
  uint16_t prepareDaq(int triggerFreq, uint8_t trgTkDel);
  uint16_t setTriggerFrequency(int triggerFreq, uint8_t TrgTkDel);
  void finalCleanup();
  void pgToDefault();

  TH1D* bookTH1D(std::string sname, std::string title, int nbins, double xmin, double xmax); 
  TH2D* bookTH2D(std::string sname, std::string title, int nbinsx, double xmin, double xmax, int nbinsy, double ymin, double max); 
  TProfile2D* bookTProfile2D(std::string sname, std::string title, 
                int nbinsx, double xmin, double xmax, int nbinsy, double ymin, double max,
                std::string option = ""); 
  void fillDacHist(std::vector<std::pair<uint8_t, std::vector<pxar::pixel> > > &results, TH1D *h, 
           int icol = -1, int irow = -1, int iroc = -1); 

  virtual void sparseRoc(int npix = 8);

  TH1D* distribution(TH2D *, int nbins, double xmin, double xmax); 
  bool threshold(TH1 *); 
  int simpleThreshold(TH1 *); 
  std::vector<int> getMaximumVthrComp(int ntrig, double frac = 0.8, int reserve = 10);
  std::vector<int> getMinimumVthrComp(std::vector<TH1*>, int reserve = 10, double nsigma = 3.);
  double getMinimumThreshold(std::vector<TH1*>);
  double getMaximumThreshold(std::vector<TH1*>);
  std::vector<TH1*> mapsWithString(std::vector<TH1*>, std::string name);
  std::vector<TH2D*> mapsWithString(std::vector<TH2D*>, std::string name);

  void print(std::string, pxar::TLogLevel log = pxar::logINFO); 
  void banner(std::string, pxar::TLogLevel log = pxar::logINFO); 
  void bigBanner(std::string, pxar::TLogLevel log = pxar::logINFO); 
  
  void cacheDacs(bool verbose = false); 
  void restoreDacs(bool verbose = false); 

  std::vector<uint8_t> getDacs(std::string dacName); 
  void setDacs(std::string dacName, std::vector<uint8_t> dacVector); 
  std::string getDacsString(std::string dacName); 

  virtual TH1* moduleMap(std::string histname); 

  void clearHistList(); 

  std::string getName() {return fName; }
  void resetDirectory();
  TDirectory* getDirectory() {return fDirectory;}

  std::vector<std::pair<std::string, std::string> > getParameters() {return fParameters;} 
  bool getParameter(std::string parName, int &); 
  bool getParameter(std::string parName, float &); 
  std::string getParameter(std::string parName);
  virtual bool setParameter(std::string parName, std::string sval); 
  virtual void setDAC(std::string parName, uint8_t val) {fApi->setDAC(parName, val);}
  virtual void setDAC(std::string parName, uint8_t val, uint8_t rocid) {fApi->setDAC(parName, val, rocid);}
  void dumpParameters(); 
  void setTitles(TH1 *h, const char *sx, const char *sy, 
         float size = 0.05, float xoff = 1.1, float yoff = 1.1, float lsize = 0.05, int font = 42);

  void setId2Idx(std::map<int, int> a);
  int getIdFromIdx(int idx); 
  int getIdxFromId(int id); 
  bool selectedRoc(int id);
  void clearSelectedPixels();
  void addSelectedPixels(std::string sval);
  bool setTestParameter(std::string parname, std::string value);

  static std::string stripPos(std::string); 

  void testDone(); // *SIGNAL*
  void update();  // *SIGNAL*
  void hvOff();  // *SIGNAL*
  void hvOn();  // *SIGNAL*
  void powerOff();  // *SIGNAL*
  void powerOn();  // *SIGNAL*
  TH1* nextHist(); 
  TH1* previousHist(); 
  

protected: 

  int histCycle(std::string hname);   
  void fillMap(TH2D *hmod, TH2D *hroc, int iroc);  

  pxar::pxarCore       *fApi;  
  PixSetup             *fPixSetup;  
  PixTestParameters    *fTestParameters;  
  PixInitFunc          *fPIF;    

  double               fThreshold, fThresholdE, fSigma, fSigmaE;  
  double               fThresholdN; 
  int                  fNtrig; 
  std::vector<double>  fPhErrP0, fPhErrP1; 
  uint32_t             fNDaqErrors; 

  std::string           fName, fTestTip, fSummaryTip, fStopTip; 

  std::vector<std::pair<std::string, std::string> > fParameters; 

  std::vector<std::vector<std::pair<std::string,uint8_t> > >  fDacCache; 

  TDirectory            *fDirectory; 
  std::list<TH1*>       fHistList; 
  std::map<TH1*, std::string> fHistOptions; 
  std::list<TH1*>::iterator fDisplayedHist;  

  std::vector<std::pair<int, int> > fPIX; 
  std::map<int, int>    fId2Idx; 
  TTree                *fTree; 
  TreeEvent             fTreeEvent;
  TTimeStamp           *fTimeStamp; 

  bool                  fProblem;
  

  // -- data members for DAQ purposes
  std::vector<std::pair<std::string, uint8_t> > fPg_setup;
  std::vector<std::vector<std::pair<int, int> > > fHotPixels;

  ClassDef(PixTest, 1); // testing PixTest

};

#endif