version

* WIP

* WIP

* WIP

* cleaned up multi

* WIP

* WIP

* WIP

* WIP

* WIP

* WIP

* WIP

* WIP

* split up python module

* WIP

* WIP

* WIP

* WIP

* WIP

* ok

* fixed bugs from rebase

* WIP

* fixed broken test

* WIP

* fixed python

* WIP

* sphinx help

* including new commands

* docs

* WIP

* WIP

* more tests

* added missing public header

* WIP

.gitignore

@@ -9,7 +9,6 @@ bin/
 *.o
 .*
 build
-docs/
 RELEASE.txt
 Testing/
 

.gitmodules

@@ -1,3 +1,3 @@
 [submodule "python/pybind11"]
-	path = python/pybind11
+	path = libs/pybind11
 	url = https://github.com/pybind/pybind11.git

.travis.yml

@@ -46,5 +46,5 @@ deploy:
   provider: script
   script: find $HOME/miniconda/conda-bld/${TRAVIS_OS_NAME}-64 -name "*.tar.bz2" -exec anaconda -t $CONDA_TOKEN upload --force {} \;
   on:
-    branch: developer
+    branch: filip1
 

CMakeLists.txt

@@ -1,10 +1,13 @@
 cmake_minimum_required(VERSION 3.9)
 project(slsDetectorPackage)
-
 set(PROJECT_VERSION 5.0.0)
-include(cmake/project_version.cmake)
+
 include(CheckIPOSupported)
 
+
+cmake_policy(SET CMP0074 NEW)
+include(cmake/project_version.cmake)
+
 # Include additional modules that are used unconditionally
 include(GNUInstallDirs)
 
@@ -34,6 +37,7 @@ option (SLS_USE_HDF5 "HDF5 File format" OFF)
 option (SLS_USE_TEXTCLIENT "Text Client" ON)
 option (SLS_USE_RECEIVER "Receiver" ON)
 option (SLS_USE_GUI "GUI" OFF)
+option (SLS_USE_SIMULATOR "Simulator" OFF)
 option (SLS_USE_TESTS "TESTS" OFF)
 option (SLS_USE_INTEGRATION_TESTS "Integration Tests" OFF)
 option(SLS_USE_SANITIZER "Sanitizers for debugging" OFF)
@@ -87,24 +91,32 @@ elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
                                                 -Wno-misleading-indentation # mostly in rapidjson remove using clang format
                                                 -Wduplicated-cond
                                                 -Wnull-dereference )
+
     endif()
     if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 8.0)
         target_compile_options(slsProjectWarnings INTERFACE 
                                                 -Wno-class-memaccess )
+
     endif()
 endif()
 
 
 if(SLS_USE_SANITIZER)
-    target_compile_options(slsProjectOptions INTERFACE -fsanitize=address,undefined)
+    target_compile_options(slsProjectOptions INTERFACE -fsanitize=address,undefined -fno-omit-frame-pointer)
+    #target_compile_options(slsProjectOptions INTERFACE -fsanitize=address,undefined)
     target_link_libraries(slsProjectOptions INTERFACE -fsanitize=address,undefined)
     # target_compile_options(slsProjectOptions INTERFACE -fsanitize=thread)
     # target_link_libraries(slsProjectOptions INTERFACE -fsanitize=thread)
 endif()
 
+#rapidjson
+add_library(rapidjson INTERFACE)
+target_include_directories(rapidjson INTERFACE
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/libs/rapidjson>  
+)
 
 # Install fake the libraries
-install(TARGETS slsProjectOptions slsProjectWarnings
+install(TARGETS slsProjectOptions slsProjectWarnings rapidjson
     EXPORT "${TARGETS_EXPORT_NAME}"
     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
     ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
@@ -113,9 +125,11 @@ install(TARGETS slsProjectOptions slsProjectWarnings
 
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 set(CMAKE_INSTALL_RPATH "$ORIGIN")
-set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
+# set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
+set(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE)
+
+
 
-find_package(Doxygen)
 find_package(ZeroMQ 4 REQUIRED)
 
 if (SLS_USE_TESTS)
@@ -123,6 +137,9 @@ if (SLS_USE_TESTS)
     add_subdirectory(tests)
 endif(SLS_USE_TESTS)
 
+
+
+
 # Common functionallity to detector and receiver
 add_subdirectory(slsSupportLib)
 
@@ -130,6 +147,7 @@ if (SLS_USE_TEXTCLIENT)
     add_subdirectory(slsDetectorSoftware)
 endif (SLS_USE_TEXTCLIENT)
 
+
 if (SLS_USE_RECEIVER)
     if (SLS_USE_HDF5)
         find_package(HDF5 1.10 COMPONENTS CXX REQUIRED)
@@ -146,11 +164,16 @@ if (SLS_USE_GUI)
     endif()
 endif (SLS_USE_GUI)
 
+if (SLS_USE_SIMULATOR)
+    add_subdirectory(slsDetectorServers)
+endif (SLS_USE_SIMULATOR)
+
 if (SLS_USE_INTEGRATION_TESTS)
     add_subdirectory(integrationTests)
 endif (SLS_USE_INTEGRATION_TESTS)
 
 if (SLS_USE_PYTHON)
+    add_subdirectory(libs/pybind11)
     add_subdirectory(python)
 endif(SLS_USE_PYTHON)
 
@@ -159,20 +182,11 @@ configure_file( .clang-tidy
 )
 
 
-if (DOXYGEN_FOUND)
-    set(DOXYGEN_IN ${CMAKE_CURRENT_SOURCE_DIR}/doxygen/Doxyfile.in)
-    set(DOXYGEN_OUT ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile)
-    configure_file(${DOXYGEN_IN} ${DOXYGEN_OUT} @ONLY)
+add_subdirectory(sample)
+
+add_subdirectory(docs)
+
 
-    # note the option ALL which allows to build the docs together with the application
-    add_custom_target( docs
-        COMMAND ${DOXYGEN_EXECUTABLE} ${DOXYGEN_OUT}
-        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-        COMMENT "Generating API documentation with Doxygen"
-        VERBATIM )
-else (DOXYGEN_FOUND)
-  message("Doxygen need to be installed to generate the doxygen documentation")
-endif (DOXYGEN_FOUND)
 
 
 if(SLS_MASTER_PROJECT)

cmake/FindSphinx.cmake

@@ -0,0 +1,11 @@
+#Look for an executable called sphinx-build
+find_program(SPHINX_EXECUTABLE
+             NAMES sphinx-build
+             DOC "Path to sphinx-build executable")
+ 
+include(FindPackageHandleStandardArgs)
+ 
+#Handle standard arguments to find_package like REQUIRED and QUIET
+find_package_handle_standard_args(Sphinx
+                                  "Failed to find sphinx-build executable"
+                                  SPHINX_EXECUTABLE)

cmk.sh

@@ -8,6 +8,8 @@ RECEIVER=0
 GUI=0
 DEBUG=0
 PYTHON=0
+TESTS=0
+SIMULATOR=0
 
 
 CLEAN=0
@@ -16,7 +18,7 @@ CMAKE_PRE=""
 CMAKE_POST=""
 
 usage() { echo -e "
-Usage: $0 [-c] [-b] [-p] [e] [t] [r] [g] [-h] [-d <HDF5 directory>] [-j] <Number of threads>
+Usage: $0 [-c] [-b] [-p] [e] [t] [r] [g] [s] [i] [-h] [-d <HDF5 directory>] [-j] <Number of threads>
  -[no option]: only make
  -c: Clean
  -b: Builds/Rebuilds CMake files normal mode
@@ -26,8 +28,10 @@ Usage: $0 [-c] [-b] [-p] [e] [t] [r] [g] [-h] [-d <HDF5 directory>] [-j] <Number
  -t: Build/Rebuilds only text client
  -r: Build/Rebuilds only receiver
  -g: Build/Rebuilds only gui
+ -s: Simulator
  -j: Number of threads to compile through
  -e: Debug mode
+ -i: Builds tests
 
 Rebuild when you switch to a new build and compile in parallel:
 ./cmk.sh -bj5
@@ -63,7 +67,7 @@ For rebuilding only certain sections
  
  " ; exit 1; }
 
-while getopts ":bpchd:j:trges:" opt ; do
+while getopts ":bpchd:j:trgeis" opt ; do
 	case $opt in
 	b) 
 		echo "Building of CMake files Required"
@@ -110,16 +114,24 @@ while getopts ":bpchd:j:trges:" opt ; do
 		echo "Compiling Options: Debug" 
 		DEBUG=1
 		;;   
-    \?)
-     	echo "Invalid option: -$OPTARG" 
+	i)
+		echo "Compiling Options: Tests" 
+		TESTS=1
+		;;   
+	s)
+		echo "Compiling Options: Simulator" 
+		SIMULATOR=1
+		;; 
+  \?)
+    echo "Invalid option: -$OPTARG" 
 		usage
-      	exit 1
-      	;;
-    :)
-      	echo "Option -$OPTARG requires an argument."
+    exit 1
+   	;;
+  :)
+    echo "Option -$OPTARG requires an argument."
 		usage
-      	exit 1
-      	;;	
+    exit 1
+    ;;	
 	esac
 done
 
@@ -169,10 +181,24 @@ fi
 
 #Debug
 if [ $DEBUG -eq 1 ]; then
-	CMAKE_POST+=" -DCMAKE_BUILD_TYPE=Debug -DSLS_USE_SANITIZER=ON "
+	CMAKE_POST+=" -DCMAKE_BUILD_TYPE=Debug "
+# CMAKE_POST+=" -DCMAKE_BUILD_TYPE=Debug -DSLS_USE_SANITIZER=ON "
 	echo "Debug Option enabled"
 fi 
 
+#Simulator
+if [ $SIMULATOR -eq 1 ]; then
+	CMAKE_POST+=" -DCMAKE_BUILD_TYPE=Debug -DSLS_USE_SIMULATOR=ON "
+	echo "Simulator Option enabled"
+fi 
+
+
+#Tests
+if [ $TESTS -eq 1 ]; then
+	CMAKE_POST+=" -DCMAKE_BUILD_TYPE=Debug -DSLS_USE_TESTS=ON -DSLS_USE_INTEGRATION_TESTS=ON"
+	echo "Tests Option enabled"
+fi 
+
 
 #hdf5 rebuild
 if [ $HDF5 -eq 1 ]; then

conda-recepie/meta.yaml

@@ -1,7 +1,7 @@
 
 package:
   name: sls_detector_software
-  version: "developer"
+  version: "filip1"
 
 source:
   - path: ..
@@ -76,7 +76,7 @@ outputs:
       run:
         - python
         - numpy
-        - sls_detector_lib=developer
+        - sls_detector_lib=filip1
         - pyzmq
         - libstdcxx-ng
         - libgcc-ng

ctbGui/Makefile.root5

@@ -0,0 +1,44 @@
+
+
+INCS=ctbMain.h ctbDacs.h   ctbPattern.h  ctbSignals.h  ctbAdcs.h ctbAcquisition.h ctbPowers.h   ctbSlowAdcs.h 
+SRC= $(SRC:.h=.cpp) ctbDict.cpp 
+LINKDEF=ctbLinkDef.h 
+ZMQLIB=../slsReceiverSoftware/include
+LIBRARYCBF=$(CBFLIBDIR)/lib/*.o
+
+INCDIR=-I../slsReceiverSoftware/include/ -I../slsDetectorSoftware/include/ -I../slsSupportLib/include/  -I../slsDetectorCalibration -I../slsDetectorCalibration/dataStructures  -I$(CBFLIBDIR)/include  -I../slsDetectorCalibration/interpolations
+LDFLAG=-L../bin -lSlsDetector -lSlsSupport  -L/usr/lib64/ -lpthread -lm  -lstdc++  -lzmq -pthread -lrt  -ltiff -L$(ZMQLIB) -L$(CBFLIBDIR)/lib/ -std=c++11
+#
+MAIN=ctbGui.cpp
+
+DESTDIR?=../bin
+
+
+OBJS = $(SRC:.cpp=.o) $(MAIN:.cpp=.o)
+
+all: $(DESTDIR)/ctbGui
+
+
+doc:
+	cd manual && make DESTDIR=$(DESTDIR)
+
+htmldoc:
+	cd manual && make html DESTDIR=$(DESTDIR)
+
+ctbDict.cpp: $(INCS)  $(LINKDEF)
+	rootcint -f ctbDict.cpp -c $(INCS) $(LINKDEF)	
+
+%.o : %.cpp 
+	echo $@
+	g++ -DMYROOT `source root-config --cflags --glibs` -lMinuit -DCTB $(LDFLAG)  -o $@ -c $< $(INCDIR)
+#$(CXX) -o $@ -c $< $(INCLUDES) $(DFLAGS) -fPIC  $(EPICSFLAGS) -lpthread #$(FLAGS)
+
+
+
+$(DESTDIR)/ctbGui: $(OBJS) $(LINKDEF) 
+	g++ -DMYROOT `source root-config --cflags --glibs` -lMinuit -DCTB $(LDFLAG) -o ctbGui $(INCDIR) $(OBJS)  ../slsDetectorCalibration/tiffIO.cpp
+	mv ctbGui $(DESTDIR)	
+
+clean:
+	rm -f $(DESTDIR)/ctbGui *.o ctbDict.* $(OBJS)
+

ctbGui/Makefile.root6

@@ -0,0 +1,46 @@
+
+
+INCS=ctbMain.h ctbDacs.h   ctbPattern.h  ctbSignals.h  ctbAdcs.h ctbAcquisition.h ctbPowers.h   ctbSlowAdcs.h  
+SRC= $(INCS:.h=.cpp) ctbDict.cpp 
+LINKDEF=ctbLinkDef.h 
+#ctbActions.h 
+ZMQLIB=../slsReceiverSoftware/include
+LIBRARYCBF=$(CBFLIBDIR)/lib/*.o
+
+INCDIR=-I../slsReceiverSoftware/include/ -I../slsDetectorSoftware/include/ -I../slsSupportLib/include/  -I../slsDetectorCalibration -I../slsDetectorCalibration/dataStructures  -I$(CBFLIBDIR)/include  -I../slsDetectorCalibration/interpolations
+
+LDFLAG=-L../build/bin -lSlsDetector -lSlsSupport  -L/usr/lib64/ -lpthread -lm  -lstdc++  -lzmq -pthread -lrt  -ltiff -L$(ZMQLIB) -L$(CBFLIBDIR)/lib/ -std=c++11
+#
+MAIN=ctbGui.cpp
+
+DESTDIR?=../build/bin
+
+
+OBJS = $(SRC:.cpp=.o) $(MAIN:.cpp=.o)
+
+all: $(DESTDIR)/ctbGui
+
+
+doc:
+	cd manual && make DESTDIR=$(DESTDIR)
+
+htmldoc:
+	cd manual && make html DESTDIR=$(DESTDIR)
+
+ctbDict.cpp: $(INCS)  $(LINKDEF)
+	rootcling -f ctbDict.cpp -c $(INCS) $(LINKDEF)	
+
+%.o : %.cpp 
+	echo $@
+	g++ -DMYROOT `source root-config --cflags --glibs` -lMinuit -DCTB $(LDFLAG)  -o $@ -c $< $(INCDIR)
+#$(CXX) -o $@ -c $< $(INCLUDES) $(DFLAGS) -fPIC  $(EPICSFLAGS) -lpthread #$(FLAGS)
+
+
+
+$(DESTDIR)/ctbGui: $(OBJS) $(LINKDEF) 
+	g++ -DMYROOT `source root-config --cflags --glibs` -lMinuit -DCTB $(LDFLAG) -o ctbGui $(INCDIR) $(OBJS)  ../slsDetectorCalibration/tiffIO.cpp
+	mv ctbGui $(DESTDIR)	
+
+clean:
+	rm -f $(DESTDIR)/ctbGui *.o ctbDict.* $(OBJS)
+

ctbGui/ctbAcquisition.h

@@ -0,0 +1,238 @@
+#ifndef CTBACQUISITION_H
+#define CTBACQUISITION_H
+#include  <TGFrame.h>
+
+#include "ctbAdcs.h"
+#include "ctbSignals.h"
+#include "ctbPattern.h"
+class TGTextEntry;
+class TGLabel;
+class TGNumberEntry;
+class TGCheckButton;
+class TThread;
+class TGraph;
+class TMultiGraph;
+class THStack;
+class TGButtonGroup;
+class TGRadioButton;
+class TGComboBox;
+class TTimer;
+class TCanvas;
+class TH2F;
+class TH1F;
+class TGLabel;
+class TGTextButton;
+
+class multiSlsDetector;
+class detectorData;
+
+template <class dataType> class slsDetectorData;
+
+class singlePhotonDetector;
+//class singlePhotonDetector;
+class commonModeSubtraction;
+
+#include <string>
+#include <stdint.h>
+using namespace std;
+
+class ctbAcquisition : public TGGroupFrame {
+
+
+  enum {DESERIALIZER, MOENCH04, MOENCH02, ADCSAR2, MYTHEN301, MYTHEN302};
+
+
+ private:
+  TGTextEntry *eOutdir;
+  TGTextEntry *eFname;
+  TGNumberEntry *eFindex;
+  TGCheckButton *cFileSave;
+
+
+  TGNumberEntry *eSerOff;
+  TGNumberEntry *eDynRange;
+  TGNumberEntry *eNumCount;
+
+
+  TGNumberEntry *eFitADC;
+  TGNumberEntry *eBitPlot;
+  TGNumberEntry *eMinRaw;
+  TGNumberEntry *eMaxRaw;
+  TGNumberEntry *eMinPedSub;
+  TGNumberEntry *eMaxPedSub;
+  TGCheckButton *cMinMaxRaw;
+  TGCheckButton *cMinMaxPedSub;
+
+
+
+
+  TGNumberEntry *eMeasurements;
+
+
+
+  TGTextButton *bStatus;
+  // TGTextButton 
+  TGCheckButton *cCompile;
+  TGTextButton *cLoad;
+  //  TGCheckButton *cRun;
+  
+  TThread *acqThread;
+
+
+  THStack *adcStack;
+  THStack *bitStack;
+  THStack *countsStack;
+
+
+  TH1F *adcHisto[NADCS];
+  TH1F *countsHisto[NADCS];
+ 
+  TH1F *bitHisto[NSIGNALS];
+  float bitOffset[NSIGNALS];
+  
+  // int enableFlag[NADCS+4];
+  int roMode;
+
+  int dBitOffset;
+
+
+
+  TH1F *adcFit;
+  TH1F *bitPlot;
+  TH1F *countsFit;
+
+
+
+  TH2F *h2DMapAn; // for 2D detectors
+  TH2F *h2DMapDig; // for 2D detectors
+  TH1F *h1DMap; //for 1D detectors
+
+  //  TH2F *h2Scan; // for 2D detectors
+  // TMultiGraph *mgAdcs;
+  // TH1I *plotAdc[NADCS];
+
+
+  multiSlsDetector* myDet;
+  
+  int plotFlag[NADCS];
+  int bitPlotFlag[NSIGNALS];
+  
+  int ip;
+  // int nChannels;
+  // int chanEnable;
+  //int nADCs;
+
+  std::vector <int> dbitlist;
+  std::vector <int> adclist;
+
+  TGButtonGroup *bgPlot;// = new TGVButtonGroup(main_frame);
+  TGRadioButton *rbPlotOff;
+  TGRadioButton *rbWaveform;
+  TGRadioButton *rbDistribution;
+  TGRadioButton *rb2D;
+  //  TGRadioButton *rbScan;
+  TGComboBox *cbDetType;
+  TGCheckButton *cbGetPedestal;
+  TGCheckButton *cbSubtractPedestal;
+  TGCheckButton *cbCommonMode;
+  TGTextButton *bResetPedestal;
+
+  TGLabel *lClickX;
+  TGLabel *lClickY;
+  TGLabel *lClickValue;
+
+
+  TCanvas *myCanvas;
+  TTimer *plotTimer;
+
+  char patternFile[10000];
+  char patternCompiler[10000];
+  
+  int globalPlot;
+  int adcPlot;
+  int dbitPlot;
+
+  int nAnalogSamples, nDigitalSamples;
+  // int iScanStep;
+
+  slsDetectorData<uint16_t> *dataStructure;
+  singlePhotonDetector *photonFinder;
+    //singlePhotonDetector *photonFinder;
+  commonModeSubtraction *commonMode;
+  int cmSub;
+
+  int stop;
+
+  uint64_t dBitMask;
+
+  int deserializer;
+
+ public:
+   ctbAcquisition(TGVerticalFrame*,  multiSlsDetector*);
+   void setOutdir();
+   void setFname();
+   void setMeasurements();
+   void setFsave(Bool_t);
+   void changePlot(Int_t);
+   void changeDetector(Int_t);
+   void changePlot();
+   void changeDetector();
+   void setFindex();
+   void Draw();
+   void setCanvas(TCanvas*);
+
+   void toggleAcquisition();
+   void loadPattern();
+   static void* ThreadHandle(void *arg);
+   void update();
+   void acquisitionFinished();
+   //  string getParameters();
+
+   void setGraph (int i ,int en, Pixel_t col);
+   void setBitGraph (int i ,int en, Pixel_t col);
+   void startAcquisition();
+   static   void progressCallback(double,void*);
+   static void dataCallback(detectorData*, long unsigned int, unsigned int,  void*);
+   int StopFlag;
+   
+   int plotData(detectorData*, int);
+
+   void setPatternFile(const char* t);
+
+   void setPatternCompiler(const char* t);
+
+   void setAnalogSamples(int);
+   void setDigitalSamples(int);
+   
+   void setADCEnable(Int_t);
+   void setDbitEnable(Int_t);
+   void setReadoutMode(int);
+   void updateChans();
+
+   void resetPedestal();
+
+   void ToggleCommonMode(Bool_t);
+   void TogglePedSub(Bool_t);
+   void ChangeHistoLimitsPedSub(Long_t );
+   void ChangeHistoLimitsRaw(Long_t);
+   void ChangeHistoLimitsPedSub( );
+   void ChangeHistoLimitsRaw();
+   void ChangeHistoLimitsPedSub(Bool_t );
+   void ChangeHistoLimitsRaw(Bool_t);
+   
+
+   void ChangeSerialOffset();
+   void ChangeSerialOffset(Long_t);
+   void ChangeNumberOfChannels();
+   void ChangeNumberOfChannels(Long_t);
+   void ChangeDynamicRange();
+   void ChangeDynamicRange(Long_t);
+
+
+   void canvasClicked();
+   void FitADC();
+   void plotBit();
+   ClassDef(ctbAcquisition,0)
+};
+
+#endif

ctbGui/ctbAdcs.cpp

@@ -0,0 +1,731 @@
+#include <TApplication.h>
+#include <TGClient.h>
+#include <TCanvas.h>
+#include <TF1.h>
+#include <TRandom.h>
+#include <TGButton.h>
+#include <TRootEmbeddedCanvas.h>
+#include <TGButtonGroup.h>
+#include <TGNumberEntry.h>
+#include <TGLabel.h>
+#include <TList.h>
+#include <TGFileDialog.h>
+#include <TGComboBox.h>
+#include <TH2F.h>
+#include <TColor.h>
+#include <TH1F.h>
+#include <TGraphErrors.h>
+#include <TGColorSelect.h>
+#include <THStack.h>
+#include <TGTab.h>
+
+#include <stdio.h>
+#include <iostream>
+#include <fstream>
+
+#include "ctbAdcs.h"
+#include "multiSlsDetector.h"
+#include "slsDetectorCommand.h"
+
+using namespace std;
+
+
+
+ctbAdc::ctbAdc(TGVerticalFrame *page, int i, multiSlsDetector *det)
+  : TGHorizontalFrame(page, 800,800), id(i), myDet(det) {
+
+  TGHorizontalFrame *hframe=this;
+  char tit[100];
+
+   page->AddFrame(hframe,new TGLayoutHints(kLHintsTop | kLHintsExpandX , 1,1,1,1));
+   hframe->MapWindow();
+
+
+   
+
+
+   sprintf(tit, "ADC%d", id);
+
+   sAdcLabel= new TGLabel(hframe, tit);
+   hframe->AddFrame(sAdcLabel,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 1, 1, 1, 1));
+   sAdcLabel->MapWindow();
+   sAdcLabel->SetTextJustify(kTextLeft);
+
+
+
+   
+   
+
+   sAdcInvert= new TGCheckButton(hframe, "Inv");
+   hframe->AddFrame( sAdcInvert,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 1, 1, 1, 1));
+   sAdcInvert->MapWindow();
+   sAdcInvert->Connect("Toggled(Bool_t)","ctbAdc",this,"ToggledInvert(Bool_t)");
+
+
+   sAdcEnable= new TGCheckButton(hframe, "En");
+   hframe->AddFrame( sAdcEnable,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 1, 1, 1, 1));
+   sAdcEnable->MapWindow();
+   // sAdcEnable->SetOn(kTRUE);
+   // sAdcEnable->SetEnabled(kFALSE);
+   sAdcEnable->Connect("Toggled(Bool_t)","ctbAdc",this,"ToggledEnable(Bool_t)");
+
+
+
+   sAdcPlot= new TGCheckButton(hframe, "Plot");
+   hframe->AddFrame( sAdcPlot,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 1, 1, 1, 1));
+   sAdcPlot->MapWindow();
+
+
+   sAdcPlot->Connect("Toggled(Bool_t)","ctbAdc",this,"ToggledPlot(Bool_t)");
+
+
+
+   fColorSel = new TGColorSelect(hframe, id+1, 0);
+
+   fColorSel->Connect("ColorSelected(Pixel_t)","ctbAdc",this,"ColorChanged(Pixel_t)");
+   hframe->AddFrame(fColorSel, new TGLayoutHints(kLHintsTop |
+                          kLHintsLeft, 2, 0, 2, 2));
+   
+
+   fColorSel->SetColor(TColor::Number2Pixel(id+1));
+   //   sprintf(tit,"adc%d",id);
+//    gADC=new TGraph();
+//    gADC->SetName(tit);
+//    gADC->SetLineColor(id+1);
+//    gADC->SetMarkerColor(id+1);
+   
+   
+
+};
+Pixel_t ctbAdc::getColor(){
+  return fColorSel->GetColor();
+}
+Bool_t ctbAdc::getEnabled(){
+  return getPlot();
+}
+Bool_t ctbAdc::getPlot(){
+  return sAdcPlot->IsOn();
+}
+Bool_t ctbAdc::getInverted(){
+  return sAdcInvert->IsOn();
+}
+
+Bool_t ctbAdc::getEnable(){
+  return sAdcEnable->IsOn();
+}
+
+
+
+void ctbAdc::setInverted(Bool_t b){
+  //  cout << id << "set enabled " << b << endl;
+  if (b)
+    sAdcInvert->SetOn(kTRUE,kTRUE);
+  else
+    sAdcInvert->SetOn(kFALSE,kTRUE);
+    
+}
+
+
+void ctbAdc::setEnable(Bool_t b){
+  //  cout << id << "set enabled " << b << endl;
+  if (b)
+    sAdcEnable->SetOn(kTRUE,kFALSE);
+  else
+    sAdcEnable->SetOn(kFALSE,kFALSE);
+    
+}
+
+
+
+
+
+void ctbAdc::setAdcAlias(char *tit, int plot, int color) {
+  if (tit)
+    sAdcLabel->SetText(tit);
+  if (plot>0)
+    sAdcPlot->SetOn(kTRUE,kTRUE);
+  else if (plot==0)
+    sAdcPlot->SetOn(kFALSE,kTRUE);
+  if (color>=0)
+    fColorSel->SetColor(color);
+  fColorSel->SetEnabled(sAdcPlot->IsOn());
+}
+
+
+string ctbAdc::getAdcAlias() {
+
+  char line[1000];
+  sprintf(line,"ADC%d %s %d %x\n",id,sAdcLabel->GetText()->Data(),sAdcPlot->IsOn(),fColorSel->GetColor());
+  return string(line);
+}
+
+void ctbAdc::update() {
+
+  
+  //Emit("ToggledAdcEnable(Int_t)", id);
+  
+}
+
+
+void ctbAdc::ToggledPlot(Bool_t b){
+
+  //  Long_t mask=b<<id;
+  //  ToggledAdcPlot(mask);
+  cout << "Colsel " << id << " enable " << b << endl;
+  if (b)
+    fColorSel->SetEnabled(kTRUE);
+  else
+    fColorSel->SetEnabled(kFALSE);
+    
+  // fColorSel->SetEnabled(sAdcPlot->IsOn());
+  Emit("ToggledAdcPlot(Int_t)", id);
+  
+}
+
+
+
+void ctbAdc::ToggledInvert(Bool_t b){
+
+    
+  // fColorSel->SetEnabled(sAdcPlot->IsOn());
+  Emit("ToggledAdcInvert(Int_t)", id);
+  
+}
+
+
+
+void ctbAdc::ToggledEnable(Bool_t b){
+
+    
+  fColorSel->SetEnabled(sAdcPlot->IsOn());
+  Emit("ToggledAdcEnable(Int_t)", id);
+  
+}
+
+
+
+
+
+
+void ctbAdc::ColorChanged(Pixel_t) {
+  
+  Emit("ToggledAdcPlot(Int_t)", id);
+
+}
+
+void ctbAdc::ToggledAdcPlot(Int_t b){
+
+  
+  Emit("ToggledAdcPlot(Int_t)", id);
+
+}
+
+void ctbAdc::ToggledAdcInvert(Int_t b){
+
+  
+  Emit("ToggledAdcInvert(Int_t)", id);
+
+}
+
+void ctbAdc::ToggledAdcEnable(Int_t b){
+
+  
+  Emit("ToggledAdcEnable(Int_t)", id);
+
+}
+
+
+
+
+void ctbAdc::setEnabled(Bool_t b){
+  //  cout << id << "set enabled " << b << endl;
+  if (b)
+    sAdcPlot->SetOn(kTRUE,kFALSE);
+  else
+    sAdcPlot->SetOn(kFALSE,kFALSE);
+    
+}
+
+
+
+void ctbAdc::setPlot(Bool_t b){
+  //  cout << id << "set enabled " << b << endl;
+  if (b)
+    sAdcPlot->SetOn(kTRUE,kTRUE);
+  else
+    sAdcPlot->SetOn(kFALSE,kTRUE);
+    
+  
+}
+
+
+
+
+
+
+
+ctbAdcs::ctbAdcs(TGVerticalFrame *page, multiSlsDetector *det)
+  : TGGroupFrame(page,"Adcs",kVerticalFrame), myDet(det) {
+
+
+  SetTitlePos(TGGroupFrame::kLeft);
+  page->AddFrame(this,new TGLayoutHints( kLHintsTop | kLHintsExpandX , 10,10,10,10));
+  MapWindow();
+  
+  char tit[100];
+
+ 
+  TGHorizontalFrame* hframe=new TGHorizontalFrame(this, 800,800);
+  AddFrame(hframe,new TGLayoutHints(kLHintsTop | kLHintsExpandX , 1,1,1,1));
+  hframe->MapWindow();
+
+
+
+
+  int idac=0;
+
+
+
+
+ 
+  TGHorizontalFrame* hhframe=new TGHorizontalFrame(this, 800,800);
+  AddFrame(hhframe,new TGLayoutHints(kLHintsTop | kLHintsExpandX , 1,1,1,1));
+  hhframe->MapWindow();
+
+  TGVerticalFrame *vframe;
+
+
+
+
+  for (idac=0; idac<NADCS; idac++) {
+    if (idac%16==0) {
+
+
+    vframe=new TGVerticalFrame(hhframe, 400,800);
+     hhframe->AddFrame(vframe,new TGLayoutHints(kLHintsTop | kLHintsExpandX , 1,1,1,1));
+    vframe->MapWindow();
+   
+  
+
+    }
+
+    sAdc[idac]=new ctbAdc(vframe,idac,myDet);
+
+    
+    sAdc[idac]->Connect("ToggledAdcPlot(Int_t)","ctbAdcs",this,"ToggledAdcPlot(Int_t)");
+    sAdc[idac]->Connect("ToggledAdcInvert(Int_t)","ctbAdcs",this,"ToggledAdcInvert(Int_t)");
+    sAdc[idac]->Connect("ToggledAdcEnable(Int_t)","ctbAdcs",this,"ToggledAdcEnable(Int_t)");
+
+  }
+
+  hframe=new TGHorizontalFrame(this, 800,800);
+  AddFrame(hframe,new TGLayoutHints(kLHintsTop | kLHintsExpandX , 1,1,1,1));
+  hframe->MapWindow();
+
+
+    bCheckHalf[0]=new TGTextButton(hframe, "All 0-15");
+    hframe->AddFrame(bCheckHalf[0],new TGLayoutHints(kLHintsTop |  kLHintsExpandX, 5, 5, 5, 5));
+    bCheckHalf[0]->MapWindow();
+    bCheckHalf[0]->Connect("Clicked()","ctbAdcs",this,"CheckHalf0()");
+
+
+    bRemoveHalf[0]=new TGTextButton(hframe, "None 0-15");
+    hframe->AddFrame(bRemoveHalf[0],new TGLayoutHints(kLHintsBottom |  kLHintsExpandX, 5, 5, 5, 5));
+    bRemoveHalf[0]->MapWindow();
+    bRemoveHalf[0]->Connect("Clicked()","ctbAdcs",this,"RemoveHalf0()");
+
+
+    bCheckHalf[1]=new TGTextButton(hframe, "All 16-23");
+    hframe->AddFrame(bCheckHalf[1],new TGLayoutHints(kLHintsTop |  kLHintsExpandX, 5, 5, 5, 5));
+    bCheckHalf[1]->MapWindow();
+    bCheckHalf[1]->Connect("Clicked()","ctbAdcs",this,"CheckHalf1()");
+    //  bCheckAll->Connect("Clicked()","ctbAdcs",this,"CheckAll()");
+
+
+    bRemoveHalf[1]=new TGTextButton(hframe, "None 16-23");
+    hframe->AddFrame(bRemoveHalf[1],new TGLayoutHints(kLHintsBottom |  kLHintsExpandX, 5, 5, 5, 5));
+    bRemoveHalf[1]->MapWindow();
+    bRemoveHalf[1]->Connect("Clicked()","ctbAdcs",this,"RemoveHalf1()");
+    // bRemoveAll->Connect("Clicked()","ctbAdcs",this,"RemoveAll()");
+
+
+
+
+  hframe=new TGHorizontalFrame(this, 800,800);
+  AddFrame(hframe,new TGLayoutHints(kLHintsTop | kLHintsExpandX , 1,1,1,1));
+  hframe->MapWindow();
+
+
+    bCheckAll=new TGTextButton(hframe, "All");
+    hframe->AddFrame(bCheckAll,new TGLayoutHints(kLHintsTop |  kLHintsExpandX, 5, 5, 5, 5));
+    bCheckAll->MapWindow();
+    bCheckAll->Connect("Clicked()","ctbAdcs",this,"CheckAll()");
+
+
+    bRemoveAll=new TGTextButton(hframe, "None");
+    hframe->AddFrame(bRemoveAll,new TGLayoutHints(kLHintsBottom |  kLHintsExpandX, 5, 5, 5, 5));
+    bRemoveAll->MapWindow();
+    bRemoveAll->Connect("Clicked()","ctbAdcs",this,"RemoveAll()");
+
+
+
+  hframe=new TGHorizontalFrame(this, 800,50);
+ AddFrame(hframe,new TGLayoutHints(kLHintsTop | kLHintsExpandX , 1,1,1,1));
+  hframe->MapWindow();
+
+
+  TGLabel *label= new TGLabel(hframe, "Inversion mask: ");
+   hframe->AddFrame(label,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 1, 1, 1, 1));
+   label->MapWindow();
+   label->SetTextJustify(kTextLeft);
+
+
+   eInversionMask = new TGNumberEntry(hframe, 0, 16,999, TGNumberFormat::kNESHex,
+                                               TGNumberFormat::kNEANonNegative, 
+                                               TGNumberFormat::kNELNoLimits);
+
+  hframe->AddFrame(eInversionMask,new TGLayoutHints(kLHintsTop |  kLHintsExpandX, 1, 1, 1, 1));
+   eInversionMask->MapWindow();
+   eInversionMask->Resize(150,30);
+   eInversionMask->SetState(kFALSE);
+
+
+  hframe=new TGHorizontalFrame(this, 800,50);
+ AddFrame(hframe,new TGLayoutHints(kLHintsTop | kLHintsExpandX , 1,1,1,1));
+  hframe->MapWindow();
+
+
+ label= new TGLabel(hframe, "Enable mask: ");
+   hframe->AddFrame(label,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 1, 1, 1, 1));
+   label->MapWindow();
+   label->SetTextJustify(kTextLeft);
+
+
+   eEnableMask = new TGNumberEntry(hframe, 0, 16,999, TGNumberFormat::kNESHex,
+                                               TGNumberFormat::kNEANonNegative, 
+                                               TGNumberFormat::kNELNoLimits);
+
+   hframe->AddFrame(eEnableMask,new TGLayoutHints(kLHintsTop |  kLHintsExpandX, 1, 1, 1, 1));
+   eEnableMask->MapWindow();
+   eEnableMask->Resize(150,30);
+   eEnableMask->SetState(kFALSE);
+
+}
+
+
+int ctbAdcs::setEnable(int reg) {
+
+  // char aargs[10][100];
+  // char *args[10];
+  string retval;
+  int retreg;
+
+  // for (int i=0; i<10; i++) args[i]=aargs[i];
+
+  // sprintf(args[0],"adcenable");
+  // sprintf(args[1],"%x",reg);
+  // slsDetectorCommand *cmd=new slsDetectorCommand(myDet);
+  // if (reg>-1) {
+  //   retval=cmd->executeLine(1,args,slsDetectorDefs::PUT_ACTION);
+  // } 
+  if (reg>-1) {
+    try {
+    myDet->setADCEnableMask(reg);
+      } catch (...) {
+    
+      cout << "Do nothing for this error" << endl;
+  }
+   
+  }
+  // retval=cmd->executeLine(1,args,slsDetectorDefs::GET_ACTION);
+  // cout <<"enable: " << retval << endl;;
+  // delete cmd;
+
+  // sscanf(retval.c_str(),"%x",&retreg);
+  try {
+  retreg=myDet->getADCEnableMask();
+      } catch (...) {
+    
+      cout << "Do nothing for this error" << endl;
+  }
+   
+  eEnableMask->SetHexNumber(retreg);
+  
+  return retreg;
+}
+
+int ctbAdcs::setInvert(int reg) {
+  
+  // char aargs[10][100];
+  // char *args[10];
+  string retval;
+  int retreg;
+
+  // for (int i=0; i<10; i++) args[i]=aargs[i];
+
+  //sprint// f(args[0],"adcinvert");
+  // sprintf(args[1],"%x",reg);
+  // slsDetectorCommand *cmd=new slsDetectorCommand(myDet);
+    
+  if (reg>-1) {  
+    try {
+    myDet->setADCInvert(reg);
+      } catch (...) {
+    
+      cout << "Do nothing for this error" << endl;
+  }
+   
+    //retval=cmd->executeLine(1,args,slsDetectorDefs::PUT_ACTION);
+  } 
+  try {
+  retreg=myDet->getADCInvert();
+      } catch (...) {
+    
+      cout << "Do nothing for this error" << endl;
+  }
+   
+  // retval=cmd->executeLine(1,args,slsDetectorDefs::GET_ACTION);
+  // cout <<"invert: " << retval << endl;;
+  // delete cmd;
+
+  // sscanf(retval.c_str(),"%x",&retreg);
+  eInversionMask->SetHexNumber(retreg);
+  return retreg;
+}
+
+
+
+void ctbAdcs::update() {
+  Int_t invreg;//=myDet->readRegister(67);//(120);
+  Int_t disreg;//=myDet->readRegister(120);//(94);
+  // for (int i=0; i<10; i++)
+  //   args[i]=aargs[i];
+
+  // string retval;
+  // sprintf(args[0],"adcenable");
+  // slsDetectorCommand *cmd=new slsDetectorCommand(myDet);
+  // retval=cmd->executeLine(1,args,slsDetectorDefs::GET_ACTION);
+  // delete cmd;
+  // // cout << retval << endl;
+
+  // sscanf(retval.c_str(),"adcenable %x",&disreg);
+
+  // eInversionMask->SetHexNumber(invreg);
+  // eEnableMask->SetHexNumber(disreg);
+
+  disreg=setEnable();
+  invreg=setInvert();
+  
+
+  for (int is=0; is<NADCS; is++) {
+    sAdc[is]->setAdcAlias(NULL,-1,-1);
+    if (invreg & (1<<is) )
+      sAdc[is]->setInverted(kTRUE);
+    else
+      sAdc[is]->setInverted(kFALSE);
+
+    if (disreg & (1<<is) )
+      sAdc[is]->setEnable(kTRUE);
+    else
+      sAdc[is]->setEnable(kFALSE);
+      
+
+  }
+  
+   Emit("AdcEnable(Int_t)", disreg);
+
+}
+string ctbAdcs::getAdcParameters() {
+  
+  ostringstream line;
+
+  line << "reg "<< hex  << setInvert() << "# ADC invert reg" << dec << endl;
+  line << "reg "<< hex  << setEnable() << " # ADC enable reg"<< dec <<  endl;
+  // line << "reg "<< hex <<  67 << " " << myDet->readRegister(67) << "# ADC invert reg" << dec << endl;
+  // line << "reg "<< hex << 120 << " " << myDet->readRegister(120) << " # ADC enable reg"<< dec <<  endl;
+  // // line << "reg "<< hex << 94 << " " << myDet->readRegister(94) << " # ADC enable reg"<< dec <<  endl;
+  return line.str();
+
+}
+
+
+void ctbAdcs::CheckAll() {
+
+
+  for (int is=0; is<NADCS; is++){
+    sAdc[is]->setPlot(kTRUE);
+    // sAdc[is]->setEnabled(kTRUE);
+  }
+}
+
+
+void ctbAdcs::RemoveAll() {
+
+
+  for (int is=0; is<NADCS; is++) {
+    //  sAdc[is]->setEnabled(kFALSE);
+    sAdc[is]->setPlot(kFALSE);
+  }
+}
+
+
+
+void ctbAdcs::CheckHalf0() {
+
+
+  for (int is=0; is<NADCS/2; is++) {
+    sAdc[is]->setPlot(kTRUE);
+    // sAdc[is]->setEnabled(kTRUE)
+  }
+}
+
+
+void ctbAdcs::RemoveHalf0() {
+
+
+  for (int is=0; is<NADCS/2; is++){
+    //  sAdc[is]->setEnabled(kFALSE);
+    sAdc[is]->setPlot(kFALSE);
+  }
+}
+
+void ctbAdcs::CheckHalf1() {
+
+
+  for (int is=NADCS/2; is<NADCS; is++){
+    sAdc[is]->setPlot(kTRUE);
+    // sAdc[is]->setEnabled(kTRUE)
+  }
+}
+
+
+void ctbAdcs::RemoveHalf1() {
+
+
+  for (int is=NADCS/2; is<NADCS; is++){
+    //  sAdc[is]->setEnabled(kFALSE);
+    sAdc[is]->setPlot(kFALSE);
+  }
+}
+
+
+// TGraph* ctbAdcs::getGraph(int i) {
+
+//   if (i>=0 &&  i<NADCS)
+//     return sAdc[i]->getGraph();
+//   return NULL;
+// }
+
+int ctbAdcs::setAdcAlias(string line) {
+
+  int is=-1, plot=0, color=-1;
+  char tit[100];
+  int narg=sscanf(line.c_str(),"ADC%d %s %d %x",&is,tit,&plot, &color);
+  if (narg<2)
+    return -1;
+  if (narg!=3)
+    color=-1;
+  if (is>=0 && is<NADCS) {
+    sAdc[is]->setAdcAlias(tit,plot,color);
+  }
+  return is;
+
+}
+
+string ctbAdcs::getAdcAlias() {
+
+  ostringstream line;
+
+  for (int is=0; is<NADCS; is++)
+    line << sAdc[is]->getAdcAlias();
+
+  return line.str();
+}
+
+
+void ctbAdcs::ToggledAdcPlot(Int_t b){
+
+  
+  Emit("ToggledAdcPlot(Int_t)", b);
+
+}
+
+void ctbAdcs::AdcEnable(Int_t b){
+   Emit("AdcEnable(Int_t)", b);
+}
+
+
+void ctbAdcs::ToggledAdcEnable(Int_t b){
+
+
+   Int_t oreg=setEnable();//myDet->readRegister(67);
+   Int_t m=1<<b;
+  
+
+   if (sAdc[b]->getEnable())
+     oreg|=m;
+   else
+     oreg&=~m;
+  
+//   cout << dec << sizeof(Long64_t) << " " << mask << " " << hex << m << " ioreg " << oreg << endl;
+
+   setEnable(oreg);//)writeRegister(67, oreg);
+   //oreg=setEnable();//myDet->readRegister(67);
+
+  
+   Emit("AdcEnable(Int_t)", oreg);
+   //cout << "enable!" << endl;
+  //  Emit("ToggledAdcPlot(Int_t)", b);
+
+}
+
+
+void ctbAdcs::ToggledAdcInvert(Int_t b){
+
+  // char val[1000];
+   Int_t oreg=setInvert();//myDet->readRegister(67);
+   Int_t m=1<<b;
+  
+
+   if (sAdc[b]->getInverted())
+     oreg|=m;
+   else
+     oreg&=~m;
+  
+//   cout << dec << sizeof(Long64_t) << " " << mask << " " << hex << m << " ioreg " << oreg << endl;
+
+   setInvert(oreg);//)writeRegister(67, oreg);
+   // oreg=setInvert();//myDet->readRegister(67);
+
+//   cout << dec << sizeof(Long64_t) << " " << mask << " " << hex << m << " ioreg " << oreg << endl;
+
+   //sprintf(val,"%X",oreg);
+   //eInversionMask->SetHexNumber(oreg);
+}
+
+
+
+
+
+Pixel_t ctbAdcs::getColor(int i){
+  if (i>=0 && i<NADCS)
+    return sAdc[i]->getColor();
+}
+
+Bool_t ctbAdcs::getEnabled(int i){
+  if (i>=0 && i<NADCS)
+    return sAdc[i]->getEnabled();
+  
+}
+
+Bool_t ctbAdcs::getEnable(int i){
+  if (i>=0 && i<NADCS)
+    return sAdc[i]->getEnable();
+  
+}
+
+Bool_t ctbAdcs::getPlot(int i){
+  if (i>=0 && i<NADCS)
+    return sAdc[i]->getPlot();
+  
+}

ctbGui/ctbAdcs.h

@@ -0,0 +1,152 @@
+
+
+
+#ifndef CTBADCS_H
+#define CTBADCS_H
+#include  <TGFrame.h>
+
+
+#define NADCS 32
+
+class TRootEmbeddedCanvas;
+class TGButtonGroup;
+class TGVerticalFrame;
+class TGHorizontalFrame;
+class TGTextEntry;
+class TGLabel;
+class TGNumberEntry;
+class TH2F;
+class TGComboBox;
+class TGCheckButton;
+class TGColorSelect;
+class TColor;
+
+class   THStack;
+class   TGraphErrors;
+class  TGTextButton;
+class  TGTab;
+
+class TGraph;
+
+class multiSlsDetector;
+
+#include <string>
+using namespace std;
+
+class ctbAdc : public TGHorizontalFrame {
+
+
+ private:
+  
+
+   TGLabel *sAdcLabel;
+   TGCheckButton *sAdcEnable;
+   TGCheckButton *sAdcPlot;
+   TGCheckButton *sAdcInvert;
+
+   TGColorSelect  *fColorSel;
+
+   //  TGraph *gADC;
+
+   int id;
+   multiSlsDetector *myDet;
+   
+ public:
+   ctbAdc(TGVerticalFrame *page, int i, multiSlsDetector *det);
+
+
+   void setAdcAlias(char *tit, int plot, int color);
+   string getAdcAlias();
+   void ToggledAdcPlot(Int_t b);
+   void ToggledAdcEnable(Int_t b);
+   void ToggledAdcInvert(Int_t b);
+
+
+   void ToggledPlot(Bool_t b);
+   void ToggledEnable(Bool_t b);
+   void ToggledInvert(Bool_t b);
+   void ColorChanged(Pixel_t);
+   void setEnabled(Bool_t b);
+   Bool_t getEnabled();
+   // TGraph *getGraph();
+   void update();
+
+   Pixel_t getColor();
+   
+   Bool_t getEnable();
+   void setEnable(Bool_t);
+   void setPlot(Bool_t);
+   Bool_t getInverted();
+   Bool_t getPlot();
+   void setInverted(Bool_t);
+
+   ClassDef(ctbAdc,0)
+     };
+
+
+
+class ctbAdcs : public TGGroupFrame {
+private:
+  
+  ctbAdc *sAdc[NADCS];
+   multiSlsDetector *myDet;
+
+   
+  TGTextButton *bCheckAll;
+  TGTextButton *bRemoveAll;
+  TGTextButton *bCheckHalf[2];
+  TGTextButton *bRemoveHalf[2];
+  TGNumberEntry *eInversionMask;
+  TGNumberEntry *eEnableMask;
+
+
+/*   TGTextButton *bPlotSelected; */
+/*   TGNumberEntry *eMinX; */
+/*   TGNumberEntry *eMaxX; */
+/*   TGNumberEntry *eMinY; */
+/*   TGNumberEntry *eMaxY; */
+  
+  
+
+/*   TGTextButton *bGetPixel; */
+/*   TGNumberEntry *ePixelX; */
+/*   TGNumberEntry *ePixelY; */
+/*   TGLabel *lPixelValue; */
+
+public:
+
+   ctbAdcs(TGVerticalFrame *page, multiSlsDetector *det);
+   int setAdcAlias(string line);
+   string getAdcAlias();
+   string getAdcParameters();
+   void ToggledAdcPlot(Int_t);
+   void ToggledAdcInvert(Int_t);
+   void ToggledAdcEnable(Int_t);
+   void AdcEnable(Int_t b);
+   //   TGraph *getGraph(int i);
+   void CheckAll();
+   void RemoveAll();
+   void update();
+
+   int setInvert(int reg=-1);
+   int setEnable(int reg=-1);
+
+
+   Pixel_t getColor(int i);
+   Bool_t getEnabled(int i);
+   Bool_t getPlot(int i);
+   Bool_t getEnable(int i);
+
+   void CheckHalf0();
+   void RemoveHalf0();
+   
+   void CheckHalf1();
+   void RemoveHalf1();
+   
+
+   ClassDef(ctbAdcs,0)
+};
+
+#endif
+
+

ctbGui/ctbDacs.cpp

@@ -0,0 +1,251 @@
+
+#include <stdio.h>
+#include <iostream>
+#include <fstream>
+
+#include <TGTextEntry.h>
+#include <TGLabel.h>
+#include <TGNumberEntry.h>
+#include <TGButton.h>
+
+#include "ctbDacs.h"
+#include "multiSlsDetector.h"
+#include "sls_detector_defs.h"
+
+using namespace std;
+
+
+
+
+
+ctbDac::ctbDac(TGGroupFrame *page, int idac, multiSlsDetector *det) : TGHorizontalFrame(page, 800,50) , id(idac), myDet(det) {
+
+
+    TGHorizontalFrame *hframe=this;
+
+    page->AddFrame(hframe,new TGLayoutHints(kLHintsTop | kLHintsExpandX , 1,1,1,1));
+    MapWindow();
+
+    char tit[100];
+    
+
+   sprintf(tit, "DAC %d:",idac);
+
+   dacsLabel= new TGCheckButton(hframe, tit);// new TGLabel(hframe, tit);
+   dacsLabel->SetOn(kTRUE, kTRUE);
+   
+   dacsLabel->Connect("Toggled(Bool_t)","ctbDac",this,"setOn(Bool_t)");
+
+
+   hframe->AddFrame(dacsLabel,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 5, 5, 5, 5));
+   dacsLabel->MapWindow();
+   dacsLabel->SetTextJustify(kTextLeft);
+
+  
+   dacsEntry = new TGNumberEntry(hframe, 0, 9,999, TGNumberFormat::kNESInteger,
+                                               TGNumberFormat::kNEANonNegative, 
+                                               TGNumberFormat::kNELLimitMinMax,
+                                               0, 65535);
+
+  hframe->AddFrame(dacsEntry,new TGLayoutHints(kLHintsTop |  kLHintsExpandX, 5, 5, 5, 5));
+   dacsEntry->MapWindow();
+   dacsEntry->Resize(150,30);
+
+
+   dacsUnit= new TGCheckButton(hframe, "mV");
+   // if (idac!=slsDetectorDefs::ADC_VPP) {
+     hframe->AddFrame( dacsUnit,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 5, 5, 5, 5));
+     dacsUnit->MapWindow();
+     if (idac==slsDetectorDefs::ADC_VPP) {
+       dacsUnit->SetEnabled(kFALSE);
+       hframe->HideFrame(dacsUnit);
+       dacsUnit->MapWindow();
+       cout << "hiding!" << endl;
+     }
+     if (idac==slsDetectorDefs::HIGH_VOLTAGE) {
+       dacsUnit->SetText("V"); 
+       dacsUnit->SetOn(kTRUE,kTRUE);
+       dacsUnit->SetEnabled(kFALSE);
+     }
+     //}
+
+
+
+   sprintf(tit, "xxx");
+   dacsValue= new TGLabel(hframe, tit);
+   hframe->AddFrame( dacsValue,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 5, 5, 5, 5));
+   dacsValue->MapWindow();
+   dacsValue->SetTextJustify(kTextLeft);
+
+   TGTextEntry *e=dacsEntry->TGNumberEntry::GetNumberEntry();
+   e->Connect("ReturnPressed()","ctbDac",this,"setValue()");
+   // e->Connect("ValueSet(Long_t)","ctbDac",this,"setValue(Long_t)");
+   dacsEntry->Connect("ValueSet(Long_t)","ctbDac",this,"setValue(Long_t)");
+   //  cout << "(((((((((((((((((((((((((((((((" << dacsEntry->GetListOfSignals()->At(0)->IsA() << endl;
+   
+
+}
+
+
+
+int ctbDac::setLabel(char *tit, int mv) {
+  if(tit)
+    dacsLabel->SetText(tit);
+  if (mv==1)
+    dacsUnit->SetOn(kTRUE,kTRUE);
+  else if (mv==0)
+    dacsUnit->SetOn(kFALSE,kTRUE);
+  // else if (mv==2) {
+  //   ;}
+  // else if  (mv==3)
+  //   ; 
+  return id;
+
+}
+
+string ctbDac::getLabel() {
+
+  ostringstream line;
+  line << dacsLabel->GetText() << " " <<  dacsUnit->IsOn() << endl;
+
+   //  line << "DAC" << dec << id << " " <<  dacsUnit->IsOn() << endl;
+
+  return line.str();
+
+}
+
+
+void ctbDac::setValue(Long_t a) {setValue();}
+
+void ctbDac::setValue() {
+
+
+
+  cout << "setting dac! "<< id << " value " << dacsEntry->GetIntNumber() << " units " << dacsUnit->IsOn() << endl;
+  try {
+    myDet->setDAC(dacsEntry->GetIntNumber(), (slsDetectorDefs::dacIndex)id, dacsUnit->IsOn()); }  catch (...) {
+    cout << "Do nothing for this error" << endl;
+  }
+
+  getValue();
+
+}
+
+void ctbDac::setOn(Bool_t b) {
+
+
+
+  //  cout << "setting dac! "<< id << endl;
+
+  if ( dacsLabel->IsOn()) {
+    setValue();
+  } else {
+    try {
+      myDet->setDAC(-100, (slsDetectorDefs::dacIndex)id, 0); 
+    }  catch (...) {
+      cout << "Do nothing for this error" << endl;
+    }
+  }
+  getValue();
+
+}
+
+int ctbDac::getValue() { 
+  int val;
+  try {
+    val=myDet->setDAC(-1,(slsDetectorDefs::dacIndex)id, dacsUnit->IsOn()); 
+  }  catch (...) {
+    cout << "Do nothing for this error" << endl;
+  }
+  char s[100];
+  cout << "dac " << id << " " << val << endl;
+    sprintf(s,"%d",val);
+    dacsValue->SetText(s);
+  if (val>=0) {
+    dacsLabel->SetOn(kTRUE);
+  } else {
+    dacsLabel->SetOn(kFALSE);
+  }
+  
+
+  return val;
+
+}
+
+
+
+
+
+ctbDacs::ctbDacs(TGVerticalFrame *page, multiSlsDetector *det)   : TGGroupFrame(page,"DACs",kVerticalFrame) , myDet(det){
+
+
+  SetTitlePos(TGGroupFrame::kLeft);
+  page->AddFrame(this,new TGLayoutHints( kLHintsTop | kLHintsExpandX , 10,10,10,10));
+  MapWindow();
+  
+  // cout << "window mapped " << endl;
+
+  for (int idac=0; idac<NDACS; idac++) {
+
+     dacs[idac]=new ctbDac(this, idac, myDet);
+
+  }
+  dacs[NDACS]=new ctbDac(this, slsDetectorDefs::ADC_VPP, myDet);
+  dacs[NDACS+1]=new ctbDac(this, slsDetectorDefs::HIGH_VOLTAGE, myDet);
+  dacs[NDACS]->setLabel("ADC Vpp",2); 
+  dacs[NDACS+1]->setLabel("High Voltage",3); 
+
+}
+
+
+int ctbDacs::setDacAlias(string line) {
+
+  int is=-1, mv=0;
+  char tit[100];
+  int narg=sscanf(line.c_str(),"DAC%d %s %d",&is,tit,&mv);
+  if (narg<2)
+    return -1;
+  if (is>=0 && is<NDACS) 
+    dacs[is]->setLabel(tit,mv);
+  return is;
+
+}
+
+string ctbDacs::getDacAlias() {
+  ostringstream line;
+
+  for (int i=0; i<NDACS; i++)
+    line << dacs[i]->getLabel() << endl;
+  return line.str();
+
+}
+
+
+
+
+
+string ctbDacs::getDacParameters() {
+
+
+  ostringstream line;
+
+  for (int i=0; i<NDACS; i++) {
+    //line << "dacs:" << i << " " << dacs[i]->getValue << endl;
+    line << "dac:" << i << " " << dacs[i]->getValue() << endl;
+  } 
+  return line.str();
+
+
+}
+
+
+
+void  ctbDacs::update() {
+
+  for (int idac=0; idac<NDACS+1; idac++) {
+    dacs[idac]->getValue();
+  }
+
+
+
+}

ctbGui/ctbDacs.h

@@ -0,0 +1,74 @@
+
+
+#ifndef CTBDACS_H
+#define CTBDACS_H
+#include  <TGFrame.h>
+
+
+#define NDACS 18
+//#define NDACS 16
+
+
+class TGTextEntry;
+class TGLabel;
+class TGNumberEntry;
+class TGCheckButton;
+
+
+class multiSlsDetector;
+
+#include <string>
+using namespace std;
+
+
+class ctbDac : public TGHorizontalFrame {
+
+
+ protected:
+  // TGLabel *dacsLabel;
+   TGNumberEntry *dacsEntry;
+   TGCheckButton *dacsUnit;
+   TGCheckButton *dacsLabel;
+   TGLabel *dacsValue;
+   int id;
+
+   multiSlsDetector* myDet;
+ public:
+   ctbDac(TGGroupFrame*, int , multiSlsDetector*);
+   void setValue();
+   void setValue(Long_t);
+   int getValue();
+   void setOn(Bool_t);
+   
+   int setLabel(char *tit, int mv);
+   string getLabel();
+
+
+
+   ClassDef(ctbDac,0)
+};
+
+class ctbDacs : public TGGroupFrame {
+private:
+  
+
+
+   ctbDac *dacs[NDACS+2];
+
+   multiSlsDetector* myDet;
+
+public:
+   ctbDacs(TGVerticalFrame *page, multiSlsDetector*);
+
+   int setDacAlias(string line);
+   // int setDacAlias(string line);
+   string getDacAlias();
+   string getDacParameters();
+
+   void update();
+
+   ClassDef(ctbDacs,0)
+};
+
+#endif
+

ctbGui/ctbGui.cpp

@@ -0,0 +1,161 @@
+#include <TApplication.h>
+#include <TColor.h>
+
+#include <TStyle.h>
+#include <TROOT.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <iostream>
+#include <fstream>
+#include <string>
+
+
+#include "multiSlsDetector.h"
+#include "sls_detector_defs.h"
+//#include "sls_receiver_defs.h"
+#include "ctbMain.h"
+using namespace std;
+
+
+int main(int argc, char **argv) {
+
+
+  string afname, cfname, pfname;
+  int id=0;
+
+  int af=0, cf=0, pf=0;
+
+
+  cout << " *** " << argc << endl;
+  for (int ia=0; ia<argc; ia++) {
+    if (strcmp(argv[ia],"-alias")==0) {
+      if (ia+1<argc) {
+	afname=argv[ia+1];
+	ia++;
+	af=1;
+      }
+
+    } else if  (strcmp(argv[ia],"-config")==0) {
+      if (ia+1<argc) {
+	cfname=argv[ia+1];
+	ia++;
+	cf=1;
+      }
+
+
+    } else if  (strcmp(argv[ia],"-par")==0) {
+      if (ia+1<argc) {
+	pfname=argv[ia+1];
+	ia++;
+	pf=1;
+      }
+
+
+    } else if  (strcmp(argv[ia],"-id")==0) {
+      if (ia+1<argc) {
+	id=atoi(argv[ia+1]);
+	ia++;
+      }
+    } 
+  }
+  
+
+  cout << " *** "  << endl;
+  
+  /****** Create detector ****************/
+  multiSlsDetector *myDet=new multiSlsDetector(id);
+  // myDet->setOnline(slsDetectorDefs::ONLINE_FLAG);
+
+  //cout << id << " " << myDet << " " << myDet->setOnline() << endl;
+  if (cf) {
+    myDet->readConfigurationFile(cfname);
+  } else
+    cout << "No config file specified" << endl;
+
+  cout << "aa" << endl;
+
+    cout << "Created multi detector id " << id << " hostname " << myDet->getHostname() << endl;
+
+  
+  cout << "bb" << endl;
+  if (pf) {
+    myDet->retrieveDetectorSetup(pfname);
+  } else
+    cout << "No parameter file specified" << endl;
+  
+
+
+
+
+  /***********Create GUI stuff *******************/
+   TApplication theApp("App",&argc,argv);
+
+
+ gStyle->SetDrawBorder(0);
+  gStyle->SetCanvasColor(kWhite);
+  gStyle->SetCanvasDefH(800);
+  gStyle->SetCanvasDefW(800);
+  gStyle->SetCanvasBorderMode(0);
+  gStyle->SetPadBorderMode(0);
+  gStyle->SetPaintTextFormat("5.2f");
+  gStyle->SetLineWidth(2);
+  gStyle->SetTextSize(1.1);
+  gStyle->SetLabelSize(0.04,"xy");
+  gStyle->SetTitleSize(0.05,"xy");
+  gStyle->SetTitleOffset(1.0,"x");
+  gStyle->SetTitleOffset(1.1,"y");
+  gStyle->SetPadTopMargin(0.15);
+  gStyle->SetPadRightMargin(0.15);
+  gStyle->SetPadBottomMargin(0.15);
+  gStyle->SetPadLeftMargin(0.15);
+  gStyle->SetLegendBorderSize(1);
+  gStyle->SetFrameBorderMode(0);
+  gStyle->SetFrameFillColor(kWhite);
+  // gStyle->SetLegendFillColor(kWhite);
+  gStyle->SetTitleFillColor(kWhite);
+  gStyle->SetFillColor(kWhite);
+  gStyle->SetStatFontSize(0.03);
+  gStyle->SetStatBorderSize(1);
+  gStyle->SetStatFormat("6.4g");
+  gStyle->SetStatX(0.95);
+  gStyle->SetStatY(0.95);
+  gStyle->SetStatW(0.2);
+  gStyle->SetStatH(0.2);
+  gStyle->SetTitleX(0.1);
+  gStyle->SetTitleY(0.95);
+  gStyle->SetTitleBorderSize(0);
+  gStyle->SetTitleFontSize(0.05);
+  gROOT->SetStyle("Default");
+
+
+  TColor::InitializeColors();
+  const Int_t NRGBs = 5;
+  const Int_t NCont = 90;
+
+  Double_t stops[NRGBs] = { 0.00, 0.34, 0.61, 0.84, 1.00 };
+  Double_t red[NRGBs]   = { 0.00, 0.00, 0.87, 1.00, 0.51 };
+  Double_t green[NRGBs] = { 0.00, 0.81, 1.00, 0.20, 0.00 };
+  Double_t blue[NRGBs]  = { 0.51, 1.00, 0.12, 0.00, 0.00 };
+  TColor::CreateGradientColorTable(NRGBs, stops, red, green, blue, NCont);
+  gStyle->SetNumberContours(NCont);
+
+
+  gROOT->ForceStyle();
+  ctbMain *mf=new ctbMain(gClient->GetRoot(),myDet);
+
+  cout << " *** " << argc << endl;
+  for (int ia=0; ia<argc; ia++)
+    cout << argv[ia] << endl;
+  
+
+  cout << " *** "  << endl;
+  
+  if (af)
+    mf->loadAlias(afname);
+  else
+    cout << "no alias specified" << endl;
+
+   theApp.Run();
+
+   return 0;
+}

ctbGui/ctbLinkDef.h

@@ -0,0 +1,15 @@
+#pragma link C++ class ctbMain;
+#pragma link C++ class ctbDacs;
+#pragma link C++ class ctbDac;
+#pragma link C++ class ctbSignals;
+#pragma link C++ class ctbSignal;
+#pragma link C++ class ctbAdc;
+#pragma link C++ class ctbAdcs;
+#pragma link C++ class ctbLoop;
+#pragma link C++ class ctbWait;
+#pragma link C++ class ctbPattern;
+#pragma link C++ class ctbAcquisition;
+#pragma link C++ class ctbPower;
+#pragma link C++ class ctbPowers;
+#pragma link C++ class ctbSlowAdc;
+#pragma link C++ class ctbSlowAdcs;

ctbGui/ctbMain.cpp

@@ -0,0 +1,709 @@
+#include <TApplication.h>
+#include <TGClient.h>
+#include <TCanvas.h>
+#include <TF1.h>
+#include <TRandom.h>
+#include <TGButton.h>
+#include <TRootEmbeddedCanvas.h>
+#include <TGButtonGroup.h>
+#include <TGNumberEntry.h>
+#include <TGLabel.h>
+#include <TList.h>
+#include <TGFileDialog.h>
+#include <TGComboBox.h>
+#include <TH2F.h>
+#include <TColor.h>
+#include <TH1F.h>
+#include <TGraphErrors.h>
+#include <THStack.h>
+#include <TGTab.h>
+#include <TApplication.h>
+#include <TGCanvas.h>
+#include <stdlib.h>
+
+#include <TGMenu.h>
+#include <TGDockableFrame.h>
+//#include <TGMenuBar.h>
+//#include <TGPopupMenu.h>
+
+
+
+
+
+
+
+#include <stdio.h>
+#include <iostream>
+#include <fstream>
+#include <string>
+
+#include "multiSlsDetector.h"
+#include "ctbMain.h"
+#include "ctbDacs.h"
+#include "ctbSlowAdcs.h"
+#include "ctbPowers.h"
+#include "ctbSignals.h"
+#include "ctbPattern.h"
+#include "ctbAdcs.h"
+#include "ctbAcquisition.h"
+//#include "ctbActions.h"
+
+using namespace std;
+
+
+
+ctbMain::ctbMain(const TGWindow *p, multiSlsDetector *det)
+  : TGMainFrame(p,800,800), pwrs(NULL), senses(NULL) {
+
+  myDet=det;
+
+  Connect("CloseWindow()", "ctbMain", this, "CloseWindow()");
+
+
+
+
+
+//   fMenuDock = new TGDockableFrame(this);
+//   AddFrame(fMenuDock, new TGLayoutHints(kLHintsExpandX, 0, 0, 1, 0));
+//   fMenuDock->SetWindowName("GuiTest Menu");
+
+  fMenuBarLayout = new TGLayoutHints(kLHintsTop | kLHintsExpandX);
+  fMenuBarItemLayout = new TGLayoutHints(kLHintsTop | kLHintsLeft, 0, 4, 0, 0);
+  fMenuBarHelpLayout = new TGLayoutHints(kLHintsTop | kLHintsRight);
+
+  fMenuFile = new TGPopupMenu(gClient->GetRoot());
+  int im=0;
+
+   fMenuFile->AddEntry("Open Alias", im++);
+   fMenuFile->AddEntry("Save Alias", im++);
+   fMenuFile->AddSeparator();
+   fMenuFile->AddEntry("Open Parameters", im++);
+   fMenuFile->AddEntry("Save Parameters", im++);
+   fMenuFile->AddSeparator();
+   fMenuFile->AddEntry("Open Configuration", im++);
+   fMenuFile->AddEntry("Save Configuration", im++);
+   fMenuFile->AddSeparator();
+   fMenuFile->AddEntry("Open Pattern", im++);
+   fMenuFile->AddEntry("Save Pattern", im++);
+   fMenuFile->AddSeparator();
+   fMenuFile->AddEntry("Exit", im++);
+
+    fMenuFile->Connect("Activated(Int_t)", "ctbMain", this,
+                       "HandleMenu(Int_t)");
+ 
+
+    i_dacs=-1;
+    i_pwrs=-1;
+    i_senses=-1;
+    i_sig=-1;
+    i_adcs=-1;
+    i_pat=-1;
+    i_acq=-1;
+
+    int i_page=0;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+  TGVerticalFrame *vframe=new TGVerticalFrame(this, 800,1200); //main frame
+
+
+
+   fMenuBar = new TGMenuBar(vframe, 1, 1, kHorizontalFrame);
+   fMenuBar->AddPopup("&File", fMenuFile, fMenuBarItemLayout);
+//    fMenuBar->AddPopup("&Test", fMenuTest, fMenuBarItemLayout);
+//    fMenuBar->AddPopup("&View", fMenuView, fMenuBarItemLayout);
+//    fMenuBar->AddPopup("&Help", fMenuHelp, fMenuBarHelpLayout);
+
+   vframe->AddFrame(fMenuBar, fMenuBarLayout);
+
+  TGHorizontalFrame* hpage=new TGHorizontalFrame(vframe, 800,1200); //horizontal frame. Inside there should be the tab and the canvas
+  mtab=new TGTab(hpage, 1500, 1200); //tab!
+  //  page=new TGVerticalFrame(mtab, 1500,1200);
+
+  cout << "DACS" << endl;
+
+  TGCompositeFrame *tf = mtab->AddTab("DACs");
+  TGVerticalFrame *page=new TGVerticalFrame(tf, 1500,1200);
+  tf->AddFrame(page, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 10,10,10,1));
+  dacs=new ctbDacs(page, myDet);
+  i_dacs=i_page++;
+  
+
+  cout << "power " << endl;
+  tf = mtab->AddTab("Power Supplies");
+  page=new TGVerticalFrame(tf, 1500,1200);
+  tf->AddFrame(page, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 10,10,10,1));
+   pwrs=new ctbPowers(page, myDet);
+
+  i_pwrs=i_page++;
+
+  cout << "sense " << endl;
+  tf = mtab->AddTab("Sense");
+  page=new TGVerticalFrame(tf, 1500,1200);
+  tf->AddFrame(page, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 10,10,10,1));
+   senses=new ctbSlowAdcs(page, myDet);
+
+  i_senses=i_page++;
+
+
+ 
+  cout << "signals " << endl;
+  tf = mtab->AddTab("Signals");
+  page=new TGVerticalFrame(tf, 1500,1200);
+  tf->AddFrame(page, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 10,10,10,1));
+  sig=new ctbSignals(page, myDet);
+  sig->Connect("ToggledSignalPlot(Int_t)","ctbMain",this,"setSignalPlot(Int_t)");
+
+  i_sig=i_page++;
+
+  cout << "adcs " << endl;
+  tf = mtab->AddTab("ADCs");
+  page=new TGVerticalFrame(tf, 1500,1200);
+  tf->AddFrame(page, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 10,10,10,1));
+  adcs=new ctbAdcs(page, myDet);
+  adcs->Connect("ToggledAdcPlot(Int_t)","ctbMain",this,"setADCPlot(Int_t)");
+  adcs->Connect("AdcEnable(Int_t)","ctbMain",this,"setADCEnable(Int_t)");
+  i_adcs=i_page++;
+
+
+  cout << "pattern" << endl;
+
+  tf = mtab->AddTab("Pattern");
+  page=new TGVerticalFrame(tf, 1500,1200);
+  tf->AddFrame(page, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 10,10,10,1));
+  pat=new ctbPattern(page, myDet);
+  pat->Connect("patternFileChanged(const char*)","ctbMain",this,"setPatternFile(const char*)");
+  pat->Connect("patternCompilerChanged(const char*)","ctbMain",this,"setPatternCompiler(const char*)");
+  pat->Connect("analogSamplesChanged(const int)","ctbMain",this,"setAnalogSamples(int)");
+  pat->Connect("digitalSamplesChanged(const int)","ctbMain",this,"setDigitalSamples(int)");
+  pat->Connect("readoutModeChanged(int)","ctbMain",this,"setReadoutMode(int)");
+
+  i_pat=i_page++;
+
+  cout << "acquisition" << endl;
+
+  tf = mtab->AddTab("Acquisition");
+  page=new TGVerticalFrame(tf, 1500,1200);
+  tf->AddFrame(page, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 10,10,10,1));
+  acq=new ctbAcquisition(page, myDet);
+
+
+  i_acq=i_page++;
+
+
+  // cout << "actions" << endl;
+  // tf = mtab->AddTab("Actions");
+  // page=new TGVerticalFrame(tf, 1500,1200);
+  // tf->AddFrame(page, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 10,10,10,1));
+  // actions=new ctbActions(page, myDet);
+
+
+  // i_actions=i_page++;
+
+
+
+   cout << "tabs finished" << endl;
+
+  hpage->AddFrame(mtab,new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 10,10,10,1));
+
+  vframe->AddFrame(hpage,new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 10,10,10,1));
+  
+  AddFrame(vframe,new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 10,10,10,1));
+  vframe->MapWindow();
+  hpage->MapWindow();
+  mtab->MapWindow();
+  page->MapWindow();
+
+  // Sets window name and shows the main frame
+   cout << "dockabel" << endl;
+   TGDockableFrame *fdock=new TGDockableFrame(hpage);
+   hpage->AddFrame(fdock, new TGLayoutHints(kLHintsBottom | kLHintsCenterX | kLHintsExpandX | kLHintsExpandY, 10,10,10,10));
+   fdock->MapWindow();
+
+   cout << "canvas" << endl;
+//    // Creates widgets of the example
+
+
+   fEcanvas = new TRootEmbeddedCanvas ("Ecanvas",fdock,800,800);//hpage,800,800);
+   //fEcanvas = new TRootEmbeddedCanvas ("Ecanvas",this,800,800);//hpage,800,800);
+  // fEcanvas->Resize();
+  //  fEcanvas->GetCanvas()->Update();
+  //AddFrame(fEcanvas, new TGLayoutHints(kLHintsBottom | kLHintsCenterX | kLHintsExpandX | kLHintsExpandY, 10,10,10,10));
+
+  // // hpage->
+  fdock->AddFrame(fEcanvas, new TGLayoutHints(kLHintsBottom | kLHintsCenterX | kLHintsExpandX | kLHintsExpandY, 10,10,10,10));
+
+
+  fEcanvas->MapWindow();
+
+  acq->setCanvas(getCanvas());
+
+
+
+  hpage->MapSubwindows();
+   mtab->Connect("Selected(Int_t)","ctbMain",this,"tabSelected(Int_t)");
+
+
+
+   cout << "connect mtab" << endl;
+
+   
+   setReadoutMode(pat->getReadoutMode());
+   setADCEnable(adcs->setEnable());
+   setAnalogSamples(pat->getAnalogSamples());
+   setDigitalSamples(pat->getDigitalSamples());
+   
+   tabSelected(0);
+
+   SetWindowName("CTB Gui");
+   MapSubwindows();
+   Resize(1500,1200);
+
+   MapWindow();
+}
+
+void ctbMain::CloseWindow() {
+   gApplication->Terminate();
+}
+
+TCanvas* ctbMain::getCanvas() {
+  return fEcanvas->GetCanvas();
+}
+
+
+
+void ctbMain::HandleMenu(Int_t id)
+{
+   // Handle menu items.
+   
+  
+ 
+
+   switch (id) {
+
+   case 0:   // fMenuFile->AddEntry("Open Alias", im++);
+     cout << "Open Alias" << endl;
+         {
+             static TString dir(".");
+             TGFileInfo fi;
+             //fi.fFileTypes = filetypes;
+             fi.fIniDir    = StrDup(dir);
+             printf("fIniDir = %s\n", fi.fIniDir);
+             new TGFileDialog(gClient->GetRoot(), this, kFDOpen, &fi);
+             printf("Open file: %s (dir: %s)\n", fi.fFilename);
+	     // dir = fi.fIniDir;
+	     if (fi.fFilename)
+	       loadAlias(fi.fFilename);
+          }
+         break;
+
+   case 1: // fMenuFile->AddEntry("Save Alias", im++);
+     cout << "Save Alias" << endl;
+         {
+             static TString dir(".");
+             TGFileInfo fi;
+             //fi.fFileTypes = filetypes;
+             fi.fIniDir    = StrDup(dir);
+             printf("fIniDir = %s\n", fi.fIniDir);
+             new TGFileDialog(gClient->GetRoot(), this, kFDSave, &fi);
+             printf("Save file: %s (dir: %s)\n", fi.fFilename);
+	     // dir = fi.fIniDir;
+	     if (fi.fFilename)
+	       saveAlias(fi.fFilename);
+          }
+         break;
+
+   case 2: //fMenuFile->AddEntry("Open Parameters", im++);
+     cout << "Open Parameters" << endl;
+         {
+             static TString dir(".");
+             TGFileInfo fi;
+             //fi.fFileTypes = filetypes;
+             fi.fIniDir    = StrDup(dir);
+             printf("fIniDir = %s\n", fi.fIniDir);
+             new TGFileDialog(gClient->GetRoot(), this, kFDOpen, &fi);
+             printf("Open file: %s (dir: %s)\n", fi.fFilename, fi.fIniDir);
+	     // dir = fi.fIniDir;
+	     if (fi.fFilename)
+	       loadParameters(fi.fFilename);
+          }
+         break;
+
+   case 3: //fMenuFile->AddEntry("Save Parameters", im++);
+     cout << "Save Parameters" << endl;
+         {
+             static TString dir(".");
+             TGFileInfo fi;
+             //fi.fFileTypes = filetypes;
+             fi.fIniDir    = StrDup(dir);
+             printf("fIniDir = %s\n", fi.fIniDir);
+             new TGFileDialog(gClient->GetRoot(), this, kFDSave, &fi);
+             printf("Open file: %s (dir: %s)\n", fi.fFilename, fi.fIniDir);
+	     // dir = fi.fIniDir;
+	     if (fi.fFilename)
+	       saveParameters(fi.fFilename);
+          }
+         break;
+
+   case 4: // fMenuFile->AddEntry("Open Configuration", im++);
+     cout << "Open configuration" << endl;
+         {
+             static TString dir(".");
+             TGFileInfo fi;
+             //fi.fFileTypes = filetypes;
+             fi.fIniDir    = StrDup(dir);
+             printf("fIniDir = %s\n", fi.fIniDir);
+             new TGFileDialog(gClient->GetRoot(), this, kFDOpen, &fi);
+             printf("Open file: %s (dir: %s)\n", fi.fFilename, fi.fIniDir);
+	     // dir = fi.fIniDir;
+	     if (fi.fFilename)
+	       loadConfiguration(fi.fFilename);
+          }
+         break;
+ 
+   case 5: //  fMenuFile->AddEntry("Save Configuration", im++);
+     cout << "Save configuration" << endl;
+         {
+             static TString dir(".");
+             TGFileInfo fi;
+             //fi.fFileTypes = filetypes;
+             fi.fIniDir    = StrDup(dir);
+             printf("fIniDir = %s\n", fi.fIniDir);
+             new TGFileDialog(gClient->GetRoot(), this, kFDSave, &fi);
+             printf("Open file: %s (dir: %s)\n", fi.fFilename, fi.fIniDir);
+	     // dir = fi.fIniDir;
+	     if (fi.fFilename)
+	       saveConfiguration(fi.fFilename);
+          }
+         break;
+
+   case 6: //fMenuFile->AddEntry("Open Pattern", im++);
+     cout << "Open pattern" << endl;
+         {
+             static TString dir(".");
+             TGFileInfo fi;
+             //fi.fFileTypes = filetypes;
+             fi.fIniDir    = StrDup(dir);
+             printf("fIniDir = %s\n", fi.fIniDir);
+             new TGFileDialog(gClient->GetRoot(), this, kFDOpen, &fi);
+             printf("Open file: %s (dir: %s)\n", fi.fFilename, fi.fIniDir);
+	     // dir = fi.fIniDir;
+	     if (fi.fFilename)
+	       loadParameters(fi.fFilename);
+          }
+     break;
+
+   case 7:   //fMenuFile->AddEntry("Save Pattern", im++);
+     cout << "Save pattern" << endl;
+         {
+             static TString dir(".");
+             TGFileInfo fi;
+             //fi.fFileTypes = filetypes;
+             fi.fIniDir    = StrDup(dir);
+             printf("fIniDir = %s\n", fi.fIniDir);
+             new TGFileDialog(gClient->GetRoot(), this, kFDSave, &fi);
+             printf("Open file: %s (dir: %s)\n", fi.fFilename, fi.fIniDir);
+	     // dir = fi.fIniDir;
+	     if (fi.fFilename)
+	       saveParameters(fi.fFilename);
+          }
+         break;
+
+   case 8: //  fMenuFile->AddEntry("Exit", im++);
+     CloseWindow();
+
+      default:
+         printf("Menu item %d selected\n", id);
+         break;
+   }
+}
+
+
+
+int  ctbMain::setADCPlot(Int_t i) {
+
+  //  cout << "ADC " << i << " plot or color toggled" << endl;
+  //  acq->setGraph(i,adcs->getGraph(i));
+  acq->setGraph(i,adcs->getEnabled(i),adcs->getColor(i));
+
+}
+
+
+int  ctbMain::setSignalPlot(Int_t i) {
+
+  //  cout << "ADC " << i << " plot or color toggled" << endl;
+  //  acq->setGraph(i,adcs->getGraph(i));
+  acq->setBitGraph(i,sig->getPlot(i),sig->getColor(i));
+
+}
+
+
+
+int  ctbMain::loadConfiguration(string fname) {
+
+    myDet->readConfigurationFile(fname);
+
+//   string line;
+//   int i;
+//   ifstream myfile (fname.c_str());
+//   if (myfile.is_open())
+//   {
+//     while ( getline (myfile,line) )
+//     {
+
+	
+      
+//     }
+//     myfile.close();
+//   }
+
+//   else cout << "Unable to open file"; 
+
+  return 0;
+
+}
+
+
+
+
+
+int  ctbMain::saveConfiguration(string fname) {
+
+
+    myDet->writeConfigurationFile(fname);
+ //  string line;
+//   int i;
+//   ofstream myfile (fname.c_str());
+//   if (myfile.is_open())
+//   {
+    
+
+//    myfile.close();
+//   }
+
+//   else cout << "Unable to open file"; 
+
+  return 0;
+
+}
+
+
+
+
+
+
+
+int  ctbMain::loadParameters(string fname) {
+
+    myDet->retrieveDetectorSetup(fname);
+
+//   string line;
+//   int i;
+//   ifstream myfile (fname.c_str());
+//   if (myfile.is_open())
+//   {
+//     while ( getline (myfile,line) )
+//     {
+
+	
+      
+//     }
+//     myfile.close();
+//   }
+
+//   else cout << "Unable to open file"; 
+
+  return 0;
+
+}
+
+
+
+
+
+int  ctbMain::saveParameters(string fname) {
+
+
+  string line;
+  int i;
+   myDet->dumpDetectorSetup(fname);
+//   ofstream myfile (fname.c_str());
+//   if (myfile.is_open())
+//   {
+
+//    myfile << dacs->getDacParameters();
+//    myfile << sig->getSignalParameters();
+//    myfile << adcs->getAdcParameters();
+
+//    myfile.close();
+//   }
+
+//   else cout << "Unable to open file"; 
+
+  return 0;
+
+}
+
+
+
+
+
+int  ctbMain::loadAlias(string fname) {
+
+
+  string line;
+  char aaaa[1000];
+  int i;
+  ifstream myfile (fname.c_str());
+  if (myfile.is_open())
+  {
+    while ( getline (myfile,line) )
+    {
+      // cout << line ;
+      if (sscanf(line.c_str(),"BIT%d",&i)>0) {
+	//cout << "*******" << line<< endl;
+	sig->setSignalAlias(line);
+      // cout << line ;
+      } else if (sscanf(line.c_str(),"DAC%d",&i)>0) {
+	dacs->setDacAlias(line);
+	//	cout << "+++++++++" << line<< endl;
+      } else if (sscanf(line.c_str(),"ADC%d",&i)>0) {
+	adcs->setAdcAlias(line);
+	//	cout << "---------" << line<< endl;
+      }      //  else
+      //	cout << "<<<<<<<" << line << endl;
+      else if (sscanf(line.c_str(),"PAT%s",aaaa)>0) {
+	pat->setPatternAlias(line);
+	//	cout << "---------" << line<< endl;
+      }	else if (sscanf(line.c_str(),"V%s",&i)>0) {
+	    if (pwrs)	pwrs->setPwrAlias(line);
+	//	cout << "+++++++++" << line<< endl;
+      } else if (sscanf(line.c_str(),"SENSE%d",&i)>0) {
+	if (senses) senses->setSlowAdcAlias(line);
+	//	cout << "+++++++++" << line<< endl;
+      } 
+      
+    }
+    myfile.close();
+  }
+
+  else cout << "Unable to open file"; 
+
+  return 0;
+
+}
+
+
+
+
+
+int  ctbMain::saveAlias(string fname) {
+
+
+  string line;
+  int i;
+  ofstream myfile (fname.c_str());
+  if (myfile.is_open())
+  {
+    //while ( getline (myfile,line) )
+    // {
+      // cout << line ;
+      //if (sscanf(line.c_str(),"BIT%d",&i)>0) {
+	//cout << "*******" << line<< endl;
+    myfile << sig->getSignalAlias();
+      // cout << line ;
+    //  } else if (sscanf(line.c_str(),"DAC%d",&i)>0) {
+    myfile << dacs->getDacAlias();
+    if (pwrs) myfile << pwrs->getPwrAlias();
+    if (senses) myfile << senses->getSlowAdcAlias();
+	//	cout << "+++++++++" << line<< endl;
+    //  } else if (sscanf(line.c_str(),"ADC%d",&i)>0) {
+    myfile << adcs->getAdcAlias();
+	//	cout << "---------" << line<< endl;
+    //  }      //  else
+      //	cout << "<<<<<<<" << line << endl;
+    myfile << pat->getPatternAlias();
+      
+    //}
+    myfile.close();
+  }
+
+  else cout << "Unable to open file"; 
+
+  return 0;
+
+}
+
+
+
+
+
+
+
+
+
+
+
+void ctbMain::tabSelected(Int_t i) {
+
+  //  cout << "Selected tab " << i << endl;
+  // cout << "Current tab is " <<  mtab->GetCurrent() << endl;
+
+  if (i==i_dacs) dacs->update();
+  else if (i==i_pwrs) pwrs->update();
+  else if (i==i_senses) ;//senses->update();
+ else if (i==i_sig) sig->update();
+ else if (i==i_adcs) adcs->update();
+ else if (i==i_pat) pat->update();
+ else if (i==i_acq) acq->update();
+ else if (i==i_acq) acq->update();
+  // else if (i==i_actions) actions->update();
+ else cout << "Unknown tab " << i << endl;
+ 
+
+}
+
+void ctbMain::setPatternFile(const char* t) {
+  acq->setPatternFile(t);
+
+}
+
+void ctbMain::setPatternCompiler(const char* t) {
+  acq->setPatternCompiler(t);
+
+
+}
+
+void ctbMain::setAnalogSamples(const int n) {
+  acq->setAnalogSamples(n);
+
+
+}
+
+void ctbMain::setDigitalSamples(const int n) {
+  acq->setDigitalSamples(n);
+
+
+}
+
+void ctbMain::setReadoutMode(int flags) {
+  acq->setReadoutMode(flags);
+}
+
+void ctbMain::setADCEnable(Int_t reg){
+  acq->setADCEnable(reg);
+}

ctbGui/ctbMain.h

@@ -0,0 +1,126 @@
+#ifndef CTBMAIN_H
+#define CTBMAIN_H
+#include <TGFrame.h>
+
+
+class TRootEmbeddedCanvas;
+class TGButtonGroup;
+class TGVerticalFrame;
+class TGHorizontalFrame;
+class TGTextEntry;
+class TGLabel;
+class TGNumberEntry;
+class TH2F;
+class TGComboBox;
+class TGCheckButton;
+
+class   THStack;
+class   TGraphErrors;
+class  TGTextButton;
+class  TGTab;
+
+class   TGMenuBar;
+class   TGPopupMenu;
+class   TGDockableFrame;
+class TGLayoutHints;
+class TGCanvas;
+class TCanvas;
+
+class   ctbDacs;
+class   ctbSlowAdcs;
+class   ctbPowers;
+
+ 
+class  ctbSignals;
+
+class multiSlsDetector;
+
+class  ctbPattern;
+class  ctbAdcs;
+class  ctbAcquisition;
+//class  ctbActions;
+
+#include <string>
+using namespace std;
+
+class ctbMain : public TGMainFrame { 
+private:
+
+
+  multiSlsDetector *myDet;
+
+
+
+   TRootEmbeddedCanvas *fEcanvas;
+   TRootEmbeddedCanvas *fModulecanvas;
+   TGButtonGroup *br;
+   
+   TGTab *mtab;
+
+   
+   ctbDacs *dacs;
+   int i_dacs;
+
+   ctbPowers *pwrs;
+   int i_pwrs;
+
+   ctbSlowAdcs *senses;
+   int i_senses;
+
+ 
+  ctbSignals *sig;
+  int i_sig;
+
+
+  ctbAdcs *adcs;
+  int i_adcs;
+  
+
+  ctbPattern *pat;
+  int i_pat;
+
+  ctbAcquisition *acq;
+  int i_acq;
+
+  // ctbActions *actions;
+  int i_actions;
+
+   TGDockableFrame    *fMenuDock;
+
+   TGMenuBar          *fMenuBar;
+   TGPopupMenu        *fMenuFile, *fMenuTest, *fMenuView, *fMenuHelp;
+   TGPopupMenu        *fCascadeMenu, *fCascade1Menu, *fCascade2Menu;
+   TGPopupMenu        *fMenuNew1, *fMenuNew2;
+   TGLayoutHints      *fMenuBarLayout, *fMenuBarItemLayout, *fMenuBarHelpLayout;
+   TGCanvas *myCanvas;
+
+
+public:
+   ctbMain(const TGWindow *p, multiSlsDetector *det);
+
+
+   int  loadAlias(string fname);
+   int  saveAlias(string fname);
+   int  loadParameters(string fname);
+   int  saveParameters(string fname);
+   int  loadConfiguration(string fname);
+   int  saveConfiguration(string fname);
+   void tabSelected(Int_t);
+   int setADCPlot(Int_t);
+   int setSignalPlot(Int_t);
+   void CloseWindow();
+
+   void setPatternFile(const char* t);
+
+   void setPatternCompiler(const char* t);
+   void setAnalogSamples(const int);
+   void setDigitalSamples(const int);
+   void setReadoutMode(int);
+   void setADCEnable(Int_t);
+
+   void HandleMenu(Int_t);
+   TCanvas* getCanvas();
+   ClassDef(ctbMain,0)
+};
+
+#endif

ctbGui/ctbPattern.h

@@ -0,0 +1,176 @@
+#ifndef CTBPATTERN_H
+#define CTBPATTERN_H
+#include  <TGFrame.h>
+
+
+#define NLOOPS 3
+#define NWAITS 3
+#define NADCS 32
+#define PATLEN 1024
+
+class TRootEmbeddedCanvas;
+class TGButtonGroup;
+class TGVerticalFrame;
+class TGHorizontalFrame;
+class TGTextEntry;
+class TGLabel;
+class TGNumberEntry;
+class TH2F;
+class TGComboBox;
+class TGCheckButton;
+class TGTextEntry;
+class TGCheckButton;
+
+class   THStack;
+class   TGraphErrors;
+class energyCalibration;
+class  TGTextButton;
+class  TGTab;
+
+class multiSlsDetector;
+
+
+#include <string>
+using namespace std;
+
+
+
+class ctbLoop : public TGHorizontalFrame {
+ 
+
+ private:
+
+   TGNumberEntry *eLoopStartAddr; 
+   TGNumberEntry *eLoopStopAddr; 
+   TGNumberEntry *eLoopNumber; 
+
+   int id;
+
+   multiSlsDetector *myDet;
+
+ public:
+   ctbLoop(TGGroupFrame *page, int i,multiSlsDetector *det);
+   
+   void setNLoops();
+   void update();
+
+   ClassDef(ctbLoop,0)
+     };
+
+class ctbWait : public TGHorizontalFrame {
+ 
+
+ private:
+
+   TGNumberEntry *eWaitAddr; 
+   TGNumberEntry *eWaitTime; 
+
+   int id;
+
+   multiSlsDetector *myDet;
+
+ public:
+   ctbWait(TGGroupFrame *page, int i,multiSlsDetector *det);
+   
+   void setWaitTime();
+   void update();
+
+   ClassDef(ctbWait,0)
+     };
+
+
+
+
+
+
+
+class ctbPattern : public TGGroupFrame {
+private:
+   
+
+   TGNumberEntry *eAdcClkFreq;
+   TGNumberEntry *eRunClkFreq;
+   TGNumberEntry *eDBitClkFreq;
+   TGNumberEntry *eAdcClkPhase;
+   TGNumberEntry *eDBitClkPhase;
+   //TGNumberEntry *eRunClkPhase;
+
+   TGNumberEntry *eStartAddr;
+   TGNumberEntry *eStopAddr;
+   TGNumberEntry *eFrames;
+   TGNumberEntry *ePeriod;
+   TGNumberEntry *eCycles;
+   // TGNumberEntry *eMeasurements;
+   TGNumberEntry *eAdcPipeline;
+   TGNumberEntry *eDBitPipeline;
+   
+   ctbLoop *eLoop[NLOOPS];
+   ctbWait *eWait[NWAITS];
+
+   TGTextEntry *patternCompiler;
+   TGTextEntry *patternFile;
+   
+   TGTextButton *browseCompiler;
+   TGTextButton *browseFile;
+   
+
+   TGNumberEntry *eAnalogSamples;
+   TGNumberEntry *eDigitalSamples;
+
+  TGCheckButton *cbAnalog;
+  TGCheckButton *cbDigital;
+  
+   char pat[PATLEN*8];
+
+   multiSlsDetector *myDet;
+
+public:
+
+   ctbPattern(TGVerticalFrame *page, multiSlsDetector *det);
+
+   void update();
+   void setAdcFreq();
+   void setRunFreq();
+   void setDBitFreq();
+   void setAdcPhase();
+   void setDBitPhase();
+   // void setRunPhase();
+   void setAdcPipeline();
+   void setDBitPipeline();
+   void setFrames();
+   void setCycles();
+   // void setMeasurements();
+   void setPeriod();
+
+   
+   void chooseCompiler();
+   void choosePattern();
+
+   string getCompiler();
+   string getPatternFile();
+   
+   void setPatternAlias(string);
+   string getPatternAlias();
+
+
+   int getAnalogSamples();
+   void  setAnalogSamples();
+   int getDigitalSamples();
+   void  setDigitalSamples();
+   void  setReadoutMode(Bool_t);
+   int  getReadoutMode();
+
+
+   void setFile();
+   void setCompiler();
+   void patternFileChanged(const char*);
+   void patternCompilerChanged(const char*);
+   void analogSamplesChanged(const int t);
+   void digitalSamplesChanged(const int t);
+   void readoutModeChanged(int);
+
+
+   ClassDef(ctbPattern,0)
+};
+
+#endif

ctbGui/ctbPowers.cpp

@@ -0,0 +1,243 @@
+#include  <TGFrame.h>
+
+
+#include <TGButtonGroup.h>
+#include <TGNumberEntry.h>
+#include <TGLabel.h>
+#include <TList.h>
+
+#include <stdio.h>
+#include <iostream>
+#include <fstream>
+
+#include "ctbDacs.h"
+#include "ctbPowers.h"
+#include "multiSlsDetector.h"
+#include "sls_detector_defs.h"
+
+using namespace std;
+
+
+
+ctbPower::ctbPower(TGGroupFrame* f, int i,  multiSlsDetector* d)
+  : ctbDac(f, i, d) 
+{
+  cout << "****************************************************************power " << i << endl;
+     dacsUnit->SetOn(kTRUE); 
+     dacsUnit->SetEnabled(kFALSE);
+     int ii=0;
+
+     switch(i) {
+     case slsDetectorDefs::V_POWER_IO: 
+     	 dacsLabel->SetText("VIO"); 
+	 ii=slsDetectorDefs::I_POWER_IO;
+     	 break; 
+     case slsDetectorDefs::V_POWER_A: 
+     	 dacsLabel->SetText("VA"); 
+	 ii=slsDetectorDefs::I_POWER_A;
+     	 break;  
+     case slsDetectorDefs::V_POWER_B: 
+     	 dacsLabel->SetText("VB"); 
+	 ii=slsDetectorDefs::I_POWER_B;
+     	 break;   
+     case slsDetectorDefs::V_POWER_C: 
+     	 dacsLabel->SetText("VC");
+	 ii=slsDetectorDefs::I_POWER_C; 
+     	 break;    
+     case slsDetectorDefs::V_POWER_D: 
+     	 dacsLabel->SetText("VD");
+	 ii=slsDetectorDefs::I_POWER_D;  
+     	 break;      
+     case slsDetectorDefs::V_POWER_CHIP: 
+     	 dacsLabel->SetText("VCHIP"); 
+     	 dacsLabel->SetEnabled(kFALSE);
+	 ii=-1;
+     	 break;    
+     default: 
+     	 dacsLabel->SetText("Bad index"); 
+	 ii=-1;
+     	 break; 
+     };
+     
+     // ctbSlowAdc *vm=new ctbSlowAdc(f,i,d);
+     // vm->setLabel("V: ");
+     // if (ii>=0) {
+     //   ctbSlowAdc *im=new ctbSlowAdc(f,ii,d);
+     //   im->setLabel("I: ");
+     // }
+
+     TGTextEntry *e=dacsEntry->TGNumberEntry::GetNumberEntry();
+     e->Disconnect 	("ReturnPressed()");
+     e->Disconnect 	("ValueSet(Long_t)");
+     
+     e->Connect("ReturnPressed()","ctbPower",this,"setValue()");
+     dacsEntry->Connect("ValueSet(Long_t)","ctbPower",this,"setValue(Long_t)");
+ };
+
+
+string ctbPower::getLabel() {
+
+  ostringstream line;
+  switch (id) {
+     case slsDetectorDefs::V_POWER_IO: 
+	 line << "VIO"; 
+	 break; 
+     case slsDetectorDefs::V_POWER_A: 
+	 line << "VA"; 
+	 break;  
+     case slsDetectorDefs::V_POWER_B: 
+	 line << "VB"; 
+	 break;   
+     case slsDetectorDefs::V_POWER_C: 
+	 line << "VC"; 
+	 break;    
+     case slsDetectorDefs::V_POWER_D: 
+	 line << "VD"; 
+	 break;      
+     case slsDetectorDefs::V_POWER_CHIP: 
+	 line << "VCHIP"; 
+	 break;    
+     default:  
+	 line << "VBAD"; 
+	 break; 
+
+  }
+  line << " " <<  dacsLabel->GetText() << endl;
+  return line.str();
+
+}
+
+
+void ctbPower::setValue(Long_t a) {cout << "ssssssssss" << endl; ctbPower::setValue();}
+void ctbPower::setValue() {
+
+
+  cout << "***************************Setting power " << dacsEntry->GetIntNumber() << " " << (slsDetectorDefs::dacIndex)id <<" " << 1 << endl;
+  myDet->setDAC(dacsEntry->GetIntNumber(), (slsDetectorDefs::dacIndex)id, 1);
+
+  getValue();
+
+}
+
+
+int ctbPower::getValue() {
+  
+  int val=myDet->setDAC(-1, (slsDetectorDefs::dacIndex)id, 1);
+  char s[100];
+  cout << "****************************Getting power " << val << " " << (slsDetectorDefs::dacIndex)id <<" " << 1 << endl;
+  sprintf(s,"%d",val);
+  dacsValue->SetText(s);
+  if (val>0) {
+    if (id!=slsDetectorDefs::V_POWER_CHIP)
+      dacsLabel->SetOn(kTRUE);
+  } else {
+    dacsLabel->SetOn(kFALSE);
+  }
+  
+
+  return val;
+
+}
+
+
+
+ctbPowers::ctbPowers(TGVerticalFrame* page, multiSlsDetector* det)   : TGGroupFrame(page,"Power Supplies",kVerticalFrame) , myDet(det){
+
+
+  SetTitlePos(TGGroupFrame::kLeft);
+  page->AddFrame(this,new TGLayoutHints( kLHintsTop | kLHintsExpandX , 10,10,10,10));
+  MapWindow();
+  
+  // cout << "window mapped " << endl;
+
+  for (int idac=0; idac<NPOWERS; idac++) {
+     dacs[idac]=new ctbPower(this, slsDetectorDefs::V_POWER_A+idac, myDet);
+
+  }
+}
+
+
+int ctbPowers::setPwrAlias(string line) {
+
+  int is=-1, mv=0;
+  char tit[100];
+  int narg;
+
+  if (sscanf(line.c_str(),"VA %s",tit)) {
+    dacs[0]->setLabel(tit,1);
+    is=0;
+  }
+
+  if (sscanf(line.c_str(),"VB %s",tit)) {
+    dacs[1]->setLabel(tit,1);
+    is=1;
+  }
+
+  if (sscanf(line.c_str(),"VC %s",tit)) {
+    dacs[2]->setLabel(tit,1);
+    is=2;
+  }
+
+  if (sscanf(line.c_str(),"VD %s",tit)) {
+    dacs[3]->setLabel(tit,1);
+    is=3;
+  }
+
+  if (sscanf(line.c_str(),"VIO %s",tit)) {
+    dacs[4]->setLabel(tit,1);
+    is=4;
+  }
+
+  if (sscanf(line.c_str(),"VCHIP %s",tit)) {
+    dacs[5]->setLabel(tit,1);
+    is=5;
+  }
+    
+  return is;
+
+}
+
+string ctbPowers::getPwrAlias() {
+
+  ostringstream line;
+
+  for (int i=0; i<NPOWERS; i++)
+    line << dacs[i]->getLabel() << endl;
+  return line.str();
+
+}
+
+
+
+
+string ctbPowers::getPwrParameters() {
+
+
+  ostringstream line;
+  line << "v_a" << " " << dacs[0]->getValue() << " mv" << endl;
+  line << "v_b" << " " << dacs[1]->getValue() << " mv" << endl;
+  line << "v_c" << " " << dacs[2]->getValue() << " mv" << endl;
+  line << "v_d" << " " << dacs[3]->getValue() << " mv" << endl;
+  line << "v_io" << " " << dacs[4]->getValue() << " mv" << endl;
+  line << "v_chip" << " " << dacs[5]->getValue() << " mv" << endl;
+  // for (int i=0; i<POWERS; i++) {
+  //   //line << "dacs:" << i << " " << dacs[i]->getValue << endl;
+  //   line << "dac:" << i << " " << dacs[i]->getValue() << endl;
+  // } 
+  return line.str();
+
+
+}
+
+
+
+void  ctbPowers::update() {
+
+  for (int idac=0; idac<NPOWERS; idac++) {
+
+    dacs[idac]->getValue();
+
+  }
+
+
+}

ctbGui/ctbPowers.h

@@ -0,0 +1,72 @@
+#ifndef CTBPOWERS_H
+#define CTBPOWERS_H
+
+#include  <TGFrame.h>
+
+#ifndef CTB
+#define NPOWERS 0
+#else
+
+#define NPOWERS 6
+#endif
+
+
+
+
+
+class TGTextEntry;
+class TGLabel;
+class TGNumberEntry;
+class TGCheckButton;
+
+
+
+
+class multiSlsDetector;
+
+
+#include <string>
+using namespace std;
+
+
+class ctbPower : public ctbDac {
+
+  
+
+
+ public:
+
+  ctbPower(TGGroupFrame* f, int i, multiSlsDetector* d);
+
+    string getLabel();
+
+    int getValue();
+    void setValue();
+    void setValue(Long_t);
+
+   ClassDef(ctbPower,0)
+};
+
+
+class ctbPowers : public TGGroupFrame 
+{
+ private:
+  
+   ctbPower *dacs[NPOWERS]; 
+
+   multiSlsDetector* myDet; 
+
+public:
+   //ctbPowers();
+    ctbPowers(TGVerticalFrame*, multiSlsDetector*);
+
+    int setPwrAlias(string); 
+    string getPwrAlias(); 
+    string getPwrParameters(); 
+
+    void update(); 
+
+    ClassDef(ctbPowers,0)
+};
+
+#endif

ctbGui/ctbSignals.cpp

@@ -0,0 +1,548 @@
+#include <TApplication.h>
+#include <TGClient.h>
+#include <TCanvas.h>
+#include <TF1.h>
+#include <TRandom.h>
+#include <TGButton.h>
+#include <TRootEmbeddedCanvas.h>
+#include <TGButtonGroup.h>
+#include <TGNumberEntry.h>
+#include <TGLabel.h>
+#include <TList.h>
+#include <TGFileDialog.h>
+#include <TGComboBox.h>
+#include <TH2F.h>
+#include <TColor.h>
+#include <TH1F.h>
+#include <TGraphErrors.h>
+#include <THStack.h>
+#include <TGTab.h>
+
+#include <stdio.h>
+#include <iostream>
+#include <fstream>
+#include <TGButton.h>
+#include <TRootEmbeddedCanvas.h>
+#include <TGButtonGroup.h>
+#include <TGNumberEntry.h>
+#include <TGLabel.h>
+#include <stdio.h>
+#include <iostream>
+#include <fstream>
+#include <TColor.h>
+#include <TGColorSelect.h>
+
+
+#include "ctbSignals.h"
+#include "multiSlsDetector.h"
+
+using namespace std;
+
+
+
+//#define DEFAULTFN "run_0.encal"
+
+
+ctbSignal::ctbSignal(TGFrame *page, int i,  multiSlsDetector *det)
+  : TGHorizontalFrame(page, 800,50), myDet(det), id(i), hsig(NULL) {
+
+
+  TGHorizontalFrame *hframe=this;
+  char tit[100];
+
+
+   
+   sprintf(tit, "BIT%d ",id);
+
+   sLabel= new TGLabel(hframe, tit);
+   hframe->AddFrame( sLabel,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 1, 1, 1, 1));
+   sLabel->MapWindow();
+   sLabel->SetTextJustify(kTextLeft);
+
+
+
+   sOutput= new TGCheckButton(hframe, "Out");
+   hframe->AddFrame( sOutput,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 1, 1, 1, 1));
+   sOutput->MapWindow();
+
+ 
+   sOutput->Connect("Toggled(Bool_t)","ctbSignal",this,"ToggledOutput(Bool_t)");
+
+   sDbitList= new TGCheckButton(hframe, "DB List");
+   hframe->AddFrame( sDbitList,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 1, 1, 1, 1));
+   sDbitList->MapWindow();
+
+   sDbitList->Connect("Toggled(Bool_t)","ctbSignal",this,"ToggledDbitList(Bool_t)");
+
+
+   sPlot= new TGCheckButton(hframe, "Plot");
+   hframe->AddFrame( sPlot,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 1, 1, 1, 1));
+   sPlot->MapWindow();
+
+   sPlot->Connect("Toggled(Bool_t)","ctbSignal",this,"ToggledPlot(Bool_t)");
+   
+   fColorSel = new TGColorSelect(hframe, id+1, 0);
+   fColorSel->Connect("ColorSelected(Pixel_t)","ctbSignal",this,"ColorChanged(Pixel_t)");
+   hframe->AddFrame(fColorSel, new TGLayoutHints(kLHintsTop |
+                          kLHintsLeft, 2, 0, 2, 2));
+   
+
+   fColorSel->SetColor(TColor::Number2Pixel(id+1));
+
+   
+   ToggledOutput(kFALSE);
+
+  
+   ToggledPlot(kFALSE);
+
+  //  if (id==63) {
+//      sOutput->SetOn(kTRUE);
+//      sOutput->SetEnabled(kFALSE);
+//    }
+// #ifdef CTB
+//    if (id==62) {
+//      sOutput->SetOn(kTRUE);
+//      sOutput->SetEnabled(kFALSE);
+//    }
+
+//    // if (id>=32 && id<48)
+//    //   fixOutput(1);
+//    // else if (id>=48 && id<64)
+//    //   fixOutput(0);
+
+// #endif
+}
+int ctbSignal::setSignalAlias(char *tit, int plot, int col) {
+
+  if (tit)
+    sLabel->SetText(tit);
+
+  if (plot>0) {
+      sPlot->SetOn(kTRUE,kTRUE); 
+  } else if (plot==0)
+      sPlot->SetOn(kFALSE,kTRUE);
+    
+  if (col>=0)
+    fColorSel->SetColor(col);//TColor::Number2Pixel(col+1));
+
+  fColorSel->SetEnabled(sPlot->IsOn());
+  return 0;
+
+}
+
+string ctbSignal::getSignalAlias() {
+  
+
+  ostringstream oss;
+  oss << "BIT" << dec << id << " " << sLabel->GetText()->Data() << " " << sPlot->IsOn() << hex << " " << fColorSel->GetColor() << endl;
+  return oss.str();
+
+
+
+
+}
+int ctbSignal::setOutput(Long64_t r) {
+
+
+  //  cout << hex << r << dec <<endl;
+
+  Long64_t mask=((Long64_t)1<<id);
+
+  if (r&mask)
+      sOutput->SetOn(kTRUE,kTRUE);
+  else 
+      sOutput->SetOn(kFALSE,kTRUE);
+    
+  return sOutput->IsOn();
+
+}
+
+int ctbSignal::fixOutput(int i) {
+
+  if (i) {
+    sPlot->SetOn(kFALSE);
+    //sClock->SetOn(kFALSE,kTRUE);
+    sOutput->SetOn(kTRUE);
+    //   sPlot->SetEnabled(kFALSE);
+    //  sClock->SetEnabled(kTRUE);
+  } else {
+    sOutput->SetOn(kFALSE,kTRUE);
+    //  sClock->SetOn(kFALSE);  
+    // sClock->SetEnabled(kFALSE);
+    sPlot->SetEnabled(kTRUE);
+  }
+  sOutput->SetEnabled(kFALSE);
+  return 0;
+
+}
+
+int ctbSignal::setDbitList(Long64_t r) {
+
+  Long64_t mask=((Long64_t)1<<id);
+
+  // cout << hex << r << dec <<endl;
+
+  if (r)
+      sDbitList->SetOn(kTRUE,kFALSE);
+  else 
+      sDbitList->SetOn(kFALSE,kFALSE);
+    
+  return sDbitList->IsOn();
+
+}
+
+int ctbSignal::isDbitList() { return sDbitList->IsOn();}
+int ctbSignal::isOutput() { return sOutput->IsOn();}
+int ctbSignal::isPlot() { return sPlot->IsOn();}
+Pixel_t ctbSignal::getColor(){return fColorSel->GetColor();}
+
+void ctbSignal::ToggledOutput(Bool_t b) {
+  Long_t mask=b<<id;
+  ToggledSignalOutput(id);
+  if (b) {
+    // sClock->SetEnabled(kTRUE);
+    sPlot->SetOn(kFALSE);
+    // sPlot->SetEnabled(kFALSE);
+    fColorSel->SetEnabled(kFALSE);
+  } else {
+    // sClock->SetEnabled(kFALSE);
+    // sClock->SetOn(kFALSE);
+    sPlot->SetEnabled(kTRUE);
+    if ( sPlot->IsOn())
+      fColorSel->SetEnabled(kFALSE);
+    else
+      fColorSel->SetEnabled(kTRUE);
+  }
+
+
+}
+
+void ctbSignal::ToggledDbitList(Bool_t b){
+  Long_t mask=id;
+  ToggledSignalDbitList(mask);
+}
+
+
+void ctbSignal::ToggledPlot(Bool_t b){
+  Long_t mask=b<<id;
+  ToggledSignalPlot(mask);
+  fColorSel->SetEnabled(b);
+}
+
+void ctbSignal::ColorChanged(Pixel_t p){
+  ToggledSignalPlot(id);
+}
+
+
+void ctbSignal::ToggledSignalOutput(Int_t b) {
+  cout << "Toggle signal " << id << " " << b  << " " <<  sOutput->IsOn() <<endl;;
+  Emit("ToggledSignalOutput(Int_t)", id);
+}
+
+void ctbSignal::ToggledSignalDbitList(Int_t b){
+  cout << "Toggle dbitlist " << id << " " << b << endl;;
+  Emit("ToggledSignalDbitList(Int_t)", id);
+}
+
+void ctbSignal::ToggledSignalPlot(Int_t b){
+  Emit("ToggledSignalPlot(Int_t)", id);
+}
+
+
+ctbSignals::ctbSignals(TGVerticalFrame *page, multiSlsDetector *det)
+  : TGGroupFrame(page,"IO Signals",kVerticalFrame), myDet(det) {
+
+
+  SetTitlePos(TGGroupFrame::kLeft);
+  page->AddFrame(this,new TGLayoutHints( kLHintsTop | kLHintsExpandX , 10,10,10,10));
+  MapWindow();
+  
+
+  TGHorizontalFrame *hframe;
+  char tit[100];
+ 
+  TGHorizontalFrame* hhframe=new TGHorizontalFrame(this, 800,800);
+  AddFrame(hhframe,new TGLayoutHints(kLHintsTop | kLHintsExpandX , 1,1,1,1));
+  hhframe->MapWindow();
+
+  TGVerticalFrame *vframe;
+
+
+
+
+  int idac=0;
+  for (idac=0; idac<NSIGNALS; idac++) {
+    if (idac%((NSIGNALS+2)/2)==0) {
+    vframe=new TGVerticalFrame(hhframe, 400,800);
+     hhframe->AddFrame(vframe,new TGLayoutHints(kLHintsTop | kLHintsExpandX , 1,1,1,1));
+    vframe->MapWindow();
+    }
+
+
+    signals[idac]=new ctbSignal(vframe,idac,myDet);
+    signals[idac]->Connect("ToggledSignalOutput(Int_t)","ctbSignals",this,"ToggledOutReg(Int_t)");
+    signals[idac]->Connect("ToggledSignalDbitList(Int_t)","ctbSignals",this,"ToggledDbitList(Int_t)");
+    signals[idac]->Connect("ToggledSignalPlot(Int_t)","ctbSignals",this,"ToggledPlot(Int_t)");
+ 
+    vframe->AddFrame(signals[idac],new TGLayoutHints(kLHintsTop | kLHintsExpandX , 1,1,1,1));
+    signals[idac]->MapWindow();
+
+
+  }
+
+// #ifdef CTB
+//   idac=62;
+//   signals[idac]=new ctbSignal(vframe,idac,myDet);
+//   vframe->AddFrame(signals[idac],new TGLayoutHints(kLHintsTop | kLHintsExpandX , 1,1,1,1));
+//   signals[idac]->MapWindow();
+//   sprintf(tit,"DBIT Latch");
+
+//   signals[idac]->setSignalAlias(tit,-1,-1);
+
+//   signals[idac]->Connect("ToggledSignalOutput(Int_t)","ctbSignals",this,"ToggledOutReg(Int_t)");
+//   signals[idac]->Connect("ToggledSignalDbitList(Int_t)","ctbSignals",this,"ToggledDbitList(Int_t)");
+//   signals[idac]->Connect("ToggledSignalPlot(Int_t)","ctbSignals",this,"ToggledPlot(Int_t)");
+
+
+// #endif
+
+
+  // idac=63;
+  // signals[idac]=new ctbSignal(vframe,idac,myDet);
+  // vframe->AddFrame(signals[idac],new TGLayoutHints(kLHintsTop | kLHintsExpandX , 1,1,1,1));
+  // signals[idac]->MapWindow();
+  // sprintf(tit,"ADC Latch");
+
+  // signals[idac]->setSignalAlias(tit,-1,-1);
+
+  // signals[idac]->Connect("ToggledSignalOutput(Int_t)","ctbSignals",this,"ToggledOutReg(Int_t)");
+  // signals[idac]->Connect("ToggledSignalDbitList(Int_t)","ctbSignals",this,"ToggledDbitList(Int_t)");
+  // signals[idac]->Connect("ToggledSignalPlot(Int_t)","ctbSignals",this,"ToggledPlot(Int_t)");
+
+
+  hframe=new TGHorizontalFrame(vframe, 800,50);
+  vframe->AddFrame(hframe,new TGLayoutHints(kLHintsTop | kLHintsExpandX , 1,1,1,1));
+  hframe->MapWindow();
+
+
+  TGLabel *label= new TGLabel(hframe, "IO Control Register: ");
+   hframe->AddFrame(label,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 1, 1, 1, 1));
+   label->MapWindow();
+   label->SetTextJustify(kTextLeft);
+
+
+   eIOCntrlRegister = new TGNumberEntry(hframe, 0, 16,999, TGNumberFormat::kNESHex,
+                                               TGNumberFormat::kNEANonNegative, 
+                                               TGNumberFormat::kNELNoLimits);
+
+  hframe->AddFrame(eIOCntrlRegister,new TGLayoutHints(kLHintsTop |  kLHintsExpandX, 1, 1, 1, 1));
+   eIOCntrlRegister->MapWindow();
+   eIOCntrlRegister->Resize(150,30);
+
+
+
+
+    hframe=new TGHorizontalFrame(vframe, 800,50);
+    vframe->AddFrame(hframe,new TGLayoutHints(kLHintsTop | kLHintsExpandX , 1,1,1,1));
+    hframe->MapWindow();
+   
+
+   label= new TGLabel(hframe, "DBit Offset: ");
+   hframe->AddFrame(label,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 1, 1, 1, 1));
+   label->MapWindow();
+   label->SetTextJustify(kTextLeft);
+
+
+   eDbitOffset = new TGNumberEntry(hframe, 0, 9,999, TGNumberFormat::kNESInteger,
+                                               TGNumberFormat::kNEANonNegative, 
+                                               TGNumberFormat::kNELNoLimits);
+
+  hframe->AddFrame(eDbitOffset,new TGLayoutHints(kLHintsTop |  kLHintsExpandX, 1, 1, 1, 1));
+   eDbitOffset->MapWindow();
+   eDbitOffset->Resize(150,30);
+   
+ 
+  TGTextEntry *e= eDbitOffset->TGNumberEntry::GetNumberEntry();
+    e->Connect("ReturnPressed()","ctbSignals",this,"setDbitOffset()");
+
+    e->Connect("ValueSet(Long_t)","ctbSignals",this,"setDbitOffset(Long_t)");
+}
+
+
+
+
+int ctbSignals::setSignalAlias(string line) {
+
+  int is=-1, plot=0, col=-1;
+  char tit[100];
+  int narg=sscanf(line.c_str(),"BIT%d %s %d %d",&is,tit,&plot,&col);
+  if (narg<2)
+    return -1;
+  if (is>=0 && is<NIOSIGNALS) {
+    signals[is]->setSignalAlias(tit,plot,col);
+  }
+  return is;
+
+}
+
+string ctbSignals::getSignalAlias() {
+
+  ostringstream oss;
+  for (int is=0; is<NIOSIGNALS; is++)
+    oss << signals[is]->getSignalAlias() << endl;
+
+
+    return oss.str();
+
+}
+
+
+void ctbSignals::update() {
+  Long64_t oreg=myDet->setPatternIOControl();//setCTBWord(-1,-1);
+  // Long64_t creg=myDet->setPatternClockControl();//setCTBWord(-2,-1);
+
+
+  char val[1000];
+  cout << hex << oreg << dec << endl;
+  //  cout << hex << creg << dec << endl;
+
+  sprintf(val,"%llX",oreg);
+  //  eIOCntrlRegister->SetHexNumber(oreg);
+ 
+
+  for (int idac=0; idac<NIOSIGNALS; idac++) {
+    signals[idac]->setOutput(oreg);
+   
+  }
+
+  Long64_t mask;
+  std::vector <int> dbitlist=myDet->getReceiverDbitList();
+  if (dbitlist.empty())
+    for (int is=0; is<64; is++) {
+      signals[is]->setDbitList(1);
+    } 
+  else {
+    for (int is=0; is<64; is++) signals[is]->setDbitList(0);
+    for (const auto &value : dbitlist)  {
+      signals[value]->setDbitList(1);
+    }
+  }
+
+
+  eDbitOffset->SetNumber(myDet->getReceiverDbitOffset());
+
+}
+
+
+string ctbSignals::getSignalParameters() {
+
+
+  ostringstream line;
+  line <<  "patioctrl " << hex << myDet->setPatternIOControl() << dec << endl;//setCTBWord(-1,-1)
+  return line.str();
+
+
+}
+
+void ctbSignals::ToggledOutReg(Int_t mask) {
+  
+  char val[1000];
+  Long64_t oreg=myDet->setPatternIOControl();//setCTBWord(-1,-1);
+  Long64_t m=((Long64_t)1)<<mask;
+  
+
+  cout << dec << sizeof(Long64_t) << " " << mask << " " << hex << m << " ioreg " << oreg;
+
+ 
+
+  if (signals[mask]->isOutput()) {
+    cout <<  " or " << m ;
+    oreg|=m;
+  }  else {
+    cout <<  " not " << ~m ;
+    oreg&=~m;
+  }
+  cout <<  " after " << oreg << endl;
+
+  myDet->setPatternIOControl(oreg);//setCTBWord(-1,oreg);
+  oreg=myDet->setPatternIOControl();//myDet->setCTBWord(-1,-1);
+
+  cout << dec << sizeof(Long64_t) << " " << mask << " " << hex << m << " ioreg " << oreg << endl;
+
+  sprintf(val,"%llX",oreg);
+  //  eIOCntrlRegister->SetHexNumber(oreg);
+  eIOCntrlRegister->SetText(val);
+  //  eIOCntrlRegister->SetNumber(oreg);
+
+}
+
+
+
+void ctbSignals::ToggledDbitList(Int_t mask){
+  
+
+
+  cout << "************* Here" << endl;
+
+
+
+  std::vector <int> new_dbitlist;
+  std::vector <int> old_dbitlist=myDet->getReceiverDbitList();
+
+  char val[1000];
+  Long64_t m=((Long64_t)1)<<mask;
+
+  if (old_dbitlist.empty() &&  signals[mask]->isDbitList()) 
+    ;
+  else {
+    int ns=0;
+    for (int is=0; is<64; is++) {
+      if (signals[is]->isDbitList()){ 
+	new_dbitlist.push_back(is);
+	ns++;
+	cout << is << " " << ns << endl;
+      }
+    }
+    if (ns>63) new_dbitlist.clear();
+    myDet->setReceiverDbitList(new_dbitlist);
+  }
+  std::vector <int> dbitlist=myDet->getReceiverDbitList();
+  if (dbitlist.empty())
+    for (int is=0; is<64; is++) signals[is]->setDbitList(1);
+  else
+    for (int is=0; is<64; is++) signals[is]->setDbitList(0);
+    for (const auto &value : dbitlist)  signals[value]->setDbitList(1);
+
+}
+
+
+
+
+void ctbSignals::ToggledPlot(Int_t b) {
+  
+  Emit("ToggledSignalPlot(Int_t)", b);
+
+}
+
+
+void ctbSignals::ToggledSignalPlot(Int_t b) {
+  
+  Emit("ToggledSignalPlot(Int_t)", b);
+
+}
+
+
+Pixel_t ctbSignals::getColor(int i){
+  if (i>=0 && i<NSIGNALS) return signals[i]->getColor();
+}
+
+int ctbSignals::getPlot(int i){
+  if (i>=0 && i<NSIGNALS) return signals[i]->isPlot();
+};
+
+void ctbSignals::setDbitOffset(Long_t) {
+  setDbitOffset();
+}
+void ctbSignals::setDbitOffset(){
+  myDet->setReceiverDbitOffset(eDbitOffset->GetNumber());
+}

ctbGui/ctbSignals.h

@@ -0,0 +1,118 @@
+#ifndef CTBSIGNALS_H
+#define CTBSIGNALS_H
+#include  <TGFrame.h>
+
+
+#define NSIGNALS 64
+
+#define NIOSIGNALS 64 //for moench board was 52
+
+
+#define ADCLATCH 63
+#define DIGSIGLATCH 62
+
+
+
+
+class TGTextEntry;
+class TGLabel;
+class TGNumberEntry;
+class TGCheckButton;
+class TH1I;
+class  TGTextButton;
+class TGColorSelect;
+
+
+
+class TGNumberEntry;
+class multiSlsDetector;
+class ctbSignal;
+
+#include <string>
+using namespace std;
+
+class ctbSignal : public TGHorizontalFrame {
+
+  // RQ_OBJECT("ctbSignal")
+
+private:
+
+   TGLabel *sLabel;
+   TGCheckButton *sOutput;
+   TGCheckButton *sDbitList;
+   TGCheckButton *sPlot;
+   TGLabel *sValue;
+   TGNumberEntry *sEntry;
+   TGColorSelect *fColorSel;
+
+   multiSlsDetector *myDet;
+   Int_t id;
+
+   TH1I *hsig;
+
+public:
+
+   ctbSignal(TGFrame *page, int i, multiSlsDetector *det);
+   int setSignalAlias(char *tit, int plot, int col);
+   string getSignalAlias();
+
+   TH1I *getPlot() {return hsig;};
+   int setOutput(Long64_t);
+   int fixOutput(int);
+   int setDbitList(Long64_t);
+
+   void ToggledOutput(Bool_t); 
+   void ToggledDbitList(Bool_t); 
+   void ToggledPlot(Bool_t); 
+   void ColorChanged(Pixel_t); 
+
+   int isDbitList();
+   int isOutput();
+   int isPlot();
+   Pixel_t getColor();
+
+
+   void ToggledSignalOutput(Int_t); //*SIGNAL*
+   void ToggledSignalDbitList(Int_t); //*SIGNAL*
+   void ToggledSignalPlot(Int_t); //*SIGNAL*
+
+
+
+   ClassDef(ctbSignal,0)
+};
+
+class ctbSignals : public TGGroupFrame {
+private:
+ 
+  ctbSignal *signals[NSIGNALS];
+
+  TGNumberEntry *eIOCntrlRegister;
+  TGNumberEntry *eDbitOffset;
+
+  multiSlsDetector *myDet;
+
+public:
+  ctbSignals(TGVerticalFrame *page, multiSlsDetector *det);
+   int setSignalAlias(string line);
+   string getSignalAlias();
+
+   int getPlot(int);
+   Pixel_t getColor(int);
+   
+   void update();
+   // void saveParameters();
+   string getSignalParameters();
+
+   //void setDbitList(Int_t);
+   void setDbitOffset(Long_t);
+   void setDbitOffset();
+
+   void ToggledOutReg(Int_t);
+   void ToggledDbitList(Int_t);
+   void ToggledPlot(Int_t);
+   void ToggledSignalPlot(Int_t); //*SIGNAL*
+
+   ClassDef(ctbSignals,0)
+};
+
+#endif

ctbGui/ctbSlowAdcs.cpp

@@ -0,0 +1,185 @@
+
+#include <stdio.h>
+#include <iostream>
+#include <fstream>
+
+#include <TGTextEntry.h>
+#include <TGLabel.h>
+#include <TGNumberEntry.h>
+#include <TGButton.h>
+
+#include "ctbSlowAdcs.h"
+#include "multiSlsDetector.h"
+#include "sls_detector_defs.h"
+
+using namespace std;
+
+
+
+
+ctbSlowAdc::ctbSlowAdc(TGGroupFrame *page, int idac, multiSlsDetector *det) : TGHorizontalFrame(page, 800,50) , id(idac), myDet(det) {
+
+
+    TGHorizontalFrame *hframe=this;
+
+    page->AddFrame(hframe,new TGLayoutHints(kLHintsTop | kLHintsExpandX , 1,1,1,1));
+    MapWindow();
+
+    char tit[100];
+    
+
+   sprintf(tit, "SENSE %d:",idac-1000);
+
+   dacsLabel= new TGLabel(hframe, tit);// new TGLabel(hframe, tit);
+   
+ 
+
+   hframe->AddFrame(dacsLabel,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 5, 5, 5, 5));
+   dacsLabel->MapWindow();
+   dacsLabel->SetTextJustify(kTextLeft);
+
+  
+
+
+   sprintf(tit, "xxx");
+   dacsValue= new TGLabel(hframe, tit);
+   hframe->AddFrame( dacsValue,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 5, 5, 5, 5));
+   dacsValue->MapWindow();
+   dacsValue->SetTextJustify(kTextLeft);
+
+   
+
+   TGTextButton *b= new TGTextButton(hframe, "Update");
+   hframe->AddFrame( b,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 5, 5, 5, 5));
+   b->MapWindow();
+   b->SetTextJustify(kTextLeft);
+
+   b->Connect("Clicked()","ctbSlowAdc",this,"getValue()");
+
+
+
+}
+
+
+
+int ctbSlowAdc::setLabel(char *tit) {
+  if(tit)
+    dacsLabel->SetText(tit);
+
+      
+  return id;
+
+}
+
+string ctbSlowAdc::getLabel() {
+
+  ostringstream line;
+  line << dacsLabel->GetText() <<  endl;
+
+   //  line << "DAC" << dec << id << " " <<  dacsUnit->IsOn() << endl;
+
+  return line.str();
+
+}
+
+
+
+int ctbSlowAdc::getValue() {
+  
+  int val=myDet->getADC((slsDetectorDefs::dacIndex)id);
+  char s[100];
+  cout << "adc " << id << " " << val << endl;
+  sprintf(s,"%d mV",val);
+  if (id==999)
+    sprintf(s,"%d <20>C",val);
+  dacsValue->SetText(s);
+ 
+  
+
+  return val;
+
+}
+
+
+
+
+
+
+
+ctbSlowAdcs::ctbSlowAdcs(TGVerticalFrame *page, multiSlsDetector *det)   : TGGroupFrame(page,"Sense",kVerticalFrame) , myDet(det){
+
+
+  SetTitlePos(TGGroupFrame::kLeft);
+  page->AddFrame(this,new TGLayoutHints( kLHintsTop | kLHintsExpandX , 10,10,10,10));
+  MapWindow();
+  
+  // cout << "window mapped " << endl;
+
+ 
+  for (int idac=0; idac<NSLOWADCS; idac++) {
+
+     adcs[idac]=new ctbSlowAdc(this, idac+1000, myDet);
+
+  }
+  adcs[NSLOWADCS]=new ctbSlowAdc(this, 999, myDet);
+  adcs[NSLOWADCS]->setLabel("Temperature"); 
+
+}
+
+
+
+
+int ctbSlowAdcs::setSlowAdcAlias(string line) {
+
+  int is=-1, mv=0;
+  char tit[100];
+  int narg=sscanf(line.c_str(),"SENSE%d %s",&is,tit,&mv);
+  if (narg<2)
+    return -1;
+  if (is>=0 && is<NSLOWADCS) 
+    adcs[is]->setLabel(tit);
+  return is;
+
+}
+
+string ctbSlowAdcs::getSlowAdcAlias() {
+
+  ostringstream line;
+
+  for (int i=0; i<NSLOWADCS; i++)
+    line << adcs[i]->getLabel() << endl;
+  return line.str();
+
+}
+
+
+
+
+string ctbSlowAdcs::getAdcParameters() {
+
+
+  ostringstream line;
+
+  for (int i=0; i<NSLOWADCS; i++) {
+    //line << "dacs:" << i << " " << dacs[i]->getValue << endl;
+    line << "adc:" << i << " " << adcs[i]->getValue() << endl;
+  }    
+  line << "adc:-1" << adcs[NSLOWADCS]->getValue() << endl;
+  return line.str();
+
+
+}
+
+
+
+void  ctbSlowAdcs::update() {
+
+
+  for (int idac=0; idac<NSLOWADCS+1; idac++) {
+
+    adcs[idac]->getValue();
+
+  }
+
+
+}

ctbGui/ctbSlowAdcs.h

@@ -0,0 +1,75 @@
+
+
+#ifndef CTBSLOWADCS_H
+#define CTBSLOWADCS_H
+#include  <TGFrame.h>
+
+
+//#define NDACS 16
+#define NSLOWADCS 8
+
+
+
+
+class TGTextEntry;
+class TGLabel;
+class TGNumberEntry;
+class TGCheckButton;
+class TGTextButton;
+
+
+
+class multiSlsDetector;
+
+#include <string>
+using namespace std;
+
+class ctbSlowAdc : public TGHorizontalFrame {
+
+
+ protected:
+  // TGLabel *dacsLabel;
+  // TGNumberEntry *dacsEntry;
+  // TGCheckButton *dacsUnit;
+   TGLabel *dacsLabel;
+   TGLabel *dacsValue;
+   int id;
+
+   multiSlsDetector* myDet;
+ public:
+   ctbSlowAdc(TGGroupFrame*, int , multiSlsDetector*);
+   int getValue();
+   
+   int setLabel(char *tit);
+   string getLabel();
+
+
+
+   ClassDef(ctbSlowAdc,0)
+};
+
+
+class ctbSlowAdcs : public TGGroupFrame {
+private:
+  
+
+
+   ctbSlowAdc *adcs[NSLOWADCS+1];
+
+   multiSlsDetector* myDet;
+
+public:
+   ctbSlowAdcs(TGVerticalFrame *page, multiSlsDetector*);
+
+   int setSlowAdcAlias(string line);
+   // int setDacAlias(string line);
+   string getSlowAdcAlias();
+   string getAdcParameters();
+
+   void update();
+
+   ClassDef(ctbSlowAdcs,0)
+};
+
+#endif
+

ctbGui/patternGenerator/deserializer.cpp

@@ -0,0 +1,110 @@
+
+#include <stdlib.h>  
+#include <stdint.h>  
+#include <string.h>  
+#include <sys/utsname.h>   
+#include <sys/types.h>
+#include <unistd.h>  
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <math.h>
+#include <fcntl.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+int main(int argc, char *argv[]) {
+
+  int iarg;
+  char fname[10000];
+  uint64_t word;
+  int val[64];
+  int bit[64];
+  FILE *fdin;
+  
+  int nb=2;
+  int off=0;
+  int ioff=0;
+  int dr=24;
+  int idr=0;
+  int ib=0;
+  int iw=0;
+  bit[0]=19;
+  bit[1]=8;
+  //  for (iarg=0; iarg<argc; iarg++) printf("%d %s\n",iarg, argv[iarg]);
+  
+  if (argc<2) printf("Error: usage is %s fname [dr off  b0 b1 bn]\n");
+  
+  if (argc>2) dr=atoi(argv[2]);
+  if (argc>3) off=atoi(argv[3]);
+  if (argc>4) {
+  for (ib=0; ib<64; ib++) {
+    if (argc>4+ib) {
+      bit[ib]=atoi(argv[4+ib]);
+      nb++;
+    }
+  }
+  
+  }
+  
+  idr=0;
+  for (ib=0; ib<nb; ib++) {
+    val[ib]=0;
+  }
+  
+  
+  fdin=fopen(argv[1],"rb");
+  if (fdin==NULL) {
+    printf("Cannot open input file %s for reading\n",argv[1]);
+    return 200;
+  } 
+  
+  while (fread((void*)&word, 8, 1, fdin)) {
+    //   printf("%llx\n",word);
+    if (ioff<off) ioff++;
+    else {
+      
+      for (ib=0; ib<nb; ib++) {
+	if (word&(1<<bit[ib])) 	  val[ib]|=(1<<idr);
+      }
+      idr++;
+      if (idr==dr) {
+	idr=0;
+	fprintf(stdout,"%d\t",iw++);
+	for (ib=0; ib<nb; ib++) {
+#ifdef HEX
+	  fprintf(stdout,"%08llx\t",val[ib]);
+#else
+	  fprintf(stdout,"%lld\t",val[ib]);
+	  
+#endif
+	  
+	  val[ib]=0;
+	}
+	fprintf(stdout,"\n");
+      }
+      
+    }
+
+  }
+  if (idr!=0) {
+    fprintf(stdout,"%d\t",iw++);
+    for (ib=0; ib<nb; ib++) {
+#ifdef HEX
+	  fprintf(stdout,"%08llx\t",val[ib]);
+#else
+	  fprintf(stdout,"%lld\t",val[ib]);
+	  
+#endif
+	  
+	  val[ib]=0;
+    }
+    fprintf(stdout,"\n");
+  }
+
+  fclose(fdin);
+
+  return 0;
+}

ctbGui/patternGenerator/generate.sh

@@ -0,0 +1,30 @@
+if [ "$#" -eq 0 ]; then
+    echo "Wrong number of arguments: usage should be $0 patname"
+    exit 1
+fi
+infile=$1
+outfile=$infile"at"
+outfilebin=$infile"bin"
+if [ "$#" -ge 2 ]; then
+    outfile=$2
+fi
+exe=$infile"exe"
+if [ "$#" -ge 4 ]; then
+    exe=$4
+fi
+
+if [ "$#" -ge 3 ]; then
+    outfilebin=$3
+fi
+
+if [ -f "$infile" ]
+then
+gcc -DINFILE="\"$infile\"" -DOUTFILE="\"$outfile\""  -DOUTFILEBIN="\"$outfilebin\"" -o $exe generator.c ; 
+echo compiling
+$exe ; 
+echo cleaning
+rm $exe
+echo done
+else
+	echo "$infile not found."
+fi

ctbGui/patternGenerator/generator.c

@@ -0,0 +1,177 @@
+/****************************************************************************
+usage to generate a patter test.pat from test.p
+
+gcc -DINFILE="\"test.p\"" -DOUTFILE="\"test.pat\"" -o test.exe generator.c ; ./test.exe ; rm test.exe
+
+
+*************************************************************************/
+
+#include <stdlib.h>  
+#include <stdint.h>  
+#include <string.h>  
+#include <sys/utsname.h>   
+#include <sys/types.h>
+#include <unistd.h>  
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <math.h>
+#include <fcntl.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#define MAXLOOPS 3
+#define MAXTIMERS 3
+#define MAXWORDS 1024
+
+
+
+uint64_t pat=0;
+uint64_t iopat=0;
+uint64_t clkpat=0;
+
+int iaddr=0;
+int waitaddr[3]={MAXWORDS,MAXWORDS,MAXWORDS};
+int startloopaddr[3]={MAXWORDS,MAXWORDS,MAXWORDS}; 
+int stoploopaddr[3]={MAXWORDS,MAXWORDS,MAXWORDS}; 
+int start=0, stop=0;
+uint64_t waittime[3]={0,0,0};
+int nloop[3]={0,0,0};
+
+char infile[10000], outfile[10000];
+
+FILE *fd, *fd1;
+uint64_t PAT[MAXWORDS];
+
+
+int i,ii,iii,j,jj,jjj,pixx,pixy,memx,memy,muxout,memclk,colclk,rowclk,muxclk,memcol,memrow,loopcounter;
+
+void setstart() {
+  start=iaddr;
+}
+
+void setstop() {
+  stop=iaddr;
+}
+
+void setinput(int bit) {
+  uint64_t mask=1;
+  mask=mask<<bit;
+  iopat &= ~mask;
+}
+
+void setoutput(int bit) {
+  uint64_t mask=1;
+  mask=mask<<bit;
+  iopat |= mask;
+}
+
+void setclk(int bit) {
+  uint64_t mask=1;
+  mask=mask<<bit;
+  iopat |= mask;
+  clkpat |= mask;
+}
+
+void clearbit(int bit){
+  uint64_t mask=1;
+  mask=mask<<bit;
+  pat &= ~mask;
+}
+void setbit(int bit){
+  uint64_t mask=1;
+  mask=mask<<bit;
+  pat |= mask;
+}
+
+int checkbit(int bit) {
+  uint64_t mask=1;
+  mask=mask<<bit;
+  return (pat & mask ) >>bit;
+}
+
+void setstartloop(int iloop) {
+  if (iloop>=0 && iloop<MAXLOOPS)
+    startloopaddr[iloop]=iaddr;
+}
+
+
+void setstoploop(int iloop) {
+  if (iloop>=0 && iloop<MAXLOOPS)
+    stoploopaddr[iloop]=iaddr;
+}
+
+
+void setnloop(int iloop, int n) {
+  if (iloop>=0 && iloop<MAXLOOPS)
+    nloop[iloop]=n;
+}
+
+void setwaitpoint(int iloop) {
+  if (iloop>=0 && iloop<MAXTIMERS)
+    waitaddr[iloop]=iaddr;
+}
+
+
+void setwaittime(int iloop, uint64_t t) {
+  if (iloop>=0 && iloop<MAXTIMERS)
+    waittime[iloop]=t;
+}
+
+
+
+
+void pw(){
+  if (iaddr<MAXWORDS)
+    PAT[iaddr]= pat;
+  fprintf(fd,"patword 0x%04x 0x%016llx\n",iaddr, pat);
+  iaddr++;
+  if (iaddr>=MAXWORDS) printf("ERROR: too many word in the pattern (%d instead of %d)!",iaddr, MAXWORDS);
+}
+
+int parseCommand(int clk, int cmdbit, int cmd, int length) {
+  int ibit;
+  clearbit(clk);
+  for (ibit=0; ibit<length; ibit++) {
+    if (cmd&(1>>ibit))
+      setbit(cmdbit);
+    else
+      clearbit(cmdbit);
+    pw();
+    /******/
+    setbit(clk);
+    pw();
+    /******/
+  }
+};
+
+
+
+main(void) {
+  int iloop=0;
+  fd=fopen(OUTFILE,"w");
+#include INFILE
+
+  fprintf(fd,"patioctrl 0x%016llx\n",iopat);
+  fprintf(fd,"patclkctrl 0x%016llx\n",clkpat);
+  fprintf(fd,"patlimits 0x%04x 0x%04x\n",start, stop);
+
+  for (iloop=0; iloop<MAXLOOPS; iloop++) {
+    fprintf(fd,"patloop%d 0x%04x 0x%04x\n",iloop, startloopaddr[iloop], stoploopaddr[iloop]);
+    if ( startloopaddr[iloop]<0 || stoploopaddr[iloop]<= startloopaddr[iloop]) nloop[iloop]=0;
+    fprintf(fd,"patnloop%d %d\n",iloop, nloop[iloop]);
+  }
+
+  for (iloop=0; iloop<MAXTIMERS; iloop++) {
+    fprintf(fd,"patwait%d 0x%04x\n",iloop, waitaddr[iloop]);
+    if (waitaddr[iloop]<0) waittime[iloop]=0;
+    fprintf(fd,"patwaittime%d %lld\n",iloop, waittime[iloop]);
+  }
+  
+  close((int)fd);
+  fd1=fopen(OUTFILEBIN,"w");
+  fwrite(PAT,sizeof(uint64_t),iaddr, fd1);
+  close((int)fd1);
+}

ctbGui/patternGenerator/test.p

@@ -0,0 +1,201 @@
+//define signals and directions (Input, outputs, clocks)
+
+
+#define compTestIN 1
+setoutput(compTestIN);
+
+#define curON 32
+setoutput(curON);
+
+#define side_clk 2
+setclk(side_clk);
+
+#define side_din 3
+setoutput(side_din);
+
+#define clear_shr 4
+setoutput(clear_shr);
+
+#define bottom_din 5
+setoutput(bottom_din);
+
+#define bottom_clk 6
+setclk(bottom_clk);
+
+#define gHG 7
+setoutput(gHG);
+
+#define bypassCDS 31
+setoutput(bypassCDS);
+
+
+#define ENprechPRE 8
+setoutput(ENprechPRE);
+
+
+#define res 9
+setoutput(res);
+
+#define pulseOFF 30
+setoutput(pulseOFF);
+
+#define connCDS 27
+setoutput(connCDS);
+
+#define Dsg_1 24
+setoutput(Dsg_1);
+
+
+#define Dsg_2 25
+setoutput(Dsg_2);
+
+
+#define Dsg_3 23
+setoutput(Dsg_3);
+
+#define sto0 10
+setoutput(sto0);
+
+#define sto1 11
+setoutput(sto1);
+
+#define sto2 12
+setoutput(sto2);
+
+#define resCDS 13
+setoutput(resCDS);
+
+#define prechargeConnect 14
+setoutput(prechargeConnect);
+
+#define pulse 15
+setoutput(pulse);
+
+#define PCT_mode 21
+setoutput(PCT_mode);
+
+#define res_DGS 16
+setoutput(res_DGS);
+
+#define adc_ena 17
+setoutput(adc_ena);
+
+
+#define CLKBIT 18
+setclk(CLKBIT);
+
+
+#define adc_sync 63
+setoutput(adc_sync);
+
+
+
+
+
+	  
+#define PW pw()
+#define SB(x) setbit(x) 
+#define CB(x) clearbit(x)
+#define CLOCK  clearbit(CLKBIT); pw();setbit(CLKBIT);pw()
+#define LCLOCK  clearbit(CLKBIT); pw();setbit(CLKBIT);pw();clearbit(CLKBIT); pw()
+#define CLOCKS(x) for (i=0;i<x;i++) {clearbit(CLKBIT);pw(); setbit(CLKBIT); pw();}
+#define STOP setstop();
+#define START setstart();
+#define REPEAT(x) for (i=0;i<(x);i++) {pw();}
+#define DOFOR(x) for (j=0;j<(x);j++) {
+// }				     
+#define STARTUP1 CB(compTestIN);SB(clear_shr);CB(side_clk);CB(side_din);CB(bottom_din);CB(bottom_clk);
+#define STARTUP2 CB(pulse);SB(PCT_mode);SB(pulseOFF);CB(curON);
+#define STARTUP3 SB(res);SB(gHG);SB(ENprechPRE);
+#define STARTUP4 SB(bypassCDS); CB(connCDS);CB(sto0);SB(sto1);SB(sto2);
+#define STARTUP5 SB(resCDS);CB(Dsg_1);CB(Dsg_2);SB(Dsg_3);CB(prechargeConnect);SB(res_DGS);
+#define STARTUP STARTUP1 STARTUP2 STARTUP3 STARTUP4 STARTUP5 PW;
+
+
+
+
+
+//****NOTES****//
+//FUNCTIONS
+//Declare functions at the beginning 
+void load_pix(int nx, int ny)
+{//SELECT PIXEL 1,1 for readout
+SB(clear_shr);PW;PW;
+CB(clear_shr);PW;PW;PW;PW;
+
+SB(side_din);PW;
+SB(side_clk);PW;
+CB(side_din);
+setstartloop(0); //loop on the rows
+SB(side_clk);PW;
+setstoploop(0);  //finish loop on the rows
+setnloop(0,ny); //set number row selected -can be changed dynamically
+CB(side_clk);PW;
+SB(bottom_din);PW;
+SB(bottom_clk);PW;
+CB(bottom_din);
+setstartloop(1); //loop on the columns
+SB(bottom_clk);PW;
+setstoploop(1); //loop on the columns
+setnloop(1,ny); //set number columns selected -can be changed dynamically
+}
+   
+void load_col(void)
+{//SELECT COLUMN 1 for readout
+SB(clear_shr);PW;PW;
+CB(clear_shr);PW;PW;PW;PW;
+SB(bottom_din);PW;
+SB(bottom_clk);PW;
+CB(bottom_clk);PW;
+CB(bottom_din);PW;
+}
+//END of FUNCTIONS
+////////////////////////////////////////////////////////
+//LET BYPASS PREAMP AND CDS and write on preamp out.//
+//THIS ALLOWS CHECKING SOURCE FOLLOWERS               //
+////////////////////////////////////////////////////////
+
+   
+PW;
+   
+SB(5); PW;
+
+CB(5); PW;
+
+START; //pattern starts from here
+STARTUP;
+setwaitpoint(0); //set wait points
+PW;
+setwaittime(0,20); //wait time - can be changed dynamically
+SB(adc_ena);PW;
+   printf("ADC sync %x %d %llx\n",iaddr,adc_sync, pat);
+SB(adc_sync);PW;
+   printf("ADC sync %x %d  %llx\n",iaddr, adc_sync, pat);
+CB(gHG);
+setwaitpoint(1); //set wait points
+setwaittime(1,16); //wait time - can be changed dynamically
+CB(adc_sync);PW;
+load_pix(10, 20);
+
+CB(res);
+//CB(Dsg_3);PW;
+CB(res_DGS);
+setwaitpoint(2); //set wait points
+setwaittime(2,1000); //wait time - can be changed dynamically
+
+//SB(res_DGS);
+//PW;
+//SB(Dsg_3);
+//
+//CB(connCDS);
+//TEST SIGNALS END
+//
+REPEAT(20)
+
+//****************//
+//*FINAL COMMANDS*//
+//****************//
+CB(adc_ena);PW;
+//STARTUP;
+STOP; PW; //stops here
+//REPEAT(4);

docs/CMakeLists.txt

@@ -0,0 +1,67 @@
+find_package(Doxygen)
+find_package(Sphinx)
+
+
+if (DOXYGEN_FOUND AND SPHINX_FOUND)
+
+    # #Utility to generate command line documentation
+    add_executable(gendoc src/gendoc.cpp)
+    target_link_libraries(gendoc PRIVATE
+      slsDetectorShared
+    )
+    set_target_properties(gendoc PROPERTIES 
+      RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
+    )
+
+    
+    
+
+    #Doxygen
+    set(DOXYGEN_IN ${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in)
+    set(DOXYGEN_OUT ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile)
+    configure_file(${DOXYGEN_IN} ${DOXYGEN_OUT} @ONLY)
+
+    #Sphinx
+    set(SPHINX_SOURCE ${CMAKE_CURRENT_SOURCE_DIR}/src)
+    set(SPHINX_BUILD ${CMAKE_CURRENT_BINARY_DIR})
+
+    set(SPHINX_SOURCE_FILES
+      src/commandline.rst
+      src/container_utils.rst
+      src/dependencies.rst
+      src/detector.rst
+      src/index.rst
+      src/installation.rst
+      src/pydetector.rst
+      src/pyenums.rst
+      src/pyexamples.rst
+      src/receiver.rst
+      src/result.rst
+      src/type_traits.rst
+      src/ToString.rst
+      
+    )
+
+    foreach(filename ${SPHINX_SOURCE_FILES})
+      configure_file(${CMAKE_CURRENT_SOURCE_DIR}/${filename} 
+                    "${SPHINX_BUILD}/${filename}")
+    endforeach(filename ${SPHINX_SOURCE_FILES})
+
+    configure_file(
+        "${CMAKE_CURRENT_SOURCE_DIR}/conf.py.in"
+        "${SPHINX_BUILD}/conf.py"
+        @ONLY)
+
+    add_custom_target(docs
+                    gendoc
+                    COMMAND ${DOXYGEN_EXECUTABLE} ${DOXYGEN_OUT}
+                    COMMAND ${SPHINX_EXECUTABLE} -a -b html
+                    -Dbreathe_projects.slsDetectorPackage=${CMAKE_CURRENT_BINARY_DIR}/xml
+                    -c "${SPHINX_BUILD}"
+                    ${SPHINX_BUILD}/src 
+                    ${SPHINX_BUILD}/html
+                    COMMENT "Generating documentation with Sphinx")
+
+else (DOXYGEN_FOUND AND SPHINX_FOUND)
+  message("Doxygen and Sphinx are needed to build documentation")
+endif (DOXYGEN_FOUND AND SPHINX_FOUND)

docs/Doxyfile.in

@@ -58,7 +58,7 @@ PROJECT_LOGO           =
 # entered, it will be relative to the location where doxygen was started. If
 # left blank the current directory will be used.
 
-OUTPUT_DIRECTORY       = @CMAKE_CURRENT_BINARY_DIR@/docs/
+OUTPUT_DIRECTORY       = @CMAKE_CURRENT_BINARY_DIR@
 
 # If the CREATE_SUBDIRS tag is set to YES then doxygen will create 4096 sub-
 # directories (in 2 levels) under the output directory of each output format and
@@ -791,7 +791,7 @@ WARN_LOGFILE           =
 # spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
 # Note: If this tag is empty the current directory is searched.
 
-INPUT                  = @CMAKE_CURRENT_SOURCE_DIR@
+INPUT                  = @PROJECT_SOURCE_DIR@
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
@@ -890,7 +890,7 @@ EXCLUDE_SYMLINKS       = NO
 # Note that the wildcards are matched against the file with absolute path, so to
 # exclude all test directories for example use the pattern */test/*
 
-EXCLUDE_PATTERNS       = */tests/* */python */manual */rapidjson */catch */integrationTests *README* */slsDetectorGui/*
+EXCLUDE_PATTERNS       = */docs/* */tests/* */python/* */manual */slsDetectorServers/* */libs/* */integrationTests *README* */slsDetectorGui/* */ctbGui/* */slsDetectorCalibration/*
 
 # The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
 # (namespaces, classes, functions, etc.) that should be excluded from the
@@ -1104,7 +1104,7 @@ IGNORE_PREFIX          =
 # If the GENERATE_HTML tag is set to YES, doxygen will generate HTML output
 # The default value is: YES.
 
-GENERATE_HTML          = YES
+GENERATE_HTML          = NO
 
 # The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a
 # relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
@@ -1936,7 +1936,7 @@ MAN_LINKS              = NO
 # captures the structure of the code including all documentation.
 # The default value is: NO.
 
-GENERATE_XML           = NO
+GENERATE_XML           = YES
 
 # The XML_OUTPUT tag is used to specify where the XML pages will be put. If a
 # relative path is entered the value of OUTPUT_DIRECTORY will be put in front of

docs/conf.py.in

@@ -0,0 +1,62 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# This file only contains a selection of the most common options. For a full
+# list see the documentation:
+# http://www.sphinx-doc.org/en/master/config
+
+# -- Path setup --------------------------------------------------------------
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+import os
+import sys
+# sys.path.insert(0, os.path.abspath('.'))
+sys.path.insert(0, os.path.abspath('../bin/'))
+#sys.path.insert(0, '/home/l_frojdh/sls/build/bin')
+#sys.path.insert(0, @CMAKE_CURRENT_BINARY_DIR@)
+print(sys.path)
+
+# -- Project information -----------------------------------------------------
+
+project = 'slsDetectorPackage'
+copyright = '2019, PSD Detector Group'
+author = 'PSD Detector Group'
+version = '@PROJECT_VERSION@'
+
+# -- General configuration ---------------------------------------------------
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = ['breathe',
+              'sphinx_rtd_theme',
+              'sphinx.ext.autodoc',
+              'sphinx.ext.napoleon',
+             ]
+
+breathe_default_project = "slsDetectorPackage"
+napoleon_use_ivar = True
+
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This pattern also affects html_static_path and html_extra_path.
+exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
+
+
+# -- Options for HTML output -------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+html_theme = "sphinx_rtd_theme"
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+#html_static_path = ['_static']

docs/src/ToString.rst

@@ -0,0 +1,6 @@
+ToString
+==============
+
+String conversion
+
+.. doxygenfile:: ToString.h

docs/src/commandline.rst

@@ -0,0 +1,16 @@
+Command line interface
+==============================================
+
+Usage
+-------------
+
+Commands can be uses either with sls_detector_get or sls_detector_put
+
+.. code-block::
+
+    sls_detector_get vrf
+
+Commands
+-----------
+
+.. include:: ../commands.rst

docs/src/container_utils.rst

@@ -0,0 +1,14 @@
+ContainerUtils
+==================
+
+Helper functions to handle standard container compliant 
+containers. Supports array, vector, sls::Result etc.
+
+While not a part of the public API we aim not to change this
+interface too much. However, we don't give the same strong
+guarantees as for Detector etc. 
+
+Any reoccurring container operation should probably be added to
+this file.  
+
+.. doxygenfile:: container_utils.h

docs/src/dependencies.rst

@@ -0,0 +1,53 @@
+Dependencies
+=========================
+
+While we value few dependencies some libraries are required in 
+order to not have to reinvent the wheel. Due to the state of package
+management in C++ we decided to bundle some of them with our source
+code. These are found in the libs/ directory. 
+
+-----------------------
+Core
+-----------------------
+To use the basic building blocks, meaning sls_detector_get/put and 
+the shared libraries these are needed: 
+
+ * Linux, preferably recent kernel (currently no cross platform support)
+ * CMake > 3.9 
+ * C++11 compatible compiler. (We test with gcc and clang)
+ * ZeroMQ version 4
+
+-----------------------
+GUI
+-----------------------
+
+The GUI is currently using Qt4 but watch out for an upgrade to 5. 
+
+ * Qt 4.8
+ * Qwt 6
+
+-----------------------
+Python bindings
+-----------------------
+
+ * Python > 3.6
+ * pybind11 (packaged in libs/)
+
+
+-----------------------
+Documentation
+-----------------------
+
+The documentation that you are reading now is built with 
+
+ * Doxygen (to extract C++ classes etc.)
+ * Breathe (Sphinx plugin to handle doxygen xml)
+ * Sphinx 
+
+-----------------------
+Packaged in libs/
+-----------------------
+
+ * catch2 (unit testing)
+ * rapidjson (streaming from receiver)
+ * pybind11 (python bindings)  

docs/src/detector.rst

@@ -0,0 +1,16 @@
+Detector
+==============================================
+
+The sls::Detector is the new public API to control 
+detectors from C++. This API is also used internally
+for the Python bindings and the command line interface. 
+If a receiver has been configured this is also controlled
+through this class.
+
+Most, if not all, functions are called in parallel
+and the return value is a thin std::vector wrapper 
+containing results from all modules. (Result<T>)
+
+.. doxygenclass:: sls::Detector
+   :members:
+   :undoc-members:

docs/src/gendoc.cpp

@@ -0,0 +1,56 @@
+/** 
+ * Utility program to generate input files for the command line 
+ * documentation. Uses the string returned from sls_detector_help cmd
+ * 
+ */
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <vector>
+
+
+#include "CmdProxy.h"
+#include "Detector.h"
+#include "sls_detector_defs.h"
+
+std::string replace_all(const std::string &src, const std::string &from,
+                        const std::string &to) {
+
+    std::string results;
+    std::string::const_iterator end = src.end();
+    std::string::const_iterator current = src.begin();
+    std::string::const_iterator next =
+        std::search(current, end, from.begin(), from.end());
+    while (next != end) {
+        results.append(current, next);
+        results.append(to);
+        current = next + from.size();
+        next = std::search(current, end, from.begin(), from.end());
+    }
+    results.append(current, next);
+    return results;
+}
+
+int main() {
+
+    std::cout << "Generating command line documentation!\n";
+
+    sls::CmdProxy<sls::Detector> proxy(nullptr);
+    auto commands = proxy.GetProxyCommands();
+
+    std::ofstream fs("commands.rst");
+    fs << ".. glossary::\n";
+
+    for (const auto &cmd : commands) {
+        std::ostringstream os;
+        proxy.Call(cmd, {}, -1, slsDetectorDefs::HELP_ACTION, os);
+
+        auto tmp = os.str().erase(0, cmd.size());
+        auto usage = tmp.substr(0, tmp.find_first_of('\n'));
+        tmp.erase(0, usage.size());
+        auto help = replace_all(tmp, "\n\t", "\n\t\t");
+        fs << '\t' << cmd << usage << help << "\n";
+    }
+
+}

docs/src/index.rst

@@ -0,0 +1,50 @@
+.. slsDetectorPackage documentation master file, created by
+   sphinx-quickstart on Mon Jul 29 17:38:15 2019.
+   You can adapt this file completely to your liking, but it should at least
+   contain the root `toctree` directive.
+
+Welcome to slsDetectorPackage's documentation!
+==============================================
+
+.. toctree::
+    :maxdepth: 1
+    :caption: Installation:
+
+    installation
+    dependencies
+   
+.. toctree::
+    :caption: C++ API
+    :maxdepth: 2
+
+    detector
+    result
+    receiver
+
+.. toctree::
+    :caption: Python API
+    :maxdepth: 2
+
+    pydetector
+    pyenums
+    pyexamples
+
+.. toctree::
+    :caption: Command line
+    :maxdepth: 2
+
+    commandline  
+
+.. toctree::
+    :caption: Developer
+
+    container_utils
+    type_traits
+    ToString
+
+.. Indices and tables
+.. ==================
+
+.. * :ref:`genindex`
+.. * :ref:`modindex`
+.. * :ref:`search`

docs/src/installation.rst

@@ -0,0 +1,5 @@
+
+Installation
+==============================================
+
+get the source etc.

docs/src/pydetector.rst

@@ -0,0 +1,9 @@
+Detector
+=====================================================
+
+.. py:currentmodule:: sls_detector
+
+.. autoclass:: ExperimentalDetector
+    :members:  
+    :undoc-members:
+    :show-inheritance:

docs/src/pyenums.rst

@@ -0,0 +1,12 @@
+Enums
+===========
+
+These enums are defined in slsDetectorDefs in the C++ package and 
+exposed to Python through pybind11.
+
+.. py:currentmodule:: sls_detector
+
+.. autoclass:: runStatus
+    :members:  
+    :undoc-members:
+    :show-inheritance:

docs/src/pyexamples.rst

@@ -18,7 +18,7 @@ file writing etc.
     threshold = range(0, 2000, 200)
     for th in threshold:
         d.vthreshold = th
-        d.acq()
+        d.acquire()
     
 
 If we want to control the shutter of for example, the big X-ray box we can add
@@ -30,7 +30,7 @@ and closes is afterwards.
     with xrf_shutter_open(box, 'Fe'):
         for th in threshold:
             d.vthreshold = th
-            d.acq()
+            d.acquire()
         
         
 -----------------------

docs/src/receiver.rst

@@ -0,0 +1,6 @@
+Receiver
+==============================================
+
+.. doxygenclass:: slsReceiver
+   :members:
+..    :undoc-members:

docs/src/result.rst

@@ -0,0 +1,4 @@
+Result
+==============================================
+
+.. doxygenfile:: Result.h

docs/src/type_traits.rst

@@ -0,0 +1,7 @@
+TypeTraits
+==============
+
+Template meta functions in the same spirit as type_traits
+from the standard library.
+
+.. doxygenfile:: TypeTraits.h

examples/jungfrau.config

@@ -1,15 +1,16 @@
-hostname bchip038+
+hostname localhost
 
 0:rx_udpport 50004
-0:rx_udpip 10.1.1.100
-0:detectorip 10.1.1.10
-rx_hostname pcmoench01
+0:rx_udpip 172.24.8.84
+0:detectorip 172.24.8.254
+rx_hostname localhost
 
-powerchip 1
+#powerchip 1
+#vhighvoltage 200
 
 #extsig:0 trigger_in_rising_edge
 #timing trigger
 
-outdir /external_pool/jungfrau_data/softwaretest
+outdir /tmp/slsdetector
 
 

examples/jungfrau_two.config

@@ -17,6 +17,7 @@ hostname bchip048+bchip052+
 rx_hostname pcmoench01
 
 powerchip 1
+vhighvoltage 200
 #extsig:0 trigger_in_rising_edge
 #timing trigger
 

integrationTests/CMakeLists.txt

@@ -7,11 +7,11 @@
 #     ${PROJECT_SOURCE_DIR}/catch
 # )
 
-target_sources(tests PRIVATE 
-    ${CMAKE_CURRENT_SOURCE_DIR}/test-integrationMulti.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/test-integrationDectector.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/test-eigerIntegration.cpp
-)
+# target_sources(tests PRIVATE 
+#     ${CMAKE_CURRENT_SOURCE_DIR}/test-integrationMulti.cpp
+#     ${CMAKE_CURRENT_SOURCE_DIR}/test-integrationDectector.cpp
+#     ${CMAKE_CURRENT_SOURCE_DIR}/test-eigerIntegration.cpp
+# )
 
 # if(SLS_USE_TESTS)
 #     set(TEST_SOURCES
@@ -32,18 +32,7 @@ target_sources(tests PRIVATE
 #             RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
 #     )
 
-#     add_executable(a src/a.cpp)
-#     target_link_libraries(a 
-#         slsProjectOptions
-#         slsProjectWarnings
-#         slsDetectorShared
-#         slsSupportLib
-#         pthread
-#         rt
-#     )  
-#     set_target_properties(a PROPERTIES
-#         RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
-#     )
+
 
 # endif()
 

integrationTests/a.cpp

@@ -1,88 +0,0 @@
-
-#include "catch.hpp"
-
-#include "ClientSocket.h"
-#include "Timer.h"
-#include "logger.h"
-#include "network_utils.h"
-#include "slsDetector.h"
-#include "sls_detector_defs.h"
-#include "sls_detector_exceptions.h"
-#include "sls_detector_funcs.h"
-#include <iomanip>
-#include <iostream>
-#include <vector>
-
-#include <arpa/inet.h>
-#include <netdb.h>
-#include <string>
-#include <sys/socket.h>
-#include <sys/types.h>
-
-#include <algorithm>
-
-#include "network_utils.h"
-
-using namespace sls;
-using ROI = slsDetectorDefs::ROI;
-
-// Easy printing of an ROI
-std::ostream &operator<<(std::ostream &out, const ROI &r) {
-    return out << "xmin: " << std::setw(5) << r.xmin
-               << " xmax: " << std::setw(5) << r.xmax
-               << " ymin: " << std::setw(5) << r.ymin
-               << " ymax: " << std::setw(5) << r.ymax;
-}
-
-int main() {
-
-    std::cout << "nullptr: " << sizeof(nullptr) << "\n";
-    // int ret[]{0,0,0};
-    // for (auto i: ret)
-    //     std::cout << i << "\n";
-    // uint32_t imageSize = 101;
-    // uint32_t packetSize = 100;
-    // std::cout << "a: " << std::ceil((double)imageSize / (double)packetSize) <<'\n';
-    // std::cout << "b: " << imageSize / packetSize <<'\n';
-    // std::cout << "c: " << static_cast<double>(imageSize / packetSize) << '\n';
-    // std::cout << "c: " << (imageSize + packetSize-1) / packetSize << '\n';
-
-    // slsDetectorDefs::ROI roilimits[5];
-    // roilimits[0].xmin = 5;
-    // roilimits[0].xmax = 12;
-    // roilimits[0].ymin = 5;
-    // roilimits[0].ymax = 15;
-
-    // roilimits[1].xmin = 0;
-    // roilimits[1].xmax = 3;
-    // roilimits[1].ymin = 20;
-    // roilimits[1].ymax = 25;
-
-    // roilimits[2].xmin = 500;
-    // roilimits[2].xmax = 600;
-    // roilimits[2].ymin = 100;
-    // roilimits[2].ymax = 200;
-
-    // roilimits[3].xmin = 300;
-    // roilimits[3].xmax = 500;
-    // roilimits[3].ymin = 800;
-    // roilimits[3].ymax = 900;
-
-    // roilimits[4].xmin = 1000;
-    // roilimits[4].xmax = 2000;
-    // roilimits[4].ymin = 300;
-    // roilimits[4].ymax = 500;
-
-    // std::cout << "Before sorting:\n";
-    // for (auto r : roilimits) {
-    //     std::cout << r << '\n';
-    // }
-
-    // std::sort(std::begin(roilimits), std::end(roilimits),
-    //           [](ROI a, ROI b) { return a.xmin < b.xmin; });
-
-    // std::cout << "After sorting: \n";
-    // for (auto r : roilimits) {
-    //     std::cout << r << '\n';
-    // }
-}

integrationTests/test-eigerIntegration.cpp

@@ -10,9 +10,9 @@ class MultiDetectorFixture {
 
   public:
     MultiDetectorFixture() : d(0, true, true) {
-        d.setHostname(hostname.c_str());
-        if (my_ip != "undefined")
-            d.setReceiverHostname(my_ip);
+        d.setHostname(test::hostname.c_str());
+        if (test::my_ip != "undefined")
+            d.setReceiverHostname(test::my_ip);
     }
     ~MultiDetectorFixture() { d.freeSharedMemory(); }
 };
@@ -99,7 +99,6 @@ int to_time(uint32_t reg) {
 
 TEST_CASE_METHOD(MultiDetectorFixture, "Read/write register",
                  "[.eigerintegration][cli]") {
-    d.setTimer(ti::MEASUREMENTS_NUMBER, 1);
     d.setNumberOfFrames(1);
     d.setExposureTime(10000);
     d.acquire();
@@ -132,7 +131,7 @@ TEST_CASE_METHOD(MultiDetectorFixture, "Get time left",
 }
 
 TEST_CASE_METHOD(MultiDetectorFixture, "Get ID", "[.eigerintegration][cli]") {
-    std::string hn = hostname;
+    std::string hn = test::hostname;
     hn.erase(std::remove(begin(hn), end(hn), 'b'), end(hn));
     hn.erase(std::remove(begin(hn), end(hn), 'e'), end(hn));
     auto hostnames = sls::split(hn, '+');

integrationTests/test-integrationDectector.cpp

@@ -16,27 +16,24 @@
 // Header holding all configurations for different detectors
 #include "tests/config.h"
 #include "tests/globals.h"
-
+// using namespace test;
 // using dt = slsDetectorDefs::detectorType;
 // extern std::string hostname;
 // extern std::string detector_type;
 // extern dt type;
 
 TEST_CASE("Single detector no receiver", "[.integration][.single]") {
-    auto t = slsDetector::getTypeFromDetector(hostname);
-    CHECK(t == type);
+    auto t = slsDetector::getTypeFromDetector(test::hostname);
+    CHECK(t == test::type);
 
     slsDetector d(t);
     CHECK(d.getDetectorTypeAsEnum() == t);
-    CHECK(d.getDetectorTypeAsString() == detector_type);
+    CHECK(d.getDetectorTypeAsString() == test::detector_type);
 
-    d.setHostname(hostname);
-    CHECK(d.getHostname() == hostname);
+    d.setHostname(test::hostname);
+    CHECK(d.getHostname() == test::hostname);
 
-    d.setOnline(true);
-    CHECK(d.getOnlineFlag() == true);
-
-    CHECK(d.setDetectorType() == type);
+    CHECK(d.setDetectorType() == test::type);
 
     d.freeSharedMemory();
 }
@@ -54,9 +51,8 @@ TEST_CASE("Set control port then create a new object with this control port",
     int new_cport = 1993;
     int new_sport = 2000;
     {
-        slsDetector d(type);
-        d.setHostname(hostname);
-        d.setOnline(true);
+        slsDetector d(test::type);
+        d.setHostname(test::hostname);
         CHECK(d.getControlPort() == old_cport);
         d.setControlPort(new_cport);
         CHECK(d.getStopPort() == old_sport);
@@ -64,24 +60,21 @@ TEST_CASE("Set control port then create a new object with this control port",
         d.freeSharedMemory();
     }
     {
-        slsDetector d(type);
-        d.setHostname(hostname);
+        slsDetector d(test::type);
+        d.setHostname(test::hostname);
         d.setControlPort(new_cport);
         d.setStopPort(new_sport);
         CHECK(d.getControlPort() == new_cport);
         CHECK(d.getStopPort() == new_sport);
 
-        d.setOnline(true);
-
         // Reset standard ports
         d.setControlPort(old_cport);
         d.setStopPort(old_sport);
         d.freeSharedMemory();
     }
 
-    slsDetector d(type);
-    d.setHostname(hostname);
-    d.setOnline(true);
+    slsDetector d(test::type);
+    d.setHostname(test::hostname);
     CHECK(d.getStopPort() == DEFAULT_PORTNO + 1);
     d.freeSharedMemory();
 }
@@ -104,11 +97,8 @@ TEST_CASE("single EIGER detector no receiver basic set and get",
     d.setHostname(c.hostname);
     CHECK(d.getHostname() == c.hostname);
 
-    d.setOnline(true);
-    CHECK(d.getOnlineFlag() == true);
-
-    CHECK(d.getReceiverOnline() == false);
-    CHECK(d.checkDetectorVersionCompatibility() == slsDetectorDefs::OK);
+    CHECK(d.getUseReceiverFlag() == false);
+    CHECK_NOTHROW(d.checkDetectorVersionCompatibility());
 
     // Setting and reading exposure time
     auto t = 1000000000;
@@ -143,9 +133,8 @@ TEST_CASE("single EIGER detector no receiver basic set and get",
 
 
 TEST_CASE("Locking mechanism and last ip", "[.integration][.single]") {
-    slsDetector d(type);
-    d.setHostname(hostname);
-    d.setOnline(true);
+    slsDetector d(test::type);
+    d.setHostname(test::hostname);
 
     // Check that detector server is unlocked then lock
     CHECK(d.lockServer() == 0);
@@ -161,14 +150,13 @@ TEST_CASE("Locking mechanism and last ip", "[.integration][.single]") {
     d.lockServer(0);
     CHECK(d.lockServer() == 0);
 
-    CHECK(d.getLastClientIP() == my_ip);
+    CHECK(d.getLastClientIP() == test::my_ip);
     d.freeSharedMemory();
 }
 
 TEST_CASE("Set settings", "[.integration][.single]"){
-    slsDetector d(type);
-    d.setHostname(hostname);
-    d.setOnline(true);
+    slsDetector d(test::type);
+    d.setHostname(test::hostname);
     CHECK(d.setSettings(defs::STANDARD) == defs::STANDARD);
 }
 
@@ -197,9 +185,8 @@ TEST_CASE("Timer functions", "[.integration][cli]") {
     // MEASURED_SUBPERIOD,	/**< measured subperiod */
     // MAX_TIMERS
 
-    slsDetector d(type);
-    d.setHostname(hostname);
-    d.setOnline(true);
+    slsDetector d(test::type);
+    d.setHostname(test::hostname);
 
     // Number of frames
     auto frames = 5;
@@ -214,14 +201,14 @@ TEST_CASE("Timer functions", "[.integration][cli]") {
     d.setTimer(slsDetectorDefs::timerIndex::FRAME_PERIOD, period);
     CHECK(d.setTimer(slsDetectorDefs::timerIndex::FRAME_PERIOD) == period);
 
-    if (type != dt::EIGER) {
+    if (test::type != dt::EIGER) {
         auto delay = 10000;
         d.setTimer(slsDetectorDefs::timerIndex::DELAY_AFTER_TRIGGER, delay);
         CHECK(d.setTimer(slsDetectorDefs::timerIndex::DELAY_AFTER_TRIGGER) ==
               delay);
     }
 
-    if (type != dt::EIGER) {
+    if (test::type != dt::EIGER) {
         auto gates = 1;
         d.setTimer(slsDetectorDefs::timerIndex::GATES_NUMBER, gates);
         CHECK(d.setTimer(slsDetectorDefs::timerIndex::GATES_NUMBER) == gates);
@@ -231,7 +218,7 @@ TEST_CASE("Timer functions", "[.integration][cli]") {
     d.setTimer(slsDetectorDefs::timerIndex::CYCLES_NUMBER, cycles);
     CHECK(d.setTimer(slsDetectorDefs::timerIndex::CYCLES_NUMBER) == cycles);
 
-    if (type == dt::EIGER) {
+    if (test::type == dt::EIGER) {
         auto subtime = 200;
         d.setTimer(slsDetectorDefs::timerIndex::SUBFRAME_ACQUISITION_TIME,
                    subtime);
@@ -253,7 +240,6 @@ TEST_CASE("Timer functions", "[.integration][cli]") {
 //     auto type = slsDetector::getTypeFromDetector(c.hostname);
 //     slsDetector d(type);
 //     d.setHostname(c.hostname);
-//     d.setOnline(true);
 
 //     auto period = 1000000000;
 //     auto exptime = 100000000;
@@ -282,10 +268,9 @@ TEST_CASE(
     // ensure eiger detector type, hostname and online
     REQUIRE(m.getDetectorTypeAsEnum() == c.type_enum);
     REQUIRE(m.getHostname() == c.hostname);
-    REQUIRE(m.setOnline(true) == slsDetectorDefs::ONLINE_FLAG);
 
     // starting state with rate correction off
-    CHECK(m.setRateCorrection(0) == 0);
+    m.setRateCorrection(0);
 
     // dr 16: clk divider, no change for ratecorr
     CHECK(m.setDynamicRange(16) == 16);
@@ -313,14 +298,14 @@ TEST_CASE(
     CHECK(m.getRateCorrection() == ratecorr);
 
     // ratecorr fail with dr 4 or 8
-    CHECK_THROWS_AS(m.setDynamicRange(8), sls::NonCriticalError);
+    CHECK_THROWS_AS(m.setDynamicRange(8), sls::RuntimeError);
     CHECK(m.getRateCorrection() == 0);
     m.setDynamicRange(16);
     m.setDynamicRange(16);
     m.setRateCorrection(ratecorr);
     m.setDynamicRange(16);
     m.setRateCorrection(ratecorr);
-    CHECK_THROWS_AS(m.setDynamicRange(4), sls::NonCriticalError);
+    CHECK_THROWS_AS(m.setDynamicRange(4), sls::RuntimeError);
     CHECK(m.getRateCorrection() == 0);
 }
 
@@ -333,7 +318,6 @@ TEST_CASE("Chiptestboard Loading Patterns", "[.ctbintegration]") {
     // ensure ctb detector type, hostname and online
     REQUIRE(m.getDetectorTypeAsEnum() == c.type_enum);
     REQUIRE(m.getHostname() == c.hostname);
-    REQUIRE(m.setOnline(true) == slsDetectorDefs::ONLINE_FLAG);
 
     uint64_t word = 0;
     int addr = 0;
@@ -360,11 +344,11 @@ TEST_CASE("Chiptestboard Loading Patterns", "[.ctbintegration]") {
     m.setPatternWord(addr, word);
     CHECK(m.setPatternWord(addr, -1) == word);
     addr = MAX_ADDR;
-    CHECK_THROWS_AS(m.setPatternWord(addr, word), sls::NonCriticalError);
+    CHECK_THROWS_AS(m.setPatternWord(addr, word), sls::RuntimeError);
     CHECK_THROWS_WITH(m.setPatternWord(addr, word),
                       Catch::Matchers::Contains("be between 0 and"));
     addr = -1;
-    CHECK_THROWS_AS(m.setPatternWord(addr, word), sls::NonCriticalError);
+    CHECK_THROWS_AS(m.setPatternWord(addr, word), sls::RuntimeError);
     CHECK_THROWS_WITH(m.setPatternWord(addr, word),
                       Catch::Matchers::Contains("be between 0 and"));
 
@@ -419,7 +403,6 @@ TEST_CASE("Chiptestboard Dbit offset, list, sampling, advinvert", "[.ctbintegrat
     // ensure ctb detector type, hostname and online
     REQUIRE(m.getDetectorTypeAsEnum() == c.type_enum);
     REQUIRE(m.getHostname() == c.hostname);
-    REQUIRE(m.setOnline(true) == slsDetectorDefs::ONLINE_FLAG);
 
     // dbit offset
     m.setReceiverDbitOffset(0);
@@ -479,4 +462,68 @@ TEST_CASE("Chiptestboard Dbit offset, list, sampling, advinvert", "[.ctbintegrat
     CHECK(m.getExternalSampling() == 1);
     CHECK(m.readRegister(0x7b) == 0x1003E);
     
+}
+
+TEST_CASE("Eiger or Jungfrau startingfnum", "[.eigerintegration][.jungfrauintegration][startingfnum]") {
+    SingleDetectorConfig c;
+
+    // pick up multi detector from shm id 0
+    multiSlsDetector m(0);
+
+    // ensure ctb detector type, hostname and online
+    REQUIRE(((m.getDetectorTypeAsEnum() == slsDetectorDefs::detectorType::EIGER) || (m.getDetectorTypeAsEnum() == slsDetectorDefs::detectorType::JUNGFRAU)));
+    REQUIRE(m.getHostname() == c.hostname);
+
+     CHECK(m.setTimer(slsDetectorDefs::FRAME_NUMBER, 1) == 1);
+
+    // starting fnum
+    uint64_t val = 8;
+
+    m.setStartingFrameNumber(val);
+    CHECK(m.getStartingFrameNumber() == val);
+    CHECK(m.acquire() == slsDetectorDefs::OK);
+    CHECK(m.getReceiverCurrentFrameIndex() == val);
+
+    ++val;
+    CHECK(m.acquire() == slsDetectorDefs::OK);
+    CHECK(m.getReceiverCurrentFrameIndex() == val);
+
+    CHECK_THROWS_AS(m.setStartingFrameNumber(0), sls::RuntimeError);
+
+    if (m.getDetectorTypeAsString() == "Eiger") {
+        val = 281474976710655;
+    } else if (m.getDetectorTypeAsString() == "Jungfrau") {
+        val = 18446744073709551615;
+    }
+    m.setStartingFrameNumber(val);
+    CHECK(m.getStartingFrameNumber() == val);
+    CHECK(m.acquire() == slsDetectorDefs::OK);
+    CHECK(m.getReceiverCurrentFrameIndex() == val);
+    CHECK(m.getStartingFrameNumber() == (val + 1));
+}
+
+TEST_CASE("Eiger readnlines", "[.eigerintegration][readnlines]") {
+    SingleDetectorConfig c;
+
+    // pick up multi detector from shm id 0
+    multiSlsDetector m(0);
+
+    // ensure detector type, hostname
+    REQUIRE((m.getDetectorTypeAsEnum() == slsDetectorDefs::detectorType::EIGER));
+    REQUIRE(m.getHostname() == c.hostname);
+
+    m.setDynamicRange(16);
+    m.enableTenGigabitEthernet(0);
+    m.setReadNLines(256);
+    CHECK(m.getReadNLines() == 256);
+    m.setReadNLines(1);
+    CHECK(m.getReadNLines() == 1);
+        
+    m.setDynamicRange(8);
+    m.setReadNLines(256);
+    CHECK(m.getReadNLines() == 256);
+    CHECK_THROWS_AS(m.setReadNLines(1), sls::RuntimeError);
+    CHECK(m.getReadNLines() == 256);
+    CHECK_THROWS_AS(m.setReadNLines(0), sls::RuntimeError);
+    m.setReadNLines(256);
 }

integrationTests/test-integrationMulti.cpp

@@ -7,19 +7,18 @@
 using namespace Catch::literals;
 
 TEST_CASE("Initialize a multi detector", "[.integration][.multi]") {
-    auto hostnames = sls::split(hostname, '+');
+    auto hostnames = sls::split(test::hostname, '+');
 
     multiSlsDetector d(0, true, true);
-    d.setHostname(hostname.c_str());
-    REQUIRE(d.setOnline() == true); // get!
+    d.setHostname(test::hostname.c_str());
 
-    CHECK(d.getHostname() == hostname);
+    CHECK(d.getHostname() == test::hostname);
     for (size_t i = 0; i != hostnames.size(); ++i) {
         CHECK(d.getHostname(i) == hostnames[i]);
     }
 
-    CHECK(d.getDetectorTypeAsEnum() == type);
-    CHECK(d.getDetectorTypeAsString() == detector_type);
+    CHECK(d.getDetectorTypeAsEnum() == test::type);
+    CHECK(d.getDetectorTypeAsString() == test::detector_type);
 
     CHECK(d.getNumberOfDetectors() == hostnames.size());
     d.freeSharedMemory();
@@ -30,7 +29,7 @@ TEST_CASE("Initialize a multi detector", "[.integration][.multi]") {
 TEST_CASE("Set and read timers", "[.integration][.multi]") {
 
     multiSlsDetector d(0, true, true);
-    d.setHostname(hostname.c_str());
+    d.setHostname(test::hostname.c_str());
 
     // FRAME_NUMBER
     int n_frames = 3;
@@ -58,9 +57,6 @@ TEST_CASE("Set and read timers", "[.integration][.multi]") {
     // PROGRESS, /**< fraction of measurement elapsed - only get! */
     // MEASUREMENTS_NUMBER,
 
-    int measurements = 2;
-    d.setTimer(ti::MEASUREMENTS_NUMBER, measurements);
-    CHECK(d.setTimer(ti::MEASUREMENTS_NUMBER, -1) == measurements);
 
     // FRAMES_FROM_START,
     // FRAMES_FROM_START_PG,
@@ -68,7 +64,7 @@ TEST_CASE("Set and read timers", "[.integration][.multi]") {
 
     // SUBFRAME_ACQUISITION_TIME, /**< subframe exposure time */
     double subframe_exposure = 2000000; // ns
-    if (type == dt::EIGER) {
+    if (test::type == dt::EIGER) {
         d.setSubFrameExposureTime(subframe_exposure);
         CHECK(d.setSubFrameExposureTime(-1) == Approx(subframe_exposure));
     }
@@ -77,13 +73,13 @@ TEST_CASE("Set and read timers", "[.integration][.multi]") {
 
     // SUBFRAME_DEADTIME, /**< subframe deadtime */
     double subframe_deadtime = 4000; // ns
-    if (type == dt::EIGER) {
+    if (test::type == dt::EIGER) {
         d.setSubFrameExposureDeadTime(subframe_deadtime);
         CHECK(d.setSubFrameExposureDeadTime(-1) == Approx(subframe_deadtime));
     }
 
     
-    if (type == dt::EIGER) {
+    if (test::type == dt::EIGER) {
         // 32bit is needed for subframe exposure
         d.setDynamicRange(32);
         CHECK(d.setDynamicRange(-1) == 32);
@@ -107,4 +103,4 @@ TEST_CASE("Set and read timers", "[.integration][.multi]") {
     // MAX_TIMERS
 
     d.freeSharedMemory();
-}
+}

manual/manual-client/Eiger_short.tex

@@ -326,7 +326,25 @@ The size of the gap pixels between modules to insert is
    GapPixelsBetweenModules_y = 36
 \end{verbatim}
 where the {\tt{GapPixelsBetweenModules\_x}} are the one on the short side of the module, while {\tt{GapPixelsBetweenModules\_y}} are the ones on the long side of the module (where the wirebonds take physical space).
-  
+  \section{QUAD special geometry}
+Starting from release 4.1.0, we support a special geometry with 2x2 pixels. This is for a Quad, where a single half module reads out 4 chips but in a quad shape. For now this hardware is only available as a PEEM detector at SIM. 
+The {\tt{detsizechan 1024 512}} needs to remain set like this for a half module. However, thanks to the command: 
+ \begin{verbatim}
+./sls_detector_put quad 1
+\end{verbatim}
+
+a 512x512 geomtry will be read out if {\tt{gappixels 0}} and 514x514 will be readout if {\tt{gappixels 1}}. Note that as above, {\tt{gappixels 1}} is not supported for {\tt{dr 4}}.   
+If  {\tt{gappixels 0}}, in the master.raw file you will read: 
+\begin{verbatim}
+row                        : 512 pixels
+col                        : 256 pixels
+\end{verbatim}
+else if {\tt{gappixels 1}}, in the master.raw file you will read: 
+\begin{verbatim}
+row                        : 514 pixels
+col                        : 257 pixels
+\end{verbatim}
+
 \section{Readout timing- maximum frame rate}\label{timing}
 IMPORTANT: to have faster readout and smaller dead time, one can configure {\tt{clkdivider}}, i.e. the speed at which the data are read, i.e. 200/100/50~MHz for {\tt{clkdivider 0/1/2}} and the dead time between frames through {\tt{flags parallel}}, i.e. acquire and read at the same time or acquire and then read out.
 The configuration of this timing variables allows to achieve different frame rates. NOTE THAT IN EIGER, WHATEVER YOU DO, THE FRAME RATE LIMITATIONS COME FROM THE NETWORK BOTTLENECK AS THE HARDWARE GOES FASTER THAN THE DATA OUT.
@@ -335,7 +353,7 @@ In the case of REAL CONTINUOUS readout, i.e. continuous acquire and readout from
 \begin{table} 
 \begin{tabular}{|c|c|c|c|c|}
 \hline
-GbE & dynamic range & continuos maximum frame rate(Hz) & minimum period ($\mu$s)& time to send out data ($\mu$s)\\
+\tiny{GbE} & \tiny{dynamic range} & \tiny{continuos maximum frame rate(Hz)} & \tiny{minimum period ($\mu$s)}& \tiny{time to send out data ($\mu$s)}\\
 \hline
 1 & 16 &  \textbf{256} & 3901 & \\ 
 \hline 
@@ -347,10 +365,10 @@ GbE & dynamic range & continuos maximum frame rate(Hz) & minimum period ($\mu$s)
 \hline
 10 & 16 & \textbf{2560} & 391 & 400\\  
 \hline 
-10 & 32 & \textbf{1280}& 782 & 800\\  
+10 & 32 & \textbf{1280} & 782 & 800\\  
 \hline 
 \end{tabular}
-\caption{Frame rate limits for the CONTINUOS streaming out of images, i.e. the data rate out is just below 1Gb/s or 10Gb/s.} 
+\caption{Frame rate limits for the CONTINUOS streaming out of images, i.e. the data rate out is just below 1Gb/s or 10Gb/s. 1280~Hz for 32-bit, 10GbE is obtained from the 10GbE limitation. The maximum achievable frame rate is 977~Hz.} 
 \label{tcont}\end{table}
  Note that in the {\tt{continuous}} flag mode, some buffering is still done on the memories, so a higher frame rate than the proper real continuous one can be achieved. Still, this extra buffering is possible till the memories are not saturated. The number of images that can be stored on the DDR2 on board memories are listed in table~\ref{timgs}.
 \begin{table}
@@ -461,7 +479,7 @@ Here below are the final tables for settting the detcetor correctly:
     \hline
     max frame rate & settings\\
     \hline
-    \textcolor{red}{170 Hz} &  \textcolor{red}{32-bit} \\
+    \textcolor{red}{189~Hz (977~Hz max)} &  \textcolor{red}{32-bit} \\
     & Nframes=infinite\\
     \hline
       \textcolor{red}{2.56 kHz} &  \textcolor{red}{16-bit}\\
@@ -483,7 +501,7 @@ BE CAREFUL that if you have the transmission delays setup (see sec.~\ref{network
     \hline
     max frame rate & settings\\
     \hline
-     \textcolor{red}{170 Hz} &  \textcolor{red}{32-bit} \\
+    \textcolor{red}{189~Hz (977~Hz)} &  \textcolor{red}{32-bit} \\
     & Nframes=infinite\\
     \hline
      \textcolor{red}{6.1 kHz} &  \textcolor{red}{16-bit}\\
@@ -537,16 +555,16 @@ The time between 12-bit subframes are listed in table~\ref{t32bitframe}.
 \begin{tiny}
 \begin{table}
 \begin{flushleft}
-\begin{tabular}{|c|c|c|c|c|c|}
+\begin{tabular}{|c|c|c|c|c|c|c|}
 \hline
-\tiny{dr} & \tiny{clkdivider} & \tiny{flags} & \tiny{t difference between subframes($\mu$s)} & \tiny{max internal subframe rate (kHz)} & \tiny{maximum frame rate (Hz)}\\
+\tiny{dr} & \tiny{clkdivider} & \tiny{flags} & \tiny{subexptime (s)} & \tiny{t difference between subframes($\mu$s)} & \tiny{max internal subframe rate (kHz)} & \tiny{maximum frame rate (Hz)}\\
 \hline
-32 & 2 & parallel & 12 & 2 & 170\\
+32 & 2 & parallel & 0.00262144 & 12 & 380 & 189\\
 \hline
-32 & 2 & nonparallel & 504 & $<2$ & 160\\
+32 & 2 & parallel & 0.000490 & 12 & 2 & 997\\
 \hline
 \end{tabular}
-\caption{Timing for the 32bit case. The maximum frame rate has been computed assuming 2 subframes of default {\tt{subexptime}} of 2.62144 ms.}
+\caption{Timing for the 32bit case. The maximum frame rate has been computed assuming 2 subframes of default {\tt{subexptime}} of 2.62144 ms, which is the default value. By setting up {\tt{subexptime}} to 490~$\mu$s one can achieve a maximum frame rate. Note that one has to leave 490$\mu$s extra between a frame and the following.}
 \label{t32bitframe}
 \end{flushleft}
 \end{table}
@@ -601,7 +619,10 @@ Here are the implemented options so far:
 \item {\tt{auto}} is the software controlled acquisition (does not use triggers), where {\tt{exptime}} and {\tt{period}} have to be set. Set number of cycles (i.e. triggers) to 1 using {\tt{cycles}}. Set number of frames using {\tt{frames}}.
 \item {\tt{trigger}} 1 frame taken for 1 trigger. Your {\tt{frames}} needs to be  1 always, {\tt{cycles}} can be changed and defines how many triggers are considered.  {\tt{exptime}} needs to be set. In the GUI this is called trigger exposure series.  
 \item {\tt{burst\_trigger}} gets only 1 trigger, but allows to take many frames. With {\tt{frames}} one can change the number of frames. {\tt{cycles}} needs to be 1.  {\tt{exptime}} and {\tt{period}} have to be set. In the gui it is called trigger readout.
-\item{\tt{gating}} allows to get a frame only when the trigger pulse is gating. Note that in this case the exp time and period only depend on the gating signal. {\tt{cycles}} allows to select how many gates to consider.  Set number of frames to 1 using {\tt{frames}}. ATTENTION: if you are in 16 bit mode and you are applying online rate corrections, as now the exptime is generated by the trigger, you might not have correct rate corrections. If you know what the exposure time is in the gating signal, then you can set the {\tt{exptime}} once and the rate corrections will be correct. If the exposure time is unknow, it is recommended that you switch off the rate corrections. In 32 bit mode, it does not matter as the rate corrections depends on the {\tt{subexptime}} which is software set independently from the gate exptime.
+\item{\tt{gating}} allows to get a frame only when the trigger pulse is gating. Note that in this case the exp time and period only depend on the gating signal. {\tt{cycles}} allows to select how many gates to consider.  Set number of frames to 1 using {\tt{frames}}. IMPORTANT: Up to firmware 23, the last subframe is oblige to finish being taken, despite the gate signal going down. This will be configurable from later fw and software version. Also, in gating mode, due to timimg of the state machine, you need to leave 500~$\mu$s deadtime between the end on an acquisition and the next. This is as the state machine is unable to check for changes in the status in the first 500~$\mu$s. ATTENTION: if you are in 16 bit mode and you are applying online rate corrections, as now the exptime is generated by the trigger, you might not have correct rate corrections. If you know what the exposure time is in the gating signal, then you can set the {\tt{exptime}} once and the rate corrections will be correct. In 32 bit mode, it does not matter as the rate corrections depends on the {\tt{subexptime}} which is software set independently from the gate exptime.
+
+When using 32-bit mode, by default the acquisition ends the last complete subframe that was started when still the acquisition time was valid. This has been chosen as many people wants to know the exact acquisition time for when the detector was taking data and also, if {\tt{ratecorr}} are active, the last subframe will be correctly corrected, while otherwise it will be corrected with a wrong subdeadtime. 
+However, from 4.1.0, in gating mode, an option to immediately terminate the subframe when the gate signal goes down it is implemented to stop the acquisition at the same time.  This option is {\tt{./sls\_detector\_put interruptsubframe 1}} while the default option is {\tt{./sls\_detector\_put interruptsubframe 0}}.  
 
 \end{itemize}
 
@@ -784,9 +805,18 @@ For configuring well the 10Gb card not to loose packets,
 \item MTU must be set up to 9000 (jumbo frames) on all the involved sides: detector, switch, server NIC
 \item you should set up static MAC address tables with separated VLANs
 \end{itemize}
-As root, also do:
+As root, also first check your ethtool settings (-small letter arguments), then change the settings (-capital letter arguments):
 \begin{verbatim}
- ethtool -G xth1 rx 4096, ethtool -C xth1 rx-usecs 100 
+ethtool -g xth1 
+ethtool -c xth1 
+ethtool -a xth1
+\end{verbatim}
+
+To change settings:
+\begin{verbatim}
+ethtool -G xth1 rx 4096 #or wheterver is the max number for your pc
+ethtool -C xth1 rx-usecs 100 
+ethtool -A xth1 rx on
 \end{verbatim}
 where {\tt{xth1}} can be replaced with the correct 10Gb device. To minimise loosing packets, priorities are set better as root user, so have the receiver as root.
 To try to bypass being root, we trued something like this:

python/CMakeLists.txt

@@ -1,11 +1,13 @@
-add_subdirectory(pybind11)
-pybind11_add_module(_sls_detector src/main.cpp)
+
+pybind11_add_module(_sls_detector 
+    src/main.cpp 
+    src/enums.cpp
+    src/experimental.cpp
+)
 
 
 
 target_link_libraries(_sls_detector PUBLIC 
-                        slsProjectOptions
-                        slsProjectWarnings
                         slsDetectorShared
                         slsReceiverShared
                         slsSupportLib

python/setup.py

@@ -36,7 +36,9 @@ class get_pybind_include(object):
 ext_modules = [
     Extension(
         '_sls_detector',
-        ['src/main.cpp'],
+        ['src/main.cpp',
+        'src/enums.cpp',
+        'src/experimental.cpp'],
         include_dirs=[
             # Path to pybind11 headers
             get_pybind_include(),

python/sls_detector/__init__.py

@@ -4,3 +4,6 @@ from .experimental import ExperimentalDetector
 from .jungfrau import Jungfrau
 from .jungfrau_ctb import JungfrauCTB
 from _sls_detector import DetectorApi
+
+import _sls_detector
+runStatus = _sls_detector.slsDetectorDefs.runStatus

python/sls_detector/decorators.py

@@ -7,49 +7,3 @@ from .errors import DetectorError
 import functools
 
 
-def error_handling(func):
-    """
-    Check for errors registered by the slsDetectorSoftware
-    """
-    @functools.wraps(func)
-    def wrapper(self, *args, **kwargs):
-        
-        # remove any previous errors
-        self._api.clearErrorMask()
-        
-        # call function
-        result = func(self, *args, **kwargs)
-        
-        # check for new errors
-        m = self.error_mask
-        if m != 0:
-            msg = self.error_message
-            self._api.clearErrorMask()
-            raise DetectorError(msg)
-        return result
-
-    return wrapper
-
-
-def property_error_handling(func):
-    """
-    Check for errors registered by the slsDetectorSoftware
-    """
-
-    @functools.wraps(func)
-    def wrapper(self, *args, **kwargs):
-        # remove any previous errors
-        self._detector._api.clearErrorMask()
-
-        # call function
-        result = func(self, *args, **kwargs)
-
-        # check for new errors
-        m = self._detector.error_mask
-        if m != 0:
-            msg = self._detector.error_message
-            self._detector._api.clearErrorMask()
-            raise DetectorError(msg)
-        return result
-
-    return wrapper

python/sls_detector/detector.py

@@ -10,7 +10,6 @@ from collections.abc import Iterable
 from collections import namedtuple
 
 from _sls_detector import DetectorApi
-from .decorators import error_handling
 from .detector_property import DetectorProperty
 from .errors import DetectorError, DetectorValueError
 from .registers import Register
@@ -41,12 +40,6 @@ class Detector:
                                               self._api.setFlippedDataY,
                                               self._api.getNumberOfDetectors,
                                               'flippeddatay')
-        try:
-            self.online = True
-            self.receiver_online = True
-        except DetectorError:
-            print('WARNING: Cannot connect to detector')
-
 
     def __len__(self):
         return self._api.getNumberOfDetectors()
@@ -97,9 +90,6 @@ class Detector:
     def busy(self, value):
         self._api.setAcquiringFlag(value)
 
-    def clear_errors(self):
-        """Clear the error mask for the detector. Used to reset after checking."""
-        self._api.clearErrorMask()
 
     @property
     def client_version(self):
@@ -732,27 +722,6 @@ class Detector:
         """
         return self._api.getNumberOfDetectors()
 
-    @property
-    def online(self):
-        """Online flag for the detector
-
-        Examples
-        ----------
-
-        ::
-
-            d.online
-            >> False
-
-            d.online = True
-
-        """
-        return self._api.getOnline()
-
-    @online.setter
-    def online(self, value):
-        self._api.setOnline(value)
-
 
     @property
     def last_client_ip(self):
@@ -798,9 +767,6 @@ class Detector:
         """
         return self._api.getReceiverOnline()
 
-    @receiver_online.setter
-    def receiver_online(self, value):
-        self._api.setReceiverOnline(value)
 
     @property
     def receiver_version(self):
@@ -1025,6 +991,11 @@ class Detector:
         self._api.setNetworkParameter('rx_zmqip', ip, -1)
 
 
+
+    @property
+    def syncclk(self):
+        return self._api.getSyncClkSpeed(-1)
+
     @property
     def detectormac(self):
         """

python/sls_detector/eiger.py

@@ -13,7 +13,6 @@ from functools import partial
 
 from .adcs import Adc, DetectorAdcs
 from .dacs import DetectorDacs
-from .decorators import error_handling
 from .detector import Detector
 from .detector_property import DetectorProperty
 from .utils import element_if_equal