after merging with developer

* not done. The 'setsockopt(SO_RECVBUF)' system call cannot set the socket buffer
  size lager than the specified in net.core.rmem_max. The requested value
  was 2 GB (commit 3b0e2e6), which is far too large for this application,
  so it was restored to the acceptable 100 MB value.

* The syscall does not fail if the requested buffer size is larger than
  net.core.rmem_max. Use 'setsockopt(SO_RECVBUFFORCE)' to actually force a
  value larger than the system limit, which can be done if run in a
  privileged context (capability CAP_NET_ADMIN set).

* The real value is read with 'getsockopt(SO_RECVBUF)'. If it
  corresponds to twice the requested value (see 'man 7 socket'), it is
  printed in green, otherwise it is signalled in red.

* The 'setsockopt(SO_RECVBUFFORCE)' syscall removes the need to write to
  /proc/sys/net/core/rmem_max, so this was was suppressed in the
  'UDPStandardImplementation' constructor.

* The test on EIGER detectors before setting the system
  buffers was removed. Was there for 9m/2m eiger, but one can take care of
  memory requirements using a customizable max socket buffer size(only with
  permissions). to be implmented later.

* The file /proc/sys/net/core/netdev_max_backlog is first read by the
  receiver to check is the current value is OK. If it is not, the receiver
  directly writes the good value into the file (instead of delegating to
  the system shell), printing a red error message if there is an access
  error (non-privileged user).

CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 2.8)
-set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")
+set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
 set (CALIBRATE OFF)
 
 option (USE_HDF5 "HDF5 File format" OFF)
@@ -7,13 +7,18 @@ option (USE_TEXTCLIENT "Text Client" OFF)
 option (USE_RECEIVER "Receiver" OFF)
 option (USE_GUI "GUI" OFF)
 
-set(CMAKE_CXX_FLAGS  "${CMAKE_CXX_FLAGS} -Wall -Wno-misleading-indentation")
+
+if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 6.0)
+	set(CMAKE_CXX_FLAGS  "${CMAKE_CXX_FLAGS} -Wall -std=c++98 -Wno-misleading-indentation")
+else ()
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -std=c++98")
+endif ()
 
 find_package(Qt4)
 find_package(Qwt 6)
 find_package(CBF)
 find_package(Doxygen)
-find_package(PNG REQUIRED)
+# find_package(PNG REQUIRED)
 
 if (USE_HDF5)
 	find_package(HDF5 1.10 COMPONENTS CXX)
@@ -31,8 +36,10 @@ endif (USE_TEXTCLIENT)
 
 if (USE_RECEIVER)
        add_subdirectory(slsReceiverSoftware)
+       add_subdirectory(manual/manual-api)    
 endif (USE_RECEIVER)
                
+               
 if (USE_GUI)   
        if (QT4_FOUND AND QWT_FOUND)
        add_subdirectory(slsDetectorGui)

Makefile

@@ -19,11 +19,12 @@ RECEIVERDIR		=	$(LIBRARYRXRDIR)
 CALWIZDIR		=	$(WD)/calibrationWizards
 MANDIR			=	$(WD)/manual
 CALIBDIR		=	$(WD)/slsDetectorCalibration
+MANAPIDIR		=	$(MANDIR)/manual-api
 
 TABSPACE		:=	"\t"
 
  
-INCLUDES=-I. -I$(LIBRARYDIR)/commonFiles -I$(LIBRARYDIR)/slsDetector -I$(LIBRARYDIR)/usersFunctions -I$(LIBRARYDIR)/multiSlsDetector -I$(LIBRARYDIR)/slsDetectorUtils -I$(LIBRARYDIR)/slsDetectorCommand -I$(LIBRARYDIR)/slsDetectorAnalysis -I$(LIBRARYDIR)/slsReceiverInterface  -I$(LIBRARYRXRDIR)/include -I$(LIBRARYDIR)/threadFiles -I$(ASM)
+INCLUDES=-I. -I$(LIBRARYDIR)/commonFiles -I$(LIBRARYDIR)/slsDetector -I$(LIBRARYDIR)/usersFunctions -I$(LIBRARYDIR)/multiSlsDetector -I$(LIBRARYDIR)/slsDetectorUtils -I$(LIBRARYDIR)/slsDetectorCommand -I$(LIBRARYDIR)/slsDetectorAnalysis -I$(LIBRARYDIR)/slsReceiverInterface  -I$(LIBRARYRXRDIR)/include -I$(LIBRARYDIR)/threadFiles -I$(LIBRARYDIR)/sharedMemory -I$(ASM)
 
 INCLUDESRXR += -I. -I$(LIBRARYRXRDIR)/include -I$(CALIBDIR) -I$(ASM) 
 #LIBFLAGRXR += 
@@ -79,6 +80,7 @@ slsReceiver_static: receiver
 receiver: #libreceiver
 #	cd  $(RECEIVERDIR) && $(MAKE) receiver FLAGS='$(FLAGS)' DESTDIR='$(BINDIR)'  LIBS='$(LDFLAGRXR)' INCLUDES='$(INCLUDESRXR)' LIBDIR='$(LIBDIR)'
 	cd  $(RECEIVERDIR) && $(MAKE) FLAGS='$(FLAGS)' DESTDIR='$(BINDIR)'  LIBS='$(LDFLAGRXR)' INCLUDES='$(INCLUDESRXR)' LIBDIR='$(LIBDIR)'
+	cd  $(MANAPIDIR) && $(MAKE) slsMultiReceiver
 	@echo ""
 	@echo "#######################################"
 	@echo "# Back in slsDetectorPackage Makefile #"
@@ -151,6 +153,7 @@ clean:
 	cd $(DOCDIR) && rm -rf * 
 	rm -rf 	slsDetectorPackageDocs;
 	rm -rf $(DETAILDOC)
+	rm -rf $(MANAPIDIR)/slsMultiReceiver
 
 
 #install_lib: 

README.md

@@ -2,7 +2,7 @@
 Detailed documentation can be found on the [official site.](https://www.psi.ch/detectors/users-support)
 
 ### Binaries
-Documentation to obtain the binaries via the conda package is available [here.](https://github.com/slsdetectorgroup/sls_detector_software)
+Documentation to obtain the binaries via the conda package is available for [lib](https://github.com/slsdetectorgroup/sls_detector_lib) and [gui](https://github.com/slsdetectorgroup/sls_detector_gui)
 
 ### Source code
 One can also obtain the source code from this repository and compile while realizing the setup dependencies as required.
@@ -19,7 +19,7 @@ Requirements: Qt 4.8 and Qwt 6.0
 ```
 If either of them does not exist, the GUI client will not be built.
 
-* Calibration wizards<br>
+* Advanced user Calibration wizards<br>
 Requirements: ROOT
 ```
     export ROOTSYS=/usr/local/root-5.34
@@ -43,6 +43,7 @@ Usage: [-c] [-b] [-h] [-d HDF5 directory] [-j]<br>
  * -r: Build/Rebuilds only receiver<br>
  * -g: Build/Rebuilds only gui<br>
  * -j: Number of threads to compile through<br>
+ * -e: Debug mode
  
 Basic Option:
 ./cmk.sh -b
@@ -86,5 +87,5 @@ After compiling, the libraries and executables will be found at `bin` directory
 ```
     $ ls bin/
     gui_client  libSlsDetector.a  libSlsDetector.so  libSlsReceiver.a  libSlsReceiver.so
-    sls_detector_acquire  sls_detector_get  slsDetectorGui  sls_detector_help  sls_detector_put  slsReceiver
+    sls_detector_acquire  sls_detector_get  slsDetectorGui  sls_detector_help  sls_detector_put  slsReceiver slsMultiReceiver
 ```

RELEASE.txt

@@ -1,113 +1,508 @@
-SLS Detector Package 3.1.1 released on 2018-03-12
+SLS Detector Package 4.0.0 released on 27.09.2018
 =================================================
 
 
 
 INTRODUCTION
 
-This document describes the differences between 3.1.0 and 3.1.0 releases.
+	This document describes the differences between 4.0.0 and 3.1.4 releases.
 
-The conda package of the binaries can be downloaded from
+	Download
+	--------
 	
-	https://github.com/slsdetectorgroup/sls_detector_software.git
+	The Source Code (Default C++ API):
+		 https://github.com/slsdetectorgroup/slsDetectorPackage
+		 
+	The Conda Lib Package:
+		https://github.com/slsdetectorgroup/sls_detector_lib
+		
+	The Conda GUI Package:
+		https://github.com/slsdetectorgroup/sls_detector_gui	
+		
+	The Python Interface (including the package):
+    	https://github.com/slsdetectorgroup/sls_detector
 	
-The Python interface to the software package (including the package) is at 
 	
-	https://github.com/slsdetectorgroup/sls_detector.git
+	Documentation
+	-------------
 	
-Manual (both HTML and pdf versions) are provided in
-	manual/docs/
-
-Documentation from Source Code can be found for the Command Line and for the API in
-	html:
+	Manual (HTML & PDF):
+		https://www.psi.ch/detectors/documentation
+		slsDetectorPackage/manual/docs/
+		
+	Command Line Documentation:
 		manual/docs/html/slsDetectorClientDocs/index.html
-		manual/docs/html/slsDetectorUsersDocs/index.html
-	pdf:
 		manual/docs/pdf/slsDetectorClientDocs.pdf
+		
+	C++ API Documentation:
+		manual/docs/html/slsDetectorUsersDocs/index.html
 		manual/docs/pdf/slsDetectorUsersDocs.pdf
-
-Example including binaries for detector and receiver user classes can be found in 
-
-	manual/manual-api
+		
+	C++ API Example:
+		manual/manual-api/mainClient.cpp
+		manual/manual-api/mainReceiver.cpp
+		
+	Python API Documentation:
+		https://slsdetectorgroup.github.io/sls_detector/
+		
+	Further Documentation:
+		https://www.psi.ch/detectors/users-support
+		
 	
-User documentation can also be accessed directly at this location:
+	Support
+	-------
 
-    https://www.psi.ch/detectors/users-support
+	General Software related:
+		dhanya.thattil@psi.ch
+		anna.bergamaschi@psi.ch
+		
+	Python related:
+		erik.frojdh@psi.ch
 
-If you have any software related questions or comments, please send them to:
-
-    dhanya.thattil@psi.ch
-    anna.bergamaschi@psi.ch
-    
-If you have any python related questions or comments, please send them to:
-	
-	erik.frojdh@psi.ch
 
 
 CONTENTS
 
-- Firmware Requirements
-- Changes in User Interface
-- New Features
-- Resolved Issues
-- Known Issues
+	1.	Firmware Requirements
+	2.	Changes in User Interface
+	3.	New/Modified Commands
+	4.	Other New Features
+	5.	Resolved Issues
+	6.	Known Issues
+	7.	Next Major Release Plans
 
 
 
-Firmware Requirements
-=====================
-
-	Please refer to the link below for more details on the firmware versions.
-		https://www.psi.ch/detectors/firmware.
+1. Firmware Requirements
+========================
 
     	Gotthard
     	========   
     	Minimum compatible version  : 11.01.2013
     	Latest version              : 08.02.2018 (50um and 25um Master)
                                       09.02.2018 (25 um Slave) 
-
-   	-Can not be upgraded remotely.
-    
-    
     	Eiger
     	=====  
-    	Minimum compatible version  : 16
-    	Latest version              : 20
-        
-    	-Can be upgraded remotely via bit files.
-    
+    	Minimum compatible version  : 22
+    	Latest version              : 22
         
     	Jungfrau
     	========       
-    	Minimum compatible version  : 13.11.2017
-    	Latest version              : 13.11.2017
+    	Minimum compatible version  : 15.06.2018
+    	Latest version              : 15.06.2018
 
-    	-Can be upgraded remotely via sls_detector_put programfpga <pof>.
-	 
+    	
+    	Detector Upgrade
+    	================
+    	Gotthard	Cannot be upgraded remotely. Requires programming via USB blaster
+    	Eiger		Can be upgraded remotely via bit files
+    	Jungfrau	Can be upgraded remotely using sls_detector_put programfpga <pof>
+    	
+    	Instructions available at
+    	https://www.psi.ch/detectors/installation-instructions
+    	under Detector Upgrade -> [Detector Type] -> Firmware. 
+    	
+    	 
+	Please refer to the link below for more details on the firmware versions.
+	https://www.psi.ch/detectors/firmware.
+		
 
 
-Changes in User Interface
-========================= 
+2. Changes in User Interface
+============================
+	
+	Client
+	------
+	
+	1.	Shared Memory:
+	
+		POSIX shared memory has been implemented and they are typically created in
+		/dev/shm/ folder.
+		
+		A multiSlsDetector object will create a shared memory segment with naming style:
+		slsDetectorPackage_x_[_z]
+		and an slsDetector object will create a shared memory segment with naming style:
+		slsDetectorPackage_x_sls_y[_z]
+		 	
+		where
+		x is the multi detector id
+		y is the sls detector id
+		z is the environment variable SLSDETNAME, if set.
+		They can be deleted directly.
+		
+		Environment variable SLSDETNAME included for user-friendliness
+		of using 2 different detectors from the same client pc. One needn't use
+		different multi detector id if the SLSDETNAME is different for both consoles.
+		
+		Constructor will fail if shared memory size is different (different package
+		releases/detectors). Loading config file cleans shared memory.
+
+
+	2.	Exceptions in constructors:
+	
+		All constructors that have an error throws an exception. For this release,
+		this is caught within the package and interfaced as error codes or messages
+		to the users using command line or API.
+		
+		As a result:
+		- slsDetectorsUsers constructor signature now includes a success flag.
+		- If one uses multiSlsDetector, slsDetector, ZmqSocket classes directly, 
+		  catch exceptions from constructors.
+		- In future releases, the exception will be thrown 
+		  outside the package for the users to handle it.
+		  
+		  
+	3.	API Compatibility:
+	
+		Client now checks API version of Detector Server - Client and Receiver - Client
+		when connecting for the first time to detector server or receiver server
+		and the online flags have not been set in shm. 
+		
+		Upon failure, error messages will ensue and further commands will not 
+		be executed. Detector servers referred to are only for Eiger, Jungfrau and Gotthard.
+		
+		Previously, the detector server would exit on mismatched Firmware-Detector
+		server mismatch. They now wait for client to ask for compatibility check,
+		which is done the first time client connects to the detector and the
+		online flag in shm has not been set.
+		
+		
+	4.	Commands "type", "id" and "replace" are removed.
+		  
+		  
+	Receiver
+	--------
+	
+	1.	Reciever Header Structure in file writing and call back:
+	
+		sls_receiver_header structure added to sls_receiver_defs.h for image headers 
+		in file writing. 
+		
+		#define MAX_NUM_PACKETS	512
+		typedef std::bitset<MAX_NUM_PACKETS> sls_bitset;
+		typedef struct {
+			sls_detector_header detHeader;	/**< is the detector header */
+			sls_bitset packetsMask;			/**< is the packets caught bit mask */
+		} sls_receiver_header;
+		
+		It includes the detector header structure + bitmask of 512 bits, 
+		where each bit represents a packet caught. This is useful in saving time 
+		in writing to file by not padding missing packets and still retaining useful data.
+		
+		The binary and HDF5 writer version number changed from 1.0 to 2.0. 
+		The detector header version remains as 1.0.
+		
+		registerCallBackRawDataReady modified to give this structure pointer,
+		instead of individual structure member pointers.
+		
+		
+	2.	ZmqSocket class:
+	
+		If one uses ZmqSocket.h, then the json header has to be parsed outside 
+		the class to allow the user to remove the restriction in extracting all data
+		from the json header.
+
+
+	3.	Receiver Call back with modified size:
+	
+		registerCallBackRawDataModifyReady call back that is similar to the receiver 
+		registerCallBackRawDataReady has been added to allow the call back to 
+		specify an updated size of image after call back. This is in view to process
+		an image in call back (including extract only a region of the image) and 
+		provide this updated size in callback. This new resized/processed image
+		will be written to file or streamed out via zmq. This is useful in ROI
+		selection in the receiver.
+
+		This also means that the call back is now called before writing to file.
+
+
+
+3. New/Modified Commands 
+========================
+	
+	Client
+	------
+
+	1.	add (modified): 
+		appends detector to end of multi detector list.
+
+	2.	replace: 
+		sets hostname/ip address for a single detector.
+
+	3.	user: 
+		get user details from shared memory.
+
+	4.	checkdetversion: 
+		checks client version compatibility with detector server.
+
+	5.	checkrecversion: 
+		checks client version compatibility with receiver server.
+		
+	
+	Receiver
+	--------
+	
+	1.	rx_zmqip:	
+		sets/gets the zmq (TCP) ip of the receiver from where data is streamed 
+		out from. (Eg. to the gui or intermediate process). By default, it is 
+		the same as the zmqip.
+	
+	2.	zmqip: 
+		sets/gets the zmq (TCP) ip, where client listens to, to reconstuct images. 
+		(Eg. from receiver or intermediate process). By default, it is the same 
+		as rx_zmqip.
+	  		 	
+	3.	rx_jsonaddheader:
+		sets/gets additional json header to be streamed out with the zmq from 
+		receiver. Default is empty. Eg. p rx_jsonaddheader \"what\":\"nothing\"
+		
+	4.	r_discardpolicy:
+		sets/gets the frame discard policy in the receiver. 
+		nodiscard - no discard (default), 
+		discardempty - discard only empty frames, 
+		discardpartial - discard any partial frame(fastest)
+		
+	5.	r_padding:
+		sets/gets the frame padding in the receiver. 
+		0 does not pad partial frames(fastest), 
+		1 (default) pads partial frames.
+		One can look at bitmask in the sls_receiver_header to process the unpadded
+		partial	frames later.
+		
+	6.	activate (modified):
+		Extra option added to pad or unpad images in receivers when deactivated.
+		activate i [padding option], where i is activate/deactivate	and padding 
+		option is "padding" (default) or "nopadding".
+		
+	7.	rx_udpsocksize:
+		sets/gets the UDP socket buffer size. Already attempts to set by default 
+		to 100mb, 2gb for Jungfrau. Does not remember custom values	in client 
+		shared memory, so must be initialized each time after setting receiver 
+		hostname in config file.
+		
+	8.	rx_realudpsocksize:
+		gets the actual UDP socket buffer size. Usually double the set udp socket 
+		buffer size due to kernel bookkeeping.
+	
+	9.	r_framesperfile:
+		sets/gets the frames per file in receiver. 0 means infinite or all frames 
+		in a single file. Default of Eiger changed from 2k to 10k.
+		
+
+	Eiger Specific
+	--------------
+	
+	1.	status trigger:
+		To trigger internally via software, one can use "status trigger".
+		
+	2.	subdeadtime:
+		sets/gets sub frame dead time in s in 32 bit mode. Subperiod is	set in 
+		the detector by subexptime + subdeadtime. This value is	normally a 
+		constant set by an expert catered to individual detector modules in the 
+		config file. Receiver files writes master file metadata subperiod 
+		instead of subdeadtime.
+		
+	3.	gappixels:
+		enables/disables gap pixels in system (detector & receiver). 1 sets, 
+		0 unsets. In Receiver, 4 bit gap pixels mode is not implemented, but is 
+		implemented in client data call back. Gap pixels are at module level 
+		and not at multi module level.
+				
+	4.	measuredperiod:
+		gets the measured frame period (time between last frame and the	previous 
+		one) in s. Makes sense only for acquisitions of more than 1 frame.
+		
+	5.	measuredsubperiod:
+		gets the measured subframe period (time between last subframe and the 
+		previous one) in s in 32 bit mode.
+
+	6.	flags(modified):
+		extra flags "nooverflow" (default) and "overflow" for sub images in	32 
+		bit mode. If set to overflow, it will set MSB of pixel data high if 
+		there was any saturation in any of the sub images 32 bit mode.
+		
+				
+	Jungfrau Specific
+	-----------------
+	
+	1.	storagecells:
+		sets/gets number of additional storage cells per acquisition. For very 
+		advanced users only. Range: 0-15. Default: 0. 
+		The #images = #frames * #cycles * (#storagecells +1).
+		
+	2.	storage_start:
+		sets/gets the storage cell that stores the first acquisition of the	series. 
+		For very advanced users only. Range: 0-15. Default: 15(0xf).  
+
+
+
+4. Other New Features
+=====================
+
+	Client
+	------
+	
+	1.	(Jungfrau & Gotthard) Settingsdir and caldir is removed from config file.
+		Default dacs are stored in detector server. Hence, these folders
+		are also removed from slsDetectorPackage/settingsdir. Eiger and Mythen 
+		continue to have them.
+		
+	2.	Depending on 1d position of detectors and detsizechan in config file,
+		row and column (previously xcoord and ycoord) are given to detector 
+		servers (Eiger and Jungfrau) to encode into the udp header.
+		
+	3.	(Eiger) Setting threshold energy changes such as CAL dac is irrelevant 
+		when interpolating between two energies and VRS dac is interpolated, not copied.
+		
+	4.	Users API updated with the following functions:
+		-	setReceiverFramesDiscardPolicy
+		-	setReceiverPartialFramesPadding
+		-	setReceiverFramesPerFile
+		-	sendSoftwareTrigger
+		-	setSubFrameExposureDeadTime
+		-	setSubFrameExposureTime
+		-	enableGapPixels
+		-	getMeasuredPeriod
+		-	getMeasuredSubFramePeriod
+		-	setOverflowMode
+		-	setNumberOfStorageCells
+		-	setStoragecellStart
+		-	setThresholdEnergy (overloaded)
+		-	resetFramesCaughtInReceiver
+		-	setReceiverFifoDepth
+		-	setFlowControl10G
+		-	setTenGigabitEthernet
+		-	getNMods
+		-	setReceiverDataStreamingOutIP
+		-	setClientDataStreamingInIP
+		
+	SlsReceiver
+	-----------
+	
+	1.	slsMultiReceiver executable added that creates multiple receiver child processes.
+		./slsMultiReceiver [start_tcp_port] [num_receivers] [1 for call back, 0 for none]
+		
+	2.	Default row and column (previously xcoord and ycoord) are hardcoded 
+		for missing packets. (Eiger and Jungfrau)
+		
+
+	Gui
+	---
+	
+	1.	(Jungfrau) Gain plot included. Option under 2D options in Plot tab.
+	
+	2.	Option to maintain aspect ratio
+	
+	3.	Start and Stop separated to prevent multiple click syndrome.
 	
 
-
-
-New Features
-============
+	Detector Server
+	---------------
+	
+	1. 	(Jungfrau) To use programfpga command, one must start server with -update
+		mode and then restart server without -update mode.
+	
+	2.	(Jungfrau) ASIC Timer configured at server start up and changed a few
+		startup values for firmware v0.7 such as adc phase, ADC_PORT_INVERT_VAL
+		and ADC offset half speed value.
+		
+	3.	(Jungfrau) Minimum exposure time of 50 us was implemented.
+	
+	4. 	(Eiger and Jungfrau) They can be configured to have x and y coord values
+		of the detector in their udp header.
 
 
 
-Resolved Issues
+
+5. Resolved Issues
+==================
+
+	Client
+	------
+	memory leak for multi threading
+	
+	1.	Compiler flag -std=c++98 enforced. Debug flag removed.
+	
+	2.	If trimen gives different list from different detectors, it returns a -1.
+	
+	3.	Version format for each submodule of the package changed to just date YYMMDD.
+		Users class fixed to give correct version, instead of -1.
+		
+	4.	Getting settings in users class gave -1. Fixed now.
+
+	5.	(Jungfrau) Programming FPGA now creates the rawbin file from pof in tmp
+		rather than source file location (for permission issues).
+		
+	6.	(Gotthard) ROI segmentation fault fixed.
+		
+	Receiver
+	--------
+	
+	1.	Silent feature of receiver fixed.
+	
+	2. 	Socket descriptor misused earlier for success flag, instead exceptions
+		used that are handled inside the package.
+
+	3.	Global optind variable initialized to instantiate multiple receivers 
+		in same process. Also removed static members to enable this feature.
+		
+	4.	Socket buffer size attempts to set for each acquiistion and provide
+		warning if no capabilities. Warnings can be removed using instruction with
+		error provided. Default Jungfrau UDP socket buffer size if 2 GB, default is 
+		100 MB.
+		
+	5.	Refactored code a bit for performance and robustness, blocking push 
+		in buffer between listener and dataprocessor
+
+	
+	Detector Server
+	---------------
+	
+	1.	(Jungfrau) Stop server also mapped during a reset. Reading power status
+		instead of user input register for power.
+	
+	2.	(Eiger) Bug fix for saving trimbits to file (Advanced users).
+	
+	3.	(Gotthard 25um) config.txt is not read again after detector startup,
+		no matter the number of times the detector server is restarted. 
+
+	
+6. Known Issues
 ===============
 
-
-Known Issues
-============
-
+	Receiver
+	--------
 	
-
+	1. 	HDF5 compression and filters are not implemented yet.
 	
-
+	
+	Detector Server
+	---------------
+	
+	1.	(Eiger) Registers mapped differently between firmware v20 and v22.
+		So, please ensure correct on-board server before switching between
+		firmware versions. Else one cannot ping it anymore. Will need to flash firmware
+		again to recover.
+		
+	2.	(Gotthard) To switch back to all ADC from single ADC ROI, one must take
+		even number of images for the receiver to understand complete images.
+		This will be fixed in the next firmware upgrade.
+	
+	
+	
+7. Next Major Release Plans
+===========================
+
+	Client
+	------
+	
+	1.	Exceptions thrown to the user to be handled.
+	
+	2. 	Compilation using c++11.
+	
+	3.	Support of Mythen II restricted to this major and its minor releases.
+	
+	4.	Restructuring and refactoring of client code. 
 
 
 

cleansharedmemory.sh

@@ -1 +1 @@
-for i in seq `ipcs -m | cut -d ' ' -f1`; do ipcrm -M $i; done;
+rm /dev/shm/slsDetectorPackage*;

cmk.sh

@@ -6,6 +6,7 @@ COMPILERTHREADS=0
 TEXTCLIENT=0
 RECEIVER=0
 GUI=0
+DEBUG=0
 
 
 CLEAN=0
@@ -24,6 +25,7 @@ Usage: $0 [-c] [-b] [-h] [-d <HDF5 directory>] [-j]
  -r: Build/Rebuilds only receiver
  -g: Build/Rebuilds only gui
  -j: Number of threads to compile through
+ -e: Debug mode
  
 For only make:
 ./cmk.sh
@@ -53,7 +55,7 @@ For rebuilding only certain sections
  
  " ; exit 1; }
 
-while getopts ":bchd:j:trg" opt ; do
+while getopts ":bchd:j:trge" opt ; do
 	case $opt in
 	b) 
 		echo "Building of CMake files Required"
@@ -90,7 +92,11 @@ while getopts ":bchd:j:trg" opt ; do
 		echo "Compiling Options: GUI" 
 		GUI=1
 		REBUILD=1
-		;;      
+		;;  
+	e)
+		echo "Compiling Options: Debug" 
+		DEBUG=1
+		;;    
     \?)
      	echo "Invalid option: -$OPTARG" 
 		usage
@@ -145,7 +151,12 @@ else
 	fi
 fi
 
-CMAKE_POST+=" -DCMAKE_BUILD_TYPE=Debug "
+#Debug
+if [ $DEBUG -eq 1 ]; then
+	CMAKE_POST+=" -DCMAKE_BUILD_TYPE=Debug "
+	echo "Debug Option enabled"
+fi 
+
 
 #hdf5 rebuild
 if [ $HDF5 -eq 1 ]; then

examples/bchip2modules.config

@@ -0,0 +1,61 @@
+detsizechan 2560 1
+
+hostname bchip074+bchip075+
+
+#replace my_installation_path 
+settingsdir /my_installation_path/slsDetectorPackage/settingsdir/gotthard
+caldir /my_installation_path/slsDetectorPackage/settingsdir/gotthard
+
+0:extsig:0 trigger_in_rising_edge
+0:rx_tcpport 1954
+0:rx_udpport 50001
+0:vhighvoltage 0
+
+1:extsig:0 trigger_in_rising_edge
+1:rx_tcpport 1955
+1:rx_udpport 50002
+#1:detectorip 10.1.1.52
+1:vhighvoltage 0
+
+##############################################################################
+#########
+######### Uncomment this part to use the gotthard25umZmq process
+#########
+##############################################################################
+
+# #replace my_receiver_hostname with the hostname of IP of the machine where the receiver runs
+#0:rx_zmqip my_receiver_hostname 
+#0:rx_zmqport 30003
+# #replace my_client_hostname with the hostname of IP of the machine where the client/GUI or softIOC runs
+#0:zmqip my_client_hostname 
+#0:zmqport  40003
+
+# #replace my_receiver_hostname with the hostname of IP of the machine where the receiver runs
+#1:rx_zmqip my_receiver_hostname 
+#1:rx_zmqport 30004
+# #replace my_client_hostname with the hostname of IP of the machine where the client/GUI or softIOC runs
+#1:zmqip  my_client_hostname 
+#1:zmqport  40004
+
+##############################################################################
+#########
+######### until here
+#########
+##############################################################################
+
+
+r_readfreq 1
+rx_datastream 1
+
+#replace my_receiver_hostname with the hostname of 1Gb IP of the machine where the receiver runs
+rx_hostname my_receiver_hostname
+rx_datastream 1
+outdir /tmp/
+angconv none
+threaded 1
+
+settings veryhighgain
+exptime 0.000005
+period 0.0001
+
+vhighvoltage 90

examples/bchip2modules_pc8829.config

@@ -0,0 +1,61 @@
+detsizechan 2560 1
+
+hostname bchip074+bchip075+
+
+#replace my_installation_path 
+settingsdir /my_installation_path/slsDetectorPackage/settingsdir/gotthard
+caldir /my_installation_path/slsDetectorPackage/settingsdir/gotthard
+
+0:extsig:0 trigger_in_rising_edge
+0:rx_tcpport 1954
+0:rx_udpport 50001
+0:vhighvoltage 0
+
+1:extsig:0 trigger_in_rising_edge
+1:rx_tcpport 1955
+1:rx_udpport 50002
+#1:detectorip 10.1.1.52
+1:vhighvoltage 0
+
+##############################################################################
+#########
+######### Uncomment this part to use the gotthard25umZmq process
+#########
+##############################################################################
+
+# #replace my_receiver_hostname with the hostname of IP of the machine where the receiver runs
+#0:rx_zmqip my_receiver_hostname 
+#0:rx_zmqport 30003
+# #replace my_client_hostname with the hostname of IP of the machine where the client/GUI or softIOC runs
+#0:zmqip my_client_hostname 
+#0:zmqport  40003
+
+# #replace my_receiver_hostname with the hostname of IP of the machine where the receiver runs
+#1:rx_zmqip my_receiver_hostname 
+#1:rx_zmqport 30004
+# #replace my_client_hostname with the hostname of IP of the machine where the client/GUI or softIOC runs
+#1:zmqip  my_client_hostname 
+#1:zmqport  40004
+
+##############################################################################
+#########
+######### until here
+#########
+##############################################################################
+
+
+r_readfreq 1
+rx_datastream 1
+
+#replace my_receiver_hostname with the hostname of 1Gb IP of the machine where the receiver runs
+rx_hostname my_receiver_hostname
+rx_datastream 1
+outdir /tmp/
+angconv none
+threaded 1
+
+settings veryhighgain
+exptime 0.000005
+period 0.0001
+
+vhighvoltage 90

examples/gotthard.config

@@ -3,12 +3,8 @@ hostname bchip007
 #0:port 1952
 #0:stopport 1953
 #0:rx_tcpport 1956 must also have this in receiver config file
-0:settingsdir /home/l_maliakal_d/mySoft/newMythenSoftware/settingsdir/gotthard
 0:angdir 1.000000
 0:moveflag 0.000000
-0:lock 0
-0:caldir /home/l_maliakal_d/mySoft/newMythenSoftware/settingsdir/gotthard
-0:ffdir /home/l_maliakal_d
 0:extsig:0 off
 #0:detectorip 129.129.202.9
 0:detectormac 00:aa:bb:cc:dd:ee
@@ -20,7 +16,6 @@ hostname bchip007
 master -1
 sync none
 outdir /bigRAID/datadir_gotthard/rec_test_data
-ffdir /home/l_maliakal_d
 headerbefore none
 headerafter none
 headerbeforepar none
@@ -29,4 +24,4 @@ badchannels none
 angconv none
 globaloff 0.000000
 binsize 0.001000
-threaded 1
+

examples/howto_gotthatd_twomodules.txt

@@ -0,0 +1,14 @@
+Turn on the two receivers:
+slsReceiver --rx_tcpport 1954 &
+slsReceiver --rx_tcpport 1955 &
+
+Switch on the photon conversion on the receiver machine (replace my_receiver_hostname):
+gotthard25umZmq my_receiver_hostname 30003 my_receiver_hostname 40003 &
+
+Run the configuration file:
+sls_detector_put config bchip2modules.config 
+
+
+Start your measurements using the command line, the slsDetectorGui or the EPICS driver
+
+

examples/jungfrau.config

@@ -1,18 +1,15 @@
 hostname bchip038+
 
-settingsdir /home/mySoft/slsDetectorsPackage/settingsdir/jungfrau
-caldir /home/mySoft/slsDetectorsPackage/settingsdir/jungfrau
-lock 0
-
 0:rx_udpport 50004
 0:rx_udpip 10.1.1.100
 0:detectorip 10.1.1.10
-
 rx_hostname pcmoench01
 
 powerchip 1
-timing auto
+
+#extsig:0 trigger_in_rising_edge
+#timing trigger
 
 outdir /external_pool/jungfrau_data/softwaretest
-threaded 1
+
 

examples/jungfrau_two.config

@@ -1,11 +1,6 @@
 detsizechan 1024 1024
 hostname bchip048+bchip052+
 
-settingsdir /home/mySoft/slsDetectorsPackage/settingsdir/jungfrau
-caldir /home/mySoft/slsDetectorsPackage/settingsdir/jungfrau
-lock 0
-
-
 0:rx_udpport 50004
 0:rx_udpip 10.1.1.100
 0:rx_udpmac F4:52:14:2F:32:00
@@ -22,9 +17,9 @@ lock 0
 rx_hostname pcmoench01
 
 powerchip 1
-extsig:0 trigger_in_rising_edge
-timing auto
+#extsig:0 trigger_in_rising_edge
+#timing trigger
 
 outdir /external_pool/jungfrau_data/softwaretest
-threaded 1
+
 

examples/moench03_T1_lab.config

@@ -0,0 +1,471 @@
+hostname bchip011
+
+patword 0000 0000000000000000
+patword 0001 0000000000000000
+patword 0002 0008000900080000
+patword 0003 0008000900080000
+patword 0004 0008000900080000
+patword 0005 0008000900080000
+patword 0006 0008000900080000
+patword 0007 0008000900080000
+patword 0008 0008000900080000
+patword 0009 0008000900080000
+patword 000a 0008000900080000
+patword 000b 0008000900080000
+patword 000c 0008000900080000
+patword 000d 0008000900080000
+patword 000e 0008000900080000
+patword 000f 0008000900080000
+patword 0010 0008000900080000
+patword 0011 0008000900080000
+patword 0012 0008000900080000
+patword 0013 0008000900080000
+patword 0014 0008000900080000
+patword 0015 0008000900080000
+patword 0016 0008400900080020
+patword 0017 0008400900080020
+patword 0018 0008599f0418503a
+patword 0019 0008599f0418503a
+patword 001a 0108599f0418503a
+patword 001b 0108599f0418503a
+patword 001c 0108599f0418503a
+patword 001d 0108599f0418503a
+patword 001e 0108599f0418503a
+patword 001f 0108599f0418503a
+patword 0020 0108599f0418503a
+patword 0021 0108599f0418503a
+patword 0022 0108599f0418503a
+patword 0023 0108599f0418503a
+patword 0024 0108599f0418503a
+patword 0025 0108599f0418503a
+patword 0026 0108599f0418503a
+patword 0027 0108599f0418503a
+patword 0028 0108599f0418503a
+patword 0029 0108599f0418503a
+patword 002a 0108599f0418503a
+patword 002b 0108599f0418503a
+patword 002c 0108599f0418503a
+patword 002d 0108599f0418503a
+patword 002e 0108599f0418503a
+patword 002f 0108599f0418503a
+patword 0030 0108599f0418503a
+patword 0031 0108599f0418503a
+patword 0032 0108599f0418503a
+patword 0033 0108599f0418503a
+patword 0034 0108599f0418503a
+patword 0035 0108599f0418503a
+patword 0036 0108599f0418503a
+patword 0037 0108599f0418503a
+patword 0038 0108599f0418503a
+patword 0039 0108599f0418503a
+patword 003a 0108599f0418503a
+patword 003b 0108599f0418503a
+patword 003c 0108599f0418503a
+patword 003d 0108599f0418503a
+patword 003e 0108599f0418503a
+patword 003f 0108599f0418503a
+patword 0040 0108599f0418503a
+patword 0041 0108599f0418503a
+patword 0042 0108599f0418503a
+patword 0043 0108599f0418503a
+patword 0044 0108599f0418503a
+patword 0045 0108599f0418503a
+patword 0046 0108599f0418503a
+patword 0047 0108599f0418503a
+patword 0048 0108599f0418503a
+patword 0049 0108599f0418503a
+patword 004a 0108599f0418503a
+patword 004b 0108599f0418503a
+patword 004c 0108599f0418503a
+patword 004d 0108599f0418503a
+patword 004e 0108599f0418503a
+patword 004f 0108599f0418503a
+patword 0050 0108599f0418503a
+patword 0051 0108599f0418503a
+patword 0052 0108599f0418503a
+patword 0053 0108599f0418503a
+patword 0054 0108599f0418503a
+patword 0055 0108599f0418503a
+patword 0056 0108599f0418503a
+patword 0057 0108599f0418503a
+patword 0058 0108599f0418503a
+patword 0059 0108599f0418503a
+patword 005a 0108599f0418503a
+patword 005b 0108599f0418503a
+patword 005c 0108599f0418503a
+patword 005d 0108599f0418503a
+patword 005e 0108599f0418503a
+patword 005f 0108599f0418503a
+patword 0060 0108599f0418503a
+patword 0061 0108599f0418503a
+patword 0062 0108599f0418503a
+patword 0063 0108599f0418503a
+patword 0064 0108599f0418503a
+patword 0065 0108599f0418503a
+patword 0066 0108599f0418503a
+patword 0067 0108599f0418503a
+patword 0068 0108599f0418503a
+patword 0069 0108599f0418503a
+patword 006a 0108599f0418503a
+patword 006b 0108599f0418503a
+patword 006c 0108599f0418503a
+patword 006d 0108599f0418503a
+patword 006e 0108599f0418503a
+patword 006f 0108599f0418503a
+patword 0070 0108599f0418503a
+patword 0071 0108599f0418503a
+patword 0072 0108599f0418503a
+patword 0073 0108599f0418503a
+patword 0074 0108599f0418503a
+patword 0075 0108599f0418503a
+patword 0076 0108599f0418503a
+patword 0077 0108599f0418503a
+patword 0078 0108599f0418503a
+patword 0079 0108599f0418503a
+patword 007a 0108599f0418503a
+patword 007b 0108599f0418503a
+patword 007c 0108599f0418503a
+patword 007d 0108599f0418503a
+patword 007e 010859960418503a
+patword 007f 010859960418503a
+patword 0080 010859960418503a
+patword 0081 010859960418503a
+patword 0082 010859960418503a
+patword 0083 010859960418503a
+patword 0084 010859960418503a
+patword 0085 010859960418503a
+patword 0086 010859960418503a
+patword 0087 010859960418503a
+patword 0088 010859960418503a
+patword 0089 010859960418503a
+patword 008a 010859960418503a
+patword 008b 010859960418503a
+patword 008c 010859960418503a
+patword 008d 010859960418503a
+patword 008e 010859960418503a
+patword 008f 010859960418503a
+patword 0090 010859960418503a
+patword 0091 010859960418503a
+patword 0092 010819960418501a
+patword 0093 010819960418501a
+patword 0094 010819960418501a
+patword 0095 010819960418501a
+patword 0096 030819960418501a
+patword 0097 030819960418501a
+patword 0098 030819960418501a
+patword 0099 030819960418501a
+patword 009a 030819960418501a
+patword 009b 030819960418501a
+patword 009c 030819960418501a
+patword 009d 030819960418501a
+patword 009e 030819960418501a
+patword 009f 030819960418501a
+patword 00a0 030819960418501a
+patword 00a1 030819960418501a
+patword 00a2 030819960418501a
+patword 00a3 030819960418501a
+patword 00a4 030819960418501a
+patword 00a5 030819960418501a
+patword 00a6 030819960418501a
+patword 00a7 030819960418501a
+patword 00a8 030819960418501a
+patword 00a9 030819960418501a
+patword 00aa 030819960418501a
+patword 00ab 030819960418501a
+patword 00ac 030819960008501a
+patword 00ad 030819960008501a
+patword 00ae 030819960008501a
+patword 00af 030819960008501a
+patword 00b0 030819960008501a
+patword 00b1 030819960008501a
+patword 00b2 030819960008501a
+patword 00b3 030819960008501a
+patword 00b4 030819960008501a
+patword 00b5 030819960008501a
+patword 00b6 030819960008501a
+patword 00b7 030819960008501a
+patword 00b8 030819960008501a
+patword 00b9 030819960008501a
+patword 00ba 030819960008501a
+patword 00bb 030819960008501a
+patword 00bc 030819960008501a
+patword 00bd 030819960008501a
+patword 00be 030819960008501a
+patword 00bf 030819960008501a
+patword 00c0 0308199f0008501a
+patword 00c1 0308199f0008501a
+patword 00c2 0308199f0008501a
+patword 00c3 0308199f0008501a
+patword 00c4 0308199f0008501a
+patword 00c5 0308199f0008501a
+patword 00c6 0308199f0008501a
+patword 00c7 0308199f0008501a
+patword 00c8 0308199f0008501a
+patword 00c9 0308199f0008501a
+patword 00ca 0308199f0008501a
+patword 00cb 0308199f0008501a
+patword 00cc 0308199f0008501a
+patword 00cd 0308199f0008501a
+patword 00ce 0308199f0008501a
+patword 00cf 0308199f0008501a
+patword 00d0 0308199f0008501a
+patword 00d1 0308199f0008501a
+patword 00d2 0308199f0008501a
+patword 00d3 0308199f0008501a
+patword 00d4 0308599f0008503a
+patword 00d5 0308599f0008503a
+patword 00d6 030c599f000850ba
+patword 00d7 030c599f000850ba
+patword 00d8 030c599f000850ba
+patword 00d9 030c599f000850ba
+patword 00da 030c599f000850ba
+patword 00db 030c599f000850ba
+patword 00dc 030c599f000850ba
+patword 00dd 030c599f000850ba
+patword 00de 030c599f000850ba
+patword 00df 030c599f000850ba
+patword 00e0 030c599f000850ba
+patword 00e1 030c599f000850ba
+patword 00e2 030c599f000850ba
+patword 00e3 030c599f000850ba
+patword 00e4 030c599f000850ba
+patword 00e5 030c599f000850ba
+patword 00e6 030c599f000850ba
+patword 00e7 030c599f000850ba
+patword 00e8 030c599f000850ba
+patword 00e9 030c599f000850ba
+patword 00ea 030c799f010858ba
+patword 00eb 030c799f010858ba
+patword 00ec 030c599f000850ba
+patword 00ed 030c599f000850ba
+patword 00ee 030c599f000850ba
+patword 00ef 030c599f000850ba
+patword 00f0 030c599f000850ba
+patword 00f1 030c599f000850ba
+patword 00f2 030c599f000850ba
+patword 00f3 030c599f000850ba
+patword 00f4 030c599f000850ba
+patword 00f5 030c599f000850ba
+patword 00f6 030c599f000850ba
+patword 00f7 030c599f000850ba
+patword 00f8 030c599f000850ba
+patword 00f9 030c599f000850ba
+patword 00fa 030c599f000850ba
+patword 00fb 030c599f000850ba
+patword 00fc 030c599f000850ba
+patword 00fd 030c599f000850ba
+patword 00fe 030c599f000850ba
+patword 00ff 030c599f000850ba
+patword 0100 030c599f000850ba
+patword 0101 030c599f000850ba
+patword 0102 030c599f400850ba
+patword 0103 030c599f400850ba
+patword 0104 030c599f600850ba
+patword 0105 030c599f400850ba
+patword 0106 030c599f400850ba
+patword 0107 030c599f400850ba
+patword 0108 870c599f682e50ba
+patword 0109 870c599f482850ba
+patword 010a 870c599f000e50ba
+patword 010b 870c599f000850ba
+patword 010c 870c599f000e50ba
+patword 010d 870c599f000850ba
+patword 010e 870c599f000e50ba
+patword 010f 870c599f000850ba
+patword 0110 870c599f000e50ba
+patword 0111 870c599f000850ba
+patword 0112 870c599f000e50ba
+patword 0113 870c599f000850ba
+patword 0114 870c599f000e50ba
+patword 0115 870c599f000850ba
+patword 0116 870c599f000e50ba
+patword 0117 870c599f000850ba
+patword 0118 870c599f000e50ba
+patword 0119 870c599f000850ba
+patword 011a 870c599f000e50ba
+patword 011b 870c599f000850ba
+patword 011c 870c599f000e50ba
+patword 011d 870c599f000850ba
+patword 011e 870c599f000e50ba
+patword 011f 870c599f000850ba
+patword 0120 870c599f000e50ba
+patword 0121 870c599f000850ba
+patword 0122 870c599f200e50ba
+patword 0123 870c599f000850ba
+patword 0124 870c599f000e50ba
+patword 0125 870c599f000850ba
+patword 0126 870c599f000e50ba
+patword 0127 870c599f000850ba
+patword 0128 870c599f000e50ba
+patword 0129 870c599f000850ba
+patword 012a 870c599f000e50ba
+patword 012b 870c599f000850ba
+patword 012c 870c599f000e50ba
+patword 012d 870c599f000850ba
+patword 012e 870c599f000e50ba
+patword 012f 870c599f000850ba
+patword 0130 870c599f000e50ba
+patword 0131 870c599f000850ba
+patword 0132 870c599f000e50ba
+patword 0133 870c599f000850ba
+patword 0134 870c599f000e50ba
+patword 0135 870c599f000850ba
+patword 0136 870c599f000e50ba
+patword 0137 870c599f000850ba
+patword 0138 870c599f000e50ba
+patword 0139 870c599f000850ba
+patword 013a 870c599f282e50ba
+patword 013b 870c599f082850ba
+patword 013c 870c599f000e50ba
+patword 013d 870c599f000850ba
+patword 013e 870c599f000e50ba
+patword 013f 870c599f000850ba
+patword 0140 870c599f000e50ba
+patword 0141 870c599f000850ba
+patword 0142 870c599f000e50ba
+patword 0143 870c599f000850ba
+patword 0144 870c599f000e50ba
+patword 0145 870c599f000850ba
+patword 0146 870c599f000e50ba
+patword 0147 870c599f000850ba
+patword 0148 870c599f000e50ba
+patword 0149 870c599f000850ba
+patword 014a 870c599f000e50ba
+patword 014b 870c599f000850ba
+patword 014c 870c599f000e50ba
+patword 014d 870c599f000850ba
+patword 014e 870c599f000e50ba
+patword 014f 870c599f000850ba
+patword 0150 870c599f000e50ba
+patword 0151 870c599f000850ba
+patword 0152 870c599f000e50ba
+patword 0153 870c599f000850ba
+patword 0154 870c599f200e50ba
+patword 0155 870c599f000850ba
+patword 0156 870c599f000e50ba
+patword 0157 870c599f000850ba
+patword 0158 870c599f000e50ba
+patword 0159 870c599f000850ba
+patword 015a 870c599f000e50ba
+patword 015b 870c599f000850ba
+patword 015c 870c599f000e50ba
+patword 015d 870c599f000850ba
+patword 015e 870c599f000e50ba
+patword 015f 870c599f000850ba
+patword 0160 870c599f000e50ba
+patword 0161 870c599f000850ba
+patword 0162 870c599f000e50ba
+patword 0163 870c599f000850ba
+patword 0164 870c599f000e50ba
+patword 0165 870c599f000850ba
+patword 0166 870c599f000e50ba
+patword 0167 870c599f000850ba
+patword 0168 870c599f000e50ba
+patword 0169 870c599f000850ba
+patword 016a 870c599f000e50ba
+patword 016b 870c599f000850ba
+patword 016c 070c599f000850ba
+patword 016d 070c599f000850ba
+patword 016e 000c599f000850ba
+patword 016f 000c599f000850ba
+patword 0170 0008599f200e503a
+patword 0171 0008599f0008503a
+patword 0172 0008599f200e503a
+patword 0173 0008599f0008503a
+patword 0174 0008599f0008503a
+patword 0175 0008599f0008503a
+patword 0176 0008599f0008503a
+patword 0177 0008599f0008503a
+patword 0178 0008599f0008503a
+patword 0179 0008599f0008503a
+patword 017a 0008599f0008503a
+patword 017b 0008599f0008503a
+patword 017c 0008599f0008503a
+patword 017d 0008599f0008503a
+patword 017e 0008599f0008503a
+patword 017f 0008599f0008503a
+patword 0180 0008599f0008503a
+patword 0181 0008599f0008503a
+patword 0182 0008599f0008503a
+patword 0183 0008599f0008503a
+patword 0184 0008599f0008503a
+patword 0185 0008599f0008503a
+patword 0186 0008599f0008503a
+patword 0187 0008599f0008503a
+patword 0188 0008599f0008503a
+patword 0189 0008599f0008503a
+patword 018a 0008599f0008503a
+patword 018b 0008599f0008503a
+patword 018c 0008599f0008503a
+patword 018d 0008599f0008503a
+patioctrl 8f0effff6dbffdbf
+patclkctrl 0000000000000000
+patlimits 0000 018c
+patloop0 013a 016b
+patnloop0 199
+patloop1 0400 0400
+patnloop1 0
+patloop2 0400 0400
+patnloop2 0
+patwait0 00aa
+patwaittime0 40000
+patwait1 0400
+patwaittime1 0
+patwait2 0400
+patwaittime2 0
+
+
+
+0:rx_udpip 10.1.1.102
+0:detectorip 10.1.1.19
+0:rx_udpport 32410
+#0:detectormac 00:ab:bc:cd:de:ef
+#0:rx_udpmac 70:10:6f:a0:b5:b1
+
+#gui listening to
+zmqip 129.129.202.131
+zmqport 30001
+
+#data streaming out of
+rx_zmqip 10.1.2.103
+rx_zmqport 30003
+
+#turn on datastream from commandline
+rx_datastream 1
+
+r_readfreq 1
+
+0:rx_hostname mpc2011
+#0:configuremac -1
+rx_datastream 1
+
+r_readfreq 1
+
+
+dac:6 800
+dac:0 1300
+dac:4 1428
+dac:1 1000
+dac:7 900
+dac:3 680
+dac:2 1400
+dac:5 1200
+adcinvert 4a342593
+samples 5000
+adcphase 90
+adcpipeline 15
+adcreg 14 40
+powerchip 1
+vhighvoltage 90
+period 0.005
+
+
+
+
+
+
+frames 100
+period 0.1
+outdir /scratch/
+enablefwrite 0
+

examples/two_gotthard.config

@@ -8,13 +8,11 @@ hostname bchip007+bchip009+
 #0:port 1952
 #0:stopport 1953
 #0:rx_tcpport 1956 
-0:settingsdir /home/l_msdetect/dhanya/slsDetectorsPackage/settingsdir/gotthard
 0:angdir 1.000000
 0:moveflag 0.000000
-0:lock 0
-0:caldir /home/l_msdetect/dhanya/slsDetectorsPackage/settingsdir/gotthard
 0:ffdir /home/l_msdetect
 0:extsig:0 off
+
 0:detectorip 10.1.1.2
 #0:detectormac 00:aa:bb:cc:dd:ee
 #0:rx_udpport 50001
@@ -28,13 +26,11 @@ hostname bchip007+bchip009+
 #1:port 1952
 #1:stopport 1953
 1:rx_tcpport 1957
-1:settingsdir /home/l_msdetect/dhanya/slsDetectorsPackage/settingsdir/gotthard
 1:angdir 1.000000
 1:moveflag 0.000000
-1:lock 0
-1:caldir /home/l_msdetect/dhanya/slsDetectorsPackage/settingsdir/gotthard
 1:ffdir /home/l_msdetect
 1:extsig:0 off
+
 1:detectorip 10.1.2.2
 #1:detectormac 00:aa:bb:cc:dd:ee
 1:rx_udpport 50004
@@ -56,4 +52,4 @@ badchannels none
 angconv none
 globaloff 0.000000
 binsize 0.001000
-threaded 1
+

manual/manual-api/CMakeLists.txt

@@ -0,0 +1,35 @@
+set(SOURCES
+    mainReceiver.cpp
+)
+
+include_directories(
+    ../../slsReceiverSoftware/include
+    ../../slsDetectorSoftware/slsDetectorAnalysis 
+    ../../build/bin 
+    ../../slsdetectorSoftware/slsDetector 
+)
+
+add_executable(slsMultiReceiver
+    ${SOURCES}
+)
+
+target_link_libraries(slsMultiReceiver
+    slsReceiverShared
+    pthread
+    zmq
+    rt
+    ${HDF5_LIBRARIES}
+)
+
+if (HDF5_FOUND)
+    target_link_libraries(slsMultiReceiver 
+    ${HDF5_LIBRARIES}
+    )
+endif ()
+
+
+set_target_properties(slsMultiReceiver PROPERTIES
+    RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
+)
+
+install(TARGETS slsMultiReceiver DESTINATION bin)

manual/manual-api/Makefile

@@ -1,18 +1,26 @@
-INCLUDES	=   -I . 
+PKGDIR		=	../..
+LIBDIR		=   $(PKGDIR)/build/bin
+INCLUDES	=   -I . -I$(PKGDIR)/slsReceiverSoftware/include -I$(PKGDIR)/slsDetectorSoftware/slsDetectorAnalysis -I$(LIBDIR) -I$(PKGDIR)/slsDetectorSoftware/slsDetector 
 SRC_DET		= 	mainClient.cpp 	
 SRC_REC		=   mainReceiver.cpp
-LIBDIR		=   .
-LDFLAG_DET 	=	-I. -L$(LIBDIR) -lSlsDetector -L/usr/lib64/ -pthread -lrt -L. -lzmq
-LDFLAG_REC 	=	-I. -L$(LIBDIR) -lSlsReceiver -L/usr/lib64/ -pthread -lrt -L. -lzmq
+ZMQLIBDIR	= 	$(PKGDIR)/slsReceiverSoftware/include
+LDFLAG_DET 	=	-I. -L$(LIBDIR) -Wl,-rpath=$(LIBDIR) -lSlsDetector -L/usr/lib64/ -pthread -lrt -L$(ZMQLIBDIR) -Wl,-rpath=$(ZMQLIBDIR) -lzmq
+LDFLAG_REC 	=	-I. -L$(LIBDIR) -Wl,-rpath=$(LIBDIR) -lSlsReceiver -L/usr/lib64/ -pthread -lrt -L$(ZMQLIBDIR) -Wl,-rpath=$(ZMQLIBDIR) -lzmq
 DESTDIR		?=	../docs
 
+HDF5 		?=	no
+HDF5_DIR 	?=	/opt/hdf5v1.10.0
 
-all: docs detUser detReceiver 
+ifeq ($(HDF5),yes)
+	LDFLAG_REC += -L$(HDF5_DIR)/lib  -Wl,-rpath=$(HDF5_DIR)/lib -lhdf5 -lhdf5_cpp -lsz -lz -DHDF5C 
+endif
+
+all: docs detUser slsMultiReceiver 
 #all: docs
 
 docs: createdocs docspdf docshtml removedocs
 
-createdocs: slsDetectorUsers.doxy slsDetectorUsers.h detectorData.h slsReceiverUsers.h mainClient.cpp mainReceiver.cpp
+createdocs: slsDetectorUsers.doxy mainClient.cpp mainReceiver.cpp
 	doxygen slsDetectorUsers.doxy	
 
 docspdf: 
@@ -35,18 +43,20 @@ detUser:$(SRC_DET)
 	mkdir -p bin
 	g++ -o bin/detUser $(SRC_DET) $(INCLUDES) $(LDFLAG_DET) -lm -lstdc++
 
-detReceiver:$(SRC_REC)
+slsMultiReceiver:$(SRC_REC)
 	echo "creating receiver"
+	echo $LDFLAG_REC
 	mkdir -p bin
-	g++ -o bin/detReceiver $(SRC_REC) $(INCLUDES) $(LDFLAG_REC) -lm -lstdc++
-	
+	g++ -o bin/slsMultiReceiver $(SRC_REC) $(INCLUDES) $(LDFLAG_REC) -lm -lstdc++
+	cp bin/slsMultiReceiver $(LIBDIR)
 	
 clean:
 	echo "cleaning for manual-api"
-	rm -rf bin/detUser bin/detReceiver slsDetectorUsersDocs
+	rm -rf bin/detUser bin/slsMultiReceiver bin/detReceiver slsDetectorUsersDocs
 	rm -rf slsDetectorUsersDocs
 	rm -rf $(DESTDIR)/html/slsDetectorUsersDocs
 	rm -rf $(DESTDIR)/pdf/slsDetectorUsersDocs.pdf
+	rm -rf $(LIBDIR)/slsMultiReceiver
 	
 
 

manual/manual-api/ansi.h

@@ -1 +0,0 @@
-../../slsReceiverSoftware/include/ansi.h

manual/manual-api/detectorData.h

@@ -1 +0,0 @@
-../../slsDetectorSoftware/slsDetectorAnalysis/detectorData.h

manual/manual-api/libSlsDetector.so

@@ -1 +0,0 @@
-../../build/bin/libSlsDetector.so

manual/manual-api/libSlsReceiver.so

@@ -1 +0,0 @@
-../../build/bin/libSlsReceiver.so

manual/manual-api/libzmq.a

@@ -1 +0,0 @@
-../../slsReceiverSoftware/include/libzmq.a

manual/manual-api/mainClient.cpp

@@ -54,7 +54,12 @@ int main(int argc,  char **argv) {
 
 
 	/** - slsDetectorUsers Object is instantiated with appropriate ID */
-	slsDetectorUsers *pDetector = new  slsDetectorUsers (id);
+	int ret = 1;
+	slsDetectorUsers *pDetector = new slsDetectorUsers (ret, id);
+	if (ret == 1) {
+		std::cout << "Error: Could not instantiate slsDetectorUsers" << std::endl;
+		return EXIT_FAILURE;
+	}
 
 
 	/** - if specified, load configuration file (necessary at least the first time it is called to properly configure advanced settings in the shared memory) */
@@ -71,10 +76,6 @@ int main(int argc,  char **argv) {
 
 	/** - registering data callback */
 	pDetector->registerDataCallback(&dataCallback, NULL);
-	/** - if receiver exists, enable data streaming from receiver to get the data */
-	pDetector->enableDataStreamingFromReceiver(1);
-	/** - create zmq sockets in client to enable data streaming in of data from receiver/different process */
-	pDetector->enableDataStreamingToClient(1);
 
 
 	/** - ensuring detector status is idle before starting acquisition. exiting if not idle */
@@ -93,7 +94,7 @@ int main(int argc,  char **argv) {
 
 	/** - start measurement */
 	pDetector->startMeasurement();
-	std::cout << "measurement finished" << std::endl;	usleep(1*1000*1000);
+	std::cout << "measurement finished" << std::endl;
 
 	/** - returning when acquisition is finished or data are avilable */
 

manual/manual-api/mainReceiver.cpp

@@ -54,7 +54,7 @@ void sigInterruptHandler(int p){
  */
 void printHelp() {
 	cprintf(RESET, "Usage:\n"
-			"./detReceiver [start_tcp_port] [num_receivers] [1 for call back, 0 for none]\n\n");
+			"./slsMultiReceiver(detReceiver) [start_tcp_port] [num_receivers] [1 for call back, 0 for none]\n\n");
 	exit(EXIT_FAILURE);
 }
 
@@ -71,7 +71,7 @@ void printHelp() {
  */
 int StartAcq(char* filepath, char* filename, uint64_t fileindex, uint32_t datasize, void*p){
 	cprintf(BLUE, "#### StartAcq:  filepath:%s  filename:%s fileindex:%llu  datasize:%u ####\n",
-			filepath, filename, fileindex, datasize);
+			filepath, filename, (long long unsigned int)fileindex, datasize);
 
 	cprintf(BLUE, "--StartAcq: returning 0\n");
 	return 0;
@@ -83,45 +83,80 @@ int StartAcq(char* filepath, char* filename, uint64_t fileindex, uint32_t datasi
  * @param p pointer to object
  */
 void AcquisitionFinished(uint64_t frames, void*p){
-	cprintf(BLUE, "#### AcquisitionFinished: frames:%llu ####\n",frames);
+	cprintf(BLUE, "#### AcquisitionFinished: frames:%llu ####\n",(long long unsigned int)frames);
 }
 
+
 /**
  * Get Receiver Data Call back
  * Prints in different colors(for each receiver process) the different headers for each image call back.
- * @param frameNumber frame number
- * @param expLength real time exposure length (in 100ns) or sub frame number (Eiger 32 bit mode only)
- * @param packetNumber number of packets caught for this frame
- * @param bunchId bunch id from beamline
- * @param timestamp time stamp  in 10MHz clock (not implemented for most)
- * @param modId module id	(not implemented for most)
- * @param xCoord x coordinates (detector id in 1D)
- * @param yCoord y coordinates (not implemented)
- * @param zCoord z coordinates (not implemented)
- * @param debug debug values if any
- * @param roundRNumber (not implemented)
- * @param detType detector type see :: detectorType
- * @param version version of standard header (structure format)
+ * @param metadata sls_receiver_header metadata
  * @param datapointer pointer to data
- * @param datasize data size in bytes
+ * @param datasize data size in bytes.
  * @param p pointer to object
  */
-void GetData(uint64_t frameNumber, uint32_t expLength, uint32_t packetNumber, uint64_t bunchId, uint64_t timestamp,
-		uint16_t modId, uint16_t xCoord, uint16_t yCoord, uint16_t zCoord, uint32_t debug, uint16_t roundRNumber, uint8_t detType, uint8_t version,
-		char* datapointer, uint32_t datasize, void* p){
+void GetData(char* metadata, char* datapointer, uint32_t datasize, void* p){
+	slsReceiverDefs::sls_receiver_header* header = (slsReceiverDefs::sls_receiver_header*)metadata;
+	slsReceiverDefs::sls_detector_header detectorHeader = header->detHeader;
 
-	PRINT_IN_COLOR (modId?modId:xCoord,
+	PRINT_IN_COLOR (detectorHeader.modId?detectorHeader.modId:detectorHeader.row,
 			"#### %d GetData: ####\n"
-			"frameNumber: %llu\t\texpLength: %u\t\tpacketNumber: %u\t\tbunchId: %llu\t\ttimestamp: %llu\t\tmodId: %u\t\t"
-			"xCoord: %u\t\tyCoord: %u\t\tzCoord: %u\t\tdebug: %u\t\troundRNumber: %u\t\tdetType: %u\t\t"
-			"version: %u\t\tfirstbytedata: 0x%x\t\tdatsize: %u\n\n",
-			xCoord, frameNumber, expLength, packetNumber, bunchId, timestamp, modId,
-			xCoord, yCoord, zCoord, debug, roundRNumber, detType, version,
-			((uint8_t)(*((uint8_t*)(datapointer)))), datasize);
+			"frameNumber: %llu\t\texpLength: %u\t\tpacketNumber: %u\t\tbunchId: %llu"
+			"\t\ttimestamp: %llu\t\tmodId: %u\t\t"
+			"row: %u\t\tcolumn: %u\t\treserved: %u\t\tdebug: %u"
+			"\t\troundRNumber: %u\t\tdetType: %u\t\tversion: %u"
+			//"\t\tpacketsMask:%s"
+			"\t\tfirstbytedata: 0x%x\t\tdatsize: %u\n\n",
+			detectorHeader.row, (long long unsigned int)detectorHeader.frameNumber,
+			detectorHeader.expLength, detectorHeader.packetNumber, (long long unsigned int)detectorHeader.bunchId,
+			(long long unsigned int)detectorHeader.timestamp, detectorHeader.modId,
+			detectorHeader.row, detectorHeader.column, detectorHeader.reserved,
+			detectorHeader.debug, detectorHeader.roundRNumber,
+			detectorHeader.detType, detectorHeader.version,
+			//header->packetsMask.to_string().c_str(),
+            ((uint8_t)(*((uint8_t*)(datapointer)))), datasize);
 }
 
 
 
+/**
+ * Get Receiver Data Call back (modified)
+ * Prints in different colors(for each receiver process) the different headers for each image call back.
+ * @param metadata sls_receiver_header metadata
+ * @param datapointer pointer to data
+ * @param datasize data size in bytes.
+ * @param revDatasize new data size in bytes after the callback.
+ * This will be the size written/streamed. (only smaller value is allowed).
+ * @param p pointer to object
+ */
+void GetData(char* metadata, char* datapointer, uint32_t &revDatasize, void* p){
+	slsReceiverDefs::sls_receiver_header* header = (slsReceiverDefs::sls_receiver_header*)metadata;
+	slsReceiverDefs::sls_detector_header detectorHeader = header->detHeader;
+
+	PRINT_IN_COLOR (detectorHeader.modId?detectorHeader.modId:detectorHeader.row,
+			"#### %d GetData: ####\n"
+			"frameNumber: %llu\t\texpLength: %u\t\tpacketNumber: %u\t\tbunchId: %llu"
+			"\t\ttimestamp: %llu\t\tmodId: %u\t\t"
+			"row: %u\t\tcolumn: %u\t\treserved: %u\t\tdebug: %u"
+			"\t\troundRNumber: %u\t\tdetType: %u\t\tversion: %u"
+			//"\t\tpacketsMask:%s"
+			"\t\tfirstbytedata: 0x%x\t\tdatsize: %u\n\n",
+			detectorHeader.row, (long long unsigned int)detectorHeader.frameNumber,
+			detectorHeader.expLength, detectorHeader.packetNumber, (long long unsigned int)detectorHeader.bunchId,
+			(long long unsigned int)detectorHeader.timestamp, detectorHeader.modId,
+			detectorHeader.row, detectorHeader.column, detectorHeader.reserved,
+			detectorHeader.debug, detectorHeader.roundRNumber,
+			detectorHeader.detType, detectorHeader.version,
+			//header->packetsMask.to_string().c_str(),
+			((uint8_t)(*((uint8_t*)(datapointer)))), revDatasize);
+
+	// if data is modified, eg ROI and size is reduced
+	revDatasize = 26000;
+}
+
+
+
+
 /**
  * Example of main program using the slsReceiverUsers class
  *
@@ -209,7 +244,8 @@ int main(int argc, char *argv[]) {
 
 				/* 	- Call back for raw data */
 				cprintf(BLUE, "Registering     GetData() \n");
-				receiver->registerCallBackRawDataReady(GetData,NULL);
+				if (withCallback == 1) receiver->registerCallBackRawDataReady(GetData,NULL);
+				else if (withCallback == 2) receiver->registerCallBackRawDataModifyReady(GetData,NULL);
 			}
 
 

manual/manual-api/slsDetectorUsers.doxy

@@ -81,7 +81,11 @@ LATEX_HIDE_INDICES = YES
 SOURCE_BROWSER	= YES
 
 PREDEFINED           = __cplusplus
-
-INPUT            = slsDetectorUsers.h detectorData.h slsReceiverUsers.h mainClient.cpp mainReceiver.cpp
+ 
+INPUT            = 		../../slsDetectorSoftware/slsDetector/slsDetectorUsers.h		\
+					 	../../slDetectorSoftware/slsDetectorAnalysis/detectorData.h 	\
+					 	../../slsReceiverSoftware/include/slsReceiverUsers.h 			\
+					 	mainClient.cpp 													\
+					 	mainReceiver.cpp
 
 OUTPUT_DIRECTORY = slsDetectorUsersDocs

manual/manual-api/slsDetectorUsers.h

@@ -1 +0,0 @@
-../../slsDetectorSoftware/slsDetector/slsDetectorUsers.h

manual/manual-api/slsReceiverUsers.h

@@ -1 +0,0 @@
-../../slsReceiverSoftware/include/slsReceiverUsers.h

manual/manual-api/sls_receiver_defs.h

@@ -1 +0,0 @@
-../../slsReceiverSoftware/include/sls_receiver_defs.h

manual/manual-api/sls_receiver_funcs.h

@@ -1 +0,0 @@
-../../slsReceiverSoftware/include/sls_receiver_funcs.h

manual/manual-api/zmq.h

@@ -1 +0,0 @@
-../../slsReceiverSoftware/include/zmq.h

manual/manual-main/slsDetectorInstall.tex

@@ -61,6 +61,11 @@ The \textit{data receiver}, which can be run on a different machine than the
 client, receives the data from the detector and processes it. The receiver can
 be configured, controlled and monitored by the client.
 
+\item \textcolor{blue}{slsMultiReceiver}: \\
+It is the same as the \textit{slsReceiver}, but that it is a single process 
+for many multiple slsReceiver child processes. One can configure the start TCP port,
+number of slsReceiver processes and if call back should be enabled or not.
+
 \item \textcolor{blue}{slsDetectorGUI}: \\
 The \textit{graphical user interface}, which provides a user friendly way
 of operating the detectors and data receivers with online data preview.
@@ -110,13 +115,13 @@ conda config --add channels conda-forge
 conda config --add channels slsdetectorgroup
 
 #Install latest version
-conda install sls_detector_software
+conda install sls_detector_lib
+conda install sls_detector_gui
 
-#Install specific release (GLIBC2.14)
-conda install sls_detector_software=3.1.0
+#Install specific release
+conda install sls_detector_lib=4.0.0
+conda install sls_detector_gui=4.0.0
 
-#Scientific Linux 6 version (GLIBC2.12)
-conda install sls_detector_software=SL6_3.1.0
 \end{verbatim}
  \item The package including Python interface
 \begin{verbatim}
@@ -127,11 +132,9 @@ conda config --add channels sls_detector
 #Install latest version
 conda install sls_detector
 
-#Install specific release (GLIBC2.14)
-conda install sls_detector=3.1.0
+#Install specific release 
+conda install sls_detector=4.0.0
 
-#Scientific Linux 6 version (GLIBC2.12)
-conda install sls_detector=SL6_3.1.0
 \end{verbatim}
 \end{itemize}
 
@@ -148,13 +151,13 @@ acquisition system, or if one wants to download the source code and compile.
 \begin{verbatim}
 #Clone source code with specific release
 git clone https://github.com/slsdetectorgroup/slsDetectorPackage.git --branch
-3.1.0
+4.0.0
 \end{verbatim}
  \item The package including Python interface
 \begin{verbatim}
 #Clone source code with specific release
 git clone https://github.com/slsdetectorgroup/sls_detector.git --branch
-3.1.0
+4.0.0
 \end{verbatim}
 \end{itemize}
 
@@ -437,14 +440,11 @@ the SLS Detector Package or a different detector type.
 One can use the \verb=cleansharedmemory.sh= script available under the
 slsDetector Package.
 
-One can also just use the following commands to clean the shared memory
-segments one by one.
-\begin{verbatim}
-#displays list of shared memeory segments 
-ipcs -m
-#remove segments that have nattach equal to zero. They key is the first column
-ipcrm -M [key]
-\end{verbatim}
+One can also just delete the files that are typically located under /dev/shm/ folder
+and starts with slsDetectorPackage.
+
+One no longer has to delete segments using ipcs.
+
 
 \section{Software Upgrade}
 
@@ -544,14 +544,14 @@ detector board the programming files and/or software package provided by
 the SLS Detectors group.
 
 \subsubsection{GOTTHARD Firmware}
-\textit{For SLS Detector Package v3.1.0} \\
+\textit{For SLS Detector Package v4.0.0} \\
 \indent Minimum compatible version: \\
 \indent \indent 11.01.2013 \\
 \indent Latest version:	\\
-\indent \indent 08.02.2018 (50um and 25um Master) \\
+\indent \indent 08.02.2018 (50um) \\
+\indent \indent 08.02.2018 (25 um Master) \\
 \indent \indent 09.02.2018 (25 um Slave) \\
 
-
 Normally, the firmware will be upgraded by us as it requires programming the
 FPGA via the USB-Blaster.
 
@@ -636,9 +636,9 @@ detector board the programming files and/or software package provided by
 the SLS Detectors group.
 
 \subsubsection{EIGER Firmware}
-\textit{For SLS Detector Package v3.1.0} \\
-\indent Minimum compatible version:  16 \\
-\indent Latest version:	20  \\
+\textit{For SLS Detector Package v4.0.0} \\
+\indent Minimum compatible version:  22 \\
+\indent Latest version:	22  \\
 
 
 \begin{enumerate}
@@ -647,6 +647,20 @@ Detector Group.
   \item If one does not have the bcp script, that should also be obtained from
 the SLS Detector Group. It is required to program the bit files and requires
 that tftp be installed on the pc.
+  \item Bring the detector into programmable mode by either of the following ways.
+Both ways end up in just the central LED blinking.
+  \begin{enumerate}
+    \item hard reset on the back panel boards resulting in blinking LEDS 
+    \item by having the following program running in the background. 
+    \begin{verbatim}
+    boot_recovery
+    \end{verbatim}
+\end{enumerate}
+  \item Start a terminal for each half module and run the following to see 
+progress.
+\begin{verbatim}
+	nc -p 3000 -u bebxxx 3000 
+\end{verbatim}
   \item Run the following to update firmware
 \begin{verbatim}
  #update back end fpga
@@ -715,9 +729,9 @@ detector board the programming files and/or software package provided by
 the SLS Detectors group.
 
 \subsubsection{JUNGFRAU Firmware}
-\textit{For SLS Detector Package v3.1.0} \\
-\indent Minimum compatible version: 13.11.2017 \\
-\indent Latest version: 13.11.2017 \\
+\textit{For SLS Detector Package v4.0.0} \\
+\indent Minimum compatible version: 15.06.2018 \\
+\indent Latest version: 15.06.2018 \\
 
 
 At times, one has to update the firmware, which then also requires updating the
@@ -733,7 +747,7 @@ Detector Group.
   \item Update the latest SLS Detector package installed.
   \item Update the on-board software as per the instructions in the next
 section.
-  \item Start the on-board server in debug mode:
+  \item Start the on-board server in update mode:
   \begin{enumerate}
     \item Connect to the blackfin on the detector\\ 
 \verb=telnet bchipxxx=
@@ -743,10 +757,10 @@ section.
       \item Comment out the line
 \verb=#ttyS0::respawn:/jungfrauDetectorServervxxx= 
       \item Reboot blackfin using \verb=reboot=
-      \item Run \verb=ps= to ensure no gotthardDetectorServers are running
+      \item Run \verb=ps= to ensure no jungfrauDetectorServers are running
     \end{enumerate}
-    \item Start the server in debug mode using: \\
-\verb=./jungfrauDetectorServerxxx -debug= \\
+    \item Start the server in update mode using: \\
+\verb=./jungfrauDetectorServerxxx -update= \\
     Leave this console on to come back to it later.
   \end{enumerate}
   \item From the command line of the pc, clear shared memory \\
@@ -759,7 +773,7 @@ script in \verb=slsDetectorPackage/cleansharedmemory.sh=
 \verb=./sls_detector_put programfpga xxx.pof= 
   \item Once the programming is done:
   \begin{enumerate}
-    \item Switch to the console that has the debug server running and kill it
+    \item Switch to the console that has the update server running and kill it
 using Ctrl+C and ensure no jungfrauDetectorServers are
 running
     \item Restart the new server to see if it runs with the new firmware \\

serverBin/eigerDetectorServer_virtualMaster

@@ -1 +0,0 @@
-../slsDetectorSoftware/eigerDetectorServer/bin/eigerDetectorServer_virtualMaster

serverBin/eigerDetectorServer_virtualSlave

@@ -1 +0,0 @@
-../slsDetectorSoftware/eigerDetectorServer/bin/eigerDetectorServer_virtualSlave

serverBin/eigerDetectorServerv3.1.0.16.1

@@ -1 +0,0 @@
-../slsDetectorSoftware/eigerDetectorServer/bin/eigerDetectorServerv3.1.0.16.1

serverBin/eigerDetectorServerv3.1.0.21.0

@@ -1 +0,0 @@
-../slsDetectorSoftware/eigerDetectorServer/bin/eigerDetectorServerv3.1.0.21.0

serverBin/eigerDetectorServerv4.0.0.22.0

@@ -0,0 +1 @@
+../slsDetectorSoftware/eigerDetectorServer/bin/eigerDetectorServerv4.0.0.22.0

serverBin/gotthardDetectorServer_virtual

@@ -1 +0,0 @@
-../slsDetectorSoftware/gotthardDetectorServer/gotthardDetectorServer_virtual

serverBin/gotthardDetectorServerv3.1.0.1

@@ -1 +0,0 @@
-../slsDetectorSoftware/gotthardDetectorServer/gotthardDetectorServerv3.1.0.1

serverBin/gotthardDetectorServerv4.0.0.3

@@ -0,0 +1 @@
+../slsDetectorSoftware/gotthardDetectorServer/gotthardDetectorServerv4.0.0.3

serverBin/jungfrauDetectorServer_virtual

@@ -1 +0,0 @@
-../slsDetectorSoftware/jungfrauDetectorServer/bin/jungfrauDetectorServer_virtual

serverBin/jungfrauDetectorServerv3.0.0.12

@@ -1 +0,0 @@
-../slsDetectorSoftware/jungfrauDetectorServer/bin/jungfrauDetectorServerv3.0.0.12

serverBin/jungfrauDetectorServerv3.1.0.2

@@ -1 +0,0 @@
-../slsDetectorSoftware/jungfrauDetectorServer/bin/jungfrauDetectorServerv3.1.0.2

serverBin/jungfrauDetectorServerv4.0.0.0

@@ -0,0 +1 @@
+../slsDetectorSoftware/jungfrauDetectorServer/bin/jungfrauDetectorServerv4.0.0.0

settingsdir/gotthard/dynamicgain/calibration.sn

@@ -1 +0,0 @@
-227 5.6

settingsdir/gotthard/dynamicgain/settings.sn

@@ -1,8 +0,0 @@
-Vref 660
-VcascN 650
-VcascP 1480
-Vout 1520
-Vcasc 1320
-Vin 1350
-Vref_comp 350
-Vib_test 2001

settingsdir/gotthard/highgain/calibration.sn

@@ -1 +0,0 @@
-227 5.6

settingsdir/gotthard/highgain/settings.sn

@@ -1,8 +0,0 @@
-Vref 660
-VcascN 650
-VcascP 1480
-Vout 1520
-Vcasc 1320
-Vin 1350
-Vref_comp 350
-Vib_test 2001

settingsdir/gotthard/lowgain/calibration.sn

@@ -1 +0,0 @@
-227 5.6

settingsdir/gotthard/lowgain/settings.sn

@@ -1,8 +0,0 @@
-Vref 660
-VcascN 650
-VcascP 1480
-Vout 1520
-Vcasc 1320
-Vin 1350
-Vref_comp 350
-Vib_test 2001

settingsdir/gotthard/mediumgain/calibration.sn

@@ -1 +0,0 @@
-227 5.6

settingsdir/gotthard/mediumgain/settings.sn

@@ -1,8 +0,0 @@
-Vref 660
-VcascN 650
-VcascP 1480
-Vout 1520
-Vcasc 1320
-Vin 1350
-Vref_comp 350
-Vib_test 2001

settingsdir/gotthard/veryhighgain/calibration.sn

@@ -1 +0,0 @@
-227 5.6

settingsdir/gotthard/veryhighgain/settings.sn

@@ -1,8 +0,0 @@
-Vref 660
-VcascN 650
-VcascP 1480
-Vout 1520
-Vcasc 1320
-Vin 1350
-Vref_comp 350
-Vib_test 2001

settingsdir/jungfrau/dynamicgain/calibration.sn

@@ -1 +0,0 @@
-227 5.6

settingsdir/jungfrau/dynamicgain/settings.sn

@@ -1,8 +0,0 @@
-VDAC0 1220
-VDAC1 3000
-VDAC2 1053
-VDAC3 1450
-VDAC4 750
-VDAC5 1000
-VDAC6 480
-VDAC7 420

settingsdir/jungfrau/dynamichg0

@@ -1 +0,0 @@
-dynamicgain

settingsdir/jungfrau/fixgain1

@@ -1 +0,0 @@
-dynamicgain

settingsdir/jungfrau/fixgain2

@@ -1 +0,0 @@
-dynamicgain

settingsdir/jungfrau/forceswitchg1

@@ -1 +0,0 @@
-dynamicgain

settingsdir/jungfrau/forceswitchg2

@@ -1 +0,0 @@
-dynamicgain

settingsdir/moench/dynamicgain/calibration.sn

@@ -1 +0,0 @@
-227 5.6

settingsdir/moench/dynamicgain/settings.sn

@@ -1,8 +0,0 @@
-VDAC0 660
-VDAC1 650
-VDAC2 1480
-VDAC3 1520
-VDAC4 1320
-VDAC5 1350
-VDAC6 887
-VDAC7 2001

settingsdir/moench/highgain/calibration.sn

@@ -1 +0,0 @@
-227 5.6

settingsdir/moench/highgain/settings.sn

@@ -1,8 +0,0 @@
-VDAC0 660
-VDAC1 650
-VDAC2 1480
-VDAC3 1520
-VDAC4 1320
-VDAC5 1350
-VDAC6 887
-VDAC7 2001

settingsdir/moench/lowgain/calibration.sn

@@ -1 +0,0 @@
-227 5.6

settingsdir/moench/lowgain/settings.sn

@@ -1,8 +0,0 @@
-VDAC0 660
-VDAC1 650
-VDAC2 1480
-VDAC3 1520
-VDAC4 1320
-VDAC5 1350
-VDAC6 887
-VDAC7 2001

settingsdir/moench/mediumgain/calibration.sn

@@ -1 +0,0 @@
-227 5.6

settingsdir/moench/mediumgain/settings.sn

@@ -1,8 +0,0 @@
-VDAC0 660
-VDAC1 650
-VDAC2 1480
-VDAC3 1520
-VDAC4 1320
-VDAC5 1350
-VDAC6 887
-VDAC7 2001

settingsdir/moench/veryhighgain/calibration.sn

@@ -1 +0,0 @@
-227 5.6

settingsdir/moench/veryhighgain/settings.sn

@@ -1,8 +0,0 @@
-VDAC0 660
-VDAC1 650
-VDAC2 1480
-VDAC3 1520
-VDAC4 1320
-VDAC5 1350
-VDAC6 887
-VDAC7 2001

settingsdir/propix/dynamicgain/calibration.sn

@@ -1 +0,0 @@
-227 5.6

settingsdir/propix/dynamicgain/settings.sn

@@ -1,8 +0,0 @@
-Vref 660
-VcascN 650
-VcascP 1480
-Vout 1520
-Vcasc 1320
-Vin 1350
-Vref_comp 887
-Vib_test 2001

settingsdir/propix/highgain/calibration.sn

@@ -1 +0,0 @@
-227 5.6

settingsdir/propix/highgain/settings.sn

@@ -1,8 +0,0 @@
-Vref 660
-VcascN 650
-VcascP 1480
-Vout 1520
-Vcasc 1320
-Vin 1350
-Vref_comp 887
-Vib_test 2001

settingsdir/propix/lowgain/calibration.sn

@@ -1 +0,0 @@
-227 5.6

settingsdir/propix/lowgain/settings.sn

@@ -1,8 +0,0 @@
-Vref 660
-VcascN 650
-VcascP 1480
-Vout 1520
-Vcasc 1320
-Vin 1350
-Vref_comp 887
-Vib_test 2001

settingsdir/propix/mediumgain/calibration.sn

@@ -1 +0,0 @@
-227 5.6

settingsdir/propix/mediumgain/settings.sn

@@ -1,8 +0,0 @@
-Vref 660
-VcascN 650
-VcascP 1480
-Vout 1520
-Vcasc 1320
-Vin 1350
-Vref_comp 887
-Vib_test 2001

settingsdir/propix/veryhighgain/calibration.sn

@@ -1 +0,0 @@
-227 5.6

settingsdir/propix/veryhighgain/settings.sn

@@ -1,8 +0,0 @@
-Vref 660
-VcascN 650
-VcascP 1480
-Vout 1520
-Vcasc 1320
-Vin 1350
-Vref_comp 887
-Vib_test 2001

slsDetectorCalibration/analogDetector.h

@@ -8,8 +8,20 @@
 #include "pedestalSubtraction.h"
 #include "commonModeSubtraction.h"
 #include "tiffIO.h"
+#include "slsInterpolation.h"
 
 
+#ifdef ROOTSPECTRUM
+#include <TPaveText.h> 
+#include <TLegend.h> 
+#include <TF1.h> 
+#include <TGraphErrors.h> 
+#include <TH2F.h> 
+#include <TASImage.h> 
+#include <TImage.h> 
+#include <TFile.h> 
+#endif
+
 using namespace std;
 
 #ifndef FRAMEMODE_DEF
@@ -18,6 +30,10 @@ using namespace std;
 enum to define the flags of the data set, which are needed to seect the type of processing it should undergo: frame, pedestal, flat
 */
  enum frameMode { eFrame, ePedestal, eFlat };
+/** 
+enum to define the detector mode
+*/
+ enum detectorMode { eAnalog, ePhotonCounting, eInterpolating };
 #endif
 
 
@@ -65,12 +81,30 @@ template <class dataType> class analogDetector {
     fMode=ePedestal;
     thr=0;
     myFile=NULL;
-    fm=new pthread_mutex_t ;
+#ifdef ROOTSPECTRUM
+    hs=new TH2F("hs","hs",2000,-100,10000,nx*ny,-0.5,nx*ny-0.5);
+#ifdef ROOTCLUST
+    hs3=new TH2F("hs3","hs3",2000,-100,3*3*10000,nx*ny,-0.5,nx*ny-0.5);
+    hs5=new TH2F("hs5","hs5",2000,-100,5*5*10000,nx*ny,-0.5,nx*ny-0.5);
+    hs7=new TH2F("hs7","hs7",2000,-100,7*7*10000,nx*ny,-0.5,nx*ny-0.5);
+    hs9=new TH2F("hs9","hs9",2000,-100,9*9*10000,nx*ny,-0.5,nx*ny-0.5);
+#endif
+#endif
   };
   /**
      destructor. Deletes the pdestalSubtraction array and the image
   */
-  virtual ~analogDetector() {for (int i=0; i<ny; i++) delete [] stat[i]; delete [] stat; delete [] image;};
+  virtual ~analogDetector() {for (int i=0; i<ny; i++) delete [] stat[i]; delete [] stat; delete [] image;
+#ifdef ROOTSPECTRUM
+    delete hs;
+#ifdef ROOTCLUST
+    delete hs3;
+    delete hs5;
+    delete hs7;
+    delete hs9;
+#endif
+#endif
+};
 
   /**
      constructor cloning another analog detector
@@ -94,7 +128,6 @@ template <class dataType> class analogDetector {
     // nSigma=orig->nSigma;
     fMode=orig->fMode;
     myFile=orig->myFile;
-    fm=orig->fm;
     
 
     stat=new pedestalSubtraction*[ny];
@@ -111,7 +144,16 @@ template <class dataType> class analogDetector {
       }
     }
     image=new int[nx*ny];
-    
+#ifdef ROOTSPECTRUM
+    hs=(TH2F*)(orig->hs)->Clone();//new TH2F("hs","hs",(orig->hs)-getNbins,-500,9500,nx*ny,-0.5,nx*ny-0.5);
+#ifdef ROOTCLUST
+     hs3=(TH2F*)(orig->hs3)->Clone();//new TH2F("hs","hs",(orig->hs)-getNbins,-500,9500,nx*ny,-0.5,nx*ny-0.5);
+     hs5=(TH2F*)(orig->hs5)->Clone();//new TH2F("hs","hs",(orig->hs)-getNbins,-500,9500,nx*ny,-0.5,nx*ny-0.5); 
+     hs7=(TH2F*)(orig->hs7)->Clone();//new TH2F("hs","hs",(orig->hs)-getNbins,-500,9500,nx*ny,-0.5,nx*ny-0.5); 
+     hs9=(TH2F*)(orig->hs9)->Clone();//new TH2F("hs","hs",(orig->hs)-getNbins,-500,9500,nx*ny,-0.5,nx*ny-0.5); 
+#endif
+#endif
+
   }
 
 
@@ -220,6 +262,15 @@ template <class dataType> class analogDetector {
 	image[iy*nx+ix]=0;
       }
     if (cmSub) cmSub->Clear(); 
+#ifdef ROOTSPECTRUM
+    hs->Reset();
+#ifdef ROOTCLUST
+     hs3->Reset();//new TH2F("hs","hs",(orig->hs)-getNbins,-500,9500,nx*ny,-0.5,nx*ny-0.5);
+     hs5->Reset();//new TH2F("hs","hs",(orig->hs)-getNbins,-500,9500,nx*ny,-0.5,nx*ny-0.5); 
+     hs7->Reset();//new TH2F("hs","hs",(orig->hs)-getNbins,-500,9500,nx*ny,-0.5,nx*ny-0.5); 
+     hs9->Reset();//new TH2F("hs","hs",(orig->hs)-getNbins,-500,9500,nx*ny,-0.5,nx*ny-0.5); 
+#endif
+#endif
   };  
   
   /** resets the commonModeSubtraction and increases the frame index */
@@ -253,24 +304,61 @@ template <class dataType> class analogDetector {
        \param iy pixel y coordinate
        \param cm 1 adds the value to common mod, 0 skips it. Defaults to 0. - not properly implemented
     */
-    virtual void addToPedestal(double val, int ix, int iy=0){ 
-      if (ix>=0 && ix<nx && iy>=0 && iy<ny) {
+    virtual void addToPedestal(double val, int ix, int iy=0, int cm=0){ 
+      if (ix>=0 && ix<nx && iy>=0 && iy<ny) { 
+	if (cmSub && cm>0)  { 
+	  val-=	getCommonMode(ix, iy);
+	}
 	stat[iy][ix].addToPedestal(val); 
-	if (cmSub)  {
-	  if (det) if (det->isGood(ix, iy)==0) return;
-	  cmSub->addToCommonMode(val, ix, iy);
-	};
+	/* if (cmSub && cm>0)  { */
+	/*   if (det) if (det->isGood(ix, iy)==0) return; */
+	/*   cmSub->addToCommonMode(val, ix, iy); */
+	/* }; */
       };
     }
     
-    /**
+    double getCommonMode(int ix, int iy) {
+      if (cmSub) return cmSub->getCommonMode(ix, iy);
+      else return 0;
+    }
+
+
+    virtual void addToCommonMode(char *data){ 
+      if (cmSub) {
+	for (int ix=xmin; ix<xmax; ix++) {
+	  for (int iy=ymin; iy<ymax; iy++) { 
+	    // if (getNumpedestals(ix,iy)>0) 
+	    if (det->isGood(ix,iy))
+	      addToCommonMode(data, ix, iy);
+	  }
+	}
+	//cout << "cm " << getCommonMode(0,0) << " " << getCommonMode(1,0) << endl;
+      }
+    }      
+    virtual void addToCommonMode(char *data, int ix, int iy=0){ 
+      if (cmSub) {
+	if (det) if (det->isGood(ix, iy)==0) return;
+	if (getNumpedestals(ix,iy)>0){
+	    cmSub->addToCommonMode(subtractPedestal(data,ix,iy,0), ix, iy);
+	    // cout << ix << " " <<subtractPedestal(data,ix,iy,0)  << endl;
+	}
+      }
+    }      
+  /**
        gets  pedestal (and common mode)
        \param ix pixel x coordinate
        \param iy pixel y coordinate
        \param cm 0 (default) without common mode subtraction, 1 with common mode subtraction (if defined)
        \returns pedestal value
     */
-    virtual double getPedestal(int ix, int iy, int cm=0){if (ix>=0 && ix<nx && iy>=0 && iy<ny) if (cmSub && cm>0) return stat[iy][ix].getPedestal()-cmSub->getCommonMode(); else return stat[iy][ix].getPedestal(); else return -1;};
+    virtual double getPedestal(int ix, int iy, int cm=0){
+      if (ix>=0 && ix<nx && iy>=0 && iy<ny) 
+	if (cmSub && cm>0) 
+	  return stat[iy][ix].getPedestal()+getCommonMode(ix,iy); 
+	else return stat[iy][ix].getPedestal(); 
+      else return -1;
+    };
+
 
     /**
        gets  pedestal rms (i.e. noise)
@@ -278,9 +366,17 @@ template <class dataType> class analogDetector {
        \param iy pixel y coordinate
        \returns pedestal rms
     */
-    virtual double getPedestalRMS(int ix, int iy){if (ix>=0 && ix<nx && iy>=0 && iy<ny) return stat[iy][ix].getPedestalRMS();else return -1;};
+    virtual double getPedestalRMS(int ix, int iy){
+      if (ix>=0 && ix<nx && iy>=0 && iy<ny) 
+	return stat[iy][ix].getPedestalRMS();
+      else return -1;
+    };
 
-   
+     virtual int getNumpedestals(int ix, int iy){
+      if (ix>=0 && ix<nx && iy>=0 && iy<ny) 
+	return stat[iy][ix].getNumpedestals();
+      else return -1;
+    };
     /**
        gets  pedestal (and common mode)
        \param ix pixel x coordinate
@@ -294,6 +390,7 @@ template <class dataType> class analogDetector {
       for (int ix=0; ix<nx; ix++) {
 	for (int iy=0; iy<ny; iy++) {
 	  ped[iy*nx+ix]=stat[iy][ix].getPedestal();
+	  //cout << ped[iy*nx+ix] << " " ;
 	}
       }
       return ped;
@@ -327,7 +424,6 @@ template <class dataType> class analogDetector {
 
 
 
-
     
     /**
        sets  pedestal
@@ -396,17 +492,45 @@ template <class dataType> class analogDetector {
   virtual void *writeImage(const char * imgname) {
     float *gm=NULL;
     void *ret;
+#ifdef ROOTSPECTRUM
+
+      TH2F *hmap=new TH2F("hmap","hmap",nx, -0.5,nx-0.5, ny, -0.5, ny-0.5);
+
+#endif
       gm=new float[nx*ny];
       for (int ix=0; ix<nx; ix++) {
 	for (int iy=0; iy<ny; iy++) {
 	    gm[iy*nx+ix]=image[iy*nx+ix];
+#ifdef ROOTSPECTRUM
+	    hmap->SetBinContent(ix+1, iy+1,image[iy*nx+ix]);
+#endif
 	}
       }
       ret=WriteToTiff(gm, imgname, ny, nx);   
       delete [] gm;
+#ifdef ROOTSPECTRUM
+      char rootfn[10000];
+      sprintf(rootfn,"%s.root",imgname);
+      TFile *f=new TFile(rootfn,"RECREATE");
+      hs->Write("hs");
+#ifdef ROOTCLUST
+      hs3->Write("hs3");
+      hs5->Write("hs5");
+      hs7->Write("hs7");
+      hs9->Write("hs9");
+#endif    
+      hmap->Write("hmap");
+      
+
+      f->Close();
+      delete f;
+      delete hmap;
+#endif
       return ret;
   }
-   
+#ifdef ROOTSPECTRUM
+  TH2F *getSpectrum(){return hs;};
+#endif
        /**
        write 32bit tiff file containing the pedestals
        \param imgname file name to be written
@@ -416,18 +540,43 @@ template <class dataType> class analogDetector {
   virtual void *writePedestals(const char * imgname) {
     float *gm=NULL;
     void *ret;
-      gm=new float[nx*ny];
-      for (int ix=0; ix<nx; ix++) {
-	for (int iy=0; iy<ny; iy++) {
-	  if (cmSub) 
-	    gm[iy*nx+ix]=stat[iy][ix].getPedestal()-cmSub->getCommonMode();
-	  else
-	    gm[iy*nx+ix]=stat[iy][ix].getPedestal();
-	}
+    gm=new float[nx*ny];
+#ifdef ROOTSPECTRUM
+
+      TH2F *hmap=new TH2F("hmap","hmap",nx, -0.5,nx-0.5, ny, -0.5, ny-0.5);
+
+#endif
+    for (int ix=0; ix<nx; ix++) {
+      for (int iy=0; iy<ny; iy++) {
+	/* if (cmSub)  */
+	/*     gm[iy*nx+ix]=stat[iy][ix].getPedestal()-cmSub->getCommonMode(); */
+	/* else */
+	  gm[iy*nx+ix]=stat[iy][ix].getPedestal();
+#ifdef ROOTSPECTRUM
+	  hmap->SetBinContent(ix+1, iy+1,gm[iy*nx+ix]);
+#endif
       }
-      ret=WriteToTiff(gm, imgname, ny, nx);   
-      delete [] gm;
-      return ret;
+    }
+    ret=WriteToTiff(gm, imgname, ny, nx);   
+    delete [] gm;
+    
+#ifdef ROOTSPECTRUM
+    char rootfn[10000];
+    sprintf(rootfn,"%s.root",imgname);
+    TFile *f=new TFile(rootfn,"RECREATE");
+    hs->Write("hs");
+#ifdef ROOTCLUST
+    hs3->Write("hs3");
+    hs5->Write("hs5");
+    hs7->Write("hs7");
+    hs9->Write("hs9");
+#endif
+    hmap->Write("hmap");
+    f->Close();
+    delete f;
+    delete hmap;
+#endif
+    return ret;
   }
   
  /**
@@ -537,19 +686,29 @@ template <class dataType> class analogDetector {
       Adds all the data for each pixels in the selected region of interest to the pedestal
        \param data pointer to the data
     */
+
     
-    virtual void addToPedestal(char *data) {
-      
+    virtual void addToPedestal(char *data, int cm=0) {
       
+      //    cout << "add to pedestal " << endl;
       newFrame();
       
-      
+      if (cmSub) {
+	addToCommonMode(data);
+      }
+            
+      //cout << xmin << " " << xmax << endl;
+      // cout << ymin << " " << ymax << endl;
       for (int ix=xmin; ix<xmax; ix++) {
 	for (int iy=ymin; iy<ymax; iy++) {
-	  
-	  
-	  addToPedestal(data,ix,iy);
-	  
+	  if (det->isGood(ix,iy)) {
+	    addToPedestal(data,ix,iy,1);
+	  //if (ix==10 && iy==10) 
+	  // cout <<ix << " " << iy << " " << getPedestal(ix,iy)<< endl;
+#ifdef ROOTSPECTRUM 
+	    subtractPedestal(data,ix,iy,cm); 
+ #endif 
+	  }
 	  
 	}
       }
@@ -559,6 +718,7 @@ template <class dataType> class analogDetector {
 
 
 
+
   /**
      Sets region of interest in which data should be processed
        \param xmi minimum x. if -1 or out of range remains unchanged
@@ -585,6 +745,20 @@ template <class dataType> class analogDetector {
       }
       
 
+#ifdef ROOTSPECTRUM
+      delete hs;
+      hs=new TH2F("hs","hs",2000,-100,10000,(xmax-xmin)*(ymax-ymin),-0.5,(xmax-xmin)*(ymax-ymin)-0.5);
+#ifdef ROOTCLUST
+      delete hs3;
+      hs3=new TH2F("hs3","hs3",2000,-100,3*3*10000,(xmax-xmin)*(ymax-ymin),-0.5,(xmax-xmin)*(ymax-ymin)-0.5);
+      delete hs5;
+      hs5=new TH2F("hs5","hs5",2000,-100,5*5*10000,(xmax-xmin)*(ymax-ymin),-0.5,(xmax-xmin)*(ymax-ymin)-0.5);
+      delete hs7;
+      hs7=new TH2F("hs7","hs7",2000,-100,7*7*10000,(xmax-xmin)*(ymax-ymin),-0.5,(xmax-xmin)*(ymax-ymin)-0.5);
+      delete hs9;
+      hs9=new TH2F("hs9","hs9",2000,-100,9*9*10000,(xmax-xmin)*(ymax-ymin),-0.5,(xmax-xmin)*(ymax-ymin)-0.5);
+#endif
+#endif
 
     };
       /**
@@ -608,7 +782,7 @@ template <class dataType> class analogDetector {
     */
 
 
-    virtual void addToPedestal(char *data, int ix, int iy=0) {
+    virtual void addToPedestal(char *data, int ix, int iy=0, int cm=0) {
       
       
       double val;
@@ -619,7 +793,15 @@ template <class dataType> class analogDetector {
 	else
 	  val=((double*)data)[iy*nx+ix];
 	
+	 /* if (ix==10 && iy==10)  */
+	 /*     cout << ix << " " << iy << " " << val ;  */
+	  /* if (ix==100 && iy==100) */
+	  /*   cout << ix << " " << iy << " " << val; */
 	addToPedestal(val,ix,iy);
+	  /* if (ix==10 && iy==10)  */
+	  /*   cout <<" " << getPedestal(ix,iy)<< endl; */
+	  /* if (ix==100 && iy==100) */
+	  /*   cout << " " << getPedestal(ix,iy)<< endl; */
       }
       return  ;
       
@@ -631,19 +813,20 @@ template <class dataType> class analogDetector {
        \param data pointer to the data
        \param val pointer where the pedestal subtracted data should be added. If NULL, the internal image is used
        \returns pointer to the pedestal subtracted data
-    */
-
-        
-   virtual  double *subtractPedestal(char *data, double *val=NULL) {
+    */ 
+  // virtual  int *subtractPedestal(char *data, int *val=NULL) {
+      
+    virtual  int *subtractPedestal(char *data, int *val=NULL, int cm=0) {
       
       newFrame();
-
+      
       if (val==NULL)
-	val=new double[nx*ny];
-
+	val=image;//new double[nx*ny];
+      
       for (int ix=xmin; ix<xmax; ix++) {
 	for (int iy=ymin; iy<ymax; iy++) {
-	  val[iy*nx+ix]+=subtractPedestal(data, ix, iy);
+	    if (det->isGood(ix,iy))
+	      val[iy*nx+ix]+=subtractPedestal(data, ix, iy,cm);
 	}
       }
       return  val;
@@ -662,8 +845,9 @@ template <class dataType> class analogDetector {
 
 
 
-   virtual  double subtractPedestal(char *data, int ix, int iy=0) {
+   virtual  double subtractPedestal(char *data, int ix, int iy=0, int cm=0) {
      double g=1.;
+     double val;
       if (ix>=0 && ix<nx && iy>=0 && iy<ny) {
 	if (gmap) {
 	  g=gmap[iy*nx+ix];
@@ -671,10 +855,41 @@ template <class dataType> class analogDetector {
 	}
 
 	if (det)
-	  return (dataSign*det->getValue(data, ix, iy)-getPedestal(ix,iy))/g;
+	  val= (dataSign*det->getValue(data, ix, iy)-getPedestal(ix,iy,cm))/g;
 	else
-	  return (((double*)data)[iy*nx+ix]-getPedestal(ix,iy))/g;
-      }
+	  val= (((double*)data)[iy*nx+ix]-getPedestal(ix,iy))/g;
+    
+#ifdef ROOTSPECTRUM
+	hs->Fill(val,(iy-ymin)*(xmax-xmin)+(ix-xmin));
+#ifdef ROOTCLUST
+	double v3=0,v5=0,v7=0,v9=0;
+	for (int iix=-4; iix<5; iix++)
+	  for (int iiy=-4; iiy<5; iiy++) {
+	    if (det)
+	      val= (dataSign*det->getValue(data, ix+iix, iy+iiy)-getPedestal(ix+iix,iy+iiy,cm))/g;
+	    else
+	      val= (((double*)data)[(iy+iiy)*nx+ix+iix]-getPedestal(ix+iix,iy+iiy,cm))/g;
+	    
+	    if (iix>-4 && iiy>-4 && iix<4 && iiy<4) {
+	      if (iix>-3 && iiy>-3 && iix<3 && iiy<3){
+		if (iix>-2 && iiy>-2 && iix<2 && iiy<2){
+		  v3+=val;
+		}
+		v5+=val;
+	      }
+	      v7+=val;
+	    }
+	    v9+=val;
+	  }
+	hs3->Fill(v3,(iy-ymin)*(xmax-xmin)+(ix-xmin));
+	hs5->Fill(v5,(iy-ymin)*(xmax-xmin)+(ix-xmin));
+	hs7->Fill(v7,(iy-ymin)*(xmax-xmin)+(ix-xmin));
+	hs9->Fill(v9,(iy-ymin)*(xmax-xmin)+(ix-xmin));
+
+#endif
+#endif
+	return val;
+      }	  
    };
       
 
@@ -703,12 +918,20 @@ template <class dataType> class analogDetector {
      double v;
      if (ix>=0 && ix<nx && iy>=0 && iy<ny) {
        v=subtractPedestal(data,ix,iy);
+
+/*        // cout << v << " " ; */
+/* #ifdef ROOTSPECTRUM */
+/*        // cout << (iy-ymin)*(xmax-xmin)+(ix-xmin) << endl; */
+/*        hs->Fill(v,(iy-ymin)*(xmax-xmin)+(ix-xmin)); */
+/* #endif */
        if (thr>0) {
 	 v+=0.5*thr;
 	 nph=v/thr;
-	 return nph;
-       } else
-	 return v;
+	 if (nph>0)
+	   return nph;
+	 return 0;
+       } 
+       return v;
      }
      return 0;  
    };
@@ -722,15 +945,19 @@ template <class dataType> class analogDetector {
      int *getNPhotons(char *data,  int *nph=NULL) {
        
        double val;
-     if (nph==NULL)
-       nph=image;
-     newFrame();
-     for (int ix=xmin; ix<xmax; ix++) {
-       for (int iy=ymin; iy<ymax; iy++) {
-	 nph[iy*nx+ix]+=getNPhotons(data, ix, iy);
+       if (nph==NULL)
+	 nph=image;
+       newFrame();
+
+       addToCommonMode(data);
+
+       for (int ix=xmin; ix<xmax; ix++) {
+	 for (int iy=ymin; iy<ymax; iy++) {
+	   if (det->isGood(ix,iy))
+	     nph[iy*nx+ix]+=getNPhotons(data, ix, iy);
+	 }
        }
-     }
-     return nph;
+       return nph;
      
    }
 
@@ -744,6 +971,23 @@ template <class dataType> class analogDetector {
 	 image[iy*nx+ix]=0;
        }
      }
+#ifdef ROOTSPECTRUM
+     //cout << "reset histogram " << endl;
+     if (hs)
+       hs->Reset();
+#ifdef ROOTCLUST
+
+     if (hs3)
+       hs3->Reset();
+     if (hs5)
+       hs5->Reset();
+     if (hs7)
+       hs7->Reset();
+     if (hs9)
+       hs9->Reset();
+#endif
+     //cout << "done " << endl;
+#endif
    };
 
     /** sets/gets number of samples for moving average pedestal calculation
@@ -788,8 +1032,11 @@ template <class dataType> class analogDetector {
       
       for (int ix=xmi; ix<xma; ix++)
 	for (int iy=ymi; iy<yma; iy++)
-	  if (ix>=0 && ix<nx && iy>=0 && iy<ny) 
-	    val+=getNPhotons(data, ix, iy);
+	  if (det->isGood(ix,iy)) {
+	    if (ix>=0 && ix<nx && iy>=0 && iy<ny) 
+	      val+=getNPhotons(data, ix, iy);
+	  }
+
       return val;
       
     };
@@ -806,14 +1053,17 @@ template <class dataType> class analogDetector {
     virtual void processData(char *data,int *val=NULL) {
       switch(fMode) {
       case ePedestal:
+	//cout << "analog ped " << endl;
 	addToPedestal(data);
 	break;
       default:
-	getNPhotons(data,val);
+	//	cout << "analog " << endl;
+	//subtractPedestal(data);
+	getNPhotons(data);
       }
     };
 
-    virtual char *getInterpolation(){return NULL;};
+    //  virtual char *getInterpolation(){return NULL;};
 
  /** sets the current frame mode for the detector
      \param f frame mode to be set
@@ -827,17 +1077,57 @@ template <class dataType> class analogDetector {
     */
     frameMode getFrameMode() {return fMode;};
     
+
+
+    //enum detectorMode { eAnalog, ePhotonCounting, eInterpolating };
+ /** sets the current detector mode for the detector
+     \param f detector mode to be set
+     \returns current detector mode
+    */
+    detectorMode setDetectorMode(detectorMode f) {dMode=f; return dMode;};
+    
+ /** gets the current detector mode for the detector
+     \returns current detector mode
+    */
+    detectorMode getDetectorMode() {return dMode;};
+  
+
 /** sets file pointer where to write the clusters to 
     \param f file pointer
     \returns current file pointer
 */
-    FILE *setFilePointer(FILE *f){myFile=f; return myFile;};
+FILE *setFilePointer(FILE *f){myFile=f; return myFile;};
 
 /** gets file pointer where to write the clusters to 
     \returns current file pointer
 */
-    FILE *getFilePointer(){return myFile;};
-    void setMutex(pthread_mutex_t *m){fm=m;};
+FILE *getFilePointer(){return myFile;};
+
+
+
+
+
+
+
+    virtual slsInterpolation *getInterpolation(){
+      return NULL;
+    };
+    
+    virtual slsInterpolation *setInterpolation(slsInterpolation *ii){return NULL;}
+
+
+
+    
+  virtual double setNSigma(double n) {return 0;};
+  virtual void setEnergyRange(double emi, double ema) {;};
+
+
+
+
+
+
+
+
  protected:
   
     slsDetectorData<dataType> *det; /**< slsDetectorData to be used */
@@ -858,9 +1148,17 @@ template <class dataType> class analogDetector {
     double thr; /**< threshold to be used for conversion into number of photons */
     //  int nSigma; /**< number of sigma to be used for conversion into number of photons if threshold is undefined */
     frameMode fMode; /**< current detector frame mode */
+    detectorMode dMode; /**< current detector frame mode */
     FILE *myFile; /**< file pointer to write to */
-    
-    pthread_mutex_t *fm;
+#ifdef ROOTSPECTRUM
+    TH2F *hs;
+#ifdef ROOTCLUST
+    TH2F *hs3;
+    TH2F *hs5;
+    TH2F *hs7;
+    TH2F *hs9;
+#endif
+#endif
 };
 
 #endif

slsDetectorCalibration/dataStructures/Mythen3_01_jctbData.h

@@ -43,7 +43,7 @@ class mythen3_01_jctbData : public slsDetectorData<short unsigned int> {
  }
  
 
- static short unsigned int* mythen03_frame(char *ptr, int dr=24,  int nch=64*3, int off=5) {
+ virtual short unsigned int* mythen03_frame(char *ptr, int dr=24,  int nch=64*3, int off=5) {
    // off=0;
     int iarg;
     int64_t word, *wp;

slsDetectorCalibration/dataStructures/Mythen3_02_jctbData.h

@@ -0,0 +1,127 @@
+#ifndef MYTHEN302JCTBDATA_H
+#define MYTHEN302JCTBDATA_H
+
+
+#include "Mythen3_01_jctbData.h"
+//class mythen3_02_jctbData : public slsDetectorData<short unsigned int> {
+class mythen3_02_jctbData : public mythen3_01_jctbData {
+
+
+ public:
+ mythen3_02_jctbData( int nch=64*3,int dr=24, int off=5): mythen3_01_jctbData( nch,dr, off)
+  //slsDetectorData<short unsigned int>(64*3,1,dr*8*nch,NULL,NULL,NULL), dynamicRange(dr), serialOffset(off), frameNumber(0), numberOfCounters(nch) 
+  {};
+
+  /* virtual void getPixel(int ip, int &x, int &y) {x=-1; y=-1;}; */
+  
+  /* virtual short unsigned int getChannel(char *data, int ix, int iy=0) { */
+  /*   int ret=-1; */
+  /*   short unsigned int *val=mythen03_frame(data,dynamicRange,numberOfCounters,serialOffset); */
+  /*   if (ix>=0 && ix<numberOfCounters) ret=val[ix]; */
+  /*   delete [] val; */
+  /*   return ret; */
+  /* }; */
+  
+ /*  virtual int getFrameNumber(char *buff) {return frameNumber;}; */
+ 
+ /*  virtual  char *findNextFrame(char *data, int &ndata, int dsize) { */
+ /*    ndata=dsize; */
+ /*    return data; */
+ /*  } */
+  
+ /* virtual char *readNextFrame(ifstream &filebin) { */
+ /*    char *data=NULL; */
+ /*    if (filebin.is_open()) { */
+ /*      data=new char[dataSize]; */
+ /*      filebin.read(data,dataSize); */
+ /*    } */
+ /*    return data; */
+ /*  } */
+ 
+ /* virtual short unsigned int **getData(char *ptr, int dsize=-1) { */
+ /*   short unsigned int **val; */
+ /*   val=new short unsigned int*[1]; */
+ /*   val[0]=mythen03_frame(ptr,dynamicRange,nx,serialOffset); */
+ /*   return val; */
+   
+ /* } */
+ 
+
+ virtual short unsigned int* mythen03_frame(char *ptr, int dr=24,  int nch=64*3, int off=5) {
+   // off=0;
+    int iarg;
+    int64_t word, *wp;
+    short unsigned int* val=new short unsigned int[nch];
+    int bit[64];
+    int nb=2;
+    int ioff=0;
+    int idr=0;
+    int ib=0;
+    int iw=0;
+    int ii=0;
+    bit[0]=17;//19;
+    bit[1]=6;//8;
+    idr=0;
+    for (ib=0; ib<nch; ib++) {
+      val[ib]=0;
+    }
+    wp=(int64_t*)ptr;
+    
+    for (iw=0; iw<nch/nb; iw) {
+      word=*wp;;
+      if (ioff<off) {
+	ioff++;
+	 cout <<"*";
+      }  else {
+	
+	if (idr<16) {
+	  for (ib=0; ib<nb; ib++) {
+	    if (word&(1<<bit[ib]))  {
+	      cout << "+" ;
+	      val[iw+nch*(ib/nb)]|=(1<<idr);
+	    }  else { 
+	      	cout << "-" ; 
+	       } 
+	  }//end for()
+	}
+	
+	idr++;
+	
+	
+	if (idr==dr) {
+	  idr=0;
+	  //  cout << dec << " " << iw << " " << val[iw] << " " << val[iw+nch/2] << endl;
+	  cout <<dec << iw<<endl;
+	  iw++;
+	}//end if()
+
+      }//end else()
+      wp+=1;
+      ii++;
+    }//end for
+    
+    cout << "Decoded "<<ii << " samples"<< endl;
+    cout << "Should be "<< nch/nb*dr+off << " samples"<< endl;
+  
+    return val;
+ }
+
+ /* virtual int setFrameNumber(int f=0) {if (f>=0) frameNumber=f; return frameNumber; }; */
+ /* virtual int setDynamicRange(int d=-1) {if (d>0 && d<=24) dynamicRange=d; return dynamicRange;}; */
+ /* virtual int setSerialOffset(int d=-1) {if (d>=0) serialOffset=d; return serialOffset;}; */
+ /* virtual int setNumberOfCounters(int d=-1) {if (d>=0) numberOfCounters=d; return numberOfCounters;}; */
+  
+
+ /* private: */
+ 
+ /* int dynamicRange; */
+ /* int serialOffset; */
+ /* int frameNumber; */
+ /* int numberOfCounters; */
+   
+   
+
+
+};
+
+#endif

slsDetectorCalibration/dataStructures/gotthardDoubleModuleDataNew.h

@@ -34,6 +34,9 @@ public:
     
     
     
+#ifdef BCHIP074_BCHIP075
+		  cout << "This is a bchip074-bchip075 system " << endl;
+#endif
 
 
 		uint16_t **dMask;
@@ -59,6 +62,11 @@ public:
 		    dMap[0][ix] = 1280*2+2*offset+ipix*2;//dataSize-2-ix;//+2*offset;
 		  // dMap[0][ix] = 2*ipix+offset*(imod+1)+1280*2*imod; 
 		  dMask[0][ix] = 0x0;
+#ifdef BCHIP074_BCHIP075
+		  int ibad=ix/2+1280*imod;
+		  if ((ibad>=128*4 && ibad<128*5) || (ibad>=9*128 && ibad<10*128) || (ibad>=(1280+128*4) && ibad<ibad>=(1280+128*6))) 
+		    	dataROIMask[0][ix]=0; 
+#endif
 		}
 
 		setDataMap(dMap);
@@ -78,7 +86,7 @@ public:
 
   int getFrameNumber(char *buff){if (offset>=sizeof(sls_detector_header)) return ((sls_detector_header*)buff)->frameNumber; return iframe;};//*((int*)(buff+5))&0xffffff;};   
 
-
+ 
 
 	/**
      gets the packets number (last packet is labelled with 0 and is replaced with 40)

slsDetectorCalibration/dataStructures/jungfrau10ModuleData.h

@@ -7,7 +7,24 @@
 class jungfrau10ModuleData : public slsDetectorData<uint16_t> {
 
  private:
-  
+
+     typedef struct {
+        uint64_t frameNumber;    /**< is the frame number */
+        uint32_t expLength;        /**< is the subframe number (32 bit eiger) or real time exposure time in 100ns (others) */
+        uint32_t packetNumber;    /**< is the packet number */
+        uint64_t bunchId;        /**< is the bunch id from beamline */
+        uint64_t timestamp;        /**< is the time stamp with 10 MHz clock */
+        uint16_t modId;            /**< is the unique module id (unique even for left, right, top, bottom) */
+        uint16_t xCoord;        /**< is the x coordinate in the complete detector system */
+        uint16_t yCoord;        /**< is the y coordinate in the complete detector system */
+        uint16_t zCoord;        /**< is the z coordinate in the complete detector system */
+        uint32_t debug;            /**< is for debugging purposes */
+        uint16_t roundRNumber;    /**< is the round robin set number */
+        uint8_t detType;        /**< is the detector type see :: detectorType */
+        uint8_t version;        /**< is the version number of this structure format */
+    } sls_detector_header;
+
+
   int iframe;
   int nadc;
   int sc_width;
@@ -25,7 +42,7 @@ class jungfrau10ModuleData : public slsDetectorData<uint16_t> {
   */
   
 
- jungfrau10ModuleData(int ns=16384): slsDetectorData<uint16_t>(256*4, 256*2, 256*256*8*2, NULL, NULL, NULL) , iframe(0), nadc(32), sc_width(64), sc_height(256) {
+ jungfrau10ModuleData(int ns=16384): slsDetectorData<uint16_t>(256*4, 256*2, 256*256*8*2+48, NULL, NULL, NULL) , iframe(0) {
 
     
    
@@ -38,43 +55,51 @@ class jungfrau10ModuleData : public slsDetectorData<uint16_t> {
     int ichip;
 
     // cout << sizeof(uint16_t) << endl;
+    int ip=0;
+    for (int iy=0; iy<256*2; iy++) {
+      for (int ix=0; ix<256*4; ix++){
+	dataMap[iy][ix]=ip*2+48;
+	ip++;
+      }
+    }
+      
 
-    for (iadc=0; iadc<nadc; iadc++) {
-      ichip=iadc/4;
+    /* for (iadc=0; iadc<nadc; iadc++) { */
+    /*   ichip=iadc/4; */
 
-      for (int i=0; i<sc_width*sc_height; i++) {
+    /*   for (int i=0; i<sc_width*sc_height; i++) { */
 
-	if (ichip%2==0) {
-	  row=sc_height+i/sc_width;
-	  col=(ichip/2)*256+iadc%4*sc_width+(i%sc_width);
-	} else { 
-	  row=sc_height-1-i/sc_width; 
-	  col=((ichip/2)*256+iadc%4*sc_width)+sc_width-(i%sc_width)-1;
-	}
+/* 	if (ichip%2==0) { */
+/* 	  row=sc_height+i/sc_width; */
+/* 	  col=(ichip/2)*256+iadc%4*sc_width+(i%sc_width); */
+/* 	} else {  */
+/* 	  row=sc_height-1-i/sc_width;  */
+/* 	  col=((ichip/2)*256+iadc%4*sc_width)+sc_width-(i%sc_width)-1; */
+/* 	} */
 	  
 
 	
-/* 	if (iadc<nadc/2) { */
-/* 	  row=sc_height+i/sc_width; */
-/* 	  col=iadc*sc_width+(i%sc_width); */
-/* 	} else { */
-/* 	  row=sc_height-1-i/sc_width; */
-/* 	  col=(nx-1)-((iadc-16)*sc_width)-(i%sc_width); */
-/* 	} */
-	if (row<0 || row>=ny ||  col<0 || col>=nx) {
-	    cout << "Wrong row, column " << row << " " << col << " " << iadc << " " << i << endl;
-	} else
-	  dataMap[row][col]=(nadc*i+iadc)*2;
-	if (dataMap[row][col]<0 || dataMap[row][col]>=dataSize)
-	   cout << "Error: pointer " << dataMap[row][col] << " out of range " << row << " " << col  <<" " << iadc << " " << i << endl;
-	else {
-	  xmap[nadc*i+iadc]=col;
-	  ymap[nadc*i+iadc]=row;
+/* /\* 	if (iadc<nadc/2) { *\/ */
+/* /\* 	  row=sc_height+i/sc_width; *\/ */
+/* /\* 	  col=iadc*sc_width+(i%sc_width); *\/ */
+/* /\* 	} else { *\/ */
+/* /\* 	  row=sc_height-1-i/sc_width; *\/ */
+/* /\* 	  col=(nx-1)-((iadc-16)*sc_width)-(i%sc_width); *\/ */
+/* /\* 	} *\/ */
+/* 	if (row<0 || row>=ny ||  col<0 || col>=nx) { */
+/* 	    cout << "Wrong row, column " << row << " " << col << " " << iadc << " " << i << endl; */
+/* 	} else */
+/* 	  dataMap[row][col]=(nadc*i+iadc)*2; */
+      /* 	if (dataMap[row][col]<0 || dataMap[row][col]>=dataSize) */
+      /* 	   cout << "Error: pointer " << dataMap[row][col] << " out of range " << row << " " << col  <<" " << iadc << " " << i << endl; */
+      /* 	else { */
+      /* 	  xmap[nadc*i+iadc]=col; */
+      /* 	  ymap[nadc*i+iadc]=row; */
 
-	}
-      }
+      /* 	} */
+      /* } */
 
-    }
+    //  }
 
     
     
@@ -91,7 +116,7 @@ class jungfrau10ModuleData : public slsDetectorData<uint16_t> {
   */
 
 
-  int getFrameNumber(char *buff){(void)buff; return iframe;};   
+  int getFrameNumber(return (sls_detector_header*)buff)->frameNumber;};   
 
   /**
 
@@ -123,29 +148,66 @@ class jungfrau10ModuleData : public slsDetectorData<uint16_t> {
      \returns pointer to the begin of the last good frame, NULL if no frame is found or last frame is incomplete
 
   */
-   char *readNextFrame(ifstream &filebin){
+  virtual char *readNextFrame(ifstream &filebin) {
+    int ff=-1, np=-1;
+    return readNextFrame(filebin, ff, np);
+  };
+
+  virtual char *readNextFrame(ifstream &filebin, int &ff) {
+    int np=-1;
+    return readNextFrame(filebin, ff, np);
+  };
+
+  virtual char *readNextFrame(ifstream &filebin, int& ff, int &np) {
+	  char *data=new char[dataSize];
+	  char *d=readNextFrame(filebin, ff, np, data);
+	  if (d==NULL) {delete [] data; data=NULL;}
+	  return data;
+  }
+
+
+  virtual char *readNextFrame(ifstream &filebin, int& ff, int &np, char *data) {
+    // char *readNextFrame(ifstream &filebin){
       //	int afifo_length=0;  
-      uint16_t *afifo_cont; 
-      int ib=0;
-      if (filebin.is_open()) {
-	afifo_cont=new uint16_t[dataSize/2];
- 	while (filebin.read(((char*)afifo_cont)+ib,2)) {
-	  ib+=2;
-	  if (ib==dataSize) break;
-	}
-	if (ib>0) {
-	  iframe++;
-	  // cout << ib << "-" << endl;
-	  return (char*)afifo_cont;
-	} else {
-	  delete [] afifo_cont;
-	  return NULL;
-	}
-      }     
-      return NULL;
-    };
+    /*   uint16_t *afifo_cont;  */
+    /*   int ib=0; */
+    /*   if (filebin.is_open()) { */
+    /* 	afifo_cont=new uint16_t[dataSize/2]; */
+    /* 	while (filebin.read(((char*)afifo_cont)+ib,2)) { */
+    /* 	  ib+=2; */
+    /* 	  if (ib==dataSize) break; */
+    /* 	} */
+    /* 	if (ib>0) { */
+    /* 	  iframe++; */
+    /* 	  // cout << ib << "-" << endl; */
+    /* 	  return (char*)afifo_cont; */
+    /* 	} else { */
+    /* 	  delete [] afifo_cont; */
+    /* 	  return NULL; */
+    /* 	} */
+    /*   }      */
+    /*   return NULL; */
+    /* }; */
 
+ char *retval=0;
+	  int  nd;
+	  int fnum = -1;
+	  np=0;
+	  int  pn;
+	  
+	  //  cout << dataSize << endl;
+	  if (ff>=0)
+	    fnum=ff;
 
+	  if (filebin.is_open()) {
+	    if (filebin.read(data, dataSize) ){
+	      ff=getFrameNumber(data);
+	      np=getPacketNumber(data);
+	      return data;
+	    }
+	  }
+	    return NULL;
+	    
   
 
 };

slsDetectorCalibration/dataStructures/moench02CtbData.h

@@ -31,23 +31,28 @@ class moench02CtbData : public slsDetectorData<uint16_t> {
   */
   
 
-  moench02CtbData(int ns=6400): slsDetectorData<uint16_t>(160, 160, ns*2*32, NULL, NULL) , nadc(4), sc_width(40), sc_height(160) {
+ moench02CtbData(int ns=6400): slsDetectorData<uint16_t>(160, 160, ns*2*32, NULL, NULL) , nadc(32), sc_width(40), sc_height(160) {
 
     
-    int adc_nr[4]={120,0,80,40};
+    int adc_off[4]={40,0,120,80};
+    int adc_nr[4]={8,10,20,23};
     int row, col;
 
     int isample;
-    int iadc;
+    int iadc, iiadc;
     int ix, iy;
     maplength=this->getDataSize()/2;
-    
+    //cout << maplength << endl;
 
-    for (iadc=0; iadc<nadc; iadc++) {
+    for (iiadc=0; iiadc<4; iiadc++) {
+      
+      iadc=adc_nr[iiadc];
+      //cout << iiadc << endl;
       for (int i=0; i<sc_width*sc_height; i++) {
-	col=adc_nr[iadc]+(i%sc_width);
+	
+	col=adc_off[iiadc]+(i%sc_width);
 	row=i/sc_width;
-	dataMap[row][col]=(32*i+iadc+2)*2;
+	dataMap[row][col]=(32*i+iadc)*2;
 	if (dataMap[row][col]<0 || dataMap[row][col]>=dataSize) {
 	  cout << "Error: pointer " << dataMap[row][col] << " out of range "<< endl;	  
 	}
@@ -56,12 +61,17 @@ class moench02CtbData : public slsDetectorData<uint16_t> {
     }
     
     for (int i=0; i<maplength; i++) {
+      //cout << i << endl;
       isample=i/32;
-      iadc=i%32;
+      iiadc=i%32;
+      iadc=-1;
+      for (int iii=0; iii<4; iii++) {
+	if (iiadc==adc_nr[iii]) iadc=iii;
+      }
       ix=isample%sc_width;
       iy=isample/sc_width;
-      if(iadc>1 && iadc<6){
-	xmap[i]=adc_nr[iadc-2]+ix;
+      if(iadc>=0){
+	xmap[i]=adc_off[iadc]+ix;
 	ymap[i]=iy;
       }else{
 	xmap[i]=-1;
@@ -71,15 +81,15 @@ class moench02CtbData : public slsDetectorData<uint16_t> {
     iframe=0;
     cout << "data struct created" << endl;
   };
-    
+  
   void getPixel(int ip, int &x, int &y) {
     if(ip>=0 && ip<maplength){
       x=xmap[ip]; 
       y=ymap[ip];
-    }else{
+    }/*else{
       cerr<<"WRONG ARRAY LENGTH"<<endl;
       cerr<<"Trying to access the "<<ip<<"-th element"<<endl;
-    }
+      }*/
 
   };
   
@@ -137,7 +147,9 @@ class moench02CtbData : public slsDetectorData<uint16_t> {
 	}
 	if (ib>0) {
 	  iframe++;
-	  //cout << ib << "-" << endl;
+	  //cout << ib/2 << "-" << endl;
+	  //for (int i=0; i<ib/2; i++)
+	  //cout << i << " " << afifo_cont[i] << endl;
 	  return (char*)afifo_cont;
 	} else {
 	  delete [] afifo_cont;

slsDetectorCalibration/dataStructures/moench02CtbDataDGS.h

@@ -0,0 +1,187 @@
+#ifndef MOENCH02CTBDATADGS_H
+#define  MOENCH02CTBDATADGS_H
+#include "slsDetectorData.h"
+
+
+
+class moench02CtbData : public slsDetectorData<uint16_t> {
+
+ private:
+  
+  int iframe;
+  // int *xmap, *ymap;
+  //int nadc;
+  int sc_width;
+  int sc_height;
+
+  int maplength;
+
+
+
+ public:
+
+
+
+
+  /**
+     Implements the slsReceiverData structure for the moench02 prototype read out by a module i.e. using the slsReceiver
+     (160x160 pixels, 40 packets 1286 large etc.)
+     \param c crosstalk parameter for the output buffer
+
+  */
+  
+
+ moench02CtbDataDGS(int ns=6400): slsDetectorData<uint16_t>(160, 160, ns*(2*32+8), NULL, NULL) ,  sc_width(40), sc_height(160) {
+
+    
+    int adc_off[4]={40,0,120,80};
+    int adc_nr[4]={8,10,20,23};
+    int row, col;
+
+    int isample;
+    int iadc, iiadc;
+    int ix, iy;
+    maplength=this->getDataSize()/2;
+    //cout << maplength << endl;
+
+    for (iiadc=0; iiadc<4; iiadc++) {
+      
+      iadc=adc_nr[iiadc];
+      //cout << iiadc << endl;
+      for (int i=0; i<sc_width*sc_height; i++) {
+	col=adc_off[iiadc]+(i%sc_width);
+	row=i/sc_width;
+	dataMap[row][col]=(32*i+iadc)*2;
+	if (dataMap[row][col]<0 || dataMap[row][col]>=dataSize) {
+	  cout << "Error: pointer " << dataMap[row][col] << " out of range "<< endl;	  
+	}
+	  
+      }
+    }
+    
+    for (int i=0; i<maplength; i++) {
+      //cout << i << endl;
+      isample=i/32;
+      iiadc=i%32;
+      iadc=-1;
+      for (int iii=0; iii<4; iii++) {
+	if (iiadc==adc_nr[iii]) iadc=iii;
+      }
+      ix=isample%sc_width;
+      iy=isample/sc_width;
+      if(iadc>=0){
+	xmap[i]=adc_off[iadc]+ix;
+	ymap[i]=iy;
+      }else{
+	xmap[i]=-1;
+	ymap[i]=-1;
+      }
+    }
+    iframe=0;
+    cout << "data struct created" << endl;
+  };
+  
+  void getPixel(int ip, int &x, int &y) {
+    if(ip>=0 && ip<maplength){
+      x=xmap[ip]; 
+      y=ymap[ip];
+    }/*else{
+      cerr<<"WRONG ARRAY LENGTH"<<endl;
+      cerr<<"Trying to access the "<<ip<<"-th element"<<endl;
+      }*/
+
+  };
+  
+  /**
+     Returns the gain for the selected pixel (at the moemnt only 3rd supercolumn)
+     \param buff pointer to the dataset
+     \param ix x coordinate 
+     \param iy y coordinate
+     \returns gain value
+   */
+
+  int getGain(char *buff, int ix, int iy) {
+    int isample=iy*sc_width+iy;
+    if (ix<sc_width) return 0; //first supercolumn no gain switching - could return the static gain if wished
+    if (ix<2*sc_width) return 0; //second supercolumn no gain switching  - could return the static gain if wished
+    if (ix<3*sc_width){ 
+      if(*((long*)(buff+(32*2*isample+8*(isample-1)))&(1>>31)) return 1;
+      return 0;
+    }
+    return 0; //not yet implemented for 4th supercolumn
+  }
+
+
+     /**
+
+     Returns the frame number for the given dataset. Purely virtual func.
+     \param buff pointer to the dataset
+     \returns frame number
+
+  */
+
+
+    virtual  int getFrameNumber(char *buff){(void)buff; return iframe;};   
+
+  /**
+
+     Returns the packet number for the given dataset. purely virtual func
+     \param buff pointer to the dataset
+     \returns packet number number
+
+
+  virtual int getPacketNumber(char *buff)=0;
+
+  */
+
+   /**
+
+     Loops over a memory slot until a complete frame is found (i.e. all packets 0 to nPackets, same frame number). purely virtual func
+     \param data pointer to the memory to be analyzed
+     \param ndata reference to the amount of data found for the frame, in case the frame is incomplete at the end of the memory slot
+     \param dsize size of the memory slot to be analyzed
+     \returns pointer to the beginning of the last good frame (might be incomplete if ndata smaller than dataSize), or NULL if no frame is found 
+
+  */
+    virtual  char *findNextFrame(char *data, int &ndata, int dsize){ndata=dsize; setDataSize(dsize);  return data;};
+
+
+   /**
+
+     Loops over a file stream until a complete frame is found (i.e. all packets 0 to nPackets, same frame number). Can be overloaded for different kind of detectors! 
+     \param filebin input file stream (binary)
+     \returns pointer to the begin of the last good frame, NULL if no frame is found or last frame is incomplete
+
+  */
+    virtual char *readNextFrame(ifstream &filebin){
+      //	int afifo_length=0;  
+      uint16_t *afifo_cont; 
+      int ib=0;
+      if (filebin.is_open()) {
+	afifo_cont=new uint16_t[dataSize/2];
+ 	while (filebin.read(((char*)afifo_cont)+ib,2)) {
+	  ib+=2;
+	  if (ib==dataSize) break;
+	}
+	if (ib>0) {
+	  iframe++;
+	  //cout << ib/2 << "-" << endl;
+	  //for (int i=0; i<ib/2; i++)
+	  //cout << i << " " << afifo_cont[i] << endl;
+	  return (char*)afifo_cont;
+	} else {
+	  delete [] afifo_cont;
+	  return NULL;
+	}
+      }     
+      return NULL;
+    };
+
+
+  
+
+};
+
+
+
+#endif

slsDetectorCalibration/dataStructures/moench03Ctb10GbT1Data.h

@@ -121,7 +121,8 @@ class moench03Ctb10GbT1Data : public slsReceiverData<uint16_t> {
 
 
 
- int getFrameNumber(char *buff){return *((int*)(buff+5))&0xffffff;};   
+  // int getFrameNumber(char *buff){return *((int*)buff)&0xffffffff;}; 
+   int getFrameNumber(char *buff){return *((int*)(buff+5))&0xffffff;};   
 
   /**
 
@@ -199,7 +200,7 @@ class moench03Ctb10GbT1Data : public slsReceiverData<uint16_t> {
 	  int  nd;
 	  int fnum = -1;
 	  np=0;
-	  int  pn;
+	  int  pn, po=0;
 	  char aa[8224];
 	  char *packet=(char *)aa;
 	  //  cout << packetSize*nPackets << endl;
@@ -217,15 +218,16 @@ class moench03Ctb10GbT1Data : public slsReceiverData<uint16_t> {
 	      if (fnum<0)
 		fnum= getFrameNumber(packet);
 	      
-	      // cout << "fn: " << fnum << "\t pn: " << pn << endl;
+	      //   cout << "fn: " << fnum << "\t pn: " << pn << endl;
 	      if (fnum>=0) {
-		if (getFrameNumber(packet) !=fnum) { 
+		if (getFrameNumber(packet) !=fnum || pn<po) { 
 		  
 		  if (np==0){
 		    // delete [] data;
 		    return NULL;
 		  } else
 		    filebin.seekg(-8208,ios_base::cur);
+		  po =pn;
 		    return data;
 		}
 		if (pn>nPackets) {
@@ -234,6 +236,7 @@ class moench03Ctb10GbT1Data : public slsReceiverData<uint16_t> {
 
 		memcpy(data+(pn-1)*packetSize, packet, packetSize);
 		np++;
+		po =pn;
 
 		if (np==nPackets)
 		  break;

slsDetectorCalibration/dataStructures/moench03T1ReceiverDataNewRect.h

@@ -0,0 +1,321 @@
+#ifndef MOENCH03T1RECDATANEWRECT_H
+#define  MOENCH03T1RECDATANEWRECT_H
+#include "slsDetectorData.h"
+
+#define VERT 1
+
+    /**
+        @short  structure for a Detector Packet or Image Header
+        @li frameNumber is the frame number
+        @li expLength is the subframe number (32 bit eiger) or real time exposure time in 100ns (others)
+        @li packetNumber is the packet number
+        @li bunchId is the bunch id from beamline
+        @li timestamp is the time stamp with 10 MHz clock
+        @li modId is the unique module id (unique even for left, right, top, bottom)
+        @li xCoord is the x coordinate in the complete detector system
+        @li yCoord is the y coordinate in the complete detector system
+        @li zCoord is the z coordinate in the complete detector system
+        @li debug is for debugging purposes
+        @li roundRNumber is the round robin set number
+        @li detType is the detector type see :: detectorType
+        @li version is the version number of this structure format
+    */
+    typedef struct {
+        uint64_t frameNumber;    /**< is the frame number */
+        uint32_t expLength;        /**< is the subframe number (32 bit eiger) or real time exposure time in 100ns (others) */
+        uint32_t packetNumber;    /**< is the packet number */
+        uint64_t bunchId;        /**< is the bunch id from beamline */
+        uint64_t timestamp;        /**< is the time stamp with 10 MHz clock */
+        uint16_t modId;            /**< is the unique module id (unique even for left, right, top, bottom) */
+        uint16_t xCoord;        /**< is the x coordinate in the complete detector system */
+        uint16_t yCoord;        /**< is the y coordinate in the complete detector system */
+        uint16_t zCoord;        /**< is the z coordinate in the complete detector system */
+        uint32_t debug;            /**< is for debugging purposes */
+        uint16_t roundRNumber;    /**< is the round robin set number */
+        uint8_t detType;        /**< is the detector type see :: detectorType */
+        uint8_t version;        /**< is the version number of this structure format */
+    } sls_detector_header;
+
+
+
+
+class moench03T1ReceiverDataNew : public slsDetectorData<uint16_t> {
+ 
+ private:
+  
+  int iframe;
+  int nadc;
+  int sc_width;
+  int sc_height;
+  const int nSamples;
+
+
+ public:
+
+
+
+
+  /**
+     Implements the slsReceiverData structure for the moench02 prototype read out by a module i.e. using the slsReceiver
+     (160x160 pixels, 40 packets 1286 large etc.)
+     \param c crosstalk parameter for the output buffer
+
+  */
+#ifdef HOR
+    moench03T1ReceiverDataNew(int ns=5000): slsDetectorData<uint16_t>(800, 200, ns*2*32+sizeof(sls_detector_header)), nSamples(ns) {
+#endif
+#ifdef VERT
+    moench03T1ReceiverDataNew(int ns=5000): slsDetectorData<uint16_t>(200, 800, ns*2*32+sizeof(sls_detector_header)), nSamples(ns) {
+#endif
+    int nadc=32;
+    int sc_width=25;
+    int sc_height=200;
+
+    int adc_nr[32]={300,325,350,375,300,325,350,375,		\
+    		    200,225,250,275,200,225,250,275,\
+    		    100,125,150,175,100,125,150,175,\
+    		    0,25,50,75,0,25,50,75};
+
+    int row, col;
+
+    int isample;
+    int iadc;
+    int ix, iy;
+    
+     int npackets=40;
+    int i;
+    int adc4(0);
+    int pix;
+
+
+    int off=0;
+#ifdef OFF_1
+    off=1;
+#endif
+    cout << "This is a MOENCH with rectangular pixels!" << endl;
+
+    for (int ip=0; ip<npackets; ip++) {
+      for (int is=0; is<128; is++) {
+
+	for (iadc=0; iadc<nadc; iadc++) {
+	  i=128*ip+is;
+	  adc4=(int)iadc/4;
+	  if (i<sc_width*sc_height) {
+	    //  for (int i=0; i<sc_width*sc_height; i++) {
+	    col=adc_nr[iadc]+(i%sc_width);
+	    if (adc4%2==0) {
+	      row=199-i/sc_width;
+	    } else {
+	      row=200+i/sc_width;
+	    }
+	    pix=sizeof(sls_detector_header)+(nadc*i+iadc)*2;//+16*(ip+1);
+	    if (pix<0 || pix>=nSamples*2*32+sizeof(sls_detector_header))
+	      cout << "Error: pointer " << dataMap[row][col] << " out of range "<< endl;
+	    ix=col;
+	    iy=row;
+#ifdef HOR
+	    if (row%2==off) {
+	      ix=2*col;
+	      iy=row/2;
+	    } else {
+	      ix=2*col+1;
+	      iy=row/2;
+	    }
+#endif
+
+#ifdef VERT
+	    if (col%2==off) {
+	      ix=col/2;
+	      iy=row*2+1;
+	    } else {
+	      ix=col/2;
+	      iy=row*2;
+	    }
+#endif
+	    dataMap[iy][ix]=pix;
+	  }
+	}
+      }
+    }
+
+    /* int ipacket; */
+    /* int ibyte; */
+    /* int ii=0; */
+    /* for (ibyte=0; ibyte<sizeof(sls_detector_header)/2; ibyte++){ */
+    /*   xmap[ibyte]=-1; */
+    /*   ymap[ibyte]=-1; */
+    /* } */
+    /* int off=sizeof(sls_detector_header)/2; */
+    /* for (ipacket=0; ipacket<npackets; ipacket++) { */
+    /*   for (ibyte=0;  ibyte< 8192/2; ibyte++) { */
+    /* 	i=ipacket*8208/2+ibyte; */
+    /* 	  isample=ii/nadc; */
+    /* 	  if (isample<nSamples) { */
+    /* 	  iadc=ii%nadc; */
+    /* 	  adc4 = (int)iadc/4; */
+    /* 	  ix=isample%sc_width; */
+    /* 	  iy=isample/sc_width; */
+    /* 	  if (adc4%2==0) { */
+    /* 	    xmap[i+off]=adc_nr[iadc]+ix; */
+    /* 	    ymap[i+off]=ny/2-1-iy; */
+    /* 	  } else { */
+    /* 	    xmap[i+off]=adc_nr[iadc]+ix; */
+    /* 	    ymap[i+off]=ny/2+iy; */
+    /* 	  } */
+    /* 	  } */
+    /* 	ii++; */
+    /* 	//	} */
+    /*   } */
+    /* } */
+    
+    iframe=0;
+    //  cout << "data struct created" << endl;
+  };
+    
+
+
+     /**
+
+     Returns the frame number for the given dataset. Purely virtual func.
+     \param buff pointer to the dataset
+     \returns frame number
+
+  */
+
+/* class jfrau_packet_header_t { */
+/*  public: */
+/* 	unsigned char reserved[4]; */
+/* 	unsigned char packetNumber[1]; */
+/* 	unsigned char frameNumber[3]; */
+/* 	unsigned char bunchid[8]; */
+/* }; */
+
+
+
+  int getFrameNumber(char *buff){return ((sls_detector_header*)buff)->frameNumber;};//*((int*)(buff+5))&0xffffff;};   
+
+  /**
+
+     Returns the packet number for the given dataset. purely virtual func
+     \param buff pointer to the dataset
+     \returns packet number number
+
+
+
+  */
+  int getPacketNumber(char *buff){return ((sls_detector_header*)buff)->packetNumber;}//((*(((int*)(buff+4))))&0xff)+1;};   
+
+/*    /\** */
+
+/*      Loops over a memory slot until a complete frame is found (i.e. all packets 0 to nPackets, same frame number). purely virtual func */
+/*      \param data pointer to the memory to be analyzed */
+/*      \param ndata reference to the amount of data found for the frame, in case the frame is incomplete at the end of the memory slot */
+/*      \param dsize size of the memory slot to be analyzed */
+/*      \returns pointer to the beginning of the last good frame (might be incomplete if ndata smaller than dataSize), or NULL if no frame is found  */
+
+/*   *\/ */
+/*     virtual  char *findNextFrame(char *data, int &ndata, int dsize){ndata=dsize; setDataSize(dsize);  return data;}; */
+
+
+/*    /\** */
+
+/*      Loops over a file stream until a complete frame is found (i.e. all packets 0 to nPackets, same frame number). Can be overloaded for different kind of detectors!  */
+/*      \param filebin input file stream (binary) */
+/*      \returns pointer to the begin of the last good frame, NULL if no frame is found or last frame is incomplete */
+
+/*   *\/ */
+/*     virtual char *readNextFrame(ifstream &filebin){ */
+/*       //	int afifo_length=0;   */
+/*       uint16_t *afifo_cont;  */
+/*       int ib=0; */
+/*       if (filebin.is_open()) { */
+/* 	afifo_cont=new uint16_t[dataSize/2]; */
+/*  	while (filebin.read(((char*)afifo_cont)+ib,2)) { */
+/* 	  ib+=2; */
+/* 	  if (ib==dataSize) break; */
+/* 	} */
+/* 	if (ib>0) { */
+/* 	  iframe++; */
+/* 	  // cout << ib << "-" << endl; */
+/* 	  return (char*)afifo_cont; */
+/* 	} else { */
+/* 	  delete [] afifo_cont; */
+/* 	  return NULL; */
+/* 	} */
+/*       }      */
+/*       return NULL; */
+/*     }; */
+
+
+  virtual char *readNextFrame(ifstream &filebin) {
+    int ff=-1, np=-1;
+    return readNextFrame(filebin, ff, np);
+  };
+
+  virtual char *readNextFrame(ifstream &filebin, int &ff) {
+    int np=-1;
+    return readNextFrame(filebin, ff, np);
+  };
+
+  virtual char *readNextFrame(ifstream &filebin, int& ff, int &np) {
+	  char *data=new char[dataSize];
+	  char *d=readNextFrame(filebin, ff, np, data);
+	  if (d==NULL) {delete [] data; data=NULL;}
+	  return data;
+  }
+
+
+
+
+  virtual char *readNextFrame(ifstream &filebin, int& ff, int &np, char *data) {
+	  char *retval=0;
+	  int  nd;
+	  int fnum = -1;
+	  np=0;
+	  int  pn;
+	  
+	  //  cout << dataSize << endl;
+	  if (ff>=0)
+	    fnum=ff;
+
+	  if (filebin.is_open()) {
+	    if (filebin.read(data, dataSize) ){
+	      ff=getFrameNumber(data);
+	      np=getPacketNumber(data);
+	      return data;
+	    }
+	  }
+	    return NULL;
+	    
+	    
+	  
+  };
+
+
+
+  /**
+
+     Loops over a memory slot until a complete frame is found (i.e. all packets 0 to nPackets, same frame number). purely virtual func
+     \param data pointer to the memory to be analyzed
+     \param ndata reference to the amount of data found for the frame, in case the frame is incomplete at the end of the memory slot
+     \param dsize size of the memory slot to be analyzed
+     \returns pointer to the beginning of the last good frame (might be incomplete if ndata smaller than dataSize), or NULL if no frame is found 
+     
+  */
+  virtual  char *findNextFrame(char *data, int &ndata, int dsize){
+    if (dsize<dataSize) ndata=dsize;
+    else ndata=dataSize;
+    return data;
+
+  }
+
+
+
+  //int getPacketNumber(int x, int y) {return dataMap[y][x]/packetSize;};
+
+};
+
+
+
+
+#endif

slsDetectorCalibration/gotthardDoubleModuleCommonModeSubtractionNew.h

@@ -0,0 +1,30 @@
+#ifndef GOTTHARDDOUBLECOMMONMODESUBTRACTION_H
+#define GOTTHARDDOUBLECOMMONMODESUBTRACTION_H
+
+
+#include "commonModeSubtractionNew.h"
+
+class gotthardDoubleModuleCommonModeSubtraction : public commonModeSubtraction {
+
+  /** @short class to calculate the common mode of the pedestals based on an approximated moving average*/ 
+
+ public:
+  
+  /** constructor
+      \param nn number of samples for the moving average to calculate the average common mode
+      \param iroi number of regions on which one can calculate the common mode separately. Defaults to 1 i.e. whole detector
+
+  */
+ gotthardDoubleModuleCommonModeSubtraction(int ns=3) : commonModeSubtraction(2, ns) {};
+
+    /** 
+	gets the common mode ROI for pixel ix, iy 
+     */
+  virtual int getROI(int ix, int iy){return ix%2;};
+
+
+};
+
+
+
+#endif

slsDetectorCalibration/gotthardExecutables/gotthard25umOnTheFlyAnalysis.C

@@ -1,215 +0,0 @@
-#include <vector>
-#include <string>
-#include <sstream>
-#include <iomanip>
-#include <fstream>
-#include <stdio.h>
-//#include <deque>
-//#include <list>
-//#include <queue>
-#include <fstream>
-#include <cstring>
-
-#include "gotthardModuleDataNew.h"
-#include "gotthardDoubleModuleDataNew.h"
-
-#include "singlePhotonDetector.h"
-//#include "interpolatingDetector.h"
-//#include "linearInterpolation.h"
-#include "multiThreadedAnalogDetector.h"
-
-#include <ctime>
-
-#define NC 1280
-#define NR 1
-
-#include "tiffIO.h"
-
-
-void *gotthardProcessFrame() {
-
-
-
-
-
-	if (argc < 3 ) {
-		cprintf(RED, "Help: ./trial [receive socket ip] [receive starting port number] [send_socket ip] [send starting port number]\n");
-		return EXIT_FAILURE;
-	}
-
-	// receive parameters
-	bool send = false;
-	  char* socketip=argv[1];
-	uint32_t portnum = atoi(argv[2]);
-	int size = 32*2*5000;//atoi(argv[3]);
-
-	// send parameters if any
-	char* socketip2 = 0;
-	uint32_t portnum2 = 0;
-	if (argc > 3) {
-		send = true;
-		socketip2 = argv[3];
-		portnum2 = atoi(argv[4]);
-	}
-	cout << "\nrx socket ip : " << socketip <<
-	  "\nrx port num  : " <<  portnum ;
-	if (send) {
-	  cout << "\nsd socket ip : " << socketip2 <<
-	    "\nsd port num  : " <<  portnum2;
-	}
-	cout << endl;
-  
-
-
-	
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-  char fname0[10000], fname1[10000];
-  char fformat[10000];
-  int fifosize=1000;
-  strcpy(fformat,"/external_pool/gotthard_data/datadir_gotthardI/bchip074075/20170731/Xray/xray_15kV_200uA_5us_d%d_f000000000000_0.raw");
-  sprintf(fname0,fformat,0,0);
-  sprintf(fname1,fformat,1,1);
-  
-  
-  int nthreads=3;
-  
-  int nph, nph1;
-  //  single_photon_hit clusters[NR*NC];
-  // cout << "hits "<< endl;
-  int etabins=550;
-  double etamin=-1, etamax=2;
-  int nsubpix=1;
-  float *etah=new float[etabins*etabins];
-  // cout << "etah "<< endl;
-  cout << "image size "<< nsubpix*nsubpix*NC*NR << endl;
- 
-  int *heta, *himage;
-
-    gotthardModuleDataNew *decoder=new   gotthardModuleDataNew();
-    gotthardDoubleModuleDataNew *det=new   gotthardDoubleModuleDataNew();
-  // cout << "decoder "<< endl;
-  // etaInterpolationPosXY *interp=new etaInterpolationPosXY(NC, NR, nsubpix, etabins, etamin, etamax);
-  // cout << "interp "<< endl;
-    //   linearInterpolation *interp=new linearInterpolation(NC, NR, nsubpix);
-  //noInterpolation *interp=new noInterpolation(NC, NR, nsubpix);
-    // interp->readFlatField("/scratch/eta_100.tiff",etamin,etamax);
-    // interpolatingDetector *filter0=new interpolatingDetector(decoder,interp, 5, 1, 0, 1000, 10);
-    // interpolatingDetector *filter1=new interpolatingDetector(decoder,interp, 5, 1, 0, 1000, 10);
-  //filter->readPedestals("/scratch/ped_100.tiff");
-  //cout << "filter "<< endl;
-  
-  singlePhotonDetector *filter=new singlePhotonDetector(det,3, 5, 1, 0, 1000, 200);
-
-  filter->setFrameMode(eFrame);
-  
-  char *buff;//[2*(48+1280*2)];
-
-
-  char *buff0;
-  char *buff1;
-
-
-  multiThreadedAnalogDetector *mt=new multiThreadedAnalogDetector(filter,nthreads,fifosize);
-  mt->setFrameMode(eFrame);
-  mt->StartThreads();
-  mt->popFree(buff);
-  buff0=buff;
-  buff1=buff+48+1280*2;
-
-
-  int photons[1280*2];
-
-  int nf=0;
-  int ok=0;
-  ifstream filebin0,filebin1;
-  std::time_t end_time;
-  int16_t dout[1280*2];
-  int iFrame=-1;
-  int np=-1;
-
-  nph=0;
-  nph1=0;
-  //int np;
-  int iph;
-  int data_ready=1;
-  int *image;
-
-  // filter->setROI(0,512,0,1);
-
-    filebin0.open((const char *)(fname0), ios::in | ios::binary);
-    filebin1.open((const char *)(fname1), ios::in | ios::binary);
-    if (filebin0.is_open() && filebin1.is_open()) {
-      cout << "Opened file " << fname0<< endl;
-      cout << "Opened file " << fname1<< endl;
-	//	mt->setFrameMode(eFrame);
-  // 	mt->prepareInterpolation(ok);
-  // mt->StartThreads();
-  // mt->popFree(buff);
-      nf=0;
-      iFrame=-1;
-      while ((decoder->readNextFrame(filebin0, iFrame, np, buff0)) && (decoder->readNextFrame(filebin1, iFrame, np, buff1))) {
-	//filter->processData(buff, photons);
-	//	cout << nf << " " << decoder->getFrameNumber(buff0) << " " << decoder->getFrameNumber(buff1) << " " << filter->getPhFrame() << " " << filter->getPhTot() << endl; 
-	// for (int i=0; i<1280*2; i++) {
-	//   filter->addToPedestal(buff,i,0);
-	//   dout[i]=filter->subtractPedestal(buff,i,0);
-	//   if (nf>10 && i<512)
-	//     if (i%2)
-	//       cout << nf << " " << i << " " << filter->getPedestal(i,0) << " " << det->getValue(buff,i,0) << " " << decoder->getValue(buff1,1280-1-i/2,0)<< " " << dout[i] << endl;
-	//     else
-	//       cout << nf << " " << i << " " << filter->getPedestal(i,0) << " " << det->getValue(buff,i,0) << " " << decoder->getValue(buff0,i/2,0)<< " " << dout[i] << endl;
-	
-	// }
-	  mt->pushData(buff);
-	  mt->nextThread();
-	  mt->popFree(buff);
-	  buff0=buff;
-	  buff1=buff+48+1280*2;
-	  
-	nf++;
-	
-	//	cout << id << " " << nf << endl;
-	if (nf%10000==0) {
-	  while (mt->isBusy()) {;}
-	  image=filter->getImage();
-	  if (image) {
-	    cout << nf << "*****************" << endl;
-	    for (int i=0; i<512; i++) {
-	      cout << image[i] << "\t";
-	    }
-	    cout << endl;
-	  }
-	  filter->clearImage();
-	  std::time(&end_time);
-	  cout << std::ctime(&end_time) << " " << nf <<   endl;
-	}
-	iFrame=-1;
-      }
-      
-      filebin0.close();
-      filebin1.close();
-    }
-    else
-      cout << "Could not open file " << fname0<< " or " << fname1 <<  endl;
-  return NULL;
-}
-  
-int main(int argc, char *argv[]){
-
-   gotthardProcessFrame();
-
-}

slsDetectorCalibration/gotthardExecutables/gotthard25umZmqAnalysis.C

@@ -14,8 +14,11 @@
 #include <fstream>
 #include <cstring>
 
+//#define BCHIP074_BCHIP075
+
 #include "gotthardModuleDataNew.h"
 #include "gotthardDoubleModuleDataNew.h"
+#include "gotthardDoubleModuleCommonModeSubtractionNew.h"
 
 #include "singlePhotonDetector.h"
 //#include "interpolatingDetector.h"
@@ -27,8 +30,7 @@
 #define NC 1280
 #define NR 1
 
-#include "tiffIO.h"
-
+//#include "tiffIO.h"
 
 
 
@@ -40,19 +42,6 @@ int main(int argc, char *argv[]){
 
 
 
-	
-
-
-
-
-
-
-
-
-
-
-
-
   int fifosize=1000;
   int nthreads=1;
   int nph, nph1;
@@ -69,16 +58,22 @@ int main(int argc, char *argv[]){
   offset=48;
   #endif
  
+  //commonModeSubtraction *cm=NULL;
 
+  gotthardDoubleModuleCommonModeSubtraction *cm=new gotthardDoubleModuleCommonModeSubtraction();
   gotthardModuleDataNew *decoder=new   gotthardModuleDataNew();
   gotthardDoubleModuleDataNew *det=new   gotthardDoubleModuleDataNew(offset);
-  singlePhotonDetector *filter=new singlePhotonDetector(det,3, 5, 1, 0, 1000, 100);
+  singlePhotonDetector *filter=new singlePhotonDetector(det,3, 5, 1, cm, 1000, 100);
+  // analogDetector<uint16_t> *filter=new analogDetector<uint16_t>(det, 1, cm, 1000);
+  // analogDetector<uint16_t> *filter_nocm=new analogDetector<uint16_t>(det, 1, NULL, 1000);
   filter->setROI(0,2560,0,1);
   char *buff;//[2*(48+1280*2)];
   char *buff0;
   char *buff1;
   multiThreadedAnalogDetector *mt=new multiThreadedAnalogDetector(filter,nthreads,fifosize);
   mt->setFrameMode(eFrame);
+  // mt->setFrameMode(eFrame);
+  // mt->setFrameMode(ePedestal);
   mt->StartThreads();
   mt->popFree(buff);
   buff0=buff;
@@ -210,7 +205,8 @@ int main(int argc, char *argv[]){
 	string filename0 = "";
 
 
-
+	int eoa0=0;
+	int eoa1=0;
 
 
 
@@ -230,7 +226,9 @@ int main(int argc, char *argv[]){
 
 
 	char ofname[10000];
+	char fn0[10000], fn1[10000];
 	FILE *fout=NULL;
+	FILE *fclust=NULL;
 	for (int i=0; i<nnx; i++)
 	  dout[i]=0;
 	char fname0[10000], fname1[10000];
@@ -279,89 +277,204 @@ int main(int argc, char *argv[]){
 	int end_of_acquisition;
 	while(1) {
 	  end_of_acquisition=0;
+	  eoa0=0;
+	  eoa1=0;
+	  
 	  //  cout << "Receive header " << nf << endl;
 	  if (!zmqsocket0->ReceiveHeader(0, acqIndex0, frameIndex0, subframeIndex0, filename0, fileindex0)) {
 	    
-	    cout << "************************************************************************** packet0!*****************************"<< endl;
-
+	    //   cout << "************************************************************************** packet0!*****************************"<< endl;
+	    eoa0=1;
 	    end_of_acquisition++;
 	  } 
 	  if (!zmqsocket1->ReceiveHeader(0, acqIndex1, frameIndex1, subframeIndex1, filename1, fileindex1)) {
-	    cout << "************************************************************************** packet1!*****************************"<< endl;
-
+	    //cout << "************************************************************************** packet1!*****************************"<< endl;
+	    eoa1=1;
 	    end_of_acquisition++;
 	  }
-	 
-	  //	  if ((!zmqsocket0->ReceiveHeader(0, acqIndex0, frameIndex0, subframeIndex0, filename0, fileindex0)) && (!zmqsocket1->ReceiveHeader(0, acqIndex1, frameIndex1, subframeIndex1, filename1, fileindex1))){
-	  if (end_of_acquisition) {
-	    cout << "************************************************************************** END OF FRAME" << end_of_acquisition << " !*****************************"<< endl;
-	    //  return 0;
 
+
+
+
+
+	  //	  if ((!zmqsocket0->ReceiveHeader(0, acqIndex0, frameIndex0, subframeIndex0, filename0, fileindex0)) && (!zmqsocket1->ReceiveHeader(0, acqIndex1, frameIndex1, subframeIndex1, filename1, fileindex1))){
+	  if (end_of_acquisition==0) {
+	    
+	    if (acqIndex0!=acqIndex1)
+	      cout << "different acquisition indexes " << acqIndex0 << " and " << acqIndex1 << endl;
+	    if (frameIndex0!=frameIndex1)
+	      cout << "different frame indexes " << frameIndex0 << " and " << frameIndex1 << endl;
+	    
+	    
+	    while (frameIndex0<frameIndex1) {
+	      cout << "aligning det 0 " << endl; 
+	      length = zmqsocket0->ReceiveData(0, buff0, size/2);
+	      if (!zmqsocket0->ReceiveHeader(0, acqIndex0, frameIndex0, subframeIndex0, filename0, fileindex0)) {
+		end_of_acquisition++;
+		eoa0=1;
+		break;
+	      } 
+	    }
+	    
+	    while (frameIndex1<frameIndex0) {
+	      cout << "aligning det 1 " << endl; 
+	      length = zmqsocket1->ReceiveData(0, buff1, size/2);
+	      if (!zmqsocket1->ReceiveHeader(0, acqIndex1, frameIndex1, subframeIndex1, filename1, fileindex1)) {
+		end_of_acquisition++;
+		eoa1=1;
+		break;
+	      } 
+	    }
+	  }
+
+
+
+	  if (eoa0!=eoa1) {
+
+	    while (eoa0<1) {
+	      length = zmqsocket0->ReceiveData(0, buff0, size/2);
+	      if (!zmqsocket0->ReceiveHeader(0, acqIndex0, frameIndex0, subframeIndex0, filename0, fileindex0)) {
+		end_of_acquisition++;
+		eoa0=1;
+	      }
+	    }
+
+
+	    while (eoa1<1) {
+	      length = zmqsocket1->ReceiveData(0, buff1, size/2);
+	      if (!zmqsocket1->ReceiveHeader(0, acqIndex1, frameIndex1, subframeIndex1, filename1, fileindex1)) {
+		end_of_acquisition++;
+		eoa1=1;
+	      }
+	    }
+	  }
+
+	  
+
+
+
+	  
+	  if (end_of_acquisition) {
+	    // cout << "************************************************************************** END OF FRAME" << end_of_acquisition << " !*****************************"<< endl;
+	    //  return 0;
+	    
+	    sprintf(ofname,"%s_%d.ph",fn0,irun);
 	    while (mt->isBusy()) {;}
 	    image=filter->getImage();
 	    if (image) {
-	      //fout=fopen(ofname,"w");
-	     cout << nf << "*****************" << endl;
+	      fout=fopen(ofname,"w");
+	      cout << nf << "*****************" << endl;
 	      for (int i=0; i<2560; i++) {
-	      // // 	fprintf(fout,"%d %d\n",i,image[i]);
-	      	dout[i]=image[i];
+		fprintf(fout,"%d %d\n",i,image[i]);
+		dout[i]=image[i];
+		if (dout[i]<0)
+		   dout[i]=0;
 	      }
-	      // // fclose(fout);;
+	      fclose(fout);
 	    }
-
+	    
 
 	    if (send) {
-		strcpy(fname0,filename0.c_str());
-		strcpy(fname1,filename1.c_str());
-		//  zmqsocket2->SendHeaderData(0, false, SLS_DETECTOR_JSON_HEADER_VERSION,16,fileindex,400,400,400*400, acqIndex,frameIndex,fname, acqIndex, 0,0,0,0,0,0,0,0,0,0,0,1);
-		zmqsocket2->SendHeaderData(0, false, SLS_DETECTOR_JSON_HEADER_VERSION,0,0,0,0,0, 0,0,fname0, 0, 0,0,0,0,0,0,0,0,0,0,0,1);
-		zmqsocket3->SendHeaderData(0, false, SLS_DETECTOR_JSON_HEADER_VERSION,0,0,0,0,0, 0,0,fname1, 0, 0,0,0,0,0,0,0,0,0,0,0,1);
-		
-		zmqsocket2->SendData((char*)dout,size/2);
-		zmqsocket3->SendData(((char*)dout)+size/2,size/2);
-		//	cprintf(GREEN, "Sent Data\n");
-
+	      
+	      zmqsocket2->SendHeaderData(0, false, SLS_DETECTOR_JSON_HEADER_VERSION,0,0,0,0,0, 0,0,fn0, 0, 0,0,0,0,0,0,0,0,0,0,0,1);
+	      zmqsocket3->SendHeaderData(0, false, SLS_DETECTOR_JSON_HEADER_VERSION,0,0,0,0,0, 0,0,fn1, 0, 0,0,0,0,0,0,0,0,0,0,0,1);
+	      
+	      zmqsocket2->SendData((char*)dout,size/2);
+	      zmqsocket3->SendData(((char*)dout)+size/2,size/2);
+	      //    	//	cprintf(GREEN, "Sent Data\n");
 
+	      
 	      zmqsocket2->SendHeaderData(0, true, SLS_DETECTOR_JSON_HEADER_VERSION);
 	      zmqsocket3->SendHeaderData(0, true, SLS_DETECTOR_JSON_HEADER_VERSION);
-
-	      cprintf(RED, "Received %d frames\n", nf);
-
 	    }
-
 	    
+	    
+	    //mt->setFrameMode(eFrame);
 	    filter->clearImage();
 	    // std::time(&end_time);
 	    // cout << std::ctime(&end_time) << " " << nf <<   endl;
-
-
-	
-
+	    fclose(fclust);
+	    fclust=NULL;
+	    
+	    
+	    
 	    continue; 
 	  }
-	  if (acqIndex0!=acqIndex1)
-	    cout << "different acquisition indexes " << acqIndex0 << " and " << acqIndex1 << endl;
-	  if (frameIndex0!=frameIndex1)
-	    cout << "different frame indexes " << frameIndex0 << " and " << frameIndex1 << endl;
+	  
+	  if (fclust==NULL) {
 
+	    strcpy(fn0,filename0.c_str());
+	    strcpy(fn1,filename1.c_str());
+	    sprintf(ofname,"%s_%d.clust",fn0,irun);
+	    fclust=fopen(ofname,"w");
+	    while (mt->isBusy()) {;}
+	    mt->setFilePointer(fclust);
+	  }
 
+	  // strcpy(fn0,filename0.c_str());
+	  // strcpy(fn1,filename1.c_str());
+	  
 	  //	  cout << "Receive data " << nf << endl;
 	  length = zmqsocket0->ReceiveData(0, buff0, size/2);
 	  length += zmqsocket1->ReceiveData(0, buff1, size/2);  
-	    
+	  
 	  irun=fileindex0;
-	  sprintf(ofname,"%s_%d.ph",filename0.c_str(),fileindex0);
 	  
+	  
+	    
+	    // //  if (nf>100)
+	    // //  mt->setFrameMode(eFrame);
+	    // //filter->clearImage();
+
+
 #endif
-	  
-	  
+
 
 	mt->pushData(buff);
 	mt->nextThread();
+	// cout << "==" << nf << endl;
+
+	    // while (mt->isBusy()) {;}
+	    // image=filter->getImage();
+	    // if (image) {
+	    //   for (int i=0; i<2560; i++) {
+	    // 	//	if (i<512)
+	
+	    // 	//  	fprintf(fout,"%d %d\n",i,image[i]);
+	    //   	dout[i]=filter->subtractPedestal(buff,i,0,1);//image[i];//filter->getPedestal(i,0);//
+	    // 	if (dout[i]<0)
+	    // 	   dout[i]=0;
+	    // 	//	cout << i << " " << image[i] << " " << dout[i] << endl;
+	    //   }
+	    // }
+
+
+	    // if (send) {
+	    // 	strcpy(fname0,filename0.c_str());
+	    // 	strcpy(fname1,filename1.c_str());
+	    // 	//  zmqsocket2->SendHeaderData(0, false, SLS_DETECTOR_JSON_HEADER_VERSION,16,fileindex,400,400,400*400, acqIndex,frameIndex,fname, acqIndex, 0,0,0,0,0,0,0,0,0,0,0,1);
+	    // 	zmqsocket2->SendHeaderData(0, false, SLS_DETECTOR_JSON_HEADER_VERSION,0,0,0,0,0, 0,0,fname0, 0, 0,0,0,0,0,0,0,0,0,0,0,1);
+	    // 	zmqsocket3->SendHeaderData(0, false, SLS_DETECTOR_JSON_HEADER_VERSION,0,0,0,0,0, 0,0,fname1, 0, 0,0,0,0,0,0,0,0,0,0,0,1);
+		
+	    // 	zmqsocket2->SendData((char*)dout,size/2);
+	    // 	zmqsocket3->SendData(((char*)dout)+size/2,size/2);
+	    // 	//	cprintf(GREEN, "Sent Data\n");
+
+
+	    // 	// zmqsocket2->SendHeaderData(0, true, SLS_DETECTOR_JSON_HEADER_VERSION);
+	    // 	// zmqsocket3->SendHeaderData(0, true, SLS_DETECTOR_JSON_HEADER_VERSION);
+
+	    // 	//	cprintf(RED, "Received %d frames\n", nf);
+
+	    // }
+	    
+
 	mt->popFree(buff);
 	buff0=buff;
 	buff1=buff+offset*2+1280*2;
 	  
+
+
 	nf++;
 	
 
@@ -370,6 +483,8 @@ int main(int argc, char *argv[]){
 #ifndef ZMQ
 
 
+	 
+
 	  while (mt->isBusy()) {;}
 	  image=filter->getImage();
 	  if (image) {
@@ -378,7 +493,7 @@ int main(int argc, char *argv[]){
 	      for (int i=0; i<512; i++) {
 		fprintf(fout,"%d %d\n",i,image[i]);
 	      }
-	      fclose(fout);;
+	      fclose(fout);
 	  }
 	  filter->clearImage();
       

slsDetectorCalibration/interpolatingDetector.h

@@ -6,7 +6,7 @@
 
 #include "slsInterpolation.h"
 
-#define M015
+//#define M015
 
 #ifdef MYROOT1
 #include <TTree.h>
@@ -17,10 +17,7 @@
 #include <iostream>
 
 using namespace std;
-#define XMIN 350/2
-#define XMAX 600/2
-#define YMIN 0
-#define YMAX 400
+
 
 class interpolatingDetector : public singlePhotonDetector {
 
@@ -50,21 +47,23 @@ class interpolatingDetector : public singlePhotonDetector {
 		       commonModeSubtraction *cm=NULL,
 		       int nped=1000, 
 		       int nd=100, int nnx=-1, int nny=-1) : 
-  singlePhotonDetector(d, 3,nsigma,sign, cm, nped, nd, nnx, nny) , interp(inte), id(0), xmin(XMIN), xmax(XMAX), ymin(YMIN), ymax(YMAX)  {
-    cout << "**"<< xmin << " " << xmax << " " << ymin << " " << ymax << endl;
+  singlePhotonDetector(d, 3,nsigma,sign, cm, nped, nd, nnx, nny) , interp(inte), id(0)  {
+    //cout << "**"<< xmin << " " << xmax << " " << ymin << " " << ymax << endl;
+    fi=new pthread_mutex_t ;
 
 };
   
   
   
  interpolatingDetector(interpolatingDetector *orig) : singlePhotonDetector(orig) {
-    interp=(orig->interp)->Clone();
-    id=orig->id;
-    xmin=orig->xmin;
-    xmax=orig->xmax;
-    ymin=orig->ymin;
-    ymax=orig->ymax;
+    // if (orig->interp)
+    //  interp=(orig->interp)->Clone();
+    // else
     
+    interp=orig->interp;
+    
+    id=orig->id;
+    fi=orig->fi;
   }
 
 
@@ -72,29 +71,50 @@ class interpolatingDetector : public singlePhotonDetector {
     return new interpolatingDetector(this);
   }
 
-  virtual int setId(int i) {id=i; interp->setId(id); return id;};
+  virtual int setId(int i) {
+    id=i; 
+    //  interp->setId(id); 
+    return id;
+  };
 
   virtual void prepareInterpolation(int &ok) {
-    cout << "*"<< endl;
-#ifdef SAVE_ALL
-    char tit[1000];
-    sprintf(tit,"/scratch/ped_%d.tiff",id);
-    writePedestals(tit);
-    sprintf(tit,"/scratch/ped_rms_%d.tiff",id);
-    writePedestalRMS(tit);
-    if (gmap) {
-      sprintf(tit,"/scratch/gmap_%d.tiff",id);
-      writeGainMap(tit);
-    }
-#endif
-    if (interp)
+   /*  cout << "*"<< endl; */
+/* #ifdef SAVE_ALL */
+/*     char tit[1000]; */
+/*     sprintf(tit,"/scratch/ped_%d.tiff",id); */
+/*     writePedestals(tit); */
+/*     sprintf(tit,"/scratch/ped_rms_%d.tiff",id); */
+/*     writePedestalRMS(tit); */
+/*     if (gmap) { */
+/*       sprintf(tit,"/scratch/gmap_%d.tiff",id); */
+/*       writeGainMap(tit); */
+/*     } */
+/* #endif */ 
+    if (interp){
+      pthread_mutex_lock(fi);
       interp->prepareInterpolation(ok);
+      pthread_mutex_unlock(fi); 
+    }
   } 
 
 
-  void clearImage() {if (interp) interp->clearInterpolatedImage(); else singlePhotonDetector::clearImage();};
+  void clearImage() {
+    if (interp) {
+      pthread_mutex_lock(fi);
+      interp->clearInterpolatedImage(); 
+      pthread_mutex_unlock(fi); 
+    } else 
+      singlePhotonDetector::clearImage();
+  };
+
+  int getImageSize(int &nnx, int &nny, int &ns) {
+    if (interp) 
+      return interp->getImageSize(nnx, nny, ns); 
+    else 
+      return analogDetector<uint16_t>::getImageSize(nnx, nny, ns);
+  };
+
 
-  int getImageSize(int &nnx, int &nny, int &ns) {if (interp) return interp->getImageSize(nnx, nny, ns); else return analogDetector<uint16_t>::getImageSize(nnx, nny, ns);};
   #ifdef MYROOT1
   virtual TH2F *getImage()
 #endif
@@ -107,7 +127,6 @@ class interpolatingDetector : public singlePhotonDetector {
      return interp->getInterpolatedImage();
    else 
      return analogDetector<uint16_t>::getImage();
-   //cout << "null " << endl;
  }
 
 #ifdef MYROOT1
@@ -149,505 +168,104 @@ class interpolatingDetector : public singlePhotonDetector {
      return NULL;
    }
   
-int addFrame(char *data,  int *ph=NULL, int ff=0) {
 
- 
-  int nph=0;
-  double val[ny][nx];
-  int cy=(clusterSizeY+1)/2;
-  int cs=(clusterSize+1)/2;
-  int ir, ic;
+
+int addFrame(char *data,  int *ph=NULL, int ff=0) {	    
   
-    double int_x,int_y, eta_x, eta_y;
-  double max=0, tl=0, tr=0, bl=0,br=0, *v, vv;
+  singlePhotonDetector::processData(data,ph);
+  int nph=0;
 
-  if (ph==NULL)
-    ph=image;
-
-  if (iframe<nDark) {
-    addToPedestal(data);
-    return 0;
+  double int_x, int_y;
+  double eta_x, eta_y;
+  if (interp) {
+  cout << "int" << endl;
+  pthread_mutex_lock(fi); 
+    for (nph=0; nph<nphFrame; nph++) {
+      if (ff) {
+	interp->addToFlatField((clusters+nph)->quadTot,(clusters+nph)->quad,(clusters+nph)->get_cluster(),eta_x, eta_y);
+      } else {
+	interp->getInterpolatedPosition((clusters+nph)->x, (clusters+nph)->y, (clusters+nph)->quadTot,(clusters+nph)->quad,(clusters+nph)->get_cluster(),int_x, int_y);
+	interp->addToImage(int_x, int_y);
+      }
+    } 
+    pthread_mutex_unlock(fi);  
   }
-  newFrame();
-  for (int ix=xmin; ix<xmax; ix++) {
-    for (int iy=ymin; iy<ymax; iy++) {
-      
-      max=0;
-      tl=0;
-      tr=0;
-      bl=0;
-      br=0;
-      tot=0;
-      quadTot=0;
-      quad=UNDEFINED_QUADRANT;
-
-     
-
-      eventMask[iy][ix]=PEDESTAL;
-      
-	
-      (clusters+nph)->rms=getPedestalRMS(ix,iy);
-      
-      
-      
-      for (int ir=-(clusterSizeY/2); ir<(clusterSizeY/2)+1; ir++) {
-	for (int ic=-(clusterSize/2); ic<(clusterSize/2)+1; ic++) {
-	  
-	  if ((iy+ir)>=iy && (iy+ir)<ny && (ix+ic)>=ix && (ix+ic)<nx) {
-	    val[iy+ir][ix+ic]=subtractPedestal(data,ix+ic,iy+ir);
-	  }
-	  
-	  v=&(val[iy+ir][ix+ic]);
-	  tot+=*v;
-	  if (ir<=0 && ic<=0)
-	    bl+=*v;
-	  if (ir<=0 && ic>=0)
-	    br+=*v;
-	  if (ir>=0 && ic<=0)
-	    tl+=*v;
-	  if (ir>=0 && ic>=0)
-	    tr+=*v;
-	  if (*v>max) {
-	    max=*v;
-	  }
-	  
-	  
-	  if (ir==0 && ic==0) {
-	    if (*v<-nSigma*cluster->rms)
-	      eventMask[iy][ix]=NEGATIVE_PEDESTAL;
-	  }
-	  
-	}
-      }
-      
-      if (bl>=br && bl>=tl && bl>=tr) {
-	(clusters+nph)->quad=BOTTOM_LEFT;
-	(clusters+nph)->quadTot=bl;
-      } else if (br>=bl && br>=tl && br>=tr) {
-	(clusters+nph)->quad=BOTTOM_RIGHT;
-	(clusters+nph)->quadTot=br;
-      } else if (tl>=br && tl>=bl && tl>=tr) {
-	(clusters+nph)->quad=TOP_LEFT;
-	(clusters+nph)->quadTot=tl;
-      } else if   (tr>=bl && tr>=tl && tr>=br) {
-	(clusters+nph)->quad=TOP_RIGHT;
-	(clusters+nph)->quadTot=tr;
-      }
-      
-      if (max>nSigma*cluster->rms || tot>sqrt(clusterSizeY*clusterSize)*nSigma*cluster->rms || ((clusters+nph)->quadTot)>sqrt(cy*cs)*nSigma*cluster->rms) {
-	if (val[iy][ix]>=max) {
-	  eventMask[iy][ix]=PHOTON_MAX;
-	  (clusters+nph)->tot=tot;
-	  (clusters+nph)->x=ix;
-	  (clusters+nph)->y=iy;
-	  (clusters+nph)->iframe=det->getFrameNumber(data);
-	  (clusters+nph)->ped=getPedestal(ix,iy,0);
-	  for (int ir=-(clusterSizeY/2); ir<(clusterSizeY/2)+1; ir++) {
-	    for (int ic=-(clusterSize/2); ic<(clusterSize/2)+1; ic++) {
-	      (clusters+nph)->set_data(val[iy+ir][ix+ic],ic,ir);
-	    }
-	  }
-
-
-
-	    
-	    if (interp) {
-	      if (ff) {
-		  interp->addToFlatField((clusters+nph)->quadTot,(clusters+nph)->quad,(clusters+nph)->get_cluster(),eta_x, eta_y);
-	      } else {
-		interp->getInterpolatedPosition(ix, iy, (clusters+nph)->quadTot,(clusters+nph)->quad,(clusters+nph)->get_cluster(),int_x, int_y);
-		interp->addToImage(int_x, int_y);
-	      }
-	    }  else 
-	      image[ix+nx*iy]++;    
-
-
-
-
-
-
-
-
-
-
-	  nph++;
-	  image[iy*nx+ix]++;
-
-	  } else {
-	    eventMask[iy][ix]=PHOTON;
-	  }
-      } else if (eventMask[iy][ix]==PEDESTAL) {
-	addToPedestal(data,ix,iy);
-      }
-
-
-    }
-  }
-  nphFrame=nph;
-  nphTot+=nph;
-  //cout << nphFrame << endl;
-  // cout <<"**********************************"<< endl;
-  writeClusters();
   return  nphFrame;
   
 };
-
-   /*********************************************************
-  int addFrame(char *data, int ff=0) {
-    
-    double g=1;
-    
-    single_photon_hit *cl;
-    single_photon_hit clust;
-    if (clusters)
-      cl=clusters;
-    else
-      cl=&clust;
-
-    
-      int ccs=clusterSize;
-      int ccy=clusterSizeY;
-
-    double int_x,int_y, eta_x, eta_y;
-    int nph=0;
-    double rest[ny][nx];
-    int cy=(clusterSizeY+1)/2;
-    int cs=(clusterSize+1)/2;
-    int ir, ic;
-    double cc[2][2];
-    double max=0, tl=0, tr=0, bl=0,br=0, v, vv;
-    int xoff,yoff;
-    int skip=0;
-    //  cout <<"fr"<< endl;
-    double tthr;
-    if (iframe<nDark) {
-      //cout << iframe << "+"<< nDark <<endl;
-      addToPedestal(data);
-      return 0;
-    }
-
-    newFrame();
-
-
-
-
-    //  cout << xmin << " " << xmax << " " << ymin << " " << ymax << endl;
-	for (int ix=xmin; ix<xmax; ix++) {
-	  for (int iy=ymin; iy<ymax; iy++) {
-	    //  for (int ix=clusterSize/2; ix<clusterSize/2-1; ix++) {
-	    // for (int iy=clusterSizeY/2; iy<ny-clusterSizeY/2; iy++) {
-
-	    //	    cout << ix << " " << iy << endl;
-	    eventMask[iy][ix]=PEDESTAL;
-	    
-	    
-	      tthr=nSigma*getPedestalRMS(ix,iy)/g;
-	      if (ix==xmin || iy==ymin)
-		rest[iy][ix]=subtractPedestal(data,ix,iy);
-	     
-	    
-	    max=0;
-	    tl=0;
-	    tr=0;
-	    bl=0;
-	    br=0;
-	    tot=0;
-	    quadTot=0;
-
-	    for (int ir=-(clusterSizeY/2); ir<(clusterSizeY/2)+1; ir++) {
-	      for (int ic=-(clusterSize/2); ic<(clusterSize/2)+1; ic++) {
-		if ((iy+ir)>=ymin && (iy+ir)<ymax && (ix+ic)>=xmin && (ix+ic)<xmax) {
-		  //cluster->set_data(rest[iy+ir][ix+ic], ic, ir);
-		  
-		  if (ir>=0 && ic>=0 ) 
-		    rest[iy+ir][ix+ic]=subtractPedestal(data,ix+ic,iy+ir);
-		  
-		  v=rest[iy+ir][ix+ic];//cluster->get_data(ic,ir);
-		  tot+=v;
-		  
-		  if (ir<=0 && ic<=0)
-		    bl+=v;
-		  if (ir<=0 && ic>=0)
-		    br+=v;
-		  if (ir>=0 && ic<=0)
-		    tl+=v;
-		  if (ir>=0 && ic>=0)
-		    tr+=v;
-		  
-		  if (v>max) {
-		    max=v;
-		  }
-		  // if (ir==0 && ic==0) {
-		    if (v>tthr) {
-		      eventMask[iy][ix]=NEIGHBOUR;
-		    }
-		    //}
-		}
-	      }
-	    }
-	    if (rest[iy][ix]<=-tthr) {
-	      eventMask[iy][ix]=NEGATIVE_PEDESTAL;
-	      //if (cluster->get_data(0,0)>=max) {
-	    } else  if (max>tthr || tot>sqrt(ccy*ccs)*tthr || quadTot>sqrt(cy*cs)*tthr) {
-	      if (rest[iy][ix]>=max) { 
-		if (bl>=br && bl>=tl && bl>=tr) {
-		  cl->quad=BOTTOM_LEFT;
-		cl->quadTot=bl;
-		} else if (br>=bl && br>=tl && br>=tr) {
-		  cl->quad=BOTTOM_RIGHT;
-		cl->quadTot=br;
-	      } else if (tl>=br && tl>=bl && tl>=tr) {
-		cl->quad=TOP_LEFT;
-		cl->quadTot=tl;
-	      } else if   (tr>=bl && tr>=tl && tr>=br) {
-		cl->quad=TOP_RIGHT;
-		cl->quadTot=tr;
-	      }
-	     
-	
-		eventMask[iy][ix]=PHOTON_MAX;
-		cl->tot=tot;
-		cl->x=ix;
-		cl->y=iy;
-		cl->ped=getPedestal(ix,iy, 0);
-		cl->rms=getPedestalRMS(ix,iy);
-	    
-	    for (int ir=-(clusterSizeY/2); ir<(clusterSizeY/2)+1; ir++) {
-	      for (int ic=-(clusterSize/2); ic<(clusterSize/2)+1; ic++) {
-		if ((iy+ir)>=ymin && (iy+ir)<ymax && (ix+ic)>=xmin && (ix+ic)<xmax) {
-		  cl->set_data(rest[iy+ir][ix+ic],ic,ir);
-		}
-	      }
-	    }
-	    
-	    
-	    if (interp) {
-	      if (ff) {
-#ifdef M015
-		if (iy>100)
-#endif
-		  interp->addToFlatField(cl->quadTot,cl->quad,cl->get_cluster(),eta_x, eta_y);
-		// if ((eta_x<0.1 || eta_x>0.9)&&(eta_y<0.1 || eta_y>0.9))
-		//  cout << ix << " " << iy << " " << eta_x <<" " << eta_y << endl;  
-		
-	      } else {
-		interp->getInterpolatedPosition(ix, iy, cl->quadTot,cl->quad,cl->get_cluster(),int_x, int_y);
-		interp->addToImage(int_x, int_y);
-	      }
-	      
-	    }  else 
-	      image[ix+nx*iy]++;    
-
-	    nph++;
-	    
-	    if (clusters) cl=(clusters+nph);	  
-	  
-
-		// rest[iy][ix]-=tthr;
-	      } else 
-		eventMask[iy][ix]=PHOTON;
-	      //else if (thr<=0 ) {
-		//addToPedestal(data,ix,iy);
-	      // }
-	    }
-	    if (eventMask[iy][ix]==PEDESTAL) {
-	      addToPedestal(data,ix,iy);
-	    }
-	  }
-	}
-	return nph;
-  }
-      
-   ******************************************/
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-  /*   for (int ix=0; ix<nx; ix++) { */
-  /*     for (int iy=0; iy<ny; iy++) { */
-  /* 	skip=0; */
-  /* 	max=0; */
-  /* 	tl=0; */
-  /* 	tr=0; */
-  /* 	bl=0; */
-  /* 	br=0; */
-  /* 	tot=0; */
-  /* 	quadTot=0; */
-  /* 	quad=UNDEFINED_QUADRANT; */
-      
-      
-      
-      
-  /* 	cl->rms=getPedestalRMS(ix,iy); */
-  /* 	//(clusters+nph)->rms=getPedestalRMS(ix,iy); */
-
-  /* 	//	cout << iframe << " " << nph << " " << ix << " " << iy << endl; */
-  /* 	if (ix==0 || iy==0) */
-  /* 	   val[iy][ix]=subtractPedestal(data,ix,iy); */
-
-  /* 	if (val[iy][ix]<-nSigma*cl->rms) { */
-  /* 	  eventMask[iy][ix]=NEGATIVE_PEDESTAL; */
-  /* 		//	cout << "neg ped" << endl; */
-  /* 	} else { */
-  /* 	  for (int ir=-(clusterSizeY/2); ir<(clusterSizeY/2)+1; ir++) { */
-  /* 	    for (int ic=-(clusterSize/2); ic<(clusterSize/2)+1; ic++) { */
-	  
-
-  /* 	    if ((iy+ir)>=0 && (iy+ir)<ny && (ix+ic)>=0 && (ix+ic)<nx) { */
-	    
-  /* 	  if (ir>=0 && ic>=0) { */
-  /* 	    val[iy+ir][ix+ic]=subtractPedestal(data,ix+ic,iy+ir); */
-  /* 	    eventMask[iy+ir][ix+ic]=PEDESTAL;  */
-  /* 	  } */
-	  
-  /* 	  //   cout << ir << " " << ic << " " << val[iy+ir][ix+ic] << endl; */
-  /* 	    v=&(val[iy+ir][ix+ic]); */
-  /* 	    // if (skip==0) { */
-  /* 	      tot+=*v; */
-  /* 	      if (ir<=0 && ic<=0) */
-  /* 		bl+=*v; */
-  /* 	      if (ir<=0 && ic>=0) */
-  /* 		br+=*v; */
-  /* 	      if (ir>=0 && ic<=0) */
-  /* 		tl+=*v; */
-  /* 	      if (ir>=0 && ic>=0) */
-  /* 		tr+=*v; */
-  /* 	      if (*v>max) { */
-  /* 		max=*v; */
-  /* 	      } */
-	     
-  /* 	} */
-  /*     } */
-  /* 	  } */
-	
-  /* 	if (bl>=br && bl>=tl && bl>=tr) { */
-  /* 	  cl->quad=BOTTOM_LEFT; */
-  /* 	  cl->quadTot=bl; */
-  /* 	} else if (br>=bl && br>=tl && br>=tr) { */
-  /* 	  cl->quad=BOTTOM_RIGHT; */
-  /* 	  cl->quadTot=br; */
-  /* 	} else if (tl>=br && tl>=bl && tl>=tr) { */
-  /* 	  cl->quad=TOP_LEFT; */
-  /* 	  cl->quadTot=tl; */
-  /* 	} else if   (tr>=bl && tr>=tl && tr>=br) { */
-  /* 	  cl->quad=TOP_RIGHT; */
-  /* 	  cl->quadTot=tr; */
-  /* 	}  */
-	
-  /* 	if (max>nSigma*cl->rms || tot>sqrt(clusterSizeY*clusterSize)*nSigma*cl->rms || (cl->quadTot)>sqrt(cy*cs)*nSigma*cl->rms) { */
-  /* 	  if (val[iy][ix]>=max) { */
-  /* 	    eventMask[iy][ix]=PHOTON_MAX; */
-  /* 	    cl->tot=tot; */
-  /* 	    cl->x=ix; */
-  /* 	    cl->y=iy; */
-  /* 	    cl->ped=getPedestal(ix,iy, 0); */
-	      
-  /* 	      if (interp) { */
-  /* 		if (ff) { */
-  /* 		  interp->addToFlatField(cl->quadTot,cl->quad,cl->get_cluster(),eta_x, eta_y); */
-  /* 		  // if ((eta_x<0.1 || eta_x>0.9)&&(eta_y<0.1 || eta_y>0.9)) */
-  /* 		  //  cout << ix << " " << iy << " " << eta_x <<" " << eta_y << endl;   */
-  /* 		} else { */
-  /* 		  interp->getInterpolatedPosition(ix, iy, cl->quadTot,cl->quad,cl->get_cluster(),int_x, int_y); */
-  /* 		  interp->addToImage(int_x, int_y); */
-  /* 		} */
-  /* 	      }  else  */
-  /* 		image[ix+nx*iy]++;     */
-
-  /* 	      if (clusters) cl=(clusters+nph);	   */
-	  
-  /* 	      nph++; */
-
-  /* 	  } else { */
-  /* 	    eventMask[iy][ix]=PHOTON; */
-  /* 	  } */
-  /* 	} else if (eventMask[iy][ix]==PEDESTAL) { */
-  /* 	  addToPedestal(data,ix,iy); */
-  /* 	} */
-	  
-  /* 	} */
-  /*     } */
-  /*     } */
-  /*     return  nph; */
-    
-  /* }; */
-  
-
-
-
-
-
-
-
   
     virtual void processData(char *data, int *val=NULL) {
-      if (interp){
-	switch(fMode) {
-	case ePedestal:
-	  addToPedestal(data);
+	switch (dMode) {
+	case eAnalog:
+	  // cout << "an" << endl;
+	  analogDetector<uint16_t>::processData(data,val);
 	  break;
-	case eFlat:
-	  addFrame(data,val,1);
+	case ePhotonCounting:
+	  // cout << "spc" << endl;
+	  singlePhotonDetector::processData(data,val);
 	  break;
 	default:
-	  addFrame(data,val,0);
+	  //cout << "int" << endl;
+	    switch(fMode) {
+	    case ePedestal:
+	      addToPedestal(data);
+	      break;
+	    case eFlat:
+	      if (interp)
+		addFrame(data,val,1);
+	      else
+		singlePhotonDetector::processData(data,val);
+	      break;
+	    default:
+	      if (interp)
+		addFrame(data,val,0);
+	      else
+		singlePhotonDetector::processData(data,val);
+	    }
 	}
-      } else
-	singlePhotonDetector::processData(data,val);
-      
 	
     };
 
-    virtual char *getInterpolation(){return (char*)interp;};
+
+
+    virtual slsInterpolation *getInterpolation(){
+      return interp;
+    };
+    
+    virtual slsInterpolation *setInterpolation(slsInterpolation *ii){
+      int ok; 
+      interp=ii; 
+      /*  pthread_mutex_lock(fi);
+      if (interp)
+	interp->prepareInterpolation(ok);
+	pthread_mutex_unlock(fi);  */
+      cout << "det" << endl;
+      return interp;
+    };
   
+    virtual void resetFlatField() { if (interp) {
+	pthread_mutex_lock(fi); 
+	interp->resetFlatField(); 
+	pthread_mutex_unlock(fi);  
+      }
+    }
+
+    virtual int getNSubPixels(){ if (interp) return interp->getNSubPixels(); else return 1;}
+    virtual int setNSubPixels(int ns)  { 
+      if (interp) {
+	pthread_mutex_lock(fi); 
+	interp->getNSubPixels(); 
+	pthread_mutex_unlock(fi);  
+      }
+      return getNSubPixels();
+    }
+
  protected:
   
   
   slsInterpolation *interp;
   int id;
-  //should put it to analogDetector
-  int xmin, xmax, ymin, ymax;
+  pthread_mutex_t *fi;
 };
 
 

slsDetectorCalibration/interpolations/eta2InterpolationBase.h

@@ -0,0 +1,434 @@
+#ifndef ETA2_INTERPOLATION_BASE_H
+#define ETA2_INTERPOLATION_BASE_H
+
+#ifdef MYROOT1
+#include <TObject.h>
+#include <TTree.h>
+#include <TH2D.h>
+#include <TH2F.h>
+#endif
+
+#include "etaInterpolationBase.h"
+
+class eta2InterpolationBase : public virtual etaInterpolationBase {
+  
+ public:
+ eta2InterpolationBase(int nx=400, int ny=400, int ns=25, int nb=-1, double emin=1, double emax=0) :  etaInterpolationBase(nx,ny, ns, nb, emin, emax) {
+    // cout << "e2ib " << nb << " " << emin << " " << emax << endl; 
+
+    /* if (nbeta<=0) { */
+    /*   nbeta=nSubPixels*10;  */
+    /* } */
+    if (etamin>=etamax) {
+      etamin=-1;
+      etamax=2; 
+      //  cout << ":" <<endl;
+    }
+    etastep=(etamax-etamin)/nbeta;
+#ifdef MYROOT1
+    delete heta;
+    delete hhx;
+    delete hhy;
+    heta=new TH2D("heta","heta",nbeta,etamin,etamax,nbeta,etamin,etamax);
+    hhx=new TH2D("hhx","hhx",nbeta,etamin,etamax,nbeta,etamin,etamax);
+    hhy=new TH2D("hhy","hhy",nbeta,etamin,etamax,nbeta,etamin,etamax);
+#endif
+#ifndef MYROOT1
+    /* delete [] heta; */
+    /* delete [] hhx; */
+    /* delete [] hhy; */
+    /* heta=new int[nbeta*nbeta]; */
+    /* hhx=new float[nbeta*nbeta]; */
+    /* hhy=new float[nbeta*nbeta]; */
+    
+#endif
+    
+    //   cout << nbeta << " " << etamin << " " << etamax << endl;
+  };
+  
+ eta2InterpolationBase(eta2InterpolationBase *orig): etaInterpolationBase(orig){ };
+
+/*  virtual eta2InterpolationBase* Clone()=0; {
+
+    return new eta2InterpolationBase(this);
+
+  };
+
+					   */
+ 
+  //////////////////////////////////////////////////////////////////////////////
+  //////////// /*It return position hit for the event in input */ //////////////
+  virtual void getInterpolatedPosition(int x, int y, int *data, double &int_x, double &int_y)
+  {
+    double sDum[2][2];
+    double tot, totquad;
+    double etax,etay;
+    
+    int corner;
+    corner=calcQuad(data, tot, totquad, sDum); 
+    if (nSubPixels>2) 
+      calcEta(totquad, sDum, etax, etay); 
+    getInterpolatedPosition(x,y,etax,etay,corner,int_x,int_y);
+
+    return;
+  };
+  
+
+  virtual void getInterpolatedPosition(int x, int y, double *data, double &int_x, double &int_y)
+  {
+    double sDum[2][2];
+    double tot, totquad;
+    double etax,etay;
+    
+    int corner;
+    corner=calcQuad(data, tot, totquad, sDum); 
+    if (nSubPixels>2) 
+      calcEta(totquad, sDum, etax, etay); 
+    getInterpolatedPosition(x,y,etax,etay,corner,int_x,int_y);
+
+    return;
+  };
+  
+
+
+
+
+
+
+
+
+  virtual void getInterpolatedPosition(int x, int y, double totquad,int quad,double *cl,double &int_x, double &int_y) {
+    
+     double cc[2][2];
+     double *cluster[3];
+     int xoff, yoff;
+     cluster[0]=cl;
+     cluster[1]=cl+3;
+     cluster[2]=cl+6;
+     
+     switch (quad) {
+     case BOTTOM_LEFT:
+       xoff=0;
+       yoff=0;
+       break;
+     case BOTTOM_RIGHT:
+       xoff=1;
+       yoff=0;
+       break;
+     case TOP_LEFT:
+       xoff=0;
+       yoff=1;
+       break;
+     case TOP_RIGHT:
+       xoff=1;
+       yoff=1;
+       break;
+     default:
+       ;
+     } 
+     double etax, etay;
+     if (nSubPixels>2) { 
+       cc[0][0]=cluster[yoff][xoff];
+       cc[1][0]=cluster[yoff+1][xoff];
+       cc[0][1]=cluster[yoff][xoff+1];
+       cc[1][1]=cluster[yoff+1][xoff+1];
+       calcEta(totquad,cc,etax,etay);
+     }
+     return getInterpolatedPosition(x,y,etax, etay,quad,int_x,int_y);
+
+  }
+
+
+
+  virtual void getInterpolatedPosition(int x, int y, double totquad,int quad,int *cl,double &int_x, double &int_y) {
+    
+     double cc[2][2];
+     int *cluster[3];
+     int xoff, yoff;
+     cluster[0]=cl;
+     cluster[1]=cl+3;
+     cluster[2]=cl+6;
+     
+     switch (quad) {
+     case BOTTOM_LEFT:
+       xoff=0;
+       yoff=0;
+       break;
+     case BOTTOM_RIGHT:
+       xoff=1;
+       yoff=0;
+       break;
+     case TOP_LEFT:
+       xoff=0;
+       yoff=1;
+       break;
+     case TOP_RIGHT:
+       xoff=1;
+       yoff=1;
+       break;
+     default:
+       ;
+     } 
+     double etax, etay;
+     if (nSubPixels>2) { 
+       cc[0][0]=cluster[yoff][xoff];
+       cc[1][0]=cluster[yoff+1][xoff];
+       cc[0][1]=cluster[yoff][xoff+1];
+       cc[1][1]=cluster[yoff+1][xoff+1];
+       calcEta(totquad,cc,etax,etay);
+     }
+     return getInterpolatedPosition(x,y,etax, etay,quad,int_x,int_y);
+
+  }
+
+
+
+
+
+
+  virtual void getInterpolatedPosition(int x, int y, double etax, double etay, int corner, double &int_x, double &int_y)
+  {
+
+
+    double xpos_eta=0,ypos_eta=0;
+    double dX,dY;
+    int ex,ey;
+    switch (corner)
+      {
+      case TOP_LEFT:
+	dX=-1.;
+	dY=0;
+	break;
+      case TOP_RIGHT:
+	;
+	dX=0;
+	dY=0;
+	break;
+      case BOTTOM_LEFT:
+	dX=-1.;
+	dY=-1.;
+	break;
+      case BOTTOM_RIGHT:
+	dX=0;
+	dY=-1.;
+	break;
+      default:
+	cout << "bad quadrant" << endl;
+	dX=0.; 
+	dY=0.;
+      }
+    
+
+     if (nSubPixels>2) { 
+
+#ifdef MYROOT1
+    xpos_eta=(hhx->GetBinContent(hhx->GetXaxis()->FindBin(etax),hhy->GetYaxis()->FindBin(etay)))/((double)nSubPixels);
+    ypos_eta=(hhy->GetBinContent(hhx->GetXaxis()->FindBin(etax),hhy->GetYaxis()->FindBin(etay)))/((double)nSubPixels);
+#endif
+#ifndef MYROOT1
+    ex=(etax-etamin)/etastep;
+    ey=(etay-etamin)/etastep;
+    if (ex<0) {
+      cout << "x*"<< ex << endl;
+      ex=0;
+	} 
+    if (ex>=nbeta) {
+      cout << "x?"<< ex << endl;
+      ex=nbeta-1;
+      
+    }
+    if (ey<0) {
+      cout << "y*"<< ey << endl;
+      ey=0;
+	} 
+    if (ey>=nbeta) {
+      cout << "y?"<< ey << endl;
+      ey=nbeta-1;
+      
+    }
+    
+    
+   
+    xpos_eta=(((double)hhx[(ey*nbeta+ex)]))+dX ;///((double)nSubPixels);
+    ypos_eta=(((double)hhy[(ey*nbeta+ex)]))+dY ;///((double)nSubPixels);
+    //else
+    //return 0;
+    
+#endif
+     } else {
+       xpos_eta=0.5*dX+0.25;
+       ypos_eta=0.5*dY+0.25;
+     }
+       
+       int_x=((double)x) + xpos_eta+0.5;
+       int_y=((double)y) +  ypos_eta+0.5;
+    
+
+  }
+
+
+  
+   virtual int addToFlatField(double totquad,int quad,int *cl,double &etax, double &etay) {
+     double cc[2][2];
+     int *cluster[3];
+     int xoff, yoff;
+     cluster[0]=cl;
+     cluster[1]=cl+3;
+     cluster[2]=cl+6;
+     
+     switch (quad) {
+     case BOTTOM_LEFT:
+       xoff=0;
+       yoff=0;
+       break;
+     case BOTTOM_RIGHT:
+       xoff=1;
+       yoff=0;
+       break;
+     case TOP_LEFT:
+       xoff=0;
+       yoff=1;
+       break;
+     case TOP_RIGHT:
+       xoff=1;
+       yoff=1;
+       break;
+     default:
+       ;
+     } 
+     cc[0][0]=cluster[yoff][xoff];
+     cc[1][0]=cluster[yoff+1][xoff];
+     cc[0][1]=cluster[yoff][xoff+1];
+     cc[1][1]=cluster[yoff+1][xoff+1];
+     
+      /* cout << cl[0] << " " << cl[1] << " " << cl[2] << endl;   */
+      /* cout << cl[3] << " " << cl[4] << " " << cl[5] << endl;   */
+      /* cout << cl[6] << " " << cl[7] << " " << cl[8] << endl;   */
+      /* cout <<"******"<<totquad << " " << quad << endl;  */
+      /* cout << cc[0][0]<< " " << cc[0][1] << endl;  */
+      /* cout << cc[1][0]<< " " << cc[1][1] << endl;  */
+     //calcMyEta(totquad,quad,cl,etax, etay);
+     calcEta(totquad, cc,etax, etay);
+
+     //     cout <<"******"<< etax << " " << etay << endl;
+
+
+     return addToFlatField(etax,etay);
+   }
+
+   virtual int addToFlatField(double totquad,int quad,double *cl,double &etax, double &etay) {
+     double cc[2][2];
+     double *cluster[3];
+     int xoff, yoff;
+     cluster[0]=cl;
+     cluster[1]=cl+3;
+     cluster[2]=cl+6;
+     
+     switch (quad) {
+     case BOTTOM_LEFT:
+       xoff=0;
+       yoff=0;
+       break;
+     case BOTTOM_RIGHT:
+       xoff=1;
+       yoff=0;
+       break;
+     case TOP_LEFT:
+       xoff=0;
+       yoff=1;
+       break;
+     case TOP_RIGHT:
+       xoff=1;
+       yoff=1;
+       break;
+     default:
+       ;
+     } 
+     cc[0][0]=cluster[yoff][xoff];
+     cc[1][0]=cluster[yoff+1][xoff];
+     cc[0][1]=cluster[yoff][xoff+1];
+     cc[1][1]=cluster[yoff+1][xoff+1];
+     
+      /* cout << cl[0] << " " << cl[1] << " " << cl[2] << endl;   */
+      /* cout << cl[3] << " " << cl[4] << " " << cl[5] << endl;   */
+      /* cout << cl[6] << " " << cl[7] << " " << cl[8] << endl;   */
+      /* cout <<"******"<<totquad << " " << quad << endl;  */
+      /* cout << cc[0][0]<< " " << cc[0][1] << endl;  */
+      /* cout << cc[1][0]<< " " << cc[1][1] << endl;  */
+     //calcMyEta(totquad,quad,cl,etax, etay);
+     calcEta(totquad, cc,etax, etay);
+
+     //     cout <<"******"<< etax << " " << etay << endl;
+
+
+     return addToFlatField(etax,etay);
+   }
+
+
+
+  //////////////////////////////////////////////////////////////////////////////////////
+  virtual int addToFlatField(double *cluster, double &etax, double &etay){
+    double sDum[2][2];
+    double tot, totquad;
+    int corner;
+    corner=calcQuad(cluster, tot, totquad, sDum); 
+    
+    double xpos_eta,ypos_eta;
+    double dX,dY;
+  
+    
+    calcEta(totquad, sDum, etax, etay); 
+   
+    return addToFlatField(etax,etay);
+
+    };
+
+  virtual int addToFlatField(int *cluster, double &etax, double &etay){
+    double sDum[2][2];
+    double tot, totquad;
+    int corner;
+    corner=calcQuad(cluster, tot, totquad, sDum); 
+    
+    double xpos_eta,ypos_eta;
+    double dX,dY;
+  
+    
+    calcEta(totquad, sDum, etax, etay); 
+   
+    return addToFlatField(etax,etay);
+
+    };
+
+
+  virtual int addToFlatField(double etax, double etay){
+#ifdef MYROOT1
+    heta->Fill(etax,etay);
+#endif
+#ifndef MYROOT1
+    int ex,ey; 
+    ex=(etax-etamin)/etastep;
+    ey=(etay-etamin)/etastep;
+    if (ey<nbeta && ex<nbeta && ex>=0 && ey>=0)
+      heta[ey*nbeta+ex]++; 
+#endif
+    return 0;    
+  };
+  
+/*  protected: */
+  
+/* #ifdef MYROOT1 */
+/*   TH2D *heta; */
+/*   TH2D *hhx; */
+/*   TH2D *hhy; */
+/* #endif */
+/* #ifndef MYROOT1 */
+/*   int *heta; */
+/*   float *hhx; */
+/*   float *hhy; */
+/* #endif */
+/*   int nbeta; */
+/*   double etamin, etamax, etastep; */
+
+};
+
+#endif