/*******************************************************************

Date:       $Date$
Revision:   $Rev$
Author:     $Author$
URL:        $URL$
ID:         $Id$

 ********************************************************************/



#ifndef MULTI_SLS_DETECTOR_H
#define MULTI_SLS_DETECTOR_H

#include "slsDetectorUtils.h"
class slsDetector;
class SharedMemory;
class ThreadPool;
class ZmqSocket;


#include <vector>
#include <string>


#define MULTI_SHMVERSION	0x180618
#define SHORT_STRING_LENGTH	50
#define DATE_LENGTH			29

/**
 @libdoc The multiSlsDetector class is used to operate several slsDetectors in parallel.
 * @short This is the base class for multi detector system functionalities
 * @author Anna Bergamaschi
 */

class multiSlsDetector  : public slsDetectorUtils {


	typedef  struct sharedMultiSlsDetector {


		/* FIXED PATTERN FOR STATIC FUNCTIONS. DO NOT CHANGE, ONLY APPEND ------*/

		/** shared memory version */
		int shmversion;

		/** last process id accessing the shared memory */
		pid_t lastPID;

		/** last user name accessing the shared memory */
		char lastUser[SHORT_STRING_LENGTH];

		/** last time stamp when accessing the shared memory */
		char lastDate[SHORT_STRING_LENGTH];

		/** number of sls detectors in shared memory */
		int numberOfDetectors;

		/** END OF FIXED PATTERN -----------------------------------------------*/




		/** Number of detectors operated at once */
		int numberOfDetector[2];

		/** online flag - is set if the detector is connected, unset if socket connection is not possible  */
		int onlineFlag;

		/** stopped flag - is set if an acquisition error occurs or the detector is stopped manually. Is reset to 0 at the start of the acquisition */
		int stoppedFlag;

		/** position of the master detector */
		int masterPosition;

		/** type of synchronization between detectors */
		synchronizationMode syncMode;

		/** Detectors offset in the X direction (in number of channels)*/
		int offsetX[MAXDET];

		/** Detectors offsets  in the Y direction (in number of channels) */
		int offsetY[MAXDET];

		/**  size of the data that are transfered from all detectors */
		int dataBytes;

		/** data bytes including gap pixels transferred from all detectors */
		int dataBytesInclGapPixels;

		/**  total number of channels for all detectors */
		int numberOfChannels;

		/**  total number of channels for all detectors  in one dimension*/
		int numberOfChannel[2];

		/** total number of channels including gap pixels in one dimension */
		int numberOfChannelInclGapPixels[2];

		/**  total number of channels for all detectors */
		int maxNumberOfChannels;

		/**  max number of channels for all detectors  in one dimension*/
		int maxNumberOfChannel[2];

		/**  max number of channels including gap pixels for all detectors  in one dimension*/
		int maxNumberOfChannelInclGapPixels[2];

		/** max number of channels allowed for the complete set of detectors in one dimension */
		int maxNumberOfChannelsPerDetector[2];

		/** timer values */
		int64_t timerValue[MAX_TIMERS];

		/** detector settings (standard, fast, etc.) */
		detectorSettings currentSettings;

		/** detector threshold (eV) */
		int currentThresholdEV;

		/** indicator for the acquisition progress - set to 0 at the beginning of the acquisition and incremented every time that the data are written to file */
		int progressIndex;

		/** total number of frames to be acquired */
		int totalProgress;

		/** current index of the output file */
		int fileIndex;

		/** name root of the output files */
		char fileName[MAX_STR_LENGTH];

		/** path of the output files */
		char filePath[MAX_STR_LENGTH];

		/** max frames per file */
		int framesPerFile;

		/** file format*/
		fileFormat fileFormatType;

		/** corrections  to be applied to the data \see ::correctionFlags */
		int correctionMask;

		/** threaded processing flag (i.e. if data are processed and written to file in a separate thread)  */
		int threadedProcessing;

		/** dead time (in ns) for rate corrections */
		double tDead;

		/** directory where the flat field files are stored */
		char flatFieldDir[MAX_STR_LENGTH];

		/** file used for flat field corrections */
		char flatFieldFile[MAX_STR_LENGTH];

		/** file with the bad channels */
		char badChanFile[MAX_STR_LENGTH];

		/** angular conversion file */
		char angConvFile[MAX_STR_LENGTH];

		/** angular direction (1 if it corresponds to the encoder direction i.e. channel 0 is 0, maxchan is positive high angle, 0 otherwise  */
		int angDirection;

		/** beamline fine offset (of the order of mdeg, might be adjusted for each measurements)  */
		double fineOffset;

		/** beamline offset (might be a few degrees beacuse of encoder offset - normally it is kept fixed for a long period of time)  */
		double globalOffset;

		/** bin size for data merging */
		double binSize;

		//X and Y displacement
		double sampleDisplacement[2];

		/** number of positions at which the detector should acquire  */
		int numberOfPositions;

		/** list of encoder positions at which the detector should acquire */
		double detPositions[MAXPOS];

		/** Scans and scripts */
		int actionMask;

		mystring actionScript[MAX_ACTIONS];
		mystring actionParameter[MAX_ACTIONS];
		int scanMode[MAX_SCAN_LEVELS];
		mystring scanScript[MAX_SCAN_LEVELS];
		mystring scanParameter[MAX_SCAN_LEVELS];
		int nScanSteps[MAX_SCAN_LEVELS];
		mysteps scanSteps[MAX_SCAN_LEVELS];
		int scanPrecision[MAX_SCAN_LEVELS];

		/** flag for acquiring */
		bool acquiringFlag;

		/** external gui */
		bool externalgui;

		/** receiver online flag - is set if the receiver is connected, unset if socket connection is not possible  */
		int receiverOnlineFlag;

		/** data streaming (up stream) enable in receiver */
		bool receiver_upstream;

	} sharedMultiSlsDetector;




public:



	using slsDetectorUtils::flatFieldCorrect;
	using slsDetectorUtils::rateCorrect;
	using slsDetectorUtils::setBadChannelCorrection;
	using slsDetectorUtils::readAngularConversion;
	using slsDetectorUtils::writeAngularConversion;

	/*
     @short Structure allocated in shared memory to store detector settings and be accessed in parallel by several applications (take care of possible conflicts!)

	 */


	/**
	 * Constructor
	 * @param id multi detector id
	 * @param verify true to verify if shared memory size matches existing one
	 * @param update true to update last user pid, date etc
	 */
	multiSlsDetector(int id = 0, bool verify = true, bool update = true);

	/**
	 * Destructor
	 */
	virtual ~multiSlsDetector();

	/**
	 * returns true. Used when reference is slsDetectorUtils and to determine if command can be implemented as slsDetector/multiSlsDetector object/
	 */
	bool isMultiSlsDetectorClass();

	/**
	 * Get sls detector object from position in detectors array
	 * @param pos position in detectors array
	 * @returns pointer to sls detector object
	 */
	slsDetector* getSlsDetector(unsigned int pos);

	/**
	 * Free shared memory from the command line
	 * avoiding creating the constructor classes and mapping
	 * @param multiId multi detector Id
	 */
	static void freeSharedMemory(int multiId);

	/**
	 * Free shared memory and delete shared memory structure
	 * occupied by the sharedMultiSlsDetector structure
	 */
	void freeSharedMemory();

	/**
	 * Get user details of shared memory
	 * @returns string with user details
	 */
	std::string getUserDetails();

	/**
	 * Sets the hostname of all sls detectors in shared memory
	 * @param s concatenated hostname of all the sls detectors
	 */
	void setHostname(std::string s);

	/**
	 * Gets the hostname of detector at particular position
	 * or concatenated hostnames of all the sls detectors
	 * @param pos position of detector in array, -1 for all detectors
	 * @returns concatenated hostnames of all detectors or hostname of specific one
	 */
	std::string getHostname(int pos = -1);


	using slsDetectorBase::getDetectorType;
	/**
	 * Get Detector type for a particular sls detector or get the first one
	 * @param pos position of sls detector in array, if -1, returns first detector type
	 * @returns detector type of sls detector in position pos, if -1, returns the first det type
	 */
	detectorType getDetectorsType(int pos = -1);

	/**
	 * Concatenates string types of all sls detectors or
	 * returns the detector type of the first sls detector
	 * @param pos position of sls detector in array, if -1, returns first detector type
	 * @returns detector type of sls detector in position pos, if -1, concatenates
	 */
	std::string sgetDetectorsType(int pos=-1);

	/**
	 * Just to overload getDetectorType
	 * Concatenates string types of all sls detectors or
	 * returns the detector type of the first sls detector
	 * @param pos position of sls detector in array, if -1, returns first detector type
	 * @returns detector type of sls detector in position pos, if -1, concatenates
	 */
	std::string getDetectorType();

	/**
	 * Creates all the threads in the threadpool
	 * throws an exception if it cannot create threads
	 */
	int createThreadPool();

	/**
	 * Destroys all the threads in the threadpool
	 */
	void destroyThreadPool();

	/**
	 * Returns the number of detectors in the multidetector structure
	 * @returns number of detectors
     */
	int getNumberOfDetectors();

	/**
	 * Returns number of detectors in dimension d
	 * @param d dimension d
	 * @returns number of detectors in dimension d
	 */
	int getNumberOfDetectors(dimension d);

	/**
	 * Returns the number of detectors in each direction
   	   @param nx number of detectors in x direction
   	   @param ny number of detectors in y direction
	 */
	void getNumberOfDetectors(int& nx, int& ny);

	/**
	 * Returns sum of all modules per sls detector (Mythen)
	 * Other detectors, it is 1
	 * @returns sum of all modules per sls detector
	 */
	int getNMods();

	/**
	 * Returns sum of all modules per sls detector in dimension d (Mythen)
	 * Other detectors, it is 1
	 * @param d dimension d
	 * @returns sum of all modules per sls detector in dimension d
	 */
	int getNMod(dimension d);

	/**
	 * Returns sum of all maximum modules per sls detector (Mythen).
	 * Other detectors, it is 1
	 * @returns sum of all maximum modules per sls detector
	 */
	int getMaxMods();


	/**
	 * Returns sum of all maximum modules per sls detector in dimension d (Mythen)
	 * Other detectors, it is 1
	 * @param d dimension d
	 * @returns sum of all maximum modules per sls detector in dimension d
	 */
	int getMaxMod(dimension d);

	/**
	 * Returns the sum of all maximum modules per sls detector in dimension d (Mythen).
	 * from the detector directly.
	 * Other detectors, it is 1
	 * @param d dimension d
	 * @returns sum of all maximum modules per sls detector in dimension d
	 */
	int getMaxNumberOfModules(dimension d=X);

	/**
	 * Sets the sum of all modules per sls detector in dimension d (Mythen).
	 * from the detector directly.
	 * Other detectors, it is 1
	 * @param i the number of modules to set to
	 * @param d dimension d
	 * @returns sum of all modules per sls detector in dimension d
	 */
	int setNumberOfModules(int i=-1, dimension d=X);

	/**
	 * Calculates the position of detector based on module number of entire multi
	 * detector list and returns the number of channels per that module (Mythen)
	 * @param imod module number of entire multi detector list
	 * @returns number of channels per module imod
	 */
	int getChansPerMod(int imod=0);

	/**
	 * Returns the total number of channels of all sls detectors
	 * @returns the total number of channels of all sls detectors
	 */
	int getTotalNumberOfChannels();

	/**
	 * Returns the total number of channels of all sls detectors in dimension d
	 * @param d dimension d
	 * @returns the total number of channels of all sls detectors in dimension d
	 */
	int getTotalNumberOfChannels(dimension d);

	/**
	 * Returns the total number of channels of all sls detectors in dimension d
	 * including gap pixels
	 * @param d dimension d
	 * @returns the total number of channels of all sls detectors in dimension d
	 * including gap pixels
	 */
	int getTotalNumberOfChannelsInclGapPixels(dimension d);

	/**
	 * Returns the maximum number of channels of all sls detectors (Mythen)
	 * @returns the maximum number of channels of all sls detectors
	 */
	int getMaxNumberOfChannels();

	/**
	 * Returns the maximum number of channels of all sls detectors in dimension d (Mythen)
	 * @param d dimension d
	 * @returns the maximum number of channels of all sls detectors in dimension d
	 */
	int getMaxNumberOfChannels(dimension d);

	/**
	 * Returns the total number of channels of all sls detectors in dimension d
	 * including gap pixels (Mythen)
	 * @param d dimension d
	 * @returns the total number of channels of all sls detectors in dimension d
	 * including gap pixels
	 */
	int getMaxNumberOfChannelsInclGapPixels(dimension d);

	/**
	 * Returns the maximum number of channels of all sls detectors in each dimension d,
	 * multi detector shared memory variable to calculate offsets for each sls detector
	 * @param d dimension d
	 * @returns the maximum number of channels of all sls detectors in dimension d
	 */
	int getMaxNumberOfChannelsPerDetector(dimension d);

	/**
	 * Sets the maximum number of channels of all sls detectors in each dimension d,
	 * multi detector shared memory variable to calculate offsets for each sls detector
	 * @param d dimension d
	 * @param i maximum number of channels for multi structure in dimension d
	 * @returns the maximum number of channels of all sls detectors in dimension d
	 */
	int setMaxNumberOfChannelsPerDetector(dimension d,int i);

	/**
	 * Updates the channel offsets in X and Y dimension for all the sls detectors
	 * It is required for decodeNMod and setting ROI
	 */
	void updateOffsets();

	/**
	 * Calculate the detector position index in multi vector and the module index
	 * using an index for all entire modules in list (Mythen)
	 * @param i position index of all modules in list
	 * @param idet position index in multi vector list
	 * @param imod module index in the sls detector
	 */
	int decodeNMod(int i, int &idet, int &imod);


	/**
	 * Checks if the multi detectors are online and sets the online flag
	 * @param online if GET_ONLINE_FLAG, only returns shared memory online flag,
	 * else sets the detector in online/offline state
     * if OFFLINE_FLAG, (i.e. no communication to the detector - using only local structure - no data acquisition possible!);
     * if ONLINE_FLAG, detector in online state (i.e. communication to the detector updating the local structure)
     * @returns online/offline status
	 */
	int setOnline(int const online=GET_ONLINE_FLAG);

	/**
	 * Checks if each of the detectors are online/offline
	 * @returns empty string if they are all online,
	 * else returns concatenation of strings of all detectors that are offline
     */
	std::string checkOnline();

	/**
	 * Activates the detector (Eiger only)
	 * @param enable active (1) or inactive (0), -1 gets
	 * @returns 0 (inactive) or 1 (active)
	 */
	int activate(int const enable=GET_ONLINE_FLAG);

	/**
	 * Load configuration from a configuration File
	 * @param fname configuration file name
	 * @return OK or FAIL
	 */
	int readConfigurationFile(std::string const fname);

	/**
	 * Write current configuration to a file
	 * @param fname configuration file name
	 * @returns OK or FAIL
	 */
	int writeConfigurationFile(std::string const fname);

	/**
	 * (Not implemented in any detector from the client)
	 * Sets/gets the detector in position i as master of the structure
	 * (e.g. it gates the other detectors and therefore must be started as last.
	 * Assumes that signal 0 is gate in, signal 1 is trigger in, signal 2 is gate out
	 * @param i position of master (-1 gets, -2 unset)
	 * @return master's position (-1 none)
	 */
	int setMaster(int i=-1);

	/** (Not implemented in any detector from the client)
	 * Sets/gets the synchronization mode of the various detector
	 * @param sync syncronization mode
	 * @returns current syncronization mode
	 */
	synchronizationMode setSynchronization(synchronizationMode sync=GET_SYNCHRONIZATION_MODE);














	angleConversionConstant *getAngularConversionPointer(int imod=0);




	/** returns the enable if data will be flipped across x or y axis
	 *  \param d axis across which data is flipped
	 *  returns 1 or 0
	 */
	int getFlippedData(dimension d=X);


	double getScanStep(int index, int istep){return thisMultiDetector->scanSteps[index][istep];};




	/**
     Prints receiver configuration
     \returns OK or FAIL
	 */
	int printReceiverConfiguration();



	/* I/O */



	/* Communication to server */

	// Expert Initialization functions

	/**
     get threshold energy
     \param imod module number (-1 all)
     \returns current threshold value for imod in ev (-1 failed)
	 */
	int getThresholdEnergy(int imod=-1);

	/**
     set threshold energy
     \param e_eV threshold in eV
     \param imod module number (-1 all)
     \param isettings ev. change settings
     \param tb 1 to include trimbits, 0 to exclude
     \returns current threshold value for imod in ev (-1 failed)
	 */
	int setThresholdEnergy(int e_eV, int imod=-1, detectorSettings isettings=GET_SETTINGS,int tb=1);

	/**
     get detector settings
     \param imod module number (-1 all)
     \returns current settings
	 */
	detectorSettings getSettings(int imod=-1);

	/**
     set detector settings
     \param isettings  settings
     \param imod module number (-1 all)
     \returns current settings

     in this function trimbits and calibration files are searched in the trimDir and calDir directories and the detector is initialized
	 */
	detectorSettings setSettings(detectorSettings isettings, int imod=-1);


	/**
     Returns the trimbits from the detector's shared memmory
     \param retval is the array with the trimbits
     \param fromDetector is true if the trimbits shared memory have to be uploaded from detector
     \returns the total number of channels for the detector
	 */
	int getChanRegs(double* retval,bool fromDetector);




	int64_t getId(idMode mode, int imod=0);
	int digitalTest(digitalTestMode mode, int imod=0);
	int executeTrimming(trimMode mode, int par1, int par2, int imod=-1);
	std::string getSettingsFile();



	/** programs FPGA with pof file
      \param fname file name
      \returns OK or FAIL
	 */
	int programFPGA(std::string fname);

	/** resets FPGA
      \returns OK or FAIL
	 */
	int resetFPGA();

	/** power on/off the chip
     \param ival on is 1, off is 0, -1 to get
      \returns OK or FAIL
	 */
	int powerChip(int ival= -1);

	/** automatic comparator disable for Jungfrau only
     \param ival on is 1, off is 0, -1 to get
      \returns OK or FAIL
	 */
	int setAutoComparatorDisableMode(int ival= -1);

	/** loads the modules settings/trimbits reading from a file -  file name extension is automatically generated! */
	int loadSettingsFile(std::string fname, int nmod=-1);

	/** gets the modules settings/trimbits and writes them to file -  file name extension is automatically generated! */
	int saveSettingsFile(std::string fname, int nmod=-1);


	/** sets all the trimbits to a particular value
      \param val trimbit value
      \param imod module number, -1 means all modules
      \returns OK or FAIL
	 */
	int setAllTrimbits(int val, int imod=-1);


	/** loads the modules calibration data reading from a file -  file name extension is automatically generated! */
	int loadCalibrationFile(std::string fname, int nmod=-1);

	/** gets the modules calibration data and writes them to file -  file name extension is automatically generated! */
	int saveCalibrationFile(std::string fname, int nmod=-1);



















	// Acquisition functions
	/**
     prepares detector for acquisition
     \returns OK if all detectors are properly started, FAIL otherwise
	 */
	int prepareAcquisition();

	/**
     prepares detector for acquisition
     \returns OK if all detectors are properly started, FAIL otherwise
	 */
	int cleanupAcquisition();

	/**
     start detector acquisition (master is started as last)
     \returns OK if all detectors are properly started, FAIL otherwise
	 */
	int startAcquisition();

	/**
     stop detector acquisition (master firtst)
     \returns OK/FAIL
	 */
	int stopAcquisition();

	/**
     start readout (without exposure or interrupting exposure) (master first)
     \returns OK/FAIL
	 */
	int startReadOut();



	/**
     start detector acquisition and read all data putting them a data queue
     \returns pointer to the front of the data queue
     \sa startAndReadAllNoWait getDataFromDetector dataQueue
	 */
	int* startAndReadAll();

	/**
     start detector acquisition and read out, but does not read data from socket 

	 */
	int startAndReadAllNoWait();

	/**
     receives a data frame from the detector socket
     \returns pointer to the data or NULL. If NULL disconnects the socket
     \sa getDataFromDetector
	 */
	//int* getDataFromDetectorNoWait();
	/**
     receives a data frame from the detector socket
     \returns pointer to the data or NULL. If NULL disconnects the socket
     \sa getDataFromDetector
	 */
	int* getDataFromDetector();

	/**
     asks and  receives a data frame from the detector and puts it in the data queue
     \returns pointer to the data or NULL. 
     \sa getDataFromDetector
	 */
	int* readFrame();

	/**
     asks and  receives all data  from the detector  and puts them in a data queue
     \returns pointer to the front of the queue  or NULL. 
     \sa getDataFromDetector  dataQueue
	 */
	int* readAll();


	/**
     pops the data from the data queue
     \returns pointer to the popped data  or NULL if the queue is empty. 
     \sa  dataQueue
	 */
	int* popDataQueue();

	/**
     pops the data from thepostprocessed data queue
     \returns pointer to the popped data  or NULL if the queue is empty. 
     \sa  finalDataQueue
	 */
	detectorData* popFinalDataQueue();




	/**
     resets the raw data queue
     \sa  dataQueue
	 */
	void resetDataQueue();

	/**
     resets the postprocessed  data queue
     \sa  finalDataQueue
	 */
	void resetFinalDataQueue();







	int setSpeed(speedVariable sp, int value=-1);


	/**
      set/get timer value
      \param index timer index
      \param t time in ns or number of...(e.g. frames, gates, probes)
      \returns timer set value in ns or number of...(e.g. frames, gates, probes)
	 */
	int64_t setTimer(timerIndex index, int64_t t=-1);
	/**
      set/get timer value
      \param index timer index
      \param t time in ns or number of...(e.g. frames, gates, probes)
      \returns timer set value in ns or number of...(e.g. frames, gates, probes)
	 */
	int64_t getTimeLeft(timerIndex index);

	/**
	 * set storage cell that stores first acquisition of the series (Jungfrau only)
	 * \param value storage cell index. Value can be 0 to 15. (-1 gets)
	 * \returns the storage cell that stores the first acquisition of the series
	 */
	int setStoragecellStart(int pos=-1);

	/*   /\**  */
	/*       get current timer value */
	/*       \param index timer index */
	/*       \returns elapsed time value in ns or number of...(e.g. frames, gates, probes) */
	/*   *\/ */
	/*   int64_t getTimeLeft(timerIndex index); */



	// Flags
	/**
      set/get dynamic range and updates the number of dataBytes
      \param n dynamic range (-1 get)
      \param pos detector position (-1 all detectors)
      \returns current dynamic range
      updates the size of the data expected from the detector
      \sa sharedSlsDetector
	 */
	int setDynamicRange(int n, int pos);

	int getDataBytes();

	/**
       decodes which detector and the corresponding channel numbers for it
       \param offsetX channel number or total channel offset in x direction
       \param offsetY channel number or total channel offset in y direction
       \param channelX channel number from detector offset in x direction
       \param channelY channel number from detector offset in x direction
       \returns detector id or -1 if channel number out of range
	 */
	int decodeNChannel(int offsetX, int offsetY, int &channelX, int &channelY);

	/**
 	 verifies that min is less than max
 	 \param n number of rois
 	 \param r array of rois
	 */
	void verifyMinMaxROI(int n, ROI r[]);

	/**
      set roi
       \param n number of rois
       \param roiLimits array of roi
       \returns success or failure
	 */
	int setROI(int n=-1,ROI roiLimits[]=NULL);

	/**
   	get roi from each detector and convert it to the multi detector scale
   	\param n number of rois
   	\returns an array of multidetector's rois
	 */
	ROI* getROI(int &n);


	//Corrections


	/**
      set flat field corrections
      \param fname name of the flat field file (or "" if disable)
      \returns 0 if disable (or file could not be read), >0 otherwise
	 */
	int setFlatFieldCorrection(std::string fname="");

	/**
      set flat field corrections
      \param corr if !=NULL the flat field corrections will be filled with corr (NULL usets ff corrections)
      \param ecorr if !=NULL the flat field correction errors will be filled with ecorr (1 otherwise)
      \returns 0 if ff correction disabled, >0 otherwise
	 */
	int setFlatFieldCorrection(double *corr, double *ecorr=NULL);

	/**
      get flat field corrections
      \param corr if !=NULL will be filled with the correction coefficients
      \param ecorr if !=NULL will be filled with the correction coefficients errors
      \returns 0 if ff correction disabled, >0 otherwise
	 */
	int getFlatFieldCorrection(double *corr=NULL, double *ecorr=NULL);








	/**
      set rate correction
      \param t dead time in ns - if 0 disable correction, if >0 set dead time to t, if <0 set deadtime to default dead time for current settings
      \returns 0 if rate correction disabled, >0 otherwise
	 */
	int setRateCorrection(double t=0);


	/**
      get rate correction
      \param t reference for dead time
      \returns 0 if rate correction disabled, >0 otherwise
	 */
	int getRateCorrection(double &t);


	/**
      get rate correction tau
      \returns 0 if rate correction disabled, otherwise the tau used for the correction
	 */
	double getRateCorrectionTau();
	/**
      get rate correction
      \returns 0 if rate correction disabled, >0 otherwise
	 */
	int getRateCorrection();

	/**
      set bad channels correction
      \param fname file with bad channel list ("" disable)
      \returns 0 if bad channel disabled, >0 otherwise
	 */
	int setBadChannelCorrection(std::string fname="");


	int setBadChannelCorrection(int nch, int *chs, int ff);



	/**
      get bad channels correction
      \param bad pointer to array that if bad!=NULL will be filled with the bad channel list
      \returns 0 if bad channel disabled or no bad channels, >0 otherwise
	 */
	int getBadChannelCorrection(int *bad=NULL);



	/**
      pure virtual function
      get angular conversion
      \param reference to diffractometer direction
      \param angconv array that will be filled with the angular conversion constants
      \returns 0 if angular conversion disabled, >0 otherwise
      \sa mythenDetector::getAngularConversion
	 */
	/////////////////////////////////////////////////// virtual int getAngularConversion(int &direction,  angleConversionConstant *angconv=NULL);



	int readAngularConversionFile(std::string fname);

	int writeAngularConversion(std::string fname);

	//  double* convertAngles(double pos);




	/**
      decode data from the detector converting them to an array of doubles, one for each channle
      \param datain data from the detector
      \returns pointer to a double array with a data per channel
	 */
	double* decodeData(int *datain, int &nn, double *fdata=NULL);




	/**
      flat field correct data
      \param datain data
      \param errin error on data (if<=0 will default to sqrt(datain)
      \param dataout corrected data
      \param errout error on corrected data
      \param ffcoefficient flat field correction coefficient
      \param fferr erro on ffcoefficient
      \returns 0
	 */
	// int flatFieldCorrect(double datain, double errin, double &dataout, double &errout, double ffcoefficient, double fferr);

	/**
      flat field correct data
      \param datain data array
      \param errin error array on data (if NULL will default to sqrt(datain)
      \param dataout array of corrected data
      \param errout error on corrected data (if not NULL)
      \returns 0
	 */
	int flatFieldCorrect(double* datain, double *errin, double* dataout, double *errout);



	/**
      rate correct data
      \param datain data
      \param errin error on data (if<=0 will default to sqrt(datain)
      \param dataout corrected data
      \param errout error on corrected data
      \param tau dead time 9in ns)
      \param t acquisition time (in ns)
      \returns 0
	 */
	//  int rateCorrect(double datain, double errin, double &dataout, double &errout, double tau, double t);

	/**
      rate correct data
      \param datain data array
      \param errin error array on data (if NULL will default to sqrt(datain)
      \param dataout array of corrected data
      \param errout error on corrected data (if not NULL)
      \returns 0
	 */
	int rateCorrect(double* datain, double *errin, double* dataout, double *errout);

	/**
      turns off server
	 */
	int exitServer();

	/** pure /////////////////////////////////////////////////// virtual function
      function for processing data
      /param delflag if 1 the data are processed, written to file and then deleted. If 0 they are added to the finalDataQueue
      \sa mythenDetector::processData
	 */
	///////////////////////////////////////////////////  virtual void* processData(int delflag=1); // thread function


	/////////////////////////////////////////////////// virtual void acquire(int delflag=1);

	/** calcualtes the total number of steps of the acquisition.
      called when number of frames, number of cycles, number of positions and scan steps change
	 */
	/////////////////////////////////////// int setTotalProgress(); ////////////// from slsDetectorUtils!

	/** returns the current progress in % */
	////////////////////////////////double getCurrentProgress();////////////// from slsDetectorUtils!


	/**
     set dacs value
     \param val value (in V)
     \param index DAC index
     \param mV 0 in dac units or 1 in mV
     \param imod module number (if -1 alla modules)
     \returns current DAC value
	 */
	dacs_t setDAC(dacs_t val, dacIndex index , int mV, int imod=-1);

	/**
     set dacs value
     \param val value (in V)
     \param index DAC index
     \param imod module number (if -1 alla modules)
     \returns current DAC value (temperature for eiger and jungfrau in millidegrees)
	 */
	dacs_t getADC(dacIndex index, int imod=-1);

	/**
     set/gets threshold temperature (Jungfrau only)
     \param val value in millidegrees, -1 gets
     \param imod module number, -1 is all
     \returns threshold temperature in millidegrees
	 */
	int setThresholdTemperature(int val=-1, int imod=-1);

	/**
     enables/disables temperature control (Jungfrau only)
     \param val value, -1 gets
     \param imod module number, -1 is all
     \returns temperature control enable
	 */
	int setTemperatureControl(int val=-1, int imod=-1);

	/**
     Resets/ gets over-temperature event (Jungfrau only)
     \param val value, -1 gets
     \param imod module number, -1 is all
     \returns over-temperature event
	 */
	int setTemperatureEvent(int val=-1, int imod=-1);

	/**
     configure channel
     \param reg channel register
     \param ichan channel number (-1 all)
     \param ichip chip number (-1 all)
     \param imod module number (-1 all)
     \returns current register value
     \sa ::sls_detector_channel
	 */
	int setChannel(int64_t reg, int ichan=-1, int ichip=-1, int imod=-1);
	/**
      pure virtual function
      get angular conversion
      \param reference to diffractometer direction
      \param angconv array that will be filled with the angular conversion constants
      \returns 0 if angular conversion disabled, >0 otherwise
      \sa mythenDetector::getAngularConversion
	 */
	int getAngularConversion(int &direction,  angleConversionConstant *angconv=NULL) ;



	/**
     get run status
     \returns status mask
	 */
	//virtual runStatus  getRunStatus()=0;
	runStatus  getRunStatus();

	void setErrorMaskFromAllDetectors();


	std::string concatResultOrPos(std::string (slsDetector::*somefunc)(int), int pos);

	template<typename T>
	bool allElemetsEqual(const std::vector<T>&);

	template<typename T>
	T callDetectorMember(T (slsDetector::*somefunc)());

	std::string callDetectorMember(std::string(slsDetector::*somefunc)());

	template<typename T, typename V>
	T callDetectorMember(T (slsDetector::*somefunc)(V), V value);

	template<typename T, typename P1, typename P2>
	T callDetectorMember(T (slsDetector::*somefunc)(P1, P2), P1 par1, P2 par2);


	//func0_t
	template<typename T>
	T parallelCallDetectorMember(T (slsDetector::*somefunc)());

	//func1_t
	template<typename T, typename P1>
	T parallelCallDetectorMember(T (slsDetector::*somefunc)(P1), P1 value); //Should probably be templated

	//func2_t
	template<typename T, typename P1, typename P2>
	T parallelCallDetectorMember(T (slsDetector::*somefunc)(P1, P2), P1 par1, P2 par2);


	int parallelCallDetectorMember(int (slsDetector::*somefunc)(int, int, int), int v0, int v1, int v2); //Should probably be templated

	template<typename T>
	T minusOneIfDifferent(const std::vector<T>&);

	/** returns the detector trimbit/settings directory  \sa sharedSlsDetector */
	std::string getSettingsDir();
	/** sets the detector trimbit/settings directory  \sa sharedSlsDetector */
	std::string setSettingsDir(std::string s);
	/**
     returns the location of the calibration files
     \sa  sharedSlsDetector
	 */
	std::string getCalDir();
	/**
     sets the location of the calibration files
     \sa  sharedSlsDetector
	 */
	std::string setCalDir(std::string s);


	std::string getNetworkParameter(networkParameter);

	/**
     sets the network parameters
     must restart streaming in client/receiver if to do with zmq after calling this function
     \param i network parameter type
     \param s value to be set
     \returns parameter

	 */
	std::string setNetworkParameter(networkParameter, std::string);
	int setPort(portType, int);
	int lockServer(int);

	std::string getLastClientIP();

	/**
     configures mac for gotthard readout
     \returns OK or FAIL
	 */
	int configureMAC();


	/** sets the enable which determines if data will be flipped across x or y axis
	 *  \param d axis across which data is flipped
	 *  \param value 0 or 1 to reset/set or -1 to get value
	 *  \return enable flipped data across x or y axis
	 */
	int setFlippedData(dimension d=X, int value=-1);

	/**
	 * Enable gap pixels, only for Eiger and for 8,16 and 32 bit mode. 4 bit mode gap pixels only in gui call back
	 * @param val 1 sets, 0 unsets, -1 gets
	 * @return gap pixel enable or -1 for error
	 */
	int enableGapPixels(int val=-1);


	int setDynamicRange(int i=-1);





	uint32_t writeRegister(uint32_t addr, uint32_t val);


	int writeAdcRegister(int addr, int val);


	uint32_t readRegister(uint32_t addr);

	/**
      sets a bit in a register
      \param addr address
      \param n nth bit ranging from 0 to 31
      \returns current register value

      DO NOT USE!!! ONLY EXPERT USER!!!
	 */
	uint32_t setBit(uint32_t addr, int n);


	/**
      clear a bit in a register
      \param addr address
      \param n nth bit ranging from 0 to 31
      \returns current register value

      DO NOT USE!!! ONLY EXPERT USER!!!
	 */
	uint32_t clearBit(uint32_t addr, int n);



	int setTrimEn(int nen, int *en=NULL);
	int getTrimEn(int *en=NULL);


	externalSignalFlag setExternalSignalFlags(externalSignalFlag pol=GET_EXTERNAL_SIGNAL_FLAG , int signalindex=0);
	int setReadOutFlags(readOutFlags flag=GET_READOUT_FLAGS);


	externalCommunicationMode setExternalCommunicationMode(externalCommunicationMode pol=GET_EXTERNAL_COMMUNICATION_MODE);

	/**
     Loads dark image or gain image to the detector
     \param index can be DARK_IMAGE or GAIN_IMAGE
     \fname file name to load data from
     \returns OK or FAIL
	 */
	int loadImageToDetector(imageType index,std::string const fname);

	/**
     sets the value of s angular conversion parameter
     \param c can be ANGULAR_DIRECTION, GLOBAL_OFFSET, FINE_OFFSET, BIN_SIZE
     \param v the value to be set
     \returns the actual value
	 */

	double setAngularConversionParameter(angleConversionParameter c, double v);

	/**

  writes a data file
  \param name of the file to be written
  \param data array of data values
  \param err array of arrors on the data. If NULL no errors will be written

  \param ang array of angular values. If NULL data will be in the form chan-val(-err) otherwise ang-val(-err)
  \param dataformat format of the data: can be 'i' integer or 'f' double (default)
  \param nch number of channels to be written to file. if -1 defaults to the number of installed channels of the detector
  \returns OK or FAIL if it could not write the file or data=NULL
  \sa mythenDetector::writeDataFile

	 */
	int writeDataFile(std::string fname, double *data, double *err=NULL, double *ang=NULL, char dataformat='f', int nch=-1);


	/**

  writes a data file
  \param name of the file to be written
  \param data array of data values
  \returns OK or FAIL if it could not write the file or data=NULL  
  \sa mythenDetector::writeDataFile
	 */
	int writeDataFile(std::string fname, int *data);

	/**

  reads a data file
  \param name of the file to be read
  \param data array of data values to be filled
  \param err array of arrors on the data. If NULL no errors are expected on the file

  \param ang array of angular values. If NULL data are expected in the form chan-val(-err) otherwise ang-val(-err)
  \param dataformat format of the data: can be 'i' integer or 'f' double (default)
  \param nch number of channels to be written to file. if <=0 defaults to the number of installed channels of the detector
  \returns OK or FAIL if it could not read the file or data=NULL

  \sa mythenDetector::readDataFile
	 */
	int readDataFile(std::string fname, double *data, double *err=NULL, double *ang=NULL, char dataformat='f');


	/**

  reads a data file
  \param name of the file to be read
  \param data array of data values
  \returns OK or FAIL if it could not read the file or data=NULL
  \sa mythenDetector::readDataFile
	 */
	int readDataFile(std::string fname, int *data);


	/**
     writes the counter memory block from the detector
     \param startACQ is 1 to start acquisition after reading counter
     \param fname file name to load data from
     \returns OK or FAIL
	 */
	int writeCounterBlockFile(std::string const fname,int startACQ=0);


	/**
     Resets counter in detector
     \param startACQ is 1 to start acquisition after resetting counter
     \returns OK or FAIL
	 */
	int resetCounterBlock(int startACQ=0);

	/** set/get counter bit in detector
	 * @param i is -1 to get, 0 to reset and any other value to set the counter bit
     /returns the counter bit in detector
	 */
	int setCounterBit(int i = -1);


	int getMoveFlag(int imod);


	//additional way of accessing
	slsDetector *operator()(int pos) {if (pos>=0 && pos< MAXDET) return detectors[pos]; return NULL;};



	//receiver

	/**
     calls setReceiverTCPSocket if online and sets the flag
	 */
	int setReceiverOnline(int const online=GET_ONLINE_FLAG);

	/**
     Checks if the receiver is really online
	 */
	std::string checkReceiverOnline();


	/**
     Sets up the file directory
     @param s file directory
     \returns file dir
	 */
	std::string setFilePath(std::string s="");

	/**
     Sets up the file name
     @param s file name
     \returns file name
	 */
	std::string setFileName(std::string s="");

	/**
     Sets the max frames per file in receiver
     @param f max frames per file
     \returns max frames per file in receiver
	 */
	int setReceiverFramesPerFile(int f = -1);

	/**
     Sets up the file format
     @param f file format
     \returns file format
	 */
	fileFormat setFileFormat(fileFormat f=GET_FILE_FORMAT);

	/**
     Sets up the file index
     @param i file index
     \returns file index
	 */
	int setFileIndex(int i=-1);

	/**
     \returns file dir
	 */
	std::string getFilePath(){return setFilePath();};

	/**
     \returns file name
	 */
	std::string getFileName(){return setFileName();};

	/**
     \returns file name
	 */
	fileFormat getFileFormat(){return setFileFormat();};

	/**
     \returns file index
	 */
	int getFileIndex(){return setFileIndex();};


	/**   Starts the listening mode of receiver
	\returns OK or FAIL
	 */
	int startReceiver();

	/**   Stops the listening mode of receiver
	\returns OK or FAIL
	 */
	int stopReceiver();

	/** Sets the receiver to start any readout remaining in the fifo and
	 * change status to transmitting.
	 * The status changes to run_finished when fifo is empty
	 */
	runStatus startReceiverReadout();

	/**   gets the status of the listening mode of receiver
	\returns status
	 */
	runStatus getReceiverStatus();

	/**   gets the number of frames caught by receiver
	\returns number of frames caught by receiver
	 */
	int getFramesCaughtByReceiver();

	/**   gets the number of frames caught by any one receiver (to avoid using threadpool)
	\returns number of frames caught by any one receiver (master receiver if exists)
	 */
	int getFramesCaughtByAnyReceiver();

	/**  gets the current frame index of receiver
     \returns current frame index of receiver
	 */
	int getReceiverCurrentFrameIndex();

	/**
	 * resets framescaught
	 * @param index frames caught by receiver
	 */
	int resetFramesCaught();

	/**
	 * Create Receiving Data Sockets
	 * @param destroy is true to destroy all the sockets
	 * @return OK or FAIL
	 */
	int createReceivingDataSockets(const bool destroy = false);



	/** Reads frames from receiver through a constant socket
	 */
	void readFrameFromReceiver();

	/** Locks/Unlocks the connection to the receiver
      /param lock sets (1), usets (0), gets (-1) the lock
      /returns lock status of the receiver
	 */
	int lockReceiver(int lock=-1);

	/**
     Returns the IP of the last client connecting to the receiver
	 */
	std::string getReceiverLastClientIP();

	/**
      Turns off the receiver server!
	 */
	int exitReceiver();

	/**
     Sets/Gets receiver file write enable
     @param enable 1 or 0 to set/reset file write enable
     /returns file write enable
	 */
	int enableWriteToFile(int enable=-1);

	/**
     Sets/Gets file overwrite enable
     @param enable 1 or 0 to set/reset file overwrite enable
     /returns file overwrite enable
	 */
	int overwriteFile(int enable=-1);

	int fillModuleMask(int *mM);

	/**checks error mask and returns error message if it exists
	 * @param myDet is the multidetector object
	 * @param critical is 1 if any of the messages is critical
	 /returns error message else an empty std::string
	 */
	std::string getErrorMessage(int &critical);

	/** Clears error mask of both multi and sls
     /returns error mask
	 */
	int64_t clearAllErrorMask();

	/** Starts acquisition, calibrates pedestal and writes to fpga
     /returns number of frames
	 */
	int calibratePedestal(int frames = 0);

	/** Sets the read receiver frequency
   	  if data required from receiver randomly readRxrFrequency=0,
   	   else every nth frame to be sent to gui
   	   @param freq is the receiver read frequency
   	   /returns read receiver frequency
	 */
	int setReadReceiverFrequency(int freq=-1);

	/** Sets the read receiver timer
   	  if data required from receiver randomly readRxrFrequency=0,
   	   then the timer between each data stream is set with time_in_ms
   	   @param time_in_ms timer between frames
   	   /returns read receiver timer
	 */
	int setReceiverReadTimer(int time_in_ms=500);


	/**
	 * Enable data streaming to client
	 * @param enable 0 to disable, 1 to enable, -1 to get the value
	 * @returns data streaming to client enable
	 */
	int enableDataStreamingToClient(int enable=-1);

	/** Enable or disable streaming data from receiver to client
	 * @param enable 0 to disable 1 to enable -1 to only get the value
	 * @returns data streaming from receiver enable
	 */
	int enableDataStreamingFromReceiver(int enable=-1);




	/** enable/disable or get data compression in receiver
	 * @param i is -1 to get, 0 to disable and 1 to enable
     /returns data compression in receiver
	 */
	int enableReceiverCompression(int i = -1);

	/** enable/disable or 10Gbe
	 * @param i is -1 to get, 0 to disable and 1 to enable
     /returns if 10Gbe is enabled
	 */
	int enableTenGigabitEthernet(int i = -1);

	/** set/get receiver fifo depth
	 * @param i is -1 to get, any other value to set the fifo deph
     /returns the receiver fifo depth
	 */
	int setReceiverFifoDepth(int i = -1);

	/** set/get receiver silent mode
	 * @param i is -1 to get, 0 unsets silent mode, 1 sets silent mode
     /returns the receiver silent mode enable
	 */
	int setReceiverSilentMode(int i = -1);



	/******** CTB funcs */

	/** opens pattern file and sends pattern to CTB
      @param fname pattern file to open
      @returns OK/FAIL
	 */
	int setCTBPattern(std::string fname);


	/** Writes a pattern word to the CTB
      @param addr address of the word, -1 is I/O control register,  -2 is clk control register
      @param word 64bit word to be written, -1 gets
      @returns actual value
	 */
	uint64_t setCTBWord(int addr,uint64_t word=-1);

	/** Sets the pattern or loop limits in the CTB
      @param level -1 complete pattern, 0,1,2, loop level
      @param start start address if >=0
      @param stop stop address if >=0
      @param n number of loops (if level >=0)
      @returns OK/FAIL
	 */
	int setCTBPatLoops(int level,int &start, int &stop, int &n);


	/** Sets the wait address in the CTB
      @param level  0,1,2, wait level
      @param addr wait address, -1 gets
      @returns actual value
	 */
	int setCTBPatWaitAddr(int level, int addr=-1);

	/** Sets the wait time in the CTB
      @param level  0,1,2, wait level
      @param t wait time, -1 gets
      @returns actual value
	 */
	int setCTBPatWaitTime(int level, uint64_t t=-1);

	/**
     Pulse Pixel
     \param n is number of times to pulse
     \param x is x coordinate
     \param y is y coordinate
     \returns OK or FAIL
	 */
	int pulsePixel(int n=0,int x=0,int y=0);

	/**
     Pulse Pixel and move by a relative value
     \param n is number of times to pulse
     \param x is relative x value
     \param y is relative y value
     \returns OK or FAIL
	 */
	int pulsePixelNMove(int n=0,int x=0,int y=0);

	/**
     Pulse Chip
     \param n is number of times to pulse
     \returns OK or FAIL
	 */
	int pulseChip(int n=0);

	/**
     Set acquiring flag in shared memory
     \param b acquiring flag
	 */
	void setAcquiringFlag(bool b=false);

	/**
     Get acquiring flag from shared memory
     \returns acquiring flag
	 */
	bool getAcquiringFlag();

	/**
	 * Check if acquiring flag is set, set error if set
	 * \returns FAIL if not ready, OK if ready
	 */
	bool isAcquireReady();

	/**
	 * Check version compatibility with detector/receiver software
	 * (if hostname/rx_hostname has been set/ sockets created)
	 * \param p port type control port or receiver port
	 * \returns FAIL for incompatibility, OK for compatibility
	 */
	int checkVersionCompatibility(portType t);


private:
	/**
	 * Initialize (open/create) shared memory for the sharedMultiDetector structure
	 * @param verify true to verify if shm size matches existing one
	 * @param update true to update last user pid, date etc
	 */
	bool initSharedMemory(bool verify = true);

	/**
	 * Initialize detector structure
	 * @param created true if shared memory was just created now
	 * @param verify true to verify if shm size matches existing one
	 */
	void initializeDetectorStructure(bool created, bool verify = true);

	/**
	 * Initialize class members (and from slsDetectorUtils)
	 */
	void initializeMembers();

	/**
	 * Update user details in detector structure
	 */
	void updateUserdetails();

	/**
	 * Execute in command line and return result
	 * @param cmd command
	 * @returns result
	 */
	std::string exec(const char* cmd);

	/**
	 * Add sls detector
	 * @param s hostname of the single detector
	 */
	void addSlsDetector (std::string s);


	/**
	 * add gap pixels to the image (only for Eiger in 4 bit mode)
	 * @param image pointer to image without gap pixels
	 * @param gpImage poiner to image with gap pixels, if NULL, allocated inside function
	 * @returns number of data bytes of image with gap pixels
	 */
	int processImageWithGapPixels(char* image, char*& gpImage);


	/** Multi detector Id */
	int detId;

	/** Shared Memory object */
	SharedMemory* sharedMemory;

	/** Shared memory structure */
	sharedMultiSlsDetector *thisMultiDetector;

	/** pointers to the slsDetector structures */
	std::vector <slsDetector*> detectors;

	/** data streaming (down stream) enabled in client (zmq sckets created) */
	bool client_downstream;

	/** ZMQ Socket - Receiver to Client */
	std::vector <ZmqSocket*> zmqSocket;

	/** Threadpool */
	ThreadPool* threadpool;
};



#endif