changes upto the receiver, not incl gui

slsDetectorSoftware/commonFiles/error_defs.h

@@ -81,6 +81,7 @@ using namespace std;
 #define THRESHOLD_NOT_SET					0x0000000040000000ULL
 #define RECEIVER_FILE_FORMAT				0x0000000080000000ULL
 #define RECEIVER_TIMER_NOT_SET				0x0000000100000000ULL
+#define RECEIVER_ENABLE_GAPPIXELS_NOT_SET	0x0000000200000000ULL
 //											0x0000000FFFFFFFFFULL
 
 /** @short class returning all error messages for error mask */
@@ -262,6 +263,9 @@ public:
 		if(slsErrorMask&RECEIVER_TIMER_NOT_SET)
 			retval.append("Could not set timer in receiver.\n");
 
+		if(slsErrorMask&RECEIVER_ENABLE_GAPPIXELS_NOT_SET)
+			retval.append("Could not enable/disable gap pixels in receiver.\n");
+
 		//------------------------------------------------------ length of message
 
 

slsDetectorSoftware/multiSlsDetector/multiSlsDetector.cpp

@@ -125,13 +125,18 @@ multiSlsDetector::multiSlsDetector(int id) :  slsDetectorUtils(), shmId(-1)
     }
     thisMultiDetector->masterPosition=-1;
     thisMultiDetector->dataBytes=0;
+    thisMultiDetector->dataBytesInclGapPixels=0;
     thisMultiDetector->numberOfChannels=0;
     thisMultiDetector->numberOfChannel[X]=0;
     thisMultiDetector->numberOfChannel[Y]=0;
+    thisMultiDetector->numberOfChannelInclGapPixels[X]=0;
+	thisMultiDetector->numberOfChannelInclGapPixels[Y]=0;
 
     thisMultiDetector->maxNumberOfChannels=0;
     thisMultiDetector->maxNumberOfChannel[X]=0;
     thisMultiDetector->maxNumberOfChannel[Y]=0;
+    thisMultiDetector->maxNumberOfChannelInclGapPixels[X]=0;
+    thisMultiDetector->maxNumberOfChannelInclGapPixels[Y]=0;
 
     thisMultiDetector->maxNumberOfChannelsPerDetector[X]=-1;
     thisMultiDetector->maxNumberOfChannelsPerDetector[Y]=-1;
@@ -386,6 +391,7 @@ int multiSlsDetector::addSlsDetector(int id, int pos) {
   ++thisMultiDetector->numberOfDetectors;
   
   thisMultiDetector->dataBytes+=detectors[pos]->getDataBytes();
+  thisMultiDetector->dataBytesInclGapPixels+=detectors[pos]->getDataBytesInclGapPixels();
  
   thisMultiDetector->numberOfChannels+=detectors[pos]->getTotalNumberOfChannels();
   thisMultiDetector->maxNumberOfChannels+=detectors[pos]->getMaxNumberOfChannels();
@@ -437,10 +443,20 @@ void multiSlsDetector::updateOffsets(){//cannot paralllize due to slsdetector ca
 	thisMultiDetector->numberOfDetector[Y] = 0;
 
 
+	// gap pixels
+	int offsetX_gp=0, offsetY_gp=0, numX_gp=0, numY_gp=0, maxX_gp=0, maxY_gp=0;
+	int prevChanX_gp=0, prevChanY_gp=0;
+	thisMultiDetector->numberOfChannelInclGapPixels[X] = 0;
+	thisMultiDetector->numberOfChannelInclGapPixels[Y] = 0;
+	thisMultiDetector->maxNumberOfChannelInclGapPixels[X] = 0;
+	thisMultiDetector->maxNumberOfChannelInclGapPixels[Y] = 0;
+
+
 	for (int i=0; i<thisMultiDetector->numberOfDetectors; ++i) {
 		if (detectors[i]) {
 #ifdef VERBOSE
 			cout<<"offsetX:"<<offsetX<<" prevChanX:"<<prevChanX<<" offsetY:"<<offsetY<<" prevChanY:"<<prevChanY<<endl;
+			cout<<"offsetX_gp:"<<offsetX_gp<<" prevChanX_gp:"<<prevChanX_gp<<" offsetY_gp:"<<offsetY_gp<<" prevChanY_gp:"<<prevChanY_gp<<endl;
 #endif
 			//cout<<" totalchan:"<< detectors[i]->getTotalNumberOfChannels(Y) <<" maxChanY:"<<maxChanY<<endl;
 			//incrementing in both direction
@@ -453,10 +469,16 @@ void multiSlsDetector::updateOffsets(){//cannot paralllize due to slsdetector ca
 					cout<<"\nDetector[" << i << "] exceeds maximum channels allowed for complete detector set in Y dimension!" << endl;
 				prevChanX = detectors[i]->getTotalNumberOfChannels(X);
 				prevChanY = detectors[i]->getTotalNumberOfChannels(Y);
+				prevChanX_gp = detectors[i]->getTotalNumberOfChannelsInclGapPixels(X);
+				prevChanY_gp = detectors[i]->getTotalNumberOfChannelsInclGapPixels(Y);
 				numX += detectors[i]->getTotalNumberOfChannels(X);
 				numY += detectors[i]->getTotalNumberOfChannels(Y);
+				numX_gp += detectors[i]->getTotalNumberOfChannelsInclGapPixels(X);
+				numY_gp += detectors[i]->getTotalNumberOfChannelsInclGapPixels(Y);
 				maxX += detectors[i]->getMaxNumberOfChannels(X);
 				maxY += detectors[i]->getMaxNumberOfChannels(Y);
+				maxX_gp += detectors[i]->getMaxNumberOfChannelsInclGapPixels(X);
+				maxY_gp += detectors[i]->getMaxNumberOfChannelsInclGapPixels(Y);
 				++thisMultiDetector->numberOfDetector[X];
 				++thisMultiDetector->numberOfDetector[Y];
 #ifdef VERBOSE
@@ -467,9 +489,13 @@ void multiSlsDetector::updateOffsets(){//cannot paralllize due to slsdetector ca
 			//incrementing in y direction
 			else if ((maxChanY == -1) || ((maxChanY > 0) && ((offsetY + prevChanY + detectors[i]->getTotalNumberOfChannels(Y)) <= maxChanY))){
 				offsetY += prevChanY;
+				offsetY_gp += prevChanY_gp;
 				prevChanY = detectors[i]->getTotalNumberOfChannels(Y);
+				prevChanY_gp = detectors[i]->getTotalNumberOfChannelsInclGapPixels(Y);
 				numY += detectors[i]->getTotalNumberOfChannels(Y);
+				numY_gp += detectors[i]->getTotalNumberOfChannelsInclGapPixels(Y);
 				maxY += detectors[i]->getMaxNumberOfChannels(Y);
+				maxY_gp += detectors[i]->getMaxNumberOfChannelsInclGapPixels(Y);
 				++thisMultiDetector->numberOfDetector[Y];
 #ifdef VERBOSE
 				cout<<"incrementing in y direction"<<endl;
@@ -481,21 +507,29 @@ void multiSlsDetector::updateOffsets(){//cannot paralllize due to slsdetector ca
 				if((maxChanX > 0) && ((offsetX + prevChanX + detectors[i]->getTotalNumberOfChannels(X)) > maxChanX))
 					cout<<"\nDetector[" << i << "] exceeds maximum channels allowed for complete detector set in X dimension!" << endl;
 				offsetY = 0;
-				prevChanY = detectors[i]->getTotalNumberOfChannels(Y);;
+				offsetY_gp = 0;
+				prevChanY = detectors[i]->getTotalNumberOfChannels(Y);
+				prevChanY_gp = detectors[i]->getTotalNumberOfChannelsInclGapPixels(Y);
 				numY = 0; //assuming symmetry with this statement. whats on 1st column should be on 2nd column
+				numY_gp = 0;
 				maxY = 0;
+				maxY_gp = 0;
 				offsetX += prevChanX;
+				offsetX_gp += prevChanX_gp;
 				prevChanX = detectors[i]->getTotalNumberOfChannels(X);
+				prevChanX_gp = detectors[i]->getTotalNumberOfChannelsInclGapPixels(X);
 				numX += detectors[i]->getTotalNumberOfChannels(X);
+				numX_gp += detectors[i]->getTotalNumberOfChannelsInclGapPixels(X);
 				maxX += detectors[i]->getMaxNumberOfChannels(X);
+				maxX_gp += detectors[i]->getMaxNumberOfChannelsInclGapPixels(X);
 				++thisMultiDetector->numberOfDetector[X];
 #ifdef VERBOSE
 				cout<<"incrementing in x direction"<<endl;
 #endif
 			}
 
-			thisMultiDetector->offsetX[i] = offsetX;
+			thisMultiDetector->offsetX[i] = offsetX_gp;
-			thisMultiDetector->offsetY[i] = offsetY;
+			thisMultiDetector->offsetY[i] = offsetY_gp;
 #ifdef VERBOSE
 			cout << "Detector[" << i << "] has offsets (" << thisMultiDetector->offsetX[i] << ", " << thisMultiDetector->offsetY[i] << ")" << endl;
 #endif
@@ -504,15 +538,25 @@ void multiSlsDetector::updateOffsets(){//cannot paralllize due to slsdetector ca
 				thisMultiDetector->numberOfChannel[X] = numX;
 			if(numY > thisMultiDetector->numberOfChannel[Y])
 				thisMultiDetector->numberOfChannel[Y] = numY;
+			if(numX_gp > thisMultiDetector->numberOfChannelInclGapPixels[X])
+				thisMultiDetector->numberOfChannelInclGapPixels[X] = numX_gp;
+			if(numY_gp > thisMultiDetector->numberOfChannelInclGapPixels[Y])
+				thisMultiDetector->numberOfChannelInclGapPixels[Y] = numY_gp;
 			if(maxX > thisMultiDetector->maxNumberOfChannel[X])
 				thisMultiDetector->maxNumberOfChannel[X] = maxX;
 			if(maxY > thisMultiDetector->maxNumberOfChannel[Y])
 				thisMultiDetector->maxNumberOfChannel[Y] = maxY;
+			if(maxX_gp > thisMultiDetector->maxNumberOfChannelInclGapPixels[X])
+				thisMultiDetector->maxNumberOfChannelInclGapPixels[X] = maxX_gp;
+			if(maxY_gp > thisMultiDetector->maxNumberOfChannelInclGapPixels[Y])
+				thisMultiDetector->maxNumberOfChannelInclGapPixels[Y] = maxY_gp;
 		}
 	}
 #ifdef VERBOSE
 	cout << "Number of Channels in X direction:" << thisMultiDetector->numberOfChannel[X] << endl;
 	cout << "Number of Channels in Y direction:" << thisMultiDetector->numberOfChannel[Y] << endl << endl;
+	cout << "Number of Channels in X direction with Gap Pixels:" << thisMultiDetector->numberOfChannelInclGapPixels[X] << endl;
+	cout << "Number of Channels in Y direction with Gap Pixels:" << thisMultiDetector->numberOfChannelInclGapPixels[Y] << endl << endl;
 #endif
 }
 
@@ -872,6 +916,7 @@ int multiSlsDetector::removeSlsDetector(int pos) {
     if (detectors[j]) {
 
       thisMultiDetector->dataBytes-=detectors[j]->getDataBytes();
+      thisMultiDetector->dataBytesInclGapPixels-=detectors[j]->getDataBytesInclGapPixels();
       thisMultiDetector->numberOfChannels-=detectors[j]->getTotalNumberOfChannels();
       thisMultiDetector->maxNumberOfChannels-=detectors[j]->getMaxNumberOfChannels();
 
@@ -2107,6 +2152,7 @@ int multiSlsDetector::setDynamicRange(int n, int pos){
 
     if (detectors[i]) {
       thisMultiDetector->dataBytes-=detectors[i]->getDataBytes();
+      thisMultiDetector->dataBytesInclGapPixels-=detectors[i]->getDataBytesInclGapPixels();
       ret=detectors[i]->setDynamicRange(n);
       if(detectors[i]->getErrorMask())
 	setErrorMask(getErrorMask()|(1<<i));
@@ -2115,6 +2161,7 @@ int multiSlsDetector::setDynamicRange(int n, int pos){
       else if (ret!=ret1)
 	ret1=FAIL;
       thisMultiDetector->dataBytes+=detectors[i]->getDataBytes();
+      thisMultiDetector->dataBytesInclGapPixels+=detectors[i]->getDataBytesInclGapPixels();
     }
   }
 
@@ -2162,13 +2209,13 @@ int multiSlsDetector::decodeNChannel(int offsetX, int offsetY, int &channelX, in
 	for(int i=0;i<thisMultiDetector->numberOfDetectors;++i){
 		if (detectors[i]) {
 			//check x offset range
-			if ((offsetX >= thisMultiDetector->offsetX[i]) && (offsetX < (thisMultiDetector->offsetX[i]+detectors[i]->getMaxNumberOfChannels(X)))){
+			if ((offsetX >= thisMultiDetector->offsetX[i]) && (offsetX < (thisMultiDetector->offsetX[i]+detectors[i]->getMaxNumberOfChannelsInclGapPixels(X)))){
 				if(offsetY==-1){
 					channelX = offsetX - thisMultiDetector->offsetX[i];
 					return i;
 				}else{
 					//check y offset range
-					if((offsetY >= thisMultiDetector->offsetY[i]) && (offsetY< (thisMultiDetector->offsetY[i]+detectors[i]->getMaxNumberOfChannels(Y)))){
+					if((offsetY >= thisMultiDetector->offsetY[i]) && (offsetY< (thisMultiDetector->offsetY[i]+detectors[i]->getMaxNumberOfChannelsInclGapPixels(Y)))){
 						channelX = offsetX - thisMultiDetector->offsetX[i];
 						channelY = offsetY - thisMultiDetector->offsetY[i];
 						return i;
@@ -2238,8 +2285,8 @@ int multiSlsDetector::setROI(int n,ROI roiLimits[]){
 				}
 				if(detectors[idet]){
 					//get last channel for each det in x and y dir
-					lastChannelX = (detectors[idet]->getMaxNumberOfChannels(X))-1;
+					lastChannelX = (detectors[idet]->getMaxNumberOfChannelsInclGapPixels(X))-1;
-					lastChannelY = (detectors[idet]->getMaxNumberOfChannels(Y))-1;
+					lastChannelY = (detectors[idet]->getMaxNumberOfChannelsInclGapPixels(Y))-1;
 
 					offsetX = thisMultiDetector->offsetX[idet];
 					offsetY = thisMultiDetector->offsetY[idet];
@@ -4061,6 +4108,7 @@ int multiSlsDetector::setDynamicRange(int p) {
 
   int ret=-100, ret1;
   thisMultiDetector->dataBytes=0;
+  thisMultiDetector->dataBytesInclGapPixels=0;
   thisMultiDetector->numberOfChannels=0;
   
   for (int idet=0; idet<thisMultiDetector->numberOfDetectors; ++idet) {
@@ -4069,8 +4117,10 @@ int multiSlsDetector::setDynamicRange(int p) {
       if(detectors[idet]->getErrorMask())
 	setErrorMask(getErrorMask()|(1<<idet));
       thisMultiDetector->dataBytes+=detectors[idet]->getDataBytes();
+      thisMultiDetector->dataBytesInclGapPixels+=detectors[idet]->getDataBytesInclGapPixels();
       //   cout << "db " << idet << " " << detectors[idet]->getDataBytes() << endl;
       thisMultiDetector->numberOfChannels+=detectors[idet]->getTotalNumberOfChannels();
+
       if (ret==-100)
 	ret=ret1;
       else if (ret!=ret1)
@@ -4123,12 +4173,14 @@ int multiSlsDetector::getMaxMods() {
   //int multiSlsDetector::getTotalNumberOfChannels(dimension d){thisMultiDetector->numberOfChannel[d]=0; for (int id=0; id< thisMultiDetector->numberOfDetectors; ++id) thisMultiDetector->numberOfChannel[d]+=detectors[id]->getTotalNumberOfChannels(d); return thisMultiDetector->numberOfChannel[d];};
   int multiSlsDetector::getTotalNumberOfChannels(dimension d){return thisMultiDetector->numberOfChannel[d];};
 
+  int multiSlsDetector::getTotalNumberOfChannelsInclGapPixels(dimension d){return thisMultiDetector->numberOfChannelInclGapPixels[d];}
+
   int multiSlsDetector::getMaxNumberOfChannels(){thisMultiDetector->maxNumberOfChannels=0; for (int id=0; id< thisMultiDetector->numberOfDetectors; ++id) thisMultiDetector->maxNumberOfChannels+=detectors[id]->getMaxNumberOfChannels();return thisMultiDetector->maxNumberOfChannels;};
 
  // int multiSlsDetector::getMaxNumberOfChannels(dimension d){thisMultiDetector->maxNumberOfChannel[d]=0; for (int id=0; id< thisMultiDetector->numberOfDetectors; ++id) thisMultiDetector->maxNumberOfChannel[d]+=detectors[id]->getMaxNumberOfChannels(d);return thisMultiDetector->maxNumberOfChannel[d];};
   int multiSlsDetector::getMaxNumberOfChannels(dimension d){return thisMultiDetector->maxNumberOfChannel[d];};
 
-
+  int multiSlsDetector::getMaxNumberOfChannelsInclGapPixels(dimension d){return thisMultiDetector->maxNumberOfChannelInclGapPixels[d];};
 
 
 
@@ -4189,6 +4241,7 @@ int multiSlsDetector::setNumberOfModules(int p, dimension d) {
   int nm, mm, nt=p;
 
   thisMultiDetector->dataBytes=0;
+  thisMultiDetector->dataBytesInclGapPixels=0;
   thisMultiDetector->numberOfChannels=0;
 
   for (int idet=0; idet<thisMultiDetector->numberOfDetectors; ++idet) {
@@ -4212,6 +4265,7 @@ int multiSlsDetector::setNumberOfModules(int p, dimension d) {
       if(detectors[idet]->getErrorMask())
 	setErrorMask(getErrorMask()|(1<<idet));
       thisMultiDetector->dataBytes+=detectors[idet]->getDataBytes();
+      thisMultiDetector->dataBytesInclGapPixels+=detectors[idet]->getDataBytesInclGapPixels();
       thisMultiDetector->numberOfChannels+=detectors[idet]->getTotalNumberOfChannels();
     }
   }
@@ -4254,7 +4308,15 @@ int multiSlsDetector::enableGapPixels(int val) {
 				ret=-1;
 		}
 
-/** do something */
+	// update data bytes incl gap pixels
+    thisMultiDetector->dataBytesInclGapPixels=0;
+	for (int i = 0; i < thisMultiDetector->numberOfDetectors; ++i) {
+		if (detectors[i])
+			thisMultiDetector->dataBytesInclGapPixels += detectors[i]->getDataBytesInclGapPixels();
+	}
+
+	// update offsets and number of channels incl gap pixels in multi level
+	updateOffsets();
 
 	return ret;
 }
@@ -5729,8 +5791,8 @@ int multiSlsDetector::getData(const int isocket, char* image, const int size,
 void multiSlsDetector::readFrameFromReceiver(){
 
 	//determine number of half readouts and maxX and maxY
-	int maxX=thisMultiDetector->numberOfChannel[X];
+	int maxX=thisMultiDetector->numberOfChannelInclGapPixels[X];
-	int maxY=thisMultiDetector->numberOfChannel[Y];
+	int maxY=thisMultiDetector->numberOfChannelInclGapPixels[Y];
 	int numSockets = thisMultiDetector->numberOfDetectors;
 	int numSocketsPerSLSDetector = 1;
 	bool jungfrau = false;
@@ -5759,11 +5821,11 @@ void multiSlsDetector::readFrameFromReceiver(){
 	int slsdatabytes = 0, slsmaxchannels = 0, slsmaxX = 0, slsmaxY=0;
 	double bytesperchannel = 0;
 	if(detectors[0]){
-		slsdatabytes = detectors[0]->getDataBytes();
+		slsdatabytes = detectors[0]->getDataBytesInclGapPixels();
-		slsmaxchannels = detectors[0]->getMaxNumberOfChannels();
+		slsmaxchannels = (detectors[0]->getMaxNumberOfChannelsInclGapPixels(X)*detectors[0]->getMaxNumberOfChannelsInclGapPixels(Y));
 		bytesperchannel = (double)slsdatabytes/(double)slsmaxchannels;
-		slsmaxX = detectors[0]->getTotalNumberOfChannels(X);
+		slsmaxX = detectors[0]->getTotalNumberOfChannelsInclGapPixels(X);
-		slsmaxY = detectors[0]->getTotalNumberOfChannels(Y);
+		slsmaxY = detectors[0]->getTotalNumberOfChannelsInclGapPixels(Y);
 	}
 
 	//getting multi values
@@ -5785,10 +5847,10 @@ void multiSlsDetector::readFrameFromReceiver(){
 
 	int expectedslssize = slsdatabytes/numSocketsPerSLSDetector;
 	char* image = new char[expectedslssize]();
-	char* multiframe = new char[thisMultiDetector->dataBytes]();
+	char* multiframe = new char[thisMultiDetector->dataBytesInclGapPixels]();
 	char* multiframegain = NULL;
 	if (jungfrau)
-		multiframegain = new char[thisMultiDetector->dataBytes]();
+		multiframegain = new char[thisMultiDetector->dataBytesInclGapPixels]();
 
 	int nch;
 
@@ -5871,7 +5933,7 @@ void multiSlsDetector::readFrameFromReceiver(){
 		//send data to callback
 		if(running){
 			if(dataReady) {
-				thisData = new detectorData(NULL,NULL,NULL,getCurrentProgress(),currentFileName.c_str(),maxX,maxY,multiframe, thisMultiDetector->dataBytes);
+				thisData = new detectorData(NULL,NULL,NULL,getCurrentProgress(),currentFileName.c_str(),maxX,maxY,multiframe, thisMultiDetector->dataBytesInclGapPixels);
 				dataReady(thisData, currentFrameIndex, currentSubFrameIndex, pCallbackArg);
 				delete thisData;
 				//cout<<"Send frame #"<< currentFrameIndex << " to gui"<<endl;

slsDetectorSoftware/multiSlsDetector/multiSlsDetector.h

@@ -87,6 +87,9 @@ class multiSlsDetector  : public slsDetectorUtils {
       
     /**  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;
@@ -94,12 +97,18 @@ class multiSlsDetector  : public slsDetectorUtils {
     /**  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];
 
@@ -363,10 +372,14 @@ class multiSlsDetector  : public slsDetectorUtils {
 
   int getTotalNumberOfChannels(dimension d);
 
+  int getTotalNumberOfChannelsInclGapPixels(dimension d);
+
   int getMaxNumberOfChannels();
 
   int getMaxNumberOfChannels(dimension d);
 
+  int getMaxNumberOfChannelsInclGapPixels(dimension d);
+
   int getMaxNumberOfChannelsPerDetector(dimension d){return thisMultiDetector->maxNumberOfChannelsPerDetector[d];};
 
   /** returns the enable if data will be flipped across x or y axis

slsDetectorSoftware/slsDetector/slsDetector.cpp

@@ -571,6 +571,9 @@ int slsDetector::initializeDetectorSize(detectorType type) {
 
     /** set thisDetector->myDetectorType to type and according to this set nChans, nChips, nDacs, nAdcs, nModMax, dynamicRange, nMod*/
     thisDetector->myDetectorType=type;
+    thisDetector->gappixels = 0;
+    thisDetector->nGappixels[X]=0;
+    thisDetector->nGappixels[Y]=0;
     switch(thisDetector->myDetectorType) {
     case MYTHEN:
       thisDetector->nChan[X]=128;
@@ -679,6 +682,8 @@ int slsDetector::initializeDetectorSize(detectorType type) {
       thisDetector->nModMax[X]=1;
       thisDetector->nModMax[Y]=1;
       thisDetector->dynamicRange=16;
+      thisDetector->nGappixels[X]=6;
+      thisDetector->nGappixels[Y]=1;
       break;
     default:
       thisDetector->nChan[X]=0;
@@ -708,14 +713,17 @@ int slsDetector::initializeDetectorSize(detectorType type) {
     thisDetector->timerValue[SAMPLES_JCTB]=1;
 
     thisDetector->dataBytes=thisDetector->nMod[X]*thisDetector->nMod[Y]*thisDetector->nChips*thisDetector->nChans*thisDetector->dynamicRange/8;
+    thisDetector->dataBytesInclGapPixels = getTotalNumberOfChannelsInclGapPixels(X)*getTotalNumberOfChannelsInclGapPixels(Y) * thisDetector->dynamicRange/8;
 
     if(thisDetector->myDetectorType==JUNGFRAUCTB) {
       getTotalNumberOfChannels();
       //      thisDetector->dataBytes=getTotalNumberOfChannels()*thisDetector->dynamicRange/8*thisDetector->timerValue[SAMPLES_JCTB];
     }
     if(thisDetector->myDetectorType==MYTHEN){
-    	if (thisDetector->dynamicRange==24 || thisDetector->timerValue[PROBES_NUMBER]>0)
+    	if (thisDetector->dynamicRange==24 || thisDetector->timerValue[PROBES_NUMBER]>0) {
     		thisDetector->dataBytes=thisDetector->nMod[X]*thisDetector->nMod[Y]*thisDetector->nChips*thisDetector->nChans*4;
+    		thisDetector->dataBytesInclGapPixels = getTotalNumberOfChannelsInclGapPixels(X)*getTotalNumberOfChannelsInclGapPixels(Y) * thisDetector->nChans*4;
+    	}
     }
 
     /** set trimDsdir, calDir to default to home directory*/
@@ -1739,10 +1747,11 @@ int slsDetector::getTotalNumberOfChannels() {
     thisDetector->nChans=thisDetector->nChan[X];
     thisDetector->dataBytes=thisDetector->nChans*thisDetector->nChips*thisDetector->nMods*2*thisDetector->timerValue[SAMPLES_JCTB];
    // cout << "Total number of channels is "<< thisDetector->nChans*thisDetector->nChips*thisDetector->nMods << " data bytes is " << thisDetector->dataBytes << endl;
+    thisDetector->dataBytesInclGapPixels = getTotalNumberOfChannelsInclGapPixels(X)*getTotalNumberOfChannelsInclGapPixels(Y) *2*thisDetector->timerValue[SAMPLES_JCTB];
   } else {
 #ifdef VERBOSE
     cout << "det type is "<< thisDetector->myDetectorType << endl;
-  cout << "Total number of channels is "<< thisDetector->nChans*thisDetector->nChips*thisDetector->nMods << " data bytes is " << thisDetector->dataBytes << endl;
+  cout << "Total number of channels is "<< thisDetector->nChans*thisDetector->nChips*thisDetector->nMods << " data bytes is " << thisDetector->dataBytes << endl; // excluding gap pixels
 #endif
   ;
   }
@@ -1754,6 +1763,10 @@ int slsDetector::getTotalNumberOfChannels(dimension d) {
   return thisDetector->nChan[d]*thisDetector->nChip[d]*thisDetector->nMod[d];
 };
 
+int slsDetector::getTotalNumberOfChannelsInclGapPixels(dimension d) {
+	getTotalNumberOfChannels();
+	return (thisDetector->nChan[d]*thisDetector->nChip[d]*thisDetector->nMod[d]) + (thisDetector->gappixels * thisDetector->nGappixels[d]);
+}
 
 
 int slsDetector::getMaxNumberOfChannels(){
@@ -1769,6 +1782,14 @@ int slsDetector::getMaxNumberOfChannels(dimension d){
   return thisDetector->nChan[d]*thisDetector->nChip[d]*thisDetector->nModMax[d];
 };
 
+int slsDetector::getMaxNumberOfChannelsInclGapPixels(dimension d) {
+	if(thisDetector->myDetectorType==JUNGFRAUCTB) {
+		if (d==X) return 36*thisDetector->nChip[d]*thisDetector->nModMax[d];
+		else return 1*thisDetector->nChip[d]*thisDetector->nModMax[d];
+	}
+	return (thisDetector->nChan[d]*thisDetector->nChip[d]*thisDetector->nModMax[d]) + (thisDetector->gappixels * thisDetector->nGappixels[d]);
+}
+
 /* needed to set/get the size of the detector */
 // if n=GET_FLAG returns the number of installed modules,
 int slsDetector::setNumberOfModules(int n, dimension d){
@@ -1849,10 +1870,13 @@ int slsDetector::setNumberOfModules(int n, dimension d){
       dr=32;
 
     thisDetector->dataBytes=thisDetector->nMod[X]*thisDetector->nMod[Y]*thisDetector->nChips*thisDetector->nChans*dr/8;
+    thisDetector->dataBytesInclGapPixels = getTotalNumberOfChannelsInclGapPixels(X)*getTotalNumberOfChannelsInclGapPixels(Y) *dr/8;
 
     if(thisDetector->myDetectorType==MYTHEN){
-      if (thisDetector->timerValue[PROBES_NUMBER]!=0)
+      if (thisDetector->timerValue[PROBES_NUMBER]!=0) {
 	thisDetector->dataBytes=thisDetector->nMod[X]*thisDetector->nMod[Y]*thisDetector->nChips*thisDetector->nChans*4;
+	thisDetector->dataBytesInclGapPixels = getTotalNumberOfChannelsInclGapPixels(X)*getTotalNumberOfChannelsInclGapPixels(Y) *4;
+      }
     }
 
     if(thisDetector->myDetectorType==JUNGFRAUCTB){
@@ -1861,6 +1885,7 @@ int slsDetector::setNumberOfModules(int n, dimension d){
 
     }
 
+
 #ifdef VERBOSE
     std::cout<< "Data size is " << thisDetector->dataBytes << std::endl;
     std::cout<< "nModX " << thisDetector->nMod[X] << " nModY " << thisDetector->nMod[Y] << " nChips " << thisDetector->nChips << " nChans " << thisDetector->nChans<< " dr " << dr << std::endl;
@@ -1985,8 +2010,45 @@ int slsDetector::enableGapPixels(int val) {
 	if(thisDetector->myDetectorType!= EIGER)
 		return -1;
 
+	if (val >= 0) {
+		val=(val>0)?1:0;
 
-	return 0;
+		// send to receiver
+		int retval=-1;
+		int fnum=F_ENABLE_GAPPIXELS_IN_RECEIVER;
+		int ret=FAIL;
+		int arg=val;
+		if (thisDetector->receiverOnlineFlag==ONLINE_FLAG) {
+			if (connectData() == OK){
+				ret=thisReceiver->sendInt(fnum,retval,arg);
+				disconnectData();
+			}
+			if((arg != retval) || (ret==FAIL)){
+				ret = FAIL;
+				setErrorMask((getErrorMask())|(RECEIVER_ENABLE_GAPPIXELS_NOT_SET));
+			}
+
+			if(ret==FORCE_UPDATE)
+				updateReceiver();
+		}
+
+		// update client
+		if (ret == OK) {
+			thisDetector->gappixels = val;
+			thisDetector->dataBytesInclGapPixels = getTotalNumberOfChannelsInclGapPixels(X)*getTotalNumberOfChannelsInclGapPixels(Y) * (thisDetector->dynamicRange/8);
+
+			// set data bytes for other detector ( for future use)
+			if(thisDetector->myDetectorType==JUNGFRAUCTB)
+				getTotalNumberOfChannels();
+			if(thisDetector->myDetectorType==MYTHEN){
+				if (thisDetector->dynamicRange==24 || thisDetector->timerValue[PROBES_NUMBER]>0) {
+					thisDetector->dataBytesInclGapPixels = getTotalNumberOfChannelsInclGapPixels(X)*getTotalNumberOfChannelsInclGapPixels(Y) * thisDetector->nChans*4;
+				}
+			}
+		}
+	}
+
+	return thisDetector->gappixels;
 }
 
 
@@ -5067,6 +5129,7 @@ int slsDetector::setDynamicRange(int n){
 
 
     thisDetector->dataBytes=thisDetector->nMod[X]*thisDetector->nMod[Y]*thisDetector->nChips*thisDetector->nChans*retval/8;
+    thisDetector->dataBytesInclGapPixels = getTotalNumberOfChannelsInclGapPixels(X)*getTotalNumberOfChannelsInclGapPixels(Y)*retval/8;
 
     if (thisDetector->myDetectorType==JUNGFRAUCTB) {
       // thisDetector->nChip[X]=retval/16;
@@ -5077,14 +5140,15 @@ int slsDetector::setDynamicRange(int n){
       //cout << "data bytes: "<< thisDetector->dataBytes << endl;
     } 
     if(thisDetector->myDetectorType==MYTHEN){
-      if (thisDetector->timerValue[PROBES_NUMBER]!=0)
+      if (thisDetector->timerValue[PROBES_NUMBER]!=0) {
 	thisDetector->dataBytes=thisDetector->nMod[X]*thisDetector->nMod[Y]*thisDetector->nChips*thisDetector->nChans*4;
+	thisDetector->dataBytesInclGapPixels = getTotalNumberOfChannelsInclGapPixels(X)*getTotalNumberOfChannelsInclGapPixels(Y)*4;
+      }
       
       if (retval==32)
 	thisDetector->dynamicRange=24;
     }
 
-
     thisDetector->dynamicRange=retval;
 
 
@@ -6078,6 +6142,7 @@ string slsDetector::setReceiver(string receiverIP){
 		std::cout << "10GbE:" << thisDetector->tenGigaEnable << endl << endl;
 		std::cout << "streaming port:" << thisDetector->zmqport << endl;
 		std::cout << "streaming source ip:" << thisDetector->zmqsrcip << endl;
+		std::cout << "enable gap pixels:" << thisDetector->gappixels << endl;
 		//std::cout << "dataStreaming:" << enableDataStreamingFromReceiver(-1) << endl << endl;
 /** enable compresison, */
 #endif
@@ -6116,6 +6181,8 @@ string slsDetector::setReceiver(string receiverIP){
 			if(thisDetector->myDetectorType == EIGER)
 				enableTenGigabitEthernet(thisDetector->tenGigaEnable);
 
+			enableGapPixels(enableGapPixels(-1));
+
 			// data streaming
 			setReceiverStreamingPort(getReceiverStreamingPort());
 			setReceiverStreamingSourceIP(getReceiverStreamingSourceIP());
@@ -8316,6 +8383,10 @@ int slsDetector::updateReceiverNoWait() {
   n += 	dataSocket->ReceiveDataOnly(path,MAX_STR_LENGTH);
   strcpy(thisDetector->zmqsrcip, path);
 
+  // gap pixels
+  n += dataSocket->ReceiveDataOnly(&ind,sizeof(ind));
+  thisDetector->gappixels = ind;
+
   if (!n) printf("n: %d\n", n);
 
   return OK;

slsDetectorSoftware/slsDetector/slsDetector.h

@@ -274,6 +274,13 @@ class slsDetector : public slsDetectorUtils, public energyConversion {
     /**  zmq tcp src ip address between receiver and gui (only data) **/
     char zmqsrcip[MAX_STR_LENGTH];
 
+    /** gap pixels enable */
+    int gappixels;
+    /** gap pixels in each direction */
+    int nGappixels[2];
+    /** data bytes including gap pixels */
+    int dataBytesInclGapPixels;
+
   } sharedSlsDetector;
 
 
@@ -678,10 +685,14 @@ class slsDetector : public slsDetectorUtils, public energyConversion {
  int getTotalNumberOfChannels(dimension d);
  //{return thisDetector->nChan[d]*thisDetector->nChip[d]*thisDetector->nMod[d];};
 
+ int getTotalNumberOfChannelsInclGapPixels(dimension d);
+
  int getMaxNumberOfChannels();//{return thisDetector->nChans*thisDetector->nChips*thisDetector->nModsMax;};
 
  int getMaxNumberOfChannels(dimension d);//{return thisDetector->nChan[d]*thisDetector->nChip[d]*thisDetector->nModMax[d];};
 
+ int getMaxNumberOfChannelsInclGapPixels(dimension d);
+
   /** 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
@@ -1201,6 +1212,12 @@ class slsDetector : public slsDetectorUtils, public energyConversion {
       \sa sharedSlsDetector
   */
   int getDataBytes(){return thisDetector->dataBytes;};
+
+  /**
+   * returns number of bytes sent by detector including gap pixels
+   * \sa sharedSlsDetector
+   */
+  int getDataBytesInclGapPixels(){return thisDetector->dataBytesInclGapPixels;};
  
 
   /**