mirror of
https://github.com/slsdetectorgroup/slsDetectorPackage.git
synced 2025-04-26 08:10:02 +02:00
changes upto the receiver, not incl gui
This commit is contained in:
Dhanya Maliakal
parent
afc08f8c30
commit
bb817733ff
@ -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
|
||||
|
||||
|
||||
|
||||
@ -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;
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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;
|
||||
|
||||
@ -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
|
||||
@ -1202,6 +1213,12 @@ class slsDetector : public slsDetectorUtils, public energyConversion {
|
||||
*/
|
||||
int getDataBytes(){return thisDetector->dataBytes;};
|
||||
|
||||
/**
|
||||
* returns number of bytes sent by detector including gap pixels
|
||||
* \sa sharedSlsDetector
|
||||
*/
|
||||
int getDataBytesInclGapPixels(){return thisDetector->dataBytesInclGapPixels;};
|
||||
|
||||
|
||||
/**
|
||||
set roi
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user