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

updated number of measurements to be taken from the detector class

Browse Source 
git-svn-id: file:///afs/psi.ch/project/sls_det_software/svn/slsDetectorGui@54 af1100a4-978c-4157-bff7-07162d2ba061
This commit is contained in:
l_maliakal_d 2012-09-10 17:55:44 +00:00
parent b85e03adfd
commit f7078c3700
7 changed files with 253 additions and 166 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
slsDetectorGui/include/qDrawPlot.h
View File

@ -94,9 +94,6 @@ public:
* @param stop_if_running is 0 to stop acquisition and 1 to start acquisition * @param stop_if_running is 0 to stop acquisition and 1 to start acquisition
*/ */
void StartStopDaqToggle(bool stop_if_running=0); void StartStopDaqToggle(bool stop_if_running=0);
/** Set number of measurements
* @param num number of measurements to be set */
void setNumMeasurements(int num){number_of_measurements = num;};
/** Set frame enabled /** Set frame enabled
* @param enable enable*/ * @param enable enable*/
void setFrameEnabled(bool enable){isFrameEnabled = enable;}; void setFrameEnabled(bool enable){isFrameEnabled = enable;};
@ -168,6 +165,8 @@ int StartDaqForGui() {return StartOrStopThread(1) ? 1:0;}
int StopDaqForGui() {return StartOrStopThread(0) ? 0:1;} int StopDaqForGui() {return StartOrStopThread(0) ? 0:1;}
/** Starts/stops Acquisition Thread */ /** Starts/stops Acquisition Thread */
bool StartOrStopThread(bool start); bool StartOrStopThread(bool start);
/** Sets up measurement each time */
void SetupMeasurement();
/** Resets the acquisition parameter like lastimagenumber */ /** Resets the acquisition parameter like lastimagenumber */
int ResetDaqForGui(); int ResetDaqForGui();
/** The function which is called when start acquisition thread is created */ /** The function which is called when start acquisition thread is created */
@ -252,8 +251,6 @@ SlsQt2DPlotLayout* plot2D;
QVector<SlsQtH1D*> plot1D_hists; QVector<SlsQtH1D*> plot1D_hists;
/** Number of Measurements */
int number_of_measurements;
/** Current Measurement */ /** Current Measurement */
int currentMeasurement; int currentMeasurement;
/** currentFrame */ /** currentFrame */
@ -391,6 +388,8 @@ int scanArgument;
/** enable angle plot */ /** enable angle plot */
bool anglePlot; bool anglePlot;
/** prevents err msg displaying twice when detector stopped, "transmitting" */
bool alreadyDisplayed;

4
slsDetectorGui/include/qTabMeasurement.h
View File

@ -43,7 +43,7 @@ public:
/** To enable expert mode /** To enable expert mode
* @param enable to enable if true * @param enable to enable if true
*/ */
void SetExpertMode(bool enable){expertMode = enable;SetupTimingMode();}; void SetExpertMode(bool enable);
@ -163,8 +163,6 @@ private:
enum{None, Auto, Trigger_Exp_Series, Trigger_Frame, Trigger_Readout, Gated, Gated_Start, Trigger_Window, NumTimingModes}; enum{None, Auto, Trigger_Exp_Series, Trigger_Frame, Trigger_Readout, Gated, Gated_Start, Trigger_Window, NumTimingModes};
/** timer to update the progress*/ /** timer to update the progress*/
QTimer *progressTimer; QTimer *progressTimer;
/** number of measurements*/
int numMeasurement;
/** current measurement */ /** current measurement */
int currentMeasurement; int currentMeasurement;
/** tool tip variables*/ /** tool tip variables*/

67
slsDetectorGui/src/qDetectorMain.cpp
View File

@ -174,47 +174,48 @@ void qDetectorMain::SetUpDetector(){
//instantiate detector and set window title //instantiate detector and set window title
myDet = new multiSlsDetector(detID); myDet = new multiSlsDetector();
string host = myDet->getHostname(detID); string host = myDet->getHostname();
cout<<"online:"<<myDet->setOnline();<<endl;
slsDetector *s = myDet->getSlsDetector(detID);
//if hostname doesnt exist even in shared memory //if hostname doesnt exist even in shared memory
if(!host.length()){ if(!host.length()){
#ifdef VERBOSE #ifdef VERBOSE
cout << endl << "No Detector Connected at id:" << detID << endl; cout << endl << "No Detector Connected." << endl;
#endif #endif
char cIndex[10]; qDefs::Message(qDefs::CRITICAL,"No Detectors Connected. ","Main");
sprintf(cIndex,"%d",detID);
qDefs::Message(qDefs::CRITICAL,string("No Detector Connected at id : ")+string(cIndex),"Main");
exit(-1);
}//if the detector is not even connected
else if(s->setTCPSocket()==slsDetectorDefs::FAIL){
qDefs::Message(qDefs::CRITICAL,string("The detector ")+host+string(" is not connected. Exiting GUI."),"Main");
cout << "The detector " << host << "is not connected. Exiting GUI." << endl;
exit(-1); exit(-1);
} }
else{
slsDetectorDefs::detectorType detType = myDet->getDetectorsType(); //check if the detector is not even connected
// Check if type valid. If not, exit string offline = myDet->checkOnline();
switch(detType){//digitalDetector decides if trimbits should be shown if(!offline.empty()){
case slsDetectorDefs::MYTHEN: digitalDetector = true; break; qDefs::Message(qDefs::CRITICAL,string("<nobr>The detector(s) <b>")+offline+string(" </b> is/are not connected. Exiting GUI.</nobr>"),"Main");
case slsDetectorDefs::EIGER: digitalDetector = true; break; cout << "The detector(s) " << host << " is/are not connected. Exiting GUI." << endl;
case slsDetectorDefs::GOTTHARD: digitalDetector = false;break; exit(-1);
case slsDetectorDefs::AGIPD: digitalDetector = false;break; }
default:
string detName = myDet->slsDetectorBase::getDetectorType(detType); // Check if type valid. If not, exit
string errorMess = host+string(" has unknown detector type \"")+ slsDetectorDefs::detectorType detType = myDet->getDetectorsType();
detName+string("\". Exiting GUI."); switch(detType){
qDefs::Message(qDefs::CRITICAL,errorMess,"Main"); //digitalDetector decides if trimbits should be shown
exit(-1); case slsDetectorDefs::MYTHEN: digitalDetector = true; break;
} case slsDetectorDefs::EIGER: digitalDetector = true; break;
setWindowTitle("SLS Detector GUI : "+ case slsDetectorDefs::GOTTHARD: digitalDetector = false;break;
QString(slsDetectorBase::getDetectorType(detType).c_str())+ " - "+QString(host.c_str())); case slsDetectorDefs::AGIPD: digitalDetector = false;break;
default:
string detName = myDet->slsDetectorBase::getDetectorType(detType);
string errorMess = host+string(" has unknown detector type \"")+
detName+string("\". Exiting GUI.");
qDefs::Message(qDefs::CRITICAL,errorMess,"Main");
exit(-1);
}
setWindowTitle("SLS Detector GUI : "+
QString(slsDetectorBase::getDetectorType(detType).c_str())+ " - "+QString(host.c_str()));
#ifdef VERBOSE #ifdef VERBOSE
cout << endl << "Type : " << slsDetectorBase::getDetectorType(detType) << "\nDetector : " << host << endl; cout << endl << "Type : " << slsDetectorBase::getDetectorType(detType) << "\nDetector : " << host << endl;
#endif #endif
myDet->setOnline(slsDetectorDefs::ONLINE_FLAG); myDet->setOnline(slsDetectorDefs::ONLINE_FLAG);
}
} }

259
slsDetectorGui/src/qDrawPlot.cpp
View File

@ -28,6 +28,7 @@ using namespace std;
//------------------------------------------------------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------------------------------------------------------
qDrawPlot::qDrawPlot(QWidget *parent,multiSlsDetector*& detector): qDrawPlot::qDrawPlot(QWidget *parent,multiSlsDetector*& detector):
QWidget(parent),myDet(detector){ QWidget(parent),myDet(detector){
SetupWidgetWindow(); SetupWidgetWindow();
@ -35,8 +36,10 @@ qDrawPlot::qDrawPlot(QWidget *parent,multiSlsDetector*& detector):
StartStopDaqToggle(); //as default StartStopDaqToggle(); //as default
} }
//------------------------------------------------------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------------------------------------------------------
qDrawPlot::~qDrawPlot(){ qDrawPlot::~qDrawPlot(){
// Clear plot // Clear plot
Clear1DPlot(); Clear1DPlot();
@ -48,13 +51,14 @@ qDrawPlot::~qDrawPlot(){
for(int i=0;i<MAXCloneWindows;i++) delete winClone[i]; for(int i=0;i<MAXCloneWindows;i++) delete winClone[i];
} }
//------------------------------------------------------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------------------------------------------------------
void qDrawPlot::SetupWidgetWindow(){ void qDrawPlot::SetupWidgetWindow(){
#ifdef VERBOSE #ifdef VERBOSE
cout << "Setting up plot variables" << endl; cout << "Setting up plot variables" << endl;
#endif #endif
number_of_measurements=1;
currentMeasurement = 0; currentMeasurement = 0;
stop_signal = 0; stop_signal = 0;
pthread_mutex_init(&last_image_complete_mutex,NULL); pthread_mutex_init(&last_image_complete_mutex,NULL);
@ -95,6 +99,8 @@ void qDrawPlot::SetupWidgetWindow(){
isFrameEnabled = false; isFrameEnabled = false;
isTriggerEnabled = false; isTriggerEnabled = false;
scanArgument = None; scanArgument = None;
alreadyDisplayed = false;
// This is so that it initially stop and plots // This is so that it initially stop and plots
running = 1; running = 1;
for(int i=0;i<MAX_1DPLOTS;i++) {histYAxis[i]=0;yvalues[i]=0; } for(int i=0;i<MAX_1DPLOTS;i++) {histYAxis[i]=0;yvalues[i]=0; }
@ -168,8 +174,10 @@ void qDrawPlot::SetupWidgetWindow(){
} }
//------------------------------------------------------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------------------------------------------------------
void qDrawPlot::Initialization(){ void qDrawPlot::Initialization(){
connect(this, SIGNAL(InterpolateSignal(bool)),plot2D, SIGNAL(InterpolateSignal(bool))); connect(this, SIGNAL(InterpolateSignal(bool)),plot2D, SIGNAL(InterpolateSignal(bool)));
connect(this, SIGNAL(ContourSignal(bool)), plot2D, SIGNAL(ContourSignal(bool))); connect(this, SIGNAL(ContourSignal(bool)), plot2D, SIGNAL(ContourSignal(bool)));
@ -183,8 +191,10 @@ void qDrawPlot::Initialization(){
} }
//------------------------------------------------------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------------------------------------------------------
void qDrawPlot::StartStopDaqToggle(bool stop_if_running){ void qDrawPlot::StartStopDaqToggle(bool stop_if_running){
#ifdef VERYVERBOSE #ifdef VERYVERBOSE
cout << "Entering StartStopDaqToggle(" << stop_if_running << ")" <<endl; cout << "Entering StartStopDaqToggle(" << stop_if_running << ")" <<endl;
@ -195,14 +205,17 @@ void qDrawPlot::StartStopDaqToggle(bool stop_if_running){
running=!running; running=!running;
}else if(!stop_if_running){ //then start }else if(!stop_if_running){ //then start
//Do the following only once before each n measurements //number of measurements
int numMeasurements = (int)myDet->setTimer(slsDetectorDefs::MEASUREMENTS_NUMBER,-1);
// Reset Current Measurement // Reset Current Measurement
currentMeasurement = 0; currentMeasurement = 0;
emit SetCurrentMeasurementSignal(currentMeasurement); emit SetCurrentMeasurementSignal(currentMeasurement);
//to get the first image //to get the first image
data_pause_over = true; data_pause_over = true;
//in case of error message
alreadyDisplayed = false;
// Number of Exposures // Number of Exposures
int numFrames = (isFrameEnabled)*((int)myDet->setTimer(slsDetectorDefs::FRAME_NUMBER,-1)); int numFrames = (isFrameEnabled)*((int)myDet->setTimer(slsDetectorDefs::FRAME_NUMBER,-1));
@ -245,8 +258,10 @@ void qDrawPlot::StartStopDaqToggle(bool stop_if_running){
} }
} }
//------------------------------------------------------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------------------------------------------------------
void qDrawPlot::StartDaq(bool start){ void qDrawPlot::StartDaq(bool start){
if(start){ if(start){
#ifdef VERBOSE #ifdef VERBOSE
@ -264,8 +279,10 @@ void qDrawPlot::StartDaq(bool start){
} }
} }
//------------------------------------------------------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------------------------------------------------------
int qDrawPlot::ResetDaqForGui(){ int qDrawPlot::ResetDaqForGui(){
if(!StopDaqForGui()) return 0; if(!StopDaqForGui()) return 0;
cout << "Resetting image number" << endl; cout << "Resetting image number" << endl;
@ -273,8 +290,10 @@ int qDrawPlot::ResetDaqForGui(){
return 1; return 1;
} }
//------------------------------------------------------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------------------------------------------------------
bool qDrawPlot::StartOrStopThread(bool start){ bool qDrawPlot::StartOrStopThread(bool start){
static bool firstTime = true; static bool firstTime = true;
static bool gui_acquisition_thread_running = 0; static bool gui_acquisition_thread_running = 0;
@ -291,92 +310,9 @@ bool qDrawPlot::StartOrStopThread(bool start){
//start part //start part
if(start){ if(start){
if(myDet->getRunStatus()==slsDetectorDefs::IDLE)
cout<<endl<<endl<<"IDLE"<<endl;
else cout<<endl<<endl<<"ERRORRRRRR: "<<myDet->getRunStatus()<<endl;
// Defaults
progress = 0; progress = 0;
currentFrame = 0; //sets up the measurement parameters
stop_signal = 0; SetupMeasurement();
histTitle[0] = "";
//for 2d scans
int currentIndex = myDet->getFileIndex();
currentScanValue = 0;
currentScanDivLevel = 0;
if(scanArgument!=None){
if(scanArgument==AllFrames){
maxPixelsY = currentIndex + number_of_exposures - 1;
minPixelsY = currentIndex;
nPixelsY = number_of_exposures;
}else if(scanArgument==FileIndex){
maxPixelsY = currentIndex + number_of_frames - 1;
minPixelsY = currentIndex;
nPixelsY = number_of_frames;
}else if(scanArgument==Level0){
//no need to check if numsteps=0,cuz otherwise this mode wont be set in plot tab
int numSteps = myDet->getScanSteps(0);
double *values = new double[numSteps];
myDet->getScanSteps(0,values);
maxPixelsY = values[numSteps-1];
minPixelsY = values[0];
nPixelsY = numSteps;
currentScanValue = values[0];
}
else {
//no need to check if numsteps=0,cuz otherwise this mode wont be set in plot tab
int numSteps = myDet->getScanSteps(1);
double *values = new double[numSteps];
myDet->getScanSteps(1,values);
maxPixelsY = values[numSteps-1];
minPixelsY = values[0];
nPixelsY = numSteps;
currentScanValue = values[0];
}
pixelWidth = (maxPixelsY -minPixelsY)/(nPixelsY-1);
startPixel = minPixelsY -(pixelWidth/2);
endPixel = maxPixelsY + (pixelWidth/2);
}else{//no scan
nPixelsY = 100;//number_of_exposures;
maxPixelsY = 100;
minPixelsY = 0;
startPixel = -0.5;
endPixel = nPixelsY-0.5;
}
cout<<"nPixelsY:"<<nPixelsY<<endl;
cout<<"minPixelsY:"<<minPixelsY<<endl;
cout<<"maxPixelsY:"<<maxPixelsY<<endl;
cout<<"startPixel:"<<startPixel<<endl;
cout<<"endPixel:"<<endPixel<<endl;
//1d
if(histXAxis) delete [] histXAxis; histXAxis = new double [nPixelsX];
if(histYAxis[0]) delete [] histYAxis[0];histYAxis[0] = new double [nPixelsX];
//2d
if(lastImageArray) delete [] lastImageArray; lastImageArray = new double[nPixelsY*nPixelsX];
//sorta useless
if(yvalues[0]) delete [] yvalues[0]; yvalues[0] = new double [nPixelsX];
if(image_data) delete [] image_data; image_data = new double[nPixelsY*nPixelsX];
//initializing 1d xaxis
for(unsigned int px=0;px<nPixelsX;px++) histXAxis[px] = px;/*+10;*/
histYAxis[0][4] = 190.56;
//initializing 2d array
for(int py=0;py<nPixelsY;py++)
for(int px=0;px<nPixelsX;px++)
lastImageArray[py*nPixelsX+px] = 0;
cout << "Starting new acquisition threadddd ...." << endl; cout << "Starting new acquisition threadddd ...." << endl;
// Setting the callback function to get data from detector class // Setting the callback function to get data from detector class
@ -397,8 +333,101 @@ bool qDrawPlot::StartOrStopThread(bool start){
return gui_acquisition_thread_running; return gui_acquisition_thread_running;
} }
//------------------------------------------------------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------------------------------------------------------
void qDrawPlot::SetupMeasurement(){
if(myDet->getRunStatus()==slsDetectorDefs::IDLE)
cout<<endl<<endl<<"IDLE"<<endl;
else cout<<endl<<endl<<"ERRORRRRRR: "<<myDet->getRunStatus()<<endl;
// Defaults
currentFrame = 0;
stop_signal = 0;
histTitle[0] = "";
//for 2d scans
int currentIndex = myDet->getFileIndex();
currentScanValue = 0;
currentScanDivLevel = 0;
if(scanArgument!=None){
if(scanArgument==AllFrames){
maxPixelsY = currentIndex + number_of_exposures - 1;
minPixelsY = currentIndex;
nPixelsY = number_of_exposures;
}else if(scanArgument==FileIndex){
maxPixelsY = currentIndex + number_of_frames - 1;
minPixelsY = currentIndex;
nPixelsY = number_of_frames;
}else if(scanArgument==Level0){
//no need to check if numsteps=0,cuz otherwise this mode wont be set in plot tab
int numSteps = myDet->getScanSteps(0);
double *values = new double[numSteps];
myDet->getScanSteps(0,values);
maxPixelsY = values[numSteps-1];
minPixelsY = values[0];
nPixelsY = numSteps;
currentScanValue = values[0];
}
else {
//no need to check if numsteps=0,cuz otherwise this mode wont be set in plot tab
int numSteps = myDet->getScanSteps(1);
double *values = new double[numSteps];
myDet->getScanSteps(1,values);
maxPixelsY = values[numSteps-1];
minPixelsY = values[0];
nPixelsY = numSteps;
currentScanValue = values[0];
}
pixelWidth = (maxPixelsY -minPixelsY)/(nPixelsY-1);
startPixel = minPixelsY -(pixelWidth/2);
endPixel = maxPixelsY + (pixelWidth/2);
}else{//no scan
nPixelsY = 100;//number_of_exposures;
maxPixelsY = 100;
minPixelsY = 0;
startPixel = -0.5;
endPixel = nPixelsY-0.5;
}
cout<<"nPixelsY:"<<nPixelsY<<endl;
cout<<"minPixelsY:"<<minPixelsY<<endl;
cout<<"maxPixelsY:"<<maxPixelsY<<endl;
cout<<"startPixel:"<<startPixel<<endl;
cout<<"endPixel:"<<endPixel<<endl;
//1d
if(histXAxis) delete [] histXAxis; histXAxis = new double [nPixelsX];
if(histYAxis[0]) delete [] histYAxis[0];histYAxis[0] = new double [nPixelsX];
//2d
if(lastImageArray) delete [] lastImageArray; lastImageArray = new double[nPixelsY*nPixelsX];
//sorta useless
if(yvalues[0]) delete [] yvalues[0]; yvalues[0] = new double [nPixelsX];
if(image_data) delete [] image_data; image_data = new double[nPixelsY*nPixelsX];
//initializing 1d xaxis
for(unsigned int px=0;px<nPixelsX;px++) histXAxis[px] = px;/*+10;*/
histYAxis[0][4] = 190.56;
//initializing 2d array
for(int py=0;py<nPixelsY;py++)
for(int px=0;px<nPixelsX;px++)
lastImageArray[py*nPixelsX+px] = 0;
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
void* qDrawPlot::DataStartAcquireThread(void *this_pointer){ void* qDrawPlot::DataStartAcquireThread(void *this_pointer){
cout << "before acquire ...." << endl; cout << "before acquire ...." << endl;
((qDrawPlot*)this_pointer)->myDet->acquire(1); ((qDrawPlot*)this_pointer)->myDet->acquire(1);
@ -406,19 +435,24 @@ void* qDrawPlot::DataStartAcquireThread(void *this_pointer){
return this_pointer; return this_pointer;
} }
//------------------------------------------------------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------------------------------------------------------
int qDrawPlot::GetDataCallBack(detectorData *data, void *this_pointer){ int qDrawPlot::GetDataCallBack(detectorData *data, void *this_pointer){
((qDrawPlot*)this_pointer)->GetData(data); ((qDrawPlot*)this_pointer)->GetData(data);
return 0; return 0;
} }
//------------------------------------------------------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------------------------------------------------------
int qDrawPlot::GetData(detectorData *data){ int qDrawPlot::GetData(detectorData *data){
#ifdef VERYVERBOSE #ifdef VERYVERBOSE
cout << "Entering GetDatafunction" << endl; cout << "Entering GetDatafunction" << endl;
#endif #endif
cout<<"progress:"<<(int)data->progressIndex<<endl;
if(!stop_signal){ if(!stop_signal){
//set title //set title
@ -618,43 +652,56 @@ int qDrawPlot::GetAcquisitionFinishedCallBack(double currentProgress,int detecto
//------------------------------------------------------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------------------------------------------------------
int qDrawPlot::AcquisitionFinished(double currentProgress,int detectorStatus){ int qDrawPlot::AcquisitionFinished(double currentProgress, int detectorStatus){
#ifdef VERBOSE #ifdef VERBOSE
cout << "Entering Acquisition Finished with status " << cout << "Entering Acquisition Finished with status " <<
slsDetectorBase::runStatusType((slsDetectorDefs::runStatus(detectorStatus))) << " and progress " << currentProgress << endl; slsDetectorBase::runStatusType((slsDetectorDefs::runStatus(detectorStatus))) << " and progress " << currentProgress << endl;
#endif #endif
//error or stopped
//error if((stop_signal)||(detectorStatus==slsDetectorDefs::ERROR)){
if(currentProgress!=100){ #ifdef VERBOSE
cout << "Error in Acquisition" << endl;
#endif
//just to be sure //just to be sure
stop_signal = 1; stop_signal = 1;
StartStopDaqToggle(true); StartStopDaqToggle(true);
emit AcquisitionErrorSignal(); emit AcquisitionErrorSignal();
} }
//normal stop else{
else if(!stop_signal){ //all measurements are over
currentMeasurement++; if(currentProgress==100){
cout<<"currentMeasurement:"<<currentMeasurement<<endl; #ifdef VERBOSE
// To start the next measurement cout << "Acquisition Finished" << endl;
if(currentMeasurement!=number_of_measurements){ #endif
emit SetCurrentMeasurementSignal(currentMeasurement);
StopDaqForGui();
StartDaq(true);
}// if all the measurements are over
else{
StartStopDaqToggle(true); StartStopDaqToggle(true);
emit UpdatingPlotFinished(); emit UpdatingPlotFinished();
} }
else{//next measurement
currentMeasurement++;
#ifdef VERBOSE
cout << "currentMeasurement:" << currentMeasurement << endl;
#endif
emit SetCurrentMeasurementSignal(currentMeasurement);
SetupMeasurement();
}
} }
return 0; return 0;
} }
//-------------------------------------------------------------------------------------------------------------------------------------------------
void qDrawPlot::ShowAcquisitionErrorMessage(){ void qDrawPlot::ShowAcquisitionErrorMessage(){
int detStatus = (int)myDet->getRunStatus(); if(!alreadyDisplayed){
string status = slsDetectorBase::runStatusType(slsDetectorDefs::runStatus(detStatus)); alreadyDisplayed = true;
qDefs::Message(qDefs::WARNING,string("<nobr>The acquisiton has ended abruptly. Current Detector Status: ")+status+string(".</nobr>"),"Dock"); int detStatus = (int)myDet->getRunStatus();
string status = slsDetectorBase::runStatusType(slsDetectorDefs::runStatus(detStatus));
qDefs::Message(qDefs::WARNING,string("<nobr>The acquisiton has ended abruptly. Current Detector Status: ")+status+string(".</nobr>"),"Dock");
}
} }
//------------------------------------------------------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------------------------------------------------------

20
slsDetectorGui/src/qTabAdvanced.cpp
View File

@ -346,6 +346,26 @@ void qTabAdvanced::UpdatePlot(){
cout << "Updating Plot" << endl; cout << "Updating Plot" << endl;
#endif #endif
int nPixelsX = myDet->getTotalNumberOfChannels();
int *histXAxis = new int[nPixelsX];
int *histYAxis = new int[100];
for(int i=0;i<nPixelsX;i++) histXAxis[i] = i;
int channelsPerDetector;
/*
for(int det=0;det<myDet->getNumberOfDetectors();det++){
slsDetector *s = myDet->getSlsDetector(det);
channelsPerDetector=s->getTotalNumberOfChannels();
if(s->chanregs){
for(int i=0;i<channelsPerDetector;i++){
memcpy(histYAxis + (det*channelsPerDetector*sizeof(int)),s->chanregs,channelsPerDetector*sizeof(int));
}
}
}
*/
cout<<"histyaxis[500]:"<<histYAxis[500]<<endl;
} }

2
slsDetectorGui/src/qTabDataOutput.cpp
View File

@ -46,7 +46,7 @@ qTabDataOutput::~qTabDataOutput(){
//------------------------------------------------------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------------------------------------------------------
void qTabDataOutput::SetupWidgetWindow(){ void qTabDataOutput::SetupWidgetWindow(){cout<<"in here"<<endl;
// Detector Type // Detector Type
detType=myDet->getDetectorsType(); detType=myDet->getDetectorsType();

58
slsDetectorGui/src/qTabMeasurement.cpp
View File

@ -48,7 +48,7 @@ qTabMeasurement::~qTabMeasurement(){
void qTabMeasurement::SetupWidgetWindow(){ void qTabMeasurement::SetupWidgetWindow(){
//Number of measurements //Number of measurements
numMeasurement=1; spinNumMeasurements->setValue((int)myDet->setTimer(slsDetectorDefs::MEASUREMENTS_NUMBER,-1));
//Timer to update the progress bar //Timer to update the progress bar
progressTimer = new QTimer(this); progressTimer = new QTimer(this);
@ -66,6 +66,7 @@ void qTabMeasurement::SetupWidgetWindow(){
"<nobr> #period#</nobr><br><br>")+ "<nobr> #period#</nobr><br><br>")+
QString("<nobr><font color=\"red\"><b>Acquisition Period</b> should be" QString("<nobr><font color=\"red\"><b>Acquisition Period</b> should be"
" greater than or equal to <b>Exposure Time</b>.</font></nobr>"); " greater than or equal to <b>Exposure Time</b>.</font></nobr>");
//File Name //File Name
dispFileName->setText(QString(myDet->getFileName().c_str())); dispFileName->setText(QString(myDet->getFileName().c_str()));
//File Index //File Index
@ -92,6 +93,24 @@ void qTabMeasurement::SetupWidgetWindow(){
//------------------------------------------------------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------------------------------------------------------
void qTabMeasurement::SetExpertMode(bool enable){
expertMode = enable;
lblNumProbes->setEnabled(enable);
spinNumProbes->setEnabled(enable);
//Number of Probes
if((enable)&&(myDet->getDetectorsType()==slsDetectorDefs::MYTHEN)){
int val = (int)myDet->setTimer(slsDetectorDefs::PROBES_NUMBER,-1);
spinNumProbes->setValue(val);
#ifdef VERBOSE
cout << "Getting number of probes : " << val << endl;
#endif
}
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
void qTabMeasurement::SetupTimingMode(){ void qTabMeasurement::SetupTimingMode(){
//Get timing mode from detector //Get timing mode from detector
slsDetectorDefs::externalCommunicationMode mode = myDet->setExternalCommunicationMode(); slsDetectorDefs::externalCommunicationMode mode = myDet->setExternalCommunicationMode();
@ -251,16 +270,6 @@ void qTabMeasurement::Enable(bool enable){
//------------------------------------------------------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------------------------------------------------------
void qTabMeasurement::setNumMeasurements(int val){
#ifdef VERBOSE
cout << "Setting Number of Measurements to " << val << endl;
#endif
numMeasurement = val;
myPlot->setNumMeasurements(val);
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
void qTabMeasurement::setFileName(const QString& fName){ void qTabMeasurement::setFileName(const QString& fName){
myDet->setFileName(fName.toAscii().data()); myDet->setFileName(fName.toAscii().data());
#ifdef VERBOSE #ifdef VERBOSE
@ -302,13 +311,13 @@ void qTabMeasurement::startStopAcquisition(){
#ifdef VERBOSE #ifdef VERBOSE
cout << "Stopping Acquisition" << endl<< endl; cout << "Stopping Acquisition" << endl<< endl;
#endif #endif
emit StopSignal();
myDet->stopAcquisition(); myDet->stopAcquisition();
progressTimer->stop(); progressTimer->stop();
btnStartStop->setText("Start"); btnStartStop->setText("Start");
btnStartStop->setIcon(*iconStart); btnStartStop->setIcon(*iconStart);
btnStartStop->setChecked(false); btnStartStop->setChecked(false);
Enable(1); Enable(1);
emit StopSignal();
} }
} }
@ -342,7 +351,8 @@ void qTabMeasurement::SetCurrentMeasurement(int val){
void qTabMeasurement::UpdateProgress(){ void qTabMeasurement::UpdateProgress(){
progressBar->setValue((int)(((currentMeasurement*100)+(myPlot->GetProgress()))/numMeasurement)); //progressBar->setValue((int)(((currentMeasurement*100)+(myPlot->GetProgress()))/spinNumMeasurements->value()));
progressBar->setValue((int)myPlot->GetProgress());
lblProgressIndex->setText(QString::number(myDet->getFileIndex())); lblProgressIndex->setText(QString::number(myDet->getFileIndex()));
} }
@ -350,12 +360,22 @@ void qTabMeasurement::UpdateProgress(){
//------------------------------------------------------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------------------------------------------------------
void qTabMeasurement::setNumMeasurements(int val){
myDet->setTimer(slsDetectorDefs::MEASUREMENTS_NUMBER,val);
#ifdef VERBOSE
cout << "Setting Number of Measurements to " << (int)myDet->setTimer(slsDetectorDefs::MEASUREMENTS_NUMBER,-1) << endl;
#endif
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
void qTabMeasurement::setNumFrames(int val){ void qTabMeasurement::setNumFrames(int val){
myDet->setTimer(slsDetectorDefs::FRAME_NUMBER,val); myDet->setTimer(slsDetectorDefs::FRAME_NUMBER,val);
#ifdef VERBOSE #ifdef VERBOSE
cout << "Setting number of frames to " << (int)myDet->setTimer(slsDetectorDefs::FRAME_NUMBER,-1) << endl; cout << "Setting number of frames to " << (int)myDet->setTimer(slsDetectorDefs::FRAME_NUMBER,-1) << endl;
#endif #endif
} }
@ -567,12 +587,12 @@ void qTabMeasurement::SetTimingMode(int mode){
} }
if(mode!=None){//Number of Probes //Number of Probes
if((myDet->getDetectorsType()==slsDetectorDefs::MYTHEN)&&(expertMode)){ if((expertMode)&&(myDet->getDetectorsType()==slsDetectorDefs::MYTHEN)){
lblNumProbes->setEnabled(true); spinNumProbes->setEnabled(true); lblNumProbes->setEnabled(true); spinNumProbes->setEnabled(true);
}
} }
//To disconnect all the signals before changing their values //To disconnect all the signals before changing their values
DeInitialization(); DeInitialization();
@ -703,6 +723,8 @@ void qTabMeasurement::EnableFileWrite(bool enable){
void qTabMeasurement::Refresh(){ void qTabMeasurement::Refresh(){
//Number of measurements
spinNumMeasurements->setValue((int)myDet->setTimer(slsDetectorDefs::MEASUREMENTS_NUMBER,-1));
//File Name //File Name
dispFileName->setText(QString(myDet->getFileName().c_str())); dispFileName->setText(QString(myDet->getFileName().c_str()));
//File Index //File Index