detectors/slsDetectorPackage
25
0
Fork 0
mirror of https://github.com/slsdetectorgroup/slsDetectorPackage.git synced 2025-04-26 00:00:02 +02:00
Code Issues Actions Packages Releases Activity

changes upto the receiver, not incl gui

Browse Source
This commit is contained in:
Dhanya Maliakal 2017-10-03 10:44:05 +02:00
parent afc08f8c30
commit bb817733ff
5 changed files with 191 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
slsDetectorSoftware/commonFiles/error_defs.h
View File

@ -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

98
slsDetectorSoftware/multiSlsDetector/multiSlsDetector.cpp
View File

@ -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->offsetY[i] = offsetY;
thisMultiDetector->offsetX[i] = offsetX_gp;
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;
lastChannelY = (detectors[idet]->getMaxNumberOfChannels(Y))-1;
lastChannelX = (detectors[idet]->getMaxNumberOfChannelsInclGapPixels(X))-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 maxY=thisMultiDetector->numberOfChannel[Y];
int maxX=thisMultiDetector->numberOfChannelInclGapPixels[X];
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();
slsmaxchannels = detectors[0]->getMaxNumberOfChannels();
slsdatabytes = detectors[0]->getDataBytesInclGapPixels();
slsmaxchannels = (detectors[0]->getMaxNumberOfChannelsInclGapPixels(X)*detectors[0]->getMaxNumberOfChannelsInclGapPixels(Y));
bytesperchannel = (double)slsdatabytes/(double)slsmaxchannels;
slsmaxX = detectors[0]->getTotalNumberOfChannels(X);
slsmaxY = detectors[0]->getTotalNumberOfChannels(Y);
slsmaxX = detectors[0]->getTotalNumberOfChannelsInclGapPixels(X);
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;

13
slsDetectorSoftware/multiSlsDetector/multiSlsDetector.h
View File

@ -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

83
slsDetectorSoftware/slsDetector/slsDetector.cpp
View File

@ -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;

17
slsDetectorSoftware/slsDetector/slsDetector.h
View File

@ -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;};
/**