mirror of
https://github.com/slsdetectorgroup/slsDetectorPackage.git
synced 2025-04-22 22:40:02 +02:00
Merge branch 'master' of gitorious.psi.ch:sls_det_software/sls_detector_software
This commit is contained in:
commit
11de59d87c
@ -18,7 +18,6 @@ using namespace std;
|
||||
|
||||
|
||||
/** Error flags */
|
||||
#define NUM_ERROR_FLAGS 32
|
||||
#define CRITICAL_ERROR_MASK 0xFFFFFFFF
|
||||
|
||||
#define CANNOT_CONNECT_TO_DETECTOR 0x8000000000000000ULL
|
||||
@ -50,6 +49,8 @@ using namespace std;
|
||||
#define RECEIVER_DYNAMIC_RANGE 0x0000000000000800ULL
|
||||
#define RECEIVER_TEN_GIGA 0x0000000000001000ULL
|
||||
#define ALLTIMBITS_NOT_SET 0x0000000000002000ULL
|
||||
#define COULD_NOT_SET_SPEED_PARAMETERS 0x0000000000004000ULL
|
||||
#define COULD_NOT_SET_READOUT_FLAGS 0x0000000000008000ULL
|
||||
|
||||
// 0x00000000FFFFFFFFULL
|
||||
/** @short class returning all error messages for error mask */
|
||||
@ -150,7 +151,11 @@ public:
|
||||
if(slsErrorMask&ALLTIMBITS_NOT_SET)
|
||||
retval.append("Could not set all trimbits to value.\n");
|
||||
|
||||
if(slsErrorMask&COULD_NOT_SET_SPEED_PARAMETERS)
|
||||
retval.append("Could not set the speed parameter value\n");
|
||||
|
||||
if(slsErrorMask&COULD_NOT_SET_READOUT_FLAGS)
|
||||
retval.append("Could not set the readout flag\n");
|
||||
|
||||
return retval;
|
||||
|
||||
|
||||
@ -140,6 +140,7 @@ typedef struct {
|
||||
double offset; /**< is the module offset (V) */
|
||||
} sls_detector_module;
|
||||
|
||||
|
||||
/**
|
||||
@short structure for a region of interest
|
||||
|
||||
|
||||
@ -43,8 +43,6 @@ unsigned int Feb_Control_triggerMode; //internal timer, external start,
|
||||
unsigned int Feb_Control_externalEnableMode; //external enabling engaged and it's polarity
|
||||
unsigned int Feb_Control_subFrameMode;
|
||||
|
||||
unsigned int Feb_Control_photon_energy_eV;
|
||||
|
||||
unsigned int Feb_Control_nimages;
|
||||
double Feb_Control_exposure_time_in_sec;
|
||||
int Feb_Control_subframe_exposure_time_in_10nsec;
|
||||
@ -450,7 +448,7 @@ int Feb_Control_AddModule1(unsigned int module_number, int top_enable, unsigned
|
||||
return parameters_ok;
|
||||
}
|
||||
|
||||
|
||||
/* not called anywhere**/
|
||||
int Feb_Control_ReadSetUpFile(unsigned int module_num, char* file_name){
|
||||
printf("Reading Setup file for module number:%d\n",module_num);
|
||||
char line[100];
|
||||
@ -486,14 +484,14 @@ int Feb_Control_ReadSetUpFile(unsigned int module_num, char* file_name){
|
||||
}
|
||||
Feb_Control_SetHighVoltage(f0);
|
||||
}
|
||||
|
||||
/*
|
||||
else if(!strcmp("photon_energy",str)){
|
||||
if(sscanf (line,"%s %f", str,&f0) < 2){
|
||||
printf("Error reading photon_energy\n");
|
||||
exit(0);
|
||||
}
|
||||
Feb_Control_SetPhotonEnergy(f0);
|
||||
}
|
||||
}*/
|
||||
|
||||
else if(!strcmp("dynamic_range",str)){
|
||||
if(sscanf (line,"%s %d", str,&i0) < 2){
|
||||
@ -591,32 +589,6 @@ unsigned int Feb_Control_GetNHalfModules(){
|
||||
return n_half_modules;
|
||||
}
|
||||
|
||||
int Feb_Control_SetPhotonEnergy(unsigned int full_energy_eV){
|
||||
/**
|
||||
|
||||
setDAC(VCMP_LL,val,imod,mV,retval);
|
||||
setDAC(VCMP_LR,val,imod,mV,retval);
|
||||
setDAC(VCMP_RL,val,imod,mV,retval);
|
||||
ind = VCMP_RR;
|
||||
*/
|
||||
Feb_Control_photon_energy_eV = full_energy_eV;
|
||||
printf("Setting photon energy to: %d eV\n",Feb_Control_photon_energy_eV);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
unsigned int Feb_Control_GetPhotonEnergy(){
|
||||
|
||||
/**
|
||||
|
||||
setDAC(VCMP_LL,val,imod,mV,retval);
|
||||
setDAC(VCMP_LR,val,imod,mV,retval);
|
||||
setDAC(VCMP_RL,val,imod,mV,retval);
|
||||
ind = VCMP_RR;
|
||||
*/
|
||||
return Feb_Control_photon_energy_eV;
|
||||
|
||||
}
|
||||
|
||||
int Feb_Control_SetIDelays(unsigned int module_num, unsigned int ndelay_units){
|
||||
return Feb_Control_SetIDelays1(module_num,0,ndelay_units)&&Feb_Control_SetIDelays1(module_num,1,ndelay_units)&&Feb_Control_SetIDelays1(module_num,2,ndelay_units)&&Feb_Control_SetIDelays1(module_num,3,ndelay_units);
|
||||
|
||||
@ -121,8 +121,6 @@ int Feb_Control_GetModuleNumber();
|
||||
int Feb_Control_SetHighVoltage(float value);
|
||||
int Feb_Control_SetHighVoltage1(unsigned int module_num,float value);
|
||||
|
||||
int Feb_Control_SetPhotonEnergy(unsigned int full_energy_eV);
|
||||
unsigned int Feb_Control_GetPhotonEnergy();
|
||||
|
||||
int Feb_Control_SetIDelays(unsigned int module_num, unsigned int ndelay_units);
|
||||
int Feb_Control_SetIDelays1(unsigned int module_num, unsigned int chip_pos, unsigned int ndelay_units);
|
||||
|
||||
Binary file not shown.
@ -26,7 +26,8 @@ int *detectorChips=NULL;
|
||||
int *detectorChans=NULL;
|
||||
dacs_t *detectorDacs=NULL;
|
||||
dacs_t *detectorAdcs=NULL;
|
||||
|
||||
int* detectorGain = NULL;
|
||||
int* detectorOffset = NULL;
|
||||
|
||||
int eiger_highvoltage = 0;
|
||||
int eiger_iodelay = 0;
|
||||
@ -53,6 +54,8 @@ int dst_requested[32] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
|
||||
//char Module_dac_names[16][10]= {"SvP","Vtr","Vrf","Vrs","SvN","Vtgstv","Vcmp_ll","Vcmp_lr","cal","Vcmp_rl","rxb_rb","rxb_lb","Vcmp_rr","Vcp","Vcn","Vis"};;
|
||||
|
||||
int default_dac_values[16] = {0,2480,3300,1400,4000,2556,1000,1000,4000,1000,1000,1000,1000,200,2000,1550};
|
||||
int default_gain_values[3] = {-314800,-314800,-314800};
|
||||
int default_offset_values[3] = {3714000,3714000,3714000};
|
||||
|
||||
|
||||
enum masterFlags masterMode=IS_SLAVE;
|
||||
@ -80,12 +83,16 @@ int initDetector(){
|
||||
detectorChans=malloc(n*NCHIP*NCHAN*sizeof(int));
|
||||
detectorDacs=malloc(n*NDAC*sizeof(dacs_t));
|
||||
detectorAdcs=malloc(n*NADC*sizeof(dacs_t));
|
||||
detectorGain=malloc(n*NGAIN*sizeof(int));
|
||||
detectorOffset=malloc(n*NOFFSET*sizeof(int));
|
||||
#ifdef VERBOSE
|
||||
printf("modules from 0x%x to 0x%x\n",detectorModules, detectorModules+n);
|
||||
printf("chips from 0x%x to 0x%x\n",detectorChips, detectorChips+n*NCHIP);
|
||||
printf("chans from 0x%x to 0x%x\n",detectorChans, detectorChans+n*NCHIP*NCHAN);
|
||||
printf("dacs from 0x%x to 0x%x\n",detectorDacs, detectorDacs+n*NDAC);
|
||||
printf("adcs from 0x%x to 0x%x\n",detectorAdcs, detectorAdcs+n*NADC);
|
||||
printf("gains from 0x%x to 0x%x\n",detectorGain, detectorGain+n*NGAIN);
|
||||
printf("offsets from 0x%x to 0x%x\n",detectorOffset, detectorOffset+n*NOFFSET);
|
||||
#endif
|
||||
for (imod=0; imod<n; imod++) {
|
||||
(detectorModules+imod)->dacs=detectorDacs+imod*NDAC;
|
||||
@ -102,6 +109,10 @@ int initDetector(){
|
||||
(detectorModules+imod)->reg=0;
|
||||
/* initialize registers, dacs, retrieve sn, adc values etc */
|
||||
}
|
||||
for(i=0;i<NGAIN;i++)
|
||||
detectorGain[i] = default_gain_values[(int)STANDARD];
|
||||
for(i=0;i<NOFFSET;i++)
|
||||
detectorOffset[i] = default_offset_values[(int)STANDARD];
|
||||
thisSettings = STANDARD;/**UNITIALIZED*/
|
||||
/*sChan=noneSelected;
|
||||
sChip=noneSelected;
|
||||
@ -124,14 +135,13 @@ int initDetector(){
|
||||
for(i=0;i<(detectorModules)->ndac;i++)
|
||||
setDAC((enum detDacIndex)i,default_dac_values[i],(detectorModules)->module,0,retval);
|
||||
|
||||
|
||||
//setting default measurement parameters
|
||||
setTimer(FRAME_NUMBER,1);
|
||||
setTimer(ACQUISITION_TIME,1E9);
|
||||
setTimer(SUBFRAME_ACQUISITION_TIME,DEFAULT_SUBFRAME_EXPOSURE_VAL);
|
||||
setTimer(FRAME_PERIOD,1E9);
|
||||
setDynamicRange(16);
|
||||
setThresholdEnergy(8000,0);
|
||||
eiger_photonenergy = -1;
|
||||
setReadOutFlags(NONPARALLEL);
|
||||
setSpeed(0,1);//clk_devider,half speed
|
||||
setHighVolage(0,0);
|
||||
@ -376,23 +386,30 @@ int enableTenGigabitEthernet(int val){
|
||||
}
|
||||
|
||||
|
||||
int setModule(sls_detector_module myMod){
|
||||
int setModule(sls_detector_module myMod, int* gain, int* offset){
|
||||
int retval[2];
|
||||
int i;
|
||||
|
||||
//#ifdef VERBOSE
|
||||
printf("Setting module with settings %d\n",myMod.reg);
|
||||
//#endif
|
||||
int i;
|
||||
for(i=0;i<myMod.ndac;i++)
|
||||
setDAC((enum detDacIndex)i,myMod.dacs[i],myMod.module,0,retval);
|
||||
|
||||
//set the settings variable
|
||||
setSettings( (enum detectorSettings)myMod.reg,-1);
|
||||
|
||||
// thisSettings = (enum detectorSettings)myMod.reg;
|
||||
// thisSettings = 0;
|
||||
//set the gains and offset variables locally
|
||||
for(i=0;i<NGAIN;i++)
|
||||
detectorGain[i] = gain[i];
|
||||
for(i=0;i<NOFFSET;i++)
|
||||
detectorOffset[i] = offset[i];
|
||||
|
||||
//copy module locally
|
||||
if (detectorModules)
|
||||
copyModule(detectorModules,&myMod);
|
||||
|
||||
setSettings( (enum detectorSettings)myMod.reg,-1); // put the settings in the module register?!?!?
|
||||
//set dac values
|
||||
for(i=0;i<myMod.ndac;i++)
|
||||
setDAC((enum detDacIndex)i,myMod.dacs[i],myMod.module,0,retval);
|
||||
|
||||
//includ gap pixels
|
||||
unsigned int tt[263680];
|
||||
@ -409,23 +426,31 @@ int setModule(sls_detector_module myMod){
|
||||
}
|
||||
}
|
||||
|
||||
//set trimbits
|
||||
if(!Feb_Control_SetTrimbits(Feb_Control_GetModuleNumber(),tt)){
|
||||
cprintf(BG_RED,"Could not set trimbits\n");
|
||||
return FAIL;
|
||||
}
|
||||
|
||||
Feb_Control_SetTrimbits(Feb_Control_GetModuleNumber(),tt);
|
||||
|
||||
// use gain and offset!!!
|
||||
|
||||
//printf("set gainval[0]:%d\n",detectorGain[0]);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int getModule(sls_detector_module *myMod){
|
||||
int getModule(sls_detector_module *myMod, int* gain, int* offset){
|
||||
int i;
|
||||
int retval[2];
|
||||
//printf("get gainval[0]:%d\n",detectorGain[0]);
|
||||
|
||||
//dacs
|
||||
for(i=0;i<NDAC;i++)
|
||||
setDAC((enum detDacIndex)i,-1,-1,0,retval);
|
||||
|
||||
//gains, offsets
|
||||
for(i=0;i<NGAIN;i++)
|
||||
gain[i] = detectorGain[i];
|
||||
for(i=0;i<NOFFSET;i++)
|
||||
offset[i] = detectorOffset[i];
|
||||
|
||||
//trimbits
|
||||
unsigned int* tt;
|
||||
@ -464,10 +489,23 @@ int getThresholdEnergy(int imod){
|
||||
}
|
||||
|
||||
|
||||
int setThresholdEnergy(int thr, int imod){
|
||||
printf(" Setting threshold energy:%d\n",thr);
|
||||
if(Feb_Control_SetPhotonEnergy(thr))
|
||||
eiger_photonenergy = thr;
|
||||
int setThresholdEnergy(int ev, int imod){
|
||||
printf(" Setting threshold energy:%d\n",ev);
|
||||
int retval[2],i;
|
||||
int thrvalue[NGAIN];
|
||||
|
||||
if(ev >= 0){
|
||||
eiger_photonenergy = ev;
|
||||
//calculate thrvalues for dacs
|
||||
for(i=0;i<NGAIN;i++)
|
||||
thrvalue[i] = (int) ((((double)detectorGain[i]/1000) * ((double)ev/1000)) + ((double)detectorOffset[i]/1000));
|
||||
|
||||
//setdacs
|
||||
setDAC(VCMP_LL,thrvalue[0],-1,0,retval);if(retval[0] != thrvalue[0]) cprintf(BG_RED,"Failed to set vcmp_ll to %d, got %d\n",retval[0],thrvalue[0]);
|
||||
setDAC(VCMP_LR,thrvalue[1],-1,0,retval);if(retval[0] != thrvalue[1]) cprintf(BG_RED,"Failed to set vcmp_lr to %d, got %d\n",retval[0],thrvalue[1]);
|
||||
setDAC(VCMP_RL,thrvalue[2],-1,0,retval);if(retval[0] != thrvalue[2]) cprintf(BG_RED,"Failed to set vcmp_rl to %d, got %d\n",retval[0],thrvalue[2]);
|
||||
setDAC(VCMP_RR,thrvalue[3],-1,0,retval);if(retval[0] != thrvalue[3]) cprintf(BG_RED,"Failed to set vcmp_rr to %d, got %d\n",retval[0],thrvalue[3]);
|
||||
}
|
||||
return getThresholdEnergy(imod);
|
||||
}
|
||||
|
||||
@ -707,7 +745,7 @@ int setDynamicRange(int dr){
|
||||
|
||||
enum readOutFlags setReadOutFlags(enum readOutFlags val){
|
||||
|
||||
enum readOutFlags retval;
|
||||
enum readOutFlags retval = GET_READOUT_FLAGS;
|
||||
if(val!=GET_READOUT_FLAGS){
|
||||
|
||||
|
||||
@ -934,16 +972,16 @@ int copyModule(sls_detector_module *destMod, sls_detector_module *srcMod){
|
||||
|
||||
|
||||
|
||||
int getTotalNumberOfChannels(){return getNumberOfChannelsPerModule();};//NCHIP*NCHAN*nModBoard;}
|
||||
int getTotalNumberOfChips(){return 4;};//NCHIP*nModBoard;}
|
||||
int getTotalNumberOfModules(){return 1;}//nModBoard;}
|
||||
int getNumberOfChannelsPerChip(){return (256*256);}//NCHAN;}
|
||||
int getNumberOfChannelsPerModule(){return getNumberOfChannelsPerChip() * getTotalNumberOfChips();}//NCHAN*NCHIP;}
|
||||
int getNumberOfChipsPerModule(){return 4;}//NCHIP;}
|
||||
int getNumberOfDACsPerModule(){return 16;}//NDAC;}
|
||||
int getNumberOfADCsPerModule(){return 0;}//NADC;}
|
||||
|
||||
|
||||
int getTotalNumberOfChannels(){return getNumberOfChannelsPerModule();}
|
||||
int getTotalNumberOfChips(){return NCHIP;}
|
||||
int getTotalNumberOfModules(){return 1;}
|
||||
int getNumberOfChannelsPerChip(){return NCHAN;}
|
||||
int getNumberOfChannelsPerModule(){return getNumberOfChannelsPerChip() * getTotalNumberOfChips();}
|
||||
int getNumberOfChipsPerModule(){return NCHIP;}
|
||||
int getNumberOfDACsPerModule(){return NDAC;}
|
||||
int getNumberOfADCsPerModule(){return NADC;}
|
||||
int getNumberOfGainsPerModule(){return NGAIN;}
|
||||
int getNumberOfOffsetsPerModule(){return NOFFSET;}
|
||||
|
||||
|
||||
|
||||
|
||||
@ -25,6 +25,9 @@
|
||||
#define NCHIP 4
|
||||
#define NDAC 16
|
||||
#define NADC 0
|
||||
#define NGAIN 4
|
||||
#define NOFFSET 4
|
||||
|
||||
#define NMAXMODX 1
|
||||
#define NMAXMODY 1
|
||||
#define NMAXMOD NMAXMODX*NMAXMODY
|
||||
|
||||
@ -4584,7 +4584,7 @@ int multiSlsDetector::resetFramesCaught() {
|
||||
|
||||
|
||||
|
||||
int* multiSlsDetector::readFrameFromReceiver(char* fName, int &acquisitionIndex, int &frameIndex){
|
||||
int* multiSlsDetector::readFrameFromReceiver(char* fName, int &acquisitionIndex, int &frameIndex, int &subFrameIndex){
|
||||
int nel=(thisMultiDetector->dataBytes)/sizeof(int);
|
||||
if(nel <= 0){
|
||||
cout << "Multislsdetector databytes not valid :" << thisMultiDetector->dataBytes << endl;
|
||||
@ -4610,7 +4610,7 @@ int* multiSlsDetector::readFrameFromReceiver(char* fName, int &acquisitionIndex
|
||||
for (int id=0; id<thisMultiDetector->numberOfDetectors; id++) {
|
||||
if (detectors[id]) {
|
||||
n=detectors[id]->getDataBytes();
|
||||
retdet=detectors[id]->readFrameFromReceiver(fName, acquisitionIndex, frameIndex);
|
||||
retdet=detectors[id]->readFrameFromReceiver(fName, acquisitionIndex, frameIndex, subFrameIndex);
|
||||
if(detectors[id]->getErrorMask())
|
||||
setErrorMask(getErrorMask()|(1<<id));
|
||||
if (retdet){
|
||||
|
||||
@ -1160,9 +1160,10 @@ class multiSlsDetector : public slsDetectorUtils {
|
||||
* @param fName file name of current frame()
|
||||
* @param acquisitionIndex current acquisition index
|
||||
* @param frameIndex current frame index (for each scan)
|
||||
* @param subFrameIndex current sub frame index (for 32 bit mode for eiger)
|
||||
/returns a frame read from recever
|
||||
*/
|
||||
int* readFrameFromReceiver(char* fName, int &acquisitionIndex, int &frameIndex);
|
||||
int* readFrameFromReceiver(char* fName, int &acquisitionIndex, int &frameIndex, int &subFrameIndex);
|
||||
|
||||
/** Locks/Unlocks the connection to the receiver
|
||||
/param lock sets (1), usets (0), gets (-1) the lock
|
||||
|
||||
@ -10,9 +10,9 @@
|
||||
using namespace std;
|
||||
|
||||
int dummyCallback(detectorData* d, int p,void*) {
|
||||
cout << "got data " << p << endl;
|
||||
|
||||
}
|
||||
cout << "got data " << p << endl;
|
||||
return 0;
|
||||
};
|
||||
|
||||
class multiSlsDetectorClient {
|
||||
|
||||
|
||||
@ -20,7 +20,7 @@ int slsDetector::initSharedMemory(detectorType type, int id) {
|
||||
*/
|
||||
key_t mem_key=DEFAULT_SHM_KEY+id;
|
||||
int shm_id;
|
||||
int nch, nm, nc, nd;
|
||||
int nch, nm, nc, nd, ng, no;
|
||||
int sz;
|
||||
|
||||
//shmId=-1;
|
||||
@ -31,18 +31,24 @@ int slsDetector::initSharedMemory(detectorType type, int id) {
|
||||
nm=24;
|
||||
nc=10;
|
||||
nd=6; // dacs+adcs
|
||||
ng=0;
|
||||
no=0;
|
||||
break;
|
||||
case PICASSO:
|
||||
nch=128; // complete mythen system
|
||||
nm=24;
|
||||
nc=12;
|
||||
nd=6; // dacs+adcs
|
||||
ng=0;
|
||||
no=0;
|
||||
break;
|
||||
case GOTTHARD:
|
||||
nch=128;
|
||||
nm=1;
|
||||
nc=10;
|
||||
nd=13; // dacs+adcs
|
||||
ng=0;
|
||||
no=0;
|
||||
break;
|
||||
case PROPIX:
|
||||
nch=22*22;
|
||||
@ -55,33 +61,41 @@ int slsDetector::initSharedMemory(detectorType type, int id) {
|
||||
nm=1; //modules/detector
|
||||
nc=4; //chips
|
||||
nd=16; //dacs+adcs
|
||||
ng=4;
|
||||
no=4;
|
||||
break;
|
||||
case MOENCH:
|
||||
nch=160*160;
|
||||
nm=1; //modules/detector
|
||||
nc=1; //chips
|
||||
nd=9; //dacs+adcs
|
||||
ng=0;
|
||||
no=0;
|
||||
break;
|
||||
case JUNGFRAUCTB:
|
||||
nch=32;
|
||||
nm=1; //modules/detector
|
||||
nc=1; //chips
|
||||
nd=16; //dacs+adcs
|
||||
ng=0;
|
||||
no=0;
|
||||
break;
|
||||
default:
|
||||
nch=0; // dum!
|
||||
nm=0; //modules/detector
|
||||
nc=0; //chips
|
||||
nd=0; //dacs+adcs
|
||||
ng=0;
|
||||
no=0;
|
||||
break;
|
||||
}
|
||||
/**
|
||||
The size of the shared memory is:
|
||||
size of shared structure + ffcoefficents +fferrors + modules+ dacs+adcs+chips+chans
|
||||
size of shared structure + ffcoefficents +fferrors + modules+ dacs+adcs+chips+chans+gain+offset
|
||||
*/
|
||||
|
||||
|
||||
sz=sizeof(sharedSlsDetector)+nm*(2*nch*nc*sizeof(double)+sizeof(sls_detector_module)+sizeof(int)*nc+sizeof(dacs_t)*nd+sizeof(int)*nch*nc);
|
||||
sz=sizeof(sharedSlsDetector)+nm*(2*nch*nc*sizeof(double)+sizeof(sls_detector_module)+sizeof(int)*nc+sizeof(dacs_t)*nd+sizeof(int)*nch*nc+sizeof(int)*ng+sizeof(int)*no);
|
||||
#ifdef VERBOSE
|
||||
std::cout<<"Size of shared memory is "<< sz << "(type " << type << " - id " << mem_key << ")"<< std::endl;
|
||||
#endif
|
||||
@ -146,6 +160,8 @@ slsDetector::slsDetector(int id,multiSlsDetector *p) :slsDetectorUtils(),
|
||||
adcs(NULL),
|
||||
chipregs(NULL),
|
||||
chanregs(NULL),
|
||||
gain(NULL),
|
||||
offset(NULL),
|
||||
thisReceiver(NULL)
|
||||
|
||||
|
||||
@ -196,6 +212,8 @@ slsDetector::slsDetector(detectorType type, int id,multiSlsDetector *p): slsDete
|
||||
adcs(NULL),
|
||||
chipregs(NULL),
|
||||
chanregs(NULL),
|
||||
gain(NULL),
|
||||
offset(NULL),
|
||||
thisReceiver(NULL)
|
||||
|
||||
{
|
||||
@ -250,6 +268,8 @@ slsDetector::slsDetector(char *name, int id, int cport,multiSlsDetector *p) : sl
|
||||
adcs(NULL),
|
||||
chipregs(NULL),
|
||||
chanregs(NULL),
|
||||
gain(NULL),
|
||||
offset(NULL),
|
||||
thisReceiver(NULL)
|
||||
|
||||
|
||||
@ -529,6 +549,8 @@ int slsDetector::initializeDetectorSize(detectorType type) {
|
||||
thisDetector->nChip[Y]=1;
|
||||
thisDetector->nDacs=6;
|
||||
thisDetector->nAdcs=0;
|
||||
thisDetector->nGain=0;
|
||||
thisDetector->nOffset=0;
|
||||
thisDetector->nModMax[X]=24;
|
||||
thisDetector->nModMax[Y]=1;
|
||||
thisDetector->dynamicRange=24;
|
||||
@ -544,6 +566,8 @@ int slsDetector::initializeDetectorSize(detectorType type) {
|
||||
thisDetector->nChip[Y]=1;
|
||||
thisDetector->nDacs=6;
|
||||
thisDetector->nAdcs=0;
|
||||
thisDetector->nGain=0;
|
||||
thisDetector->nOffset=0;
|
||||
thisDetector->nModMax[X]=6;
|
||||
thisDetector->nModMax[Y]=1;
|
||||
thisDetector->dynamicRange=24;
|
||||
@ -555,6 +579,8 @@ int slsDetector::initializeDetectorSize(detectorType type) {
|
||||
thisDetector->nChip[Y]=1;
|
||||
thisDetector->nDacs=8;
|
||||
thisDetector->nAdcs=5;
|
||||
thisDetector->nGain=0;
|
||||
thisDetector->nOffset=0;
|
||||
thisDetector->nModMax[X]=1;
|
||||
thisDetector->nModMax[Y]=1;
|
||||
thisDetector->dynamicRange=16;
|
||||
@ -566,6 +592,8 @@ int slsDetector::initializeDetectorSize(detectorType type) {
|
||||
thisDetector->nChip[Y]=1;
|
||||
thisDetector->nDacs=8;
|
||||
thisDetector->nAdcs=5;
|
||||
thisDetector->nGain=0;
|
||||
thisDetector->nOffset=0;
|
||||
thisDetector->nModMax[X]=1;
|
||||
thisDetector->nModMax[Y]=1;
|
||||
thisDetector->dynamicRange=16;
|
||||
@ -577,6 +605,8 @@ int slsDetector::initializeDetectorSize(detectorType type) {
|
||||
thisDetector->nChip[Y]=1;
|
||||
thisDetector->nDacs=8;
|
||||
thisDetector->nAdcs=1;
|
||||
thisDetector->nGain=0;
|
||||
thisDetector->nOffset=0;
|
||||
thisDetector->nModMax[X]=1;
|
||||
thisDetector->nModMax[Y]=1;
|
||||
thisDetector->dynamicRange=16;
|
||||
@ -588,6 +618,8 @@ int slsDetector::initializeDetectorSize(detectorType type) {
|
||||
thisDetector->nChip[Y]=1;
|
||||
thisDetector->nDacs=16;
|
||||
thisDetector->nAdcs=1;
|
||||
thisDetector->nGain=0;
|
||||
thisDetector->nOffset=0;
|
||||
thisDetector->nModMax[X]=1;
|
||||
thisDetector->nModMax[Y]=1;
|
||||
thisDetector->dynamicRange=16;
|
||||
@ -599,6 +631,8 @@ int slsDetector::initializeDetectorSize(detectorType type) {
|
||||
thisDetector->nChip[Y]=1;
|
||||
thisDetector->nDacs=16;
|
||||
thisDetector->nAdcs=0;
|
||||
thisDetector->nGain=4;
|
||||
thisDetector->nOffset=4;
|
||||
thisDetector->nModMax[X]=1;
|
||||
thisDetector->nModMax[Y]=1;
|
||||
thisDetector->dynamicRange=16;
|
||||
@ -610,6 +644,8 @@ int slsDetector::initializeDetectorSize(detectorType type) {
|
||||
thisDetector->nChip[Y]=0;
|
||||
thisDetector->nDacs=0;
|
||||
thisDetector->nAdcs=0;
|
||||
thisDetector->nGain=0;
|
||||
thisDetector->nOffset=0;
|
||||
thisDetector->nModMax[X]=0;
|
||||
thisDetector->nModMax[Y]=0;
|
||||
thisDetector->dynamicRange=32;
|
||||
@ -725,7 +761,8 @@ int slsDetector::initializeDetectorSize(detectorType type) {
|
||||
thisDetector->adcoff=thisDetector->dacoff+sizeof(dacs_t)*thisDetector->nDacs*thisDetector->nModsMax;
|
||||
thisDetector->chipoff=thisDetector->adcoff+sizeof(dacs_t)*thisDetector->nAdcs*thisDetector->nModsMax;
|
||||
thisDetector->chanoff=thisDetector->chipoff+sizeof(int)*thisDetector->nChips*thisDetector->nModsMax;
|
||||
|
||||
thisDetector->gainoff=thisDetector->chanoff+sizeof(int)*thisDetector->nGain*thisDetector->nModsMax;
|
||||
thisDetector->offsetoff=thisDetector->gainoff+sizeof(int)*thisDetector->nOffset*thisDetector->nModsMax;
|
||||
|
||||
//update?!?!?!?
|
||||
|
||||
@ -745,6 +782,8 @@ int slsDetector::initializeDetectorSize(detectorType type) {
|
||||
adcs=(dacs_t*)(goff+thisDetector->adcoff);
|
||||
chipregs=(int*)(goff+thisDetector->chipoff);
|
||||
chanregs=(int*)(goff+thisDetector->chanoff);
|
||||
gain=(int*)(goff+thisDetector->gainoff);
|
||||
offset=(int*)(goff+thisDetector->offsetoff);
|
||||
if (thisDetector->alreadyExisting==0) {
|
||||
/** if thisDetector is new, initialize its structures \sa initializeDetectorStructure(); */
|
||||
initializeDetectorStructure();
|
||||
@ -864,6 +903,18 @@ int slsDetector::initializeDetectorStructure() {
|
||||
for (int ichan=0; ichan<thisDetector->nChans*thisDetector->nChips; ichan++) {
|
||||
*(chanregs+ichan+thisDetector->nChips*thisDetector->nChans*imod)=-1;
|
||||
}
|
||||
|
||||
/** initializes the gain values to 0 */
|
||||
for (int igain=0; igain<thisDetector->nGain; igain++) {
|
||||
*(gain+igain+thisDetector->nGain*imod)=0;
|
||||
}
|
||||
|
||||
|
||||
/** initializes the offset values to 0 */
|
||||
for (int ioffset=0; ioffset<thisDetector->nOffset; ioffset++) {
|
||||
*(offset+ioffset+thisDetector->nOffset*imod)=0;
|
||||
}
|
||||
|
||||
/** initialize gain and offset to -1 */
|
||||
thisMod->gain=-1.;
|
||||
thisMod->offset=-1.;
|
||||
@ -910,7 +961,7 @@ slsDetectorDefs::sls_detector_module* slsDetector::createModule(detectorType t)
|
||||
nm=1; //modules/detector
|
||||
nc=4*1; //chips
|
||||
nd=16; //dacs
|
||||
na=0; //use for gain????
|
||||
na=0;
|
||||
break;
|
||||
case MOENCH:
|
||||
nch=160*160;
|
||||
@ -2554,6 +2605,8 @@ slsDetectorDefs::sls_detector_chip slsDetector::getChip(int ichip, int imod){
|
||||
|
||||
int slsDetector::setModule(int reg, int imod){
|
||||
sls_detector_module myModule;
|
||||
int* g=0;
|
||||
int* o=0;
|
||||
|
||||
#ifdef VERBOSE
|
||||
std::cout << "slsDetector set module " << std::endl;
|
||||
@ -2622,16 +2675,14 @@ int slsDetector::setModule(int reg, int imod){
|
||||
ads[i]=-1;
|
||||
myModule.adcs=ads;
|
||||
}
|
||||
ret=setModule(myModule);
|
||||
ret=setModule(myModule,g,o);
|
||||
}
|
||||
return ret;
|
||||
|
||||
|
||||
};
|
||||
|
||||
|
||||
|
||||
int slsDetector::setModule(sls_detector_module module){
|
||||
int slsDetector::setModule(sls_detector_module module, int* gainval, int* offsetval){
|
||||
|
||||
int fnum=F_SET_MODULE;
|
||||
int retval;
|
||||
@ -2649,6 +2700,13 @@ int slsDetector::setModule(sls_detector_module module){
|
||||
if (connectControl() == OK){
|
||||
controlSocket->SendDataOnly(&fnum,sizeof(fnum));
|
||||
sendModule(&module);
|
||||
|
||||
//extra gain and offset - eiger
|
||||
if((thisDetector->nGain) && (gainval))
|
||||
controlSocket->SendDataOnly(gainval,sizeof(int)*thisDetector->nGain);
|
||||
if((thisDetector->nOffset) && (offsetval))
|
||||
controlSocket->SendDataOnly(offsetval,sizeof(int)*thisDetector->nOffset);
|
||||
|
||||
controlSocket->ReceiveDataOnly(&ret,sizeof(ret));
|
||||
if (ret!=FAIL) {
|
||||
controlSocket->ReceiveDataOnly(&retval,sizeof(retval));
|
||||
@ -2700,6 +2758,16 @@ int slsDetector::setModule(sls_detector_module module){
|
||||
(detectorModules+imod)->reg=module.reg;
|
||||
}
|
||||
}
|
||||
|
||||
if ((thisDetector->nGain) && (gainval) && (gain)) {
|
||||
for (int i=0; i<thisDetector->nGain; i++)
|
||||
gain[i+imod*thisDetector->nGain]=gainval[i];
|
||||
}
|
||||
|
||||
if ((thisDetector->nOffset) && (offsetval) && (offset)) {
|
||||
for (int i=0; i<thisDetector->nOffset; i++)
|
||||
offset[i+imod*thisDetector->nOffset]=offsetval[i];
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef VERBOSE
|
||||
@ -2709,106 +2777,131 @@ int slsDetector::setModule(sls_detector_module module){
|
||||
return retval;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
slsDetectorDefs::sls_detector_module *slsDetector::getModule(int imod){
|
||||
|
||||
#ifdef VERBOSE
|
||||
std::cout << "slsDetector get module " << std::endl;
|
||||
std::cout << "slsDetector get module " << std::endl;
|
||||
#endif
|
||||
|
||||
int fnum=F_GET_MODULE;
|
||||
sls_detector_module *myMod=createModule();
|
||||
int fnum=F_GET_MODULE;
|
||||
sls_detector_module *myMod=createModule();
|
||||
|
||||
int* gainval=0, *offsetval=0;
|
||||
if(thisDetector->nGain)
|
||||
gainval=new int[thisDetector->nGain];
|
||||
if(thisDetector->nOffset)
|
||||
offsetval=new int[thisDetector->nOffset];
|
||||
|
||||
//char *ptr, *goff=(char*)thisDetector;
|
||||
//char *ptr, *goff=(char*)thisDetector;
|
||||
|
||||
// int chanreg[thisDetector->nChans*thisDetector->nChips];
|
||||
//int chipreg[thisDetector->nChips];
|
||||
//double dac[thisDetector->nDacs], adc[thisDetector->nAdcs];
|
||||
// int chanreg[thisDetector->nChans*thisDetector->nChips];
|
||||
//int chipreg[thisDetector->nChips];
|
||||
//double dac[thisDetector->nDacs], adc[thisDetector->nAdcs];
|
||||
|
||||
int ret=FAIL;
|
||||
char mess[100];
|
||||
// int n;
|
||||
int ret=FAIL;
|
||||
char mess[100];
|
||||
// int n;
|
||||
|
||||
#ifdef VERBOSE
|
||||
std::cout<< "getting module " << imod << std::endl;
|
||||
std::cout<< "getting module " << imod << std::endl;
|
||||
#endif
|
||||
|
||||
myMod->module=imod;
|
||||
// myMod.nchan=thisDetector->nChans*thisDetector->nChips;
|
||||
//myMod.chanregs=chanreg;
|
||||
//myMod.nchip=thisDetector->nChips;
|
||||
//myMod.chipregs=chipreg;
|
||||
//myMod.ndac=thisDetector->nDacs;
|
||||
//myMod.dacs=dac;
|
||||
//myMod.ndac=thisDetector->nAdcs;
|
||||
//myMod.dacs=adc;
|
||||
myMod->module=imod;
|
||||
// myMod.nchan=thisDetector->nChans*thisDetector->nChips;
|
||||
//myMod.chanregs=chanreg;
|
||||
//myMod.nchip=thisDetector->nChips;
|
||||
//myMod.chipregs=chipreg;
|
||||
//myMod.ndac=thisDetector->nDacs;
|
||||
//myMod.dacs=dac;
|
||||
//myMod.ndac=thisDetector->nAdcs;
|
||||
//myMod.dacs=adc;
|
||||
|
||||
|
||||
if (thisDetector->onlineFlag==ONLINE_FLAG) {
|
||||
if (connectControl() == OK){
|
||||
controlSocket->SendDataOnly(&fnum,sizeof(fnum));
|
||||
controlSocket->SendDataOnly(&imod,sizeof(imod));
|
||||
|
||||
controlSocket->ReceiveDataOnly(&ret,sizeof(ret));
|
||||
if (ret!=FAIL) {
|
||||
receiveModule(myMod);
|
||||
|
||||
|
||||
|
||||
if (thisDetector->onlineFlag==ONLINE_FLAG) {
|
||||
if (connectControl() == OK){
|
||||
controlSocket->SendDataOnly(&fnum,sizeof(fnum));
|
||||
controlSocket->SendDataOnly(&imod,sizeof(imod));
|
||||
|
||||
controlSocket->ReceiveDataOnly(&ret,sizeof(ret));
|
||||
if (ret!=FAIL) {
|
||||
receiveModule(myMod);
|
||||
} else {
|
||||
controlSocket->ReceiveDataOnly(mess,sizeof(mess));
|
||||
std::cout<< "Detector returned error: " << mess << std::endl;
|
||||
}
|
||||
controlSocket->Disconnect();
|
||||
if (ret==FORCE_UPDATE)
|
||||
updateDetector();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (ret!=FAIL) {
|
||||
if (detectorModules) {
|
||||
if (imod>=0 && imod<thisDetector->nMod[X]*thisDetector->nMod[Y]) {
|
||||
(detectorModules+imod)->nchan=myMod->nchan;
|
||||
(detectorModules+imod)->nchip=myMod->nchip;
|
||||
(detectorModules+imod)->ndac=myMod->ndac;
|
||||
(detectorModules+imod)->nadc=myMod->nadc;
|
||||
thisDetector->nChips=myMod->nchip;
|
||||
thisDetector->nChans=myMod->nchan/myMod->nchip;
|
||||
thisDetector->nDacs=myMod->ndac;
|
||||
thisDetector->nAdcs=myMod->nadc;
|
||||
|
||||
for (int ichip=0; ichip<thisDetector->nChips; ichip++) {
|
||||
if (chipregs)
|
||||
chipregs[ichip+thisDetector->nChips*imod]=myMod->chipregs[ichip];
|
||||
|
||||
if (chanregs) {
|
||||
for (int i=0; i<thisDetector->nChans; i++) {
|
||||
chanregs[i+ichip*thisDetector->nChans+thisDetector->nChips*thisDetector->nChans*imod]=myMod->chanregs[ichip*thisDetector->nChans+i];
|
||||
}
|
||||
}
|
||||
}
|
||||
if (dacs) {
|
||||
for (int i=0; i<thisDetector->nDacs; i++)
|
||||
dacs[i+imod*thisDetector->nDacs]=myMod->dacs[i];
|
||||
}
|
||||
if (adcs) {
|
||||
for (int i=0; i<thisDetector->nAdcs; i++)
|
||||
adcs[i+imod*thisDetector->nAdcs]=myMod->adcs[i];
|
||||
//extra gain and offset - eiger
|
||||
if(thisDetector->nGain)
|
||||
controlSocket->ReceiveDataOnly(gainval,sizeof(int)*thisDetector->nGain);
|
||||
if(thisDetector->nOffset)
|
||||
controlSocket->ReceiveDataOnly(offsetval,sizeof(int)*thisDetector->nOffset);
|
||||
} else {
|
||||
controlSocket->ReceiveDataOnly(mess,sizeof(mess));
|
||||
std::cout<< "Detector returned error: " << mess << std::endl;
|
||||
}
|
||||
controlSocket->Disconnect();
|
||||
if (ret==FORCE_UPDATE)
|
||||
updateDetector();
|
||||
}
|
||||
}
|
||||
|
||||
(detectorModules+imod)->gain=myMod->gain;
|
||||
(detectorModules+imod)->offset=myMod->offset;
|
||||
(detectorModules+imod)->serialnumber=myMod->serialnumber;
|
||||
(detectorModules+imod)->reg=myMod->reg;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
deleteModule(myMod);
|
||||
myMod=NULL;
|
||||
}
|
||||
return myMod;
|
||||
|
||||
if (ret!=FAIL) {
|
||||
if (detectorModules) {
|
||||
if (imod>=0 && imod<thisDetector->nMod[X]*thisDetector->nMod[Y]) {
|
||||
(detectorModules+imod)->nchan=myMod->nchan;
|
||||
(detectorModules+imod)->nchip=myMod->nchip;
|
||||
(detectorModules+imod)->ndac=myMod->ndac;
|
||||
(detectorModules+imod)->nadc=myMod->nadc;
|
||||
thisDetector->nChips=myMod->nchip;
|
||||
thisDetector->nChans=myMod->nchan/myMod->nchip;
|
||||
thisDetector->nDacs=myMod->ndac;
|
||||
thisDetector->nAdcs=myMod->nadc;
|
||||
|
||||
for (int ichip=0; ichip<thisDetector->nChips; ichip++) {
|
||||
if (chipregs)
|
||||
chipregs[ichip+thisDetector->nChips*imod]=myMod->chipregs[ichip];
|
||||
|
||||
if (chanregs) {
|
||||
for (int i=0; i<thisDetector->nChans; i++) {
|
||||
chanregs[i+ichip*thisDetector->nChans+thisDetector->nChips*thisDetector->nChans*imod]=myMod->chanregs[ichip*thisDetector->nChans+i];
|
||||
}
|
||||
}
|
||||
}
|
||||
if (dacs) {
|
||||
for (int i=0; i<thisDetector->nDacs; i++)
|
||||
dacs[i+imod*thisDetector->nDacs]=myMod->dacs[i];
|
||||
}
|
||||
if (adcs) {
|
||||
for (int i=0; i<thisDetector->nAdcs; i++)
|
||||
adcs[i+imod*thisDetector->nAdcs]=myMod->adcs[i];
|
||||
}
|
||||
|
||||
(detectorModules+imod)->gain=myMod->gain;
|
||||
(detectorModules+imod)->offset=myMod->offset;
|
||||
(detectorModules+imod)->serialnumber=myMod->serialnumber;
|
||||
(detectorModules+imod)->reg=myMod->reg;
|
||||
}
|
||||
}
|
||||
|
||||
if ((thisDetector->nGain) && (gainval) && (gain)) {
|
||||
for (int i=0; i<thisDetector->nGain; i++)
|
||||
gain[i+imod*thisDetector->nGain]=gainval[i];
|
||||
}
|
||||
|
||||
if ((thisDetector->nOffset) && (offsetval) && (offset)) {
|
||||
for (int i=0; i<thisDetector->nOffset; i++)
|
||||
offset[i+imod*thisDetector->nOffset]=offsetval[i];
|
||||
}
|
||||
|
||||
if(gainval) delete[]gainval;
|
||||
if(offsetval) delete[]offsetval;
|
||||
|
||||
} else {
|
||||
deleteModule(myMod);
|
||||
myMod=NULL;
|
||||
}
|
||||
return myMod;
|
||||
}
|
||||
|
||||
|
||||
@ -2958,6 +3051,19 @@ slsDetectorDefs::detectorSettings slsDetector::setSettings( detectorSettings ise
|
||||
string settingsfname, calfname;
|
||||
string ssettings;
|
||||
|
||||
int* gainval=0, *offsetval=0;
|
||||
if(thisDetector->nGain)
|
||||
gainval=new int[thisDetector->nGain];
|
||||
if(thisDetector->nOffset)
|
||||
offsetval=new int[thisDetector->nOffset];
|
||||
|
||||
int ret=0;
|
||||
|
||||
if(thisDetector->nGain)
|
||||
gainval = new int[thisDetector->nGain];
|
||||
if(thisDetector->nOffset)
|
||||
offsetval = new int[thisDetector->nOffset];
|
||||
|
||||
switch (isettings) {
|
||||
case STANDARD:
|
||||
if ( (thisDetector->myDetectorType == MYTHEN) ||
|
||||
@ -3068,61 +3174,86 @@ slsDetectorDefs::detectorSettings slsDetector::setSettings( detectorSettings ise
|
||||
oscfn << thisDetector->calDir << ssettings << "/calibration.sn" << setfill('0') << setw(3) << hex << getId(MODULE_SERIAL_NUMBER, im) << setbase(10);
|
||||
}
|
||||
|
||||
|
||||
//settings file****
|
||||
settingsfname=ostfn.str();
|
||||
#ifdef VERBOSE
|
||||
cout << "the settings file name is "<<settingsfname << endl;
|
||||
#endif
|
||||
if (readSettingsFile(settingsfname,thisDetector->myDetectorType, myMod)) {
|
||||
calfname=oscfn.str();
|
||||
#ifdef VERBOSE
|
||||
cout << calfname << endl;
|
||||
#endif
|
||||
|
||||
//reads calibration files here!
|
||||
|
||||
|
||||
readCalibrationFile(calfname,myMod->gain, myMod->offset);
|
||||
setModule(*myMod);
|
||||
|
||||
|
||||
|
||||
} else {
|
||||
ostringstream ostfn,oscfn;
|
||||
if (!readSettingsFile(settingsfname,thisDetector->myDetectorType, myMod)) {
|
||||
//if it didnt open, try default settings file
|
||||
ostringstream ostfn_default;
|
||||
switch(thisDetector->myDetectorType){
|
||||
case MOENCH:
|
||||
case GOTTHARD:
|
||||
case PROPIX:
|
||||
case JUNGFRAUCTB:
|
||||
ostfn << thisDetector->settingsDir << ssettings << ssettings << ".settings";
|
||||
ostfn_default << thisDetector->settingsDir << ssettings << ssettings << ".settings";
|
||||
break;
|
||||
case EIGER:
|
||||
default:
|
||||
ostfn << thisDetector->settingsDir << ssettings << ssettings << ".trim";
|
||||
ostfn_default << thisDetector->settingsDir << ssettings << ssettings << ".trim";
|
||||
break;
|
||||
}
|
||||
oscfn << thisDetector->calDir << ssettings << ssettings << ".cal";
|
||||
calfname=oscfn.str();
|
||||
settingsfname=ostfn.str();
|
||||
settingsfname=ostfn_default.str();
|
||||
#ifdef VERBOSE
|
||||
cout << settingsfname << endl;
|
||||
cout << calfname << endl;
|
||||
#endif
|
||||
if (readSettingsFile(settingsfname,thisDetector->myDetectorType, myMod)) {
|
||||
calfname=oscfn.str();
|
||||
readCalibrationFile(calfname,myMod->gain, myMod->offset);
|
||||
setModule(*myMod);
|
||||
}else{
|
||||
if (!readSettingsFile(settingsfname,thisDetector->myDetectorType, myMod)) {
|
||||
//if default doesnt work, return error
|
||||
std::cout << "Could not open settings file" << endl;
|
||||
setErrorMask((getErrorMask())|(SETTINGS_FILE_NOT_OPEN));
|
||||
return thisDetector->currentSettings;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
//calibration file****
|
||||
calfname=oscfn.str();
|
||||
#ifdef VERBOSE
|
||||
cout << "Specific file:"<< calfname << endl;
|
||||
#endif
|
||||
//extra gain and offset
|
||||
if(thisDetector->nGain)
|
||||
ret = readCalibrationFile(calfname,gainval, offsetval,thisDetector->myDetectorType );
|
||||
//normal gain and offset inside sls_detector_module
|
||||
else
|
||||
ret = readCalibrationFile(calfname,myMod->gain, myMod->offset);
|
||||
|
||||
//if it didnt open, try default
|
||||
if(ret != OK){
|
||||
ostringstream oscfn_default;
|
||||
oscfn_default << thisDetector->calDir << ssettings << ssettings << ".cal";
|
||||
calfname=oscfn_default.str();
|
||||
#ifdef VERBOSE
|
||||
cout << "Default file:" << calfname << endl;
|
||||
#endif
|
||||
//extra gain and offset
|
||||
if(thisDetector->nGain)
|
||||
ret = readCalibrationFile(calfname,gainval, offsetval,thisDetector->myDetectorType );
|
||||
//normal gain and offset inside sls_detector_module
|
||||
else
|
||||
ret = readCalibrationFile(calfname,myMod->gain, myMod->offset);
|
||||
}
|
||||
//if default doesnt work, return error
|
||||
if(ret != OK){
|
||||
std::cout << "Could not open calibration file" << calfname << endl;
|
||||
setErrorMask((getErrorMask())|(SETTINGS_FILE_NOT_OPEN));
|
||||
return thisDetector->currentSettings;
|
||||
}
|
||||
|
||||
//if everything worked, set module****
|
||||
setModule(*myMod,gainval,offsetval);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
deleteModule(myMod);
|
||||
if(gainval) delete [] gainval;
|
||||
if(offsetval) delete [] offsetval;
|
||||
|
||||
switch(thisDetector->myDetectorType==MYTHEN){
|
||||
if (thisDetector->correctionMask&(1<<RATE_CORRECTION)) {
|
||||
int isett=getSettings(imod);
|
||||
@ -4131,6 +4262,7 @@ int slsDetector::setSpeed(speedVariable sp, int value) {
|
||||
if (ret==FAIL) {
|
||||
controlSocket->ReceiveDataOnly(mess,sizeof(mess));
|
||||
std::cout<< "Detector returned error: " << mess << std::endl;
|
||||
setErrorMask((getErrorMask())|(COULD_NOT_SET_SPEED_PARAMETERS));
|
||||
} else {
|
||||
controlSocket->ReceiveDataOnly(&retval,sizeof(retval));
|
||||
}
|
||||
@ -4399,6 +4531,7 @@ int slsDetector::setReadOutFlags(readOutFlags flag){
|
||||
if (ret==FAIL) {
|
||||
controlSocket->ReceiveDataOnly(mess,sizeof(mess));
|
||||
std::cout<< "Detector returned error: " << mess << std::endl;
|
||||
setErrorMask((getErrorMask())|(COULD_NOT_SET_READOUT_FLAGS));
|
||||
} else {
|
||||
controlSocket->ReceiveDataOnly(&retval,sizeof(retval));
|
||||
thisDetector->roFlags=retval;
|
||||
@ -5853,6 +5986,7 @@ int slsDetector::writeSettingsFile(string fname, int imod){
|
||||
int slsDetector::loadSettingsFile(string fname, int imod) {
|
||||
|
||||
sls_detector_module *myMod=NULL;
|
||||
int* g=0; int* o=0;
|
||||
string fn=fname;
|
||||
fn=fname;
|
||||
int mmin=0, mmax=setNumberOfModules();
|
||||
@ -5878,7 +6012,7 @@ int slsDetector::loadSettingsFile(string fname, int imod) {
|
||||
//settings is saved in myMod.reg for all except mythen
|
||||
if(thisDetector->myDetectorType!=MYTHEN)
|
||||
myMod->reg=thisDetector->currentSettings;
|
||||
setModule(*myMod);
|
||||
setModule(*myMod,g,o);
|
||||
deleteModule(myMod);
|
||||
} else
|
||||
return FAIL;
|
||||
@ -5955,7 +6089,21 @@ int slsDetector::loadCalibrationFile(string fname, int imod) {
|
||||
|
||||
sls_detector_module *myMod=NULL;
|
||||
string fn=fname;
|
||||
|
||||
int* gainval=0, *offsetval=0;
|
||||
if(thisDetector->nGain)
|
||||
gainval=new int[thisDetector->nGain];
|
||||
if(thisDetector->nOffset)
|
||||
offsetval=new int[thisDetector->nOffset];
|
||||
|
||||
fn=fname;
|
||||
|
||||
if(thisDetector->nGain)
|
||||
gainval = new int[thisDetector->nGain];
|
||||
if(thisDetector->nOffset)
|
||||
offsetval = new int[thisDetector->nOffset];
|
||||
|
||||
|
||||
int mmin=0, mmax=setNumberOfModules();
|
||||
if (imod>=0) {
|
||||
mmin=imod;
|
||||
@ -5973,10 +6121,21 @@ int slsDetector::loadCalibrationFile(string fname, int imod) {
|
||||
}
|
||||
fn=ostfn.str();
|
||||
if((myMod=getModule(im))){
|
||||
if(readCalibrationFile(fn, myMod->gain, myMod->offset)==FAIL)
|
||||
return FAIL;
|
||||
setModule(*myMod);
|
||||
|
||||
//extra gain and offset
|
||||
if(thisDetector->nGain){
|
||||
if(readCalibrationFile(fn,gainval, offsetval,thisDetector->myDetectorType)==FAIL)
|
||||
return FAIL;
|
||||
} //normal gain and offset inside sls_detector_module
|
||||
else{
|
||||
if(readCalibrationFile(fn,myMod->gain, myMod->offset)==FAIL)
|
||||
return FAIL;
|
||||
}
|
||||
setModule(*myMod,gainval,offsetval);
|
||||
|
||||
deleteModule(myMod);
|
||||
if(gainval) delete[]gainval;
|
||||
if(offsetval) delete offsetval;
|
||||
} else
|
||||
return FAIL;
|
||||
}
|
||||
@ -6002,7 +6161,13 @@ int slsDetector::saveCalibrationFile(string fname, int imod) {
|
||||
else
|
||||
ostfn << fname << ".sn" << setfill('0') << setw(3) << hex << getId(MODULE_SERIAL_NUMBER,im);
|
||||
if ((myMod=getModule(im))) {
|
||||
ret=writeCalibrationFile(ostfn.str(), myMod->gain, myMod->offset);
|
||||
//extra gain and offset
|
||||
if(thisDetector->nGain)
|
||||
ret=writeCalibrationFile(ostfn.str(),gain, offset,thisDetector->myDetectorType);
|
||||
//normal gain and offset inside sls_detector_module
|
||||
else
|
||||
ret=writeCalibrationFile(ostfn.str(),myMod->gain, myMod->offset);
|
||||
|
||||
deleteModule(myMod);
|
||||
}else
|
||||
return FAIL;
|
||||
@ -6540,7 +6705,7 @@ int slsDetector::resetFramesCaught(){
|
||||
|
||||
|
||||
|
||||
int* slsDetector::readFrameFromReceiver(char* fName, int &acquisitionIndex, int &frameIndex){
|
||||
int* slsDetector::readFrameFromReceiver(char* fName, int &acquisitionIndex, int &frameIndex, int &subFrameIndex){
|
||||
int fnum=F_READ_RECEIVER_FRAME;
|
||||
int nel=thisDetector->dataBytes/sizeof(int);
|
||||
int* retval=new int[nel];
|
||||
@ -6567,6 +6732,8 @@ int* slsDetector::readFrameFromReceiver(char* fName, int &acquisitionIndex, int
|
||||
n=dataSocket->ReceiveDataOnly(fName,MAX_STR_LENGTH);
|
||||
n=dataSocket->ReceiveDataOnly(&acquisitionIndex,sizeof(acquisitionIndex));
|
||||
n=dataSocket->ReceiveDataOnly(&frameIndex,sizeof(frameIndex));
|
||||
if(thisDetector->myDetectorType == EIGER)
|
||||
n=dataSocket->ReceiveDataOnly(&subFrameIndex,sizeof(subFrameIndex));
|
||||
n=dataSocket->ReceiveDataOnly(retval,thisDetector->dataBytes);
|
||||
|
||||
#ifdef VERBOSE
|
||||
|
||||
@ -126,11 +126,17 @@ class slsDetector : public slsDetectorUtils, public energyConversion {
|
||||
int nDacs;
|
||||
/** number of adcs per module */
|
||||
int nAdcs;
|
||||
/** number of extra gain values*/
|
||||
int nGain;
|
||||
/** number of extra offset values */
|
||||
int nOffset;
|
||||
/** dynamic range of the detector data */
|
||||
int dynamicRange;
|
||||
/** size of the data that are transfered from the detector */
|
||||
int dataBytes;
|
||||
|
||||
|
||||
|
||||
/** 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) */
|
||||
@ -230,7 +236,10 @@ class slsDetector : public slsDetectorUtils, public energyConversion {
|
||||
int chipoff;
|
||||
/** memory offsets for the channel register arrays -trimbits*/
|
||||
int chanoff;
|
||||
|
||||
/** memory offsets for the gain register arrays */
|
||||
int gainoff;
|
||||
/** memory offsets for the offset register arrays -trimbits*/
|
||||
int offsetoff;
|
||||
|
||||
|
||||
/* receiver*/
|
||||
@ -894,10 +903,12 @@ class slsDetector : public slsDetectorUtils, public energyConversion {
|
||||
/**
|
||||
configure chip
|
||||
\param module module to be set - must contain correct module number and also channel and chip registers
|
||||
\param gainval pointer to extra gain values
|
||||
\param offsetval pointer to extra offset values
|
||||
\returns current register value
|
||||
\sa ::sls_detector_module
|
||||
*/
|
||||
int setModule(sls_detector_module module);
|
||||
int setModule(sls_detector_module module, int* gainval, int* offsetval);
|
||||
//virtual int setModule(sls_detector_module module);
|
||||
|
||||
/**
|
||||
@ -1543,9 +1554,10 @@ class slsDetector : public slsDetectorUtils, public energyConversion {
|
||||
* @param fName file name of current frame()
|
||||
* @param acquisitionIndex current acquisition index
|
||||
* @param frameIndex current frame index (for each scan)
|
||||
* @param subFrameIndex current sub frame index (for 32 bit mode for eiger)
|
||||
/returns a frame read from recever
|
||||
*/
|
||||
int* readFrameFromReceiver(char* fName, int &acquisitionIndex, int &frameIndex);
|
||||
int* readFrameFromReceiver(char* fName, int &acquisitionIndex, int &frameIndex, int &subFrameIndex);
|
||||
|
||||
/** Locks/Unlocks the connection to the receiver
|
||||
/param lock sets (1), usets (0), gets (-1) the lock
|
||||
@ -1770,6 +1782,10 @@ class slsDetector : public slsDetectorUtils, public energyConversion {
|
||||
int *chipregs;
|
||||
/** pointer to channal registers */
|
||||
int *chanregs;
|
||||
/** pointer to gain values */
|
||||
int *gain;
|
||||
/** pointer to offset values */
|
||||
int *offset;
|
||||
|
||||
receiverInterface *thisReceiver;
|
||||
|
||||
|
||||
@ -499,9 +499,10 @@ class slsDetectorBase : public virtual slsDetectorDefs, public virtual errorDef
|
||||
* @param fName file name of current frame()
|
||||
* @param acquisitionIndex current acquisition index
|
||||
* @param frameIndex current frame index (for each scan)
|
||||
* @param subFrameIndex current sub frame index (for 32 bit mode for eiger)
|
||||
/returns a frame read from recever
|
||||
*/
|
||||
virtual int* readFrameFromReceiver(char* fName, int &acquisitionIndex, int &frameIndex)=0;
|
||||
virtual int* readFrameFromReceiver(char* fName, int &acquisitionIndex, int &frameIndex, int &subFrameIndex)=0;
|
||||
|
||||
|
||||
/** Sets the read receiver frequency
|
||||
|
||||
@ -268,7 +268,7 @@ int64_t slsDetectorUsers::getThisSoftwareVersion(){
|
||||
|
||||
|
||||
|
||||
void slsDetectorUsers::registerDataCallback(int( *userCallback)(detectorData*, int, void*), void *pArg){
|
||||
void slsDetectorUsers::registerDataCallback(int( *userCallback)(detectorData*, int, int, void*), void *pArg){
|
||||
myDetector->registerDataCallback(userCallback,pArg);
|
||||
}
|
||||
|
||||
|
||||
@ -408,10 +408,10 @@ class slsDetectorUsers
|
||||
|
||||
/**
|
||||
@short register calbback for accessing detector final data
|
||||
\param userCallback function for plotting/analyzing the data. Its arguments are the data structure d and the frame number f.
|
||||
\param userCallback function for plotting/analyzing the data. Its arguments are the data structure d and the frame number f, s is for subframe number for eiger for 32 bit mode
|
||||
*/
|
||||
|
||||
void registerDataCallback(int( *userCallback)(detectorData* d, int f, void*), void *pArg);
|
||||
void registerDataCallback(int( *userCallback)(detectorData* d, int f, int s, void*), void *pArg);
|
||||
|
||||
/**
|
||||
@short register callback for accessing raw data - if the rawDataCallback is registered, no filewriting/postprocessing will be carried on automatically by the software - the raw data are deleted by the software
|
||||
|
||||
@ -641,9 +641,10 @@ virtual int resetFramesCaught()=0;
|
||||
* @param fName file name of current frame()
|
||||
* @param acquisitionIndex current acquisition index
|
||||
* @param frameIndex current frame index (for each scan)
|
||||
* @param subFrameIndex current sub frame index (for 32 bit mode for eiger)
|
||||
/returns a frame read from recever
|
||||
*/
|
||||
virtual int* readFrameFromReceiver(char* fName, int &acquisitionIndex, int &frameIndex)=0;
|
||||
virtual int* readFrameFromReceiver(char* fName, int &acquisitionIndex, int &frameIndex, int &subFrameIndex)=0;
|
||||
|
||||
|
||||
/**
|
||||
|
||||
@ -47,7 +47,6 @@ int energyConversion::readCalibrationFile(string fname, double &gain, double &of
|
||||
int energyConversion::writeCalibrationFile(string fname, double gain, double offset){
|
||||
//std::cout<< "Function not yet implemented " << std::endl;
|
||||
ofstream outfile;
|
||||
|
||||
outfile.open (fname.c_str());
|
||||
|
||||
// >> i/o operations here <<
|
||||
@ -70,66 +69,62 @@ int energyConversion::writeCalibrationFile(string fname, double gain, double off
|
||||
};
|
||||
|
||||
|
||||
int energyConversion::readCalibrationFile(string fname, double *gain, double *offset, detectorType myDetectorType){
|
||||
int energyConversion::readCalibrationFile(string fname, int *gain, int *offset, detectorType myDetectorType){
|
||||
|
||||
|
||||
|
||||
string str;
|
||||
ifstream infile;
|
||||
double o,g;
|
||||
int ig=0;
|
||||
switch (myDetectorType) {
|
||||
case EIGER:
|
||||
string str;
|
||||
ifstream infile;
|
||||
double o,g;
|
||||
int ig=0;
|
||||
switch (myDetectorType) {
|
||||
case EIGER:
|
||||
|
||||
|
||||
|
||||
#ifdef VERBOSE
|
||||
std::cout<< "Opening file "<< fname << std::endl;
|
||||
std::cout<< "Opening file "<< fname << std::endl;
|
||||
#endif
|
||||
infile.open(fname.c_str(), ios_base::in);
|
||||
if (infile.is_open()) {
|
||||
|
||||
for (ig=0; ig<4; ig++) {
|
||||
//while ( (getline(infile,str)) > -1) {
|
||||
getline(infile,str);
|
||||
infile.open(fname.c_str(), ios_base::in);
|
||||
if (infile.is_open()) {
|
||||
for (ig=0; ig<4; ig++) {
|
||||
//while ( (getline(infile,str)) > -1) {
|
||||
getline(infile,str);
|
||||
#ifdef VERBOSE
|
||||
std::cout<< str << std::endl;
|
||||
std::cout<< str << std::endl;
|
||||
#endif
|
||||
istringstream ssstr(str);
|
||||
ssstr >> o >> g;
|
||||
offset[ig]=o;
|
||||
gain[ig]=g;
|
||||
// ig++;
|
||||
if (ig>=4)
|
||||
break;
|
||||
}
|
||||
infile.close();
|
||||
cout << "Calibration file loaded: " << fname << endl;
|
||||
} else {
|
||||
std::cout<< "Could not open calibration file "<< fname << std::endl;
|
||||
gain[0]=0.;
|
||||
offset[0]=0.;
|
||||
istringstream ssstr(str);
|
||||
ssstr >> o >> g;
|
||||
offset[ig]=(int)(o*1000);
|
||||
gain[ig]=(int)(g*1000);
|
||||
// ig++;
|
||||
if (ig>=4)
|
||||
break;
|
||||
}
|
||||
infile.close();
|
||||
cout << "Calibration file loaded: " << fname << endl;
|
||||
} else {
|
||||
cout << "Could not open calibration file: "<< fname << std::endl;
|
||||
gain[0]=0;
|
||||
offset[0]=0;
|
||||
#ifndef MYROOT
|
||||
return FAIL;
|
||||
return FAIL;
|
||||
#endif
|
||||
return -1;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
#ifndef MYROOT
|
||||
return OK;
|
||||
return OK;
|
||||
#endif
|
||||
return 0;
|
||||
break;
|
||||
|
||||
|
||||
|
||||
|
||||
default:
|
||||
return readCalibrationFile(fname, *gain, *offset);
|
||||
}
|
||||
return 0;
|
||||
break;
|
||||
default:
|
||||
std::cout<< "Writing Calibration Files for this detector not defined\n" << std::endl;
|
||||
return FAIL;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
int energyConversion::writeCalibrationFile(string fname, double *gain, double *offset, detectorType myDetectorType){
|
||||
int energyConversion::writeCalibrationFile(string fname, int *gain, int *offset, detectorType myDetectorType){
|
||||
//std::cout<< "Function not yet implemented " << std::endl;
|
||||
ofstream outfile;
|
||||
switch (myDetectorType) {
|
||||
@ -140,7 +135,7 @@ int energyConversion::writeCalibrationFile(string fname, double *gain, double *o
|
||||
// >> i/o operations here <<
|
||||
if (outfile.is_open()) {
|
||||
for (int ig=0; ig<4; ig++)
|
||||
outfile << offset[ig] << " " << gain[ig] << std::endl;
|
||||
outfile << ((double)offset[ig]/1000) << " " << ((double)gain[ig]/1000) << std::endl;
|
||||
} else {
|
||||
std::cout<< "Could not open calibration file "<< fname << " for writing" << std::endl;
|
||||
#ifndef MYROOT
|
||||
@ -156,7 +151,8 @@ int energyConversion::writeCalibrationFile(string fname, double *gain, double *o
|
||||
return 0;
|
||||
break;
|
||||
default:
|
||||
return writeCalibrationFile(fname, *gain, *offset);
|
||||
std::cout<< "Writing Calibration Files for this detector not defined\n" << std::endl;
|
||||
return FAIL;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
@ -54,7 +54,7 @@ class energyConversion
|
||||
\param gain reference to the gain variable
|
||||
\offset reference to the offset variable
|
||||
*/
|
||||
static int readCalibrationFile(string fname, double *gain, double *offset, detectorType myDetectorType);
|
||||
static int readCalibrationFile(string fname, int *gain, int *offset, detectorType myDetectorType);
|
||||
|
||||
/**
|
||||
writes a calibration file
|
||||
@ -62,7 +62,7 @@ class energyConversion
|
||||
\param gain
|
||||
\param offset
|
||||
*/
|
||||
static int writeCalibrationFile(string fname, double *gain, double *offset, detectorType myDetectorType);
|
||||
static int writeCalibrationFile(string fname, int *gain, int *offset, detectorType myDetectorType);
|
||||
|
||||
|
||||
|
||||
|
||||
@ -138,7 +138,7 @@ void postProcessing::processFrame(int *myData, int delflag, int jctb) {
|
||||
// cout << "callback arg "<< getCurrentProgress()<< " " << (fname+string(".raw")).c_str() << " " << getTotalNumberOfChannels() << endl;
|
||||
// cout << "DATAREADY 1" <<endl;
|
||||
thisData=new detectorData(fdata,NULL,NULL,getCurrentProgress(),(fname+string(".raw")).c_str(),getTotalNumberOfChannels());
|
||||
dataReady(thisData, currentFrameIndex, pCallbackArg);
|
||||
dataReady(thisData, currentFrameIndex, -1, pCallbackArg);
|
||||
delete thisData;
|
||||
fdata=NULL;
|
||||
}
|
||||
@ -281,7 +281,7 @@ data queue size unlock
|
||||
// cout << "callback arg "<< getCurrentProgress()<< " " << (fname+ext).c_str() << " " << np << endl;
|
||||
//cout << "ADATREADY 2 " << endl;
|
||||
thisData=new detectorData(val,err,ang,getCurrentProgress(),(fname+ext).c_str(),np);
|
||||
dataReady(thisData, currentFrameIndex, pCallbackArg);
|
||||
dataReady(thisData, currentFrameIndex, -1, pCallbackArg);
|
||||
delete thisData;
|
||||
ang=NULL;
|
||||
val=NULL;
|
||||
@ -500,6 +500,7 @@ void* postProcessing::processData(int delflag) {
|
||||
int caught = -1;
|
||||
int currentAcquisitionIndex = -1;
|
||||
int currentFrameIndex = -1;
|
||||
int currentSubFrameIndex = -1;
|
||||
bool newData = false;
|
||||
int nthframe = setReadReceiverFrequency(0);
|
||||
|
||||
@ -633,7 +634,7 @@ void* postProcessing::processData(int delflag) {
|
||||
strcpy(currentfName,"");
|
||||
pthread_mutex_lock(&mg);
|
||||
//int* receiverData = new int [getTotalNumberOfChannels()];
|
||||
int* receiverData = readFrameFromReceiver(currentfName,currentAcquisitionIndex,currentFrameIndex);
|
||||
int* receiverData = readFrameFromReceiver(currentfName,currentAcquisitionIndex,currentFrameIndex,currentSubFrameIndex);
|
||||
pthread_mutex_unlock(&mg);
|
||||
|
||||
//if detector returned null
|
||||
@ -664,7 +665,7 @@ void* postProcessing::processData(int delflag) {
|
||||
if ((fdata) && (dataReady)){
|
||||
// cout << "DATAREADY 3" << endl;
|
||||
thisData = new detectorData(fdata,NULL,NULL,getCurrentProgress(),currentfName,getTotalNumberOfChannels());
|
||||
dataReady(thisData, currentFrameIndex, pCallbackArg);
|
||||
dataReady(thisData, currentFrameIndex, currentSubFrameIndex, pCallbackArg);
|
||||
delete thisData;
|
||||
fdata = NULL;
|
||||
progress = caught;
|
||||
|
||||
@ -238,7 +238,7 @@ s
|
||||
void ResetPositionIndex(){pthread_mutex_lock(&mp); resetPositionIndex(); pthread_mutex_unlock(&mp);};
|
||||
|
||||
|
||||
void registerDataCallback(int( *userCallback)(detectorData*, int, void*), void *pArg) {dataReady = userCallback; pCallbackArg = pArg;};
|
||||
void registerDataCallback(int( *userCallback)(detectorData*, int, int, void*), void *pArg) {dataReady = userCallback; pCallbackArg = pArg;};
|
||||
|
||||
|
||||
void registerRawDataCallback(int( *userCallback)(double*, int, void*), void *pArg) {rawDataReady = userCallback; pRawDataArg = pArg;};
|
||||
@ -335,7 +335,7 @@ s
|
||||
private:
|
||||
double *fdata;
|
||||
|
||||
int (*dataReady)(detectorData*,int, void*);
|
||||
int (*dataReady)(detectorData*,int, int,void*);
|
||||
void *pCallbackArg;
|
||||
|
||||
int (*rawDataReady)(double*,int,void*);
|
||||
|
||||
@ -60,14 +60,21 @@ int setChip(sls_detector_chip myChip);
|
||||
int getChip(sls_detector_chip *myChip);
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef EIGERD
|
||||
int setModule(sls_detector_module myMod, int* gain, int* offset);
|
||||
int getModule(sls_detector_module *myMod, int* gain, int* offset);
|
||||
#else
|
||||
int setModule(sls_detector_module myMod);
|
||||
int getModule(sls_detector_module *myMod);
|
||||
#endif
|
||||
|
||||
|
||||
enum detectorSettings setSettings(enum detectorSettings sett, int imod);
|
||||
|
||||
#if defined(MYTHEND) || defined(EIGERD)
|
||||
int getThresholdEnergy(int imod);
|
||||
int setThresholdEnergy(int thr, int imod);
|
||||
int setThresholdEnergy(int ev, int imod);
|
||||
#endif
|
||||
|
||||
int startStateMachine();
|
||||
@ -118,7 +125,10 @@ int getNumberOfChannelsPerModule();
|
||||
int getNumberOfChipsPerModule();
|
||||
int getNumberOfDACsPerModule();
|
||||
int getNumberOfADCsPerModule();
|
||||
|
||||
#ifdef EIGERD
|
||||
int getNumberOfGainsPerModule();
|
||||
int getNumberOfOffsetsPerModule();
|
||||
#endif
|
||||
|
||||
enum externalSignalFlag getExtSignal(int signalindex);
|
||||
enum externalSignalFlag setExtSignal(int signalindex, enum externalSignalFlag flag);
|
||||
|
||||
@ -1788,11 +1788,15 @@ int get_chip(int file_des) {
|
||||
|
||||
}
|
||||
int set_module(int file_des) {
|
||||
int retval, n;
|
||||
int retval, n,i;
|
||||
int ret=OK,ret1=OK;
|
||||
|
||||
#ifdef SLS_DETECTOR_FUNCTION_LIST
|
||||
sls_detector_module myModule;
|
||||
#ifdef EIGERD
|
||||
int *myGain = (int*)malloc(getNumberOfGainsPerModule()*sizeof(int));
|
||||
int *myOffset = (int*)malloc(getNumberOfOffsetsPerModule()*sizeof(int));
|
||||
#endif
|
||||
int *myChip=(int*)malloc(getNumberOfChipsPerModule()*sizeof(int));
|
||||
int *myChan=(int*)malloc(getNumberOfChannelsPerModule()*sizeof(int));
|
||||
int *myDac=(int*)malloc(getNumberOfDACsPerModule()*sizeof(int));
|
||||
@ -1823,7 +1827,16 @@ int set_module(int file_des) {
|
||||
sprintf(mess,"could not allocate chans\n");
|
||||
ret=FAIL;
|
||||
}
|
||||
|
||||
#ifdef EIGERD
|
||||
if (!myGain){
|
||||
sprintf(mess,"could not allocate gains\n");
|
||||
ret=FAIL;
|
||||
}
|
||||
if (!myOffset){
|
||||
sprintf(mess,"could not allocate offsets\n");
|
||||
ret=FAIL;
|
||||
}
|
||||
#endif
|
||||
myModule.nchip=getNumberOfChipsPerModule();
|
||||
myModule.nchan=getNumberOfChannelsPerModule();
|
||||
myModule.ndac=getNumberOfDACsPerModule();
|
||||
@ -1834,17 +1847,25 @@ int set_module(int file_des) {
|
||||
printf("Setting module\n");
|
||||
#endif
|
||||
ret=receiveModule(file_des, &myModule);
|
||||
|
||||
|
||||
#ifdef EIGERD
|
||||
n = receiveData(file_des,myGain,sizeof(int)*getNumberOfGainsPerModule(),INT32);
|
||||
n = receiveData(file_des,myOffset,sizeof(int)*getNumberOfOffsetsPerModule(),INT32);
|
||||
#endif
|
||||
if (ret>=0)
|
||||
ret=OK;
|
||||
else
|
||||
ret=FAIL;
|
||||
|
||||
|
||||
#ifdef VERBOSE
|
||||
//#ifdef VERBOSE
|
||||
printf("module number is %d,register is %d, nchan %d, nchip %d, ndac %d, nadc %d, gain %f, offset %f\n",myModule.module, myModule.reg, myModule.nchan, myModule.nchip, myModule.ndac, myModule.nadc, myModule.gain,myModule.offset);
|
||||
#ifdef EIGERD
|
||||
for(i=0;i<getNumberOfGainsPerModule();i++)
|
||||
printf("gain[%d]:%d\t%f\n",i,myGain[i],((double)myGain[i]/1000));
|
||||
for(i=0;i<getNumberOfOffsetsPerModule();i++)
|
||||
printf("offset[%d]:%d\t%f\n",i,myOffset[i],((double)myOffset[i]/1000));
|
||||
#endif
|
||||
//#endif
|
||||
|
||||
|
||||
if (ret==OK) {
|
||||
@ -1852,7 +1873,12 @@ int set_module(int file_des) {
|
||||
ret=FAIL;
|
||||
sprintf(mess,"Detector locked by %s\n",lastClientIP);
|
||||
} else {
|
||||
retval=setModule(myModule);
|
||||
#ifdef EIGERD
|
||||
ret=setModule(myModule, myGain, myOffset);
|
||||
#else
|
||||
ret=setModule(myModule);
|
||||
#endif
|
||||
retval = ret;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
@ -1878,6 +1904,10 @@ int set_module(int file_des) {
|
||||
free(myChan);
|
||||
free(myDac);
|
||||
free(myAdc);
|
||||
#ifdef EIGERD
|
||||
free(myGain);
|
||||
free(myOffset);
|
||||
#endif
|
||||
#endif
|
||||
return ret;
|
||||
}
|
||||
@ -1895,6 +1925,10 @@ int get_module(int file_des) {
|
||||
sls_detector_module myModule;
|
||||
|
||||
#ifdef SLS_DETECTOR_FUNCTION_LIST
|
||||
#ifdef EIGERD
|
||||
int *myGain = (int*)malloc(getNumberOfGainsPerModule()*sizeof(int));
|
||||
int *myOffset = (int*)malloc(getNumberOfOffsetsPerModule()*sizeof(int));
|
||||
#endif
|
||||
int *myChip=(int*)malloc(getNumberOfChipsPerModule()*sizeof(int));
|
||||
int *myChan=(int*)malloc(getNumberOfChannelsPerModule()*sizeof(int));
|
||||
int *myDac=(int*)malloc(getNumberOfDACsPerModule()*sizeof(int));
|
||||
@ -1925,7 +1959,16 @@ int get_module(int file_des) {
|
||||
sprintf(mess,"could not allocate chans\n");
|
||||
ret=FAIL;
|
||||
}
|
||||
|
||||
#ifdef EIGERD
|
||||
if (!myGain){
|
||||
sprintf(mess,"could not allocate gains\n");
|
||||
ret=FAIL;
|
||||
}
|
||||
if (!myOffset){
|
||||
sprintf(mess,"could not allocate offsets\n");
|
||||
ret=FAIL;
|
||||
}
|
||||
#endif
|
||||
myModule.ndac=getNumberOfDACsPerModule();
|
||||
myModule.nchip=getNumberOfChipsPerModule();
|
||||
myModule.nchan=getNumberOfChannelsPerModule();
|
||||
@ -1948,7 +1991,18 @@ int get_module(int file_des) {
|
||||
if (imod>=0) {
|
||||
ret=OK;
|
||||
myModule.module=imod;
|
||||
#ifdef EIGERD
|
||||
getModule(&myModule, myGain, myOffset);
|
||||
#ifdef VERBOSE
|
||||
for(i=0;i<getNumberOfGainsPerModule();i++)
|
||||
printf("gain[%d]:%d\t%f\n",i,myGain[i],((double)myGain[i]/1000));
|
||||
for(i=0;i<getNumberOfOffsetsPerModule();i++)
|
||||
printf("offset[%d]:%d\t%f\n",i,myOffset[i],((double)myOffset[i]/1000));
|
||||
#endif
|
||||
#else
|
||||
getModule(&myModule);
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef VERBOSE
|
||||
printf("Returning module %d of register %x\n", imod, myModule.reg);
|
||||
@ -1967,6 +2021,10 @@ int get_module(int file_des) {
|
||||
if (ret!=FAIL) {
|
||||
/* send return argument */
|
||||
ret=sendModule(file_des, &myModule);
|
||||
#ifdef EIGERD
|
||||
n = sendData(file_des,myGain,sizeof(int)*getNumberOfGainsPerModule(),INT32);
|
||||
n = sendData(file_des,myOffset,sizeof(int)*getNumberOfOffsetsPerModule(),INT32);
|
||||
#endif
|
||||
} else {
|
||||
n += sendData(file_des,mess,sizeof(mess),OTHER);
|
||||
}
|
||||
@ -1976,6 +2034,10 @@ int get_module(int file_des) {
|
||||
free(myChan);
|
||||
free(myDac);
|
||||
free(myAdc);
|
||||
#ifdef EIGERD
|
||||
free(myGain);
|
||||
free(myOffset);
|
||||
#endif
|
||||
#endif
|
||||
/*return ok/fail*/
|
||||
return ret;
|
||||
@ -2717,9 +2779,10 @@ int set_readout_flags(int file_des) {
|
||||
#endif
|
||||
|
||||
if (ret==OK) {
|
||||
if (retval == -1) {
|
||||
if ((retval == -1) || ((arg!=-1)&&((retval&arg)!=arg))){
|
||||
cprintf(RED,"arg:0x%x, retval:0x%x retval&arg:0x%x\n",(int)arg,(int)retval,retval&arg);
|
||||
ret=FAIL;
|
||||
sprintf(mess,"Could not change readout flag: should be %d but is %d\n", arg, retval);
|
||||
sprintf(mess,"Could not change readout flag: should be 0x%x but is 0x%x\n", arg, retval);
|
||||
cprintf(RED, "%s",mess);
|
||||
}else if (differentClients)
|
||||
ret=FORCE_UPDATE;
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user