\section{sls\-Detector Class Reference}
\label{classslsDetector}\index{slsDetector@{slsDetector}}
This is the base class for all SLS detector functionalities.  


{\tt \#include $<$sls\-Detector.h$>$}

Inheritance diagram for sls\-Detector::\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[height=2cm]{classslsDetector}
\end{center}
\end{figure}
\subsection*{Public Types}
\begin{CompactItemize}
\item 
typedef \bf{sls\-Detector::shared\-Sls\-Detector} \bf{shared\-Sls\-Detector}
\begin{CompactList}\small\item\em Structure allocated in shared memory to store detector settings and be accessed in parallel by several applications (take care of possible conflicts!). \item\end{CompactList}\item 
\bf{GET\_\-ONLINE\_\-FLAG}
\item 
\bf{OFFLINE\_\-FLAG}
\item 
\bf{ONLINE\_\-FLAG}
\item 
enum \{ \bf{GET\_\-ONLINE\_\-FLAG}, 
\bf{OFFLINE\_\-FLAG}, 
\bf{ONLINE\_\-FLAG}
 \}
\end{CompactItemize}
\subsection*{Public Member Functions}
\begin{CompactItemize}
\item 
\bf{sls\-Detector} (\bf{detector\-Type} type=GENERIC, int id=0)
\item 
\bf{$\sim$sls\-Detector} ()
\item 
int \bf{set\-Online} (int const online)
\item 
int \bf{exists} ()
\item 
int \bf{read\-Configuration\-File} (string const fname)
\item 
int \bf{write\-Configuration\-File} (string const fname)
\item 
int \bf{dump\-Detector\-Setup} (string const fname)
\item 
int \bf{retrieve\-Detector\-Setup} (string const fname)
\item 
int \bf{set\-TCPSocket} (string const name=\char`\"{}\char`\"{}, int const control\_\-port=-1, int const stop\_\-port=-1, int const data\_\-port=-1)
\item 
char $\ast$ \bf{get\-Hostname} ()
\item 
int \bf{get\-Control\-Port} ()
\item 
int \bf{get\-Stop\-Port} ()
\item 
int \bf{get\-Data\-Port} ()
\item 
char $\ast$ \bf{get\-Trim\-Dir} ()
\item 
char $\ast$ \bf{set\-Trim\-Dir} (string s)
\item 
int \bf{get\-Trim\-En} (int $\ast$en)
\item 
\bf{sls\_\-detector\_\-module} $\ast$ \bf{read\-Trim\-File} (string fname, \bf{sls\_\-detector\_\-module} $\ast$my\-Mod=NULL)
\item 
int \bf{write\-Trim\-File} (string fname, \bf{sls\_\-detector\_\-module} mod)
\item 
int \bf{write\-Trim\-File} (string fname, int imod)
\item 
char $\ast$ \bf{set\-File\-Path} (string s)
\item 
char $\ast$ \bf{set\-File\-Name} (string s)
\item 
int \bf{set\-File\-Index} (int i)
\item 
char $\ast$ \bf{get\-File\-Path} ()
\item 
char $\ast$ \bf{get\-File\-Name} ()
\item 
int \bf{get\-File\-Index} ()
\item 
string \bf{create\-File\-Name} ()
\item 
int \bf{write\-Data\-File} (string fname, float $\ast$data, float $\ast$err=NULL, float $\ast$ang=NULL, char dataformat='f', int nch=-1)
\item 
int \bf{write\-Data\-File} (string fname, int $\ast$data)
\item 
int \bf{read\-Data\-File} (string fname, float $\ast$data, float $\ast$err=NULL, float $\ast$ang=NULL, char dataformat='f', int nch=0)
\item 
int \bf{read\-Data\-File} (string fname, int $\ast$data)
\item 
char $\ast$ \bf{get\-Cal\-Dir} ()
\item 
char $\ast$ \bf{set\-Cal\-Dir} (string s)
\item 
int \bf{read\-Calibration\-File} (string fname, float \&gain, float \&offset)
\item 
int \bf{write\-Calibration\-File} (string fname, float gain, float offset)
\item 
int \bf{read\-Angular\-Conversion} (string fname=\char`\"{}\char`\"{})
\item 
int \bf{write\-Angular\-Conversion} (string fname=\char`\"{}\char`\"{})
\item 
int \bf{exec\-Command} (string cmd, string answer)
\item 
int \bf{set\-Detector\-Type} (\bf{detector\-Type} type=GET\_\-DETECTOR\_\-TYPE)
\item 
int \bf{set\-Detector\-Type} (string type)
\item 
void \bf{get\-Detector\-Type} (char $\ast$type)
\item 
int \bf{set\-Number\-Of\-Modules} (int n, \bf{dimension} d=X)
\item 
int \bf{get\-Max\-Number\-Of\-Modules} (\bf{dimension} d=X)
\item 
\bf{external\-Signal\-Flag} \bf{set\-External\-Signal\-Flags} (\bf{external\-Signal\-Flag} pol=GET\_\-EXTERNAL\_\-SIGNAL\_\-FLAG, int signalindex=0)
\item 
\bf{external\-Communication\-Mode} \bf{set\-External\-Communication\-Mode} (\bf{external\-Communication\-Mode} pol=GET\_\-EXTERNAL\_\-COMMUNICATION\_\-MODE)
\item 
int64\_\-t \bf{get\-Id} (\bf{id\-Mode} mode, int imod=0)
\item 
int \bf{digital\-Test} (\bf{digital\-Test\-Mode} mode, int imod=0)
\item 
int $\ast$ \bf{analog\-Test} (\bf{analog\-Test\-Mode} mode)
\item 
int \bf{enable\-Analog\-Output} (int ichan)
\item 
int \bf{enable\-Analog\-Output} (int imod, int ichip, int ichan)
\item 
int \bf{give\-Calibration\-Pulse} (float vcal, int npulses)
\item 
int \bf{write\-Register} (int addr, int val)
\item 
int \bf{read\-Register} (int addr)
\item 
float \bf{set\-DAC} (float val, \bf{dac\-Index} index, int imod=-1)
\item 
float \bf{get\-ADC} (\bf{dac\-Index} index, int imod=0)
\item 
int \bf{set\-Channel} (int64\_\-t reg, int ichan=-1, int ichip=-1, int imod=-1)
\item 
int \bf{set\-Channel} (\bf{sls\_\-detector\_\-channel} chan)
\item 
\bf{sls\_\-detector\_\-channel} \bf{get\-Channel} (int ichan, int ichip, int imod)
\item 
int \bf{set\-Chip} (int reg, int ichip=-1, int imod=-1)
\item 
int \bf{set\-Chip} (\bf{sls\_\-detector\_\-chip} chip)
\item 
\bf{sls\_\-detector\_\-chip} \bf{get\-Chip} (int ichip, int imod)
\item 
int \bf{set\-Module} (int reg, int imod=-1)
\item 
int \bf{set\-Module} (\bf{sls\_\-detector\_\-module} module)
\item 
\bf{sls\_\-detector\_\-module} $\ast$ \bf{get\-Module} (int imod)
\item 
int \bf{get\-Threshold\-Energy} (int imod=-1)
\item 
int \bf{set\-Threshold\-Energy} (int e\_\-e\-V, int imod=-1, \bf{detector\-Settings} isettings=GET\_\-SETTINGS)
\item 
\bf{detector\-Settings} \bf{get\-Settings} (int imod=-1)
\item 
\bf{detector\-Settings} \bf{set\-Settings} (\bf{detector\-Settings} isettings, int imod=-1)
\item 
int \bf{start\-Acquisition} ()
\item 
int \bf{stop\-Acquisition} ()
\item 
int \bf{start\-Read\-Out} ()
\item 
int \bf{get\-Run\-Status} ()
\item 
int $\ast$ \bf{start\-And\-Read\-All} ()
\item 
int \bf{start\-And\-Read\-All\-No\-Wait} ()
\item 
int $\ast$ \bf{get\-Data\-From\-Detector\-No\-Wait} ()
\item 
int $\ast$ \bf{read\-Frame} ()
\item 
int $\ast$ \bf{read\-All} ()
\item 
int $\ast$ \bf{pop\-Data\-Queue} ()
\item 
int64\_\-t \bf{set\-Timer} (\bf{timer\-Index} index, int64\_\-t t=-1)
\item 
int64\_\-t \bf{get\-Time\-Left} (\bf{timer\-Index} index)
\item 
int \bf{set\-Clock\-Divider} (int i)
\item 
int \bf{get\-Clock\-Divider} ()
\item 
int \bf{set\-Set\-Length} (int i)
\item 
int \bf{get\-Set\-Length} ()
\item 
int \bf{set\-Dynamic\-Range} (int n=-1)
\item 
int \bf{set\-ROI} (int nroi=-1, int $\ast$xmin=NULL, int $\ast$xmax=NULL, int $\ast$ymin=NULL, int $\ast$ymax=NULL)
\item 
int \bf{set\-Read\-Out\-Flags} (\bf{read\-Out\-Flags} flag)
\item 
int \bf{execute\-Trimming} (\bf{trim\-Mode} mode, int par1, int par2, int imod=-1)
\item 
int \bf{set\-Flat\-Field\-Correction} (string fname=\char`\"{}\char`\"{})
\item 
int \bf{get\-Flat\-Field\-Corrections} (float $\ast$corr=NULL, float $\ast$ecorr=NULL)
\item 
int \bf{set\-Rate\-Correction} (float t=0)
\item 
int \bf{get\-Rate\-Corrections} (float \&t)
\item 
int \bf{get\-Rate\-Corrections} ()
\item 
int \bf{set\-Bad\-Channel\-Correction} (string fname=\char`\"{}\char`\"{})
\item 
int \bf{get\-Bad\-Channel\-Corrections} (int $\ast$bad=NULL)
\item 
int \bf{set\-Angular\-Conversion} (string fname=\char`\"{}\char`\"{})
\item 
int \bf{get\-Angular\-Conversion} (int \&direction, \bf{angle\-Conversion\-Constant} $\ast$angconv=NULL)
\item 
float \bf{set\-Global\-Offset} (float f)
\item 
float \bf{set\-Fine\-Offset} (float f)
\item 
float \bf{get\-Fine\-Offset} ()
\item 
float \bf{get\-Global\-Offset} ()
\item 
int \bf{set\-Positions} (int n\-Pos, float $\ast$\bf{pos})
\item 
int \bf{get\-Positions} (float $\ast$\bf{pos}=NULL)
\item 
float \bf{set\-Bin\-Size} (float bs)
\item 
float \bf{get\-Bin\-Size} ()
\item 
float $\ast$ \bf{decode\-Data} (int $\ast$datain)
\item 
int \bf{flat\-Field\-Correct} (float datain, float errin, float \&dataout, float \&errout, float ffcoefficient, float fferr)
\item 
int \bf{flat\-Field\-Correct} (float $\ast$datain, float $\ast$errin, float $\ast$dataout, float $\ast$errout)
\item 
int \bf{rate\-Correct} (float datain, float errin, float \&dataout, float \&errout, float tau, float t)
\item 
int \bf{rate\-Correct} (float $\ast$datain, float $\ast$errin, float $\ast$dataout, float $\ast$errout)
\item 
int \bf{reset\-Merging} (float $\ast$mp, float $\ast$mv, float $\ast$me, int $\ast$mm)
\item 
int \bf{add\-To\-Merging} (float $\ast$p1, float $\ast$v1, float $\ast$e1, float $\ast$mp, float $\ast$mv, float $\ast$me, int $\ast$mm)
\item 
int \bf{finalize\-Merging} (float $\ast$mp, float $\ast$mv, float $\ast$me, int $\ast$mm)
\item 
int \bf{exit\-Server} ()
\item 
void $\ast$ \bf{process\-Data} ()
\item 
\bf{sls\_\-detector\_\-module} $\ast$ \bf{create\-Module} ()
\item 
void \bf{delete\-Module} (\bf{sls\_\-detector\_\-module} $\ast$my\-Mod)
\item 
void \bf{acquire} ()
\end{CompactItemize}
\subsection*{Private Member Functions}
\begin{CompactItemize}
\item 
int $\ast$ \bf{get\-Data\-From\-Detector} ()
\item 
int \bf{init\-Shared\-Memory} (\bf{detector\-Type} type=GENERIC, int id=0)
\item 
int \bf{free\-Shared\-Memory} ()
\item 
int \bf{initialize\-Detector\-Size} (\bf{detector\-Type} type)
\item 
int \bf{initialize\-Detector\-Structure} ()
\item 
int \bf{send\-Channel} (\bf{sls\_\-detector\_\-channel} $\ast$)
\item 
int \bf{send\-Chip} (\bf{sls\_\-detector\_\-chip} $\ast$)
\item 
int \bf{send\-Module} (\bf{sls\_\-detector\_\-module} $\ast$)
\item 
int \bf{receive\-Channel} (\bf{sls\_\-detector\_\-channel} $\ast$)
\item 
int \bf{receive\-Chip} (\bf{sls\_\-detector\_\-chip} $\ast$)
\item 
int \bf{receive\-Module} (\bf{sls\_\-detector\_\-module} $\ast$)
\item 
void \bf{start\-Thread} ()
\item 
int \bf{fill\-Bad\-Channel\-Mask} ()
\end{CompactItemize}
\subsection*{Private Attributes}
\begin{CompactItemize}
\item 
\bf{shared\-Sls\-Detector} $\ast$ \bf{this\-Detector}
\item 
int \bf{online\-Flag}
\item 
int \bf{det\-Id}
\item 
int \bf{shm\-Id}
\item 
\bf{My\-Socket\-TCP} $\ast$ \bf{control\-Socket}
\item 
\bf{My\-Socket\-TCP} $\ast$ \bf{stop\-Socket}
\item 
\bf{My\-Socket\-TCP} $\ast$ \bf{data\-Socket}
\item 
queue$<$ int $\ast$ $>$ \bf{data\-Queue}
\item 
pthread\_\-t \bf{data\-Processing\-Thread}
\item 
float \bf{current\-Position}
\item 
float \bf{current\-Position\-Index}
\item 
float \bf{current\-I0}
\item 
float $\ast$ \bf{merging\-Bins}
\item 
float $\ast$ \bf{merging\-Counts}
\item 
float $\ast$ \bf{merging\-Errors}
\item 
int $\ast$ \bf{merging\-Multiplicity}
\item 
float $\ast$ \bf{ffcoefficients}
\item 
float $\ast$ \bf{fferrors}
\item 
\bf{sls\_\-detector\_\-module} $\ast$ \bf{detector\-Modules}
\item 
float $\ast$ \bf{dacs}
\item 
float $\ast$ \bf{adcs}
\item 
int $\ast$ \bf{chipregs}
\item 
int $\ast$ \bf{chanregs}
\item 
int $\ast$ \bf{bad\-Channel\-Mask}
\end{CompactItemize}
\subsection*{Classes}
\begin{CompactItemize}
\item 
struct \bf{shared\-Sls\-Detector}
\begin{CompactList}\small\item\em Structure allocated in shared memory to store detector settings and be accessed in parallel by several applications (take care of possible conflicts!). \item\end{CompactList}\end{CompactItemize}


\subsection{Detailed Description}
This is the base class for all SLS detector functionalities. 

The \doxyref{sls\-Detector}{p.}{classslsDetector} class is expected to become the interface class for all SLS Detectors acquisition (and analysis) software.

\begin{Desc}
\item[Author:]Anna Bergamaschi \end{Desc}
\begin{Desc}
\item[Version:]0.1alpha (any string) \end{Desc}




\subsection{Member Typedef Documentation}
\index{slsDetector@{sls\-Detector}!sharedSlsDetector@{sharedSlsDetector}}
\index{sharedSlsDetector@{sharedSlsDetector}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}typedef struct \bf{sls\-Detector::shared\-Sls\-Detector}  \bf{sls\-Detector::shared\-Sls\-Detector}}\label{classslsDetector_2dd6bff7d94ab8005c2797152b19264e}


Structure allocated in shared memory to store detector settings and be accessed in parallel by several applications (take care of possible conflicts!). 



\subsection{Member Enumeration Documentation}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}anonymous enum}\label{classslsDetector_ac085f1939dcfed328dc6ff4b11fdb44}


online flags enum\begin{Desc}
\item[See also:]\doxyref{set\-Online}{p.}{classslsDetector_f041f723f702c17de292061d6d609698} \end{Desc}
\begin{Desc}
\item[Enumerator: ]\par
\begin{description}
\index{GET_ONLINE_FLAG@{GET\_\-ONLINE\_\-FLAG}!slsDetector@{slsDetector}}\index{slsDetector@{slsDetector}!GET_ONLINE_FLAG@{GET\_\-ONLINE\_\-FLAG}}\item[{\em 
GET\_\-ONLINE\_\-FLAG\label{classslsDetector_ac085f1939dcfed328dc6ff4b11fdb44617c55ac8cf00235b76c1c1481238abb}
}]returns wether the detector is in online or offline state \index{OFFLINE_FLAG@{OFFLINE\_\-FLAG}!slsDetector@{slsDetector}}\index{slsDetector@{slsDetector}!OFFLINE_FLAG@{OFFLINE\_\-FLAG}}\item[{\em 
OFFLINE\_\-FLAG\label{classslsDetector_ac085f1939dcfed328dc6ff4b11fdb44da0a4f5b33e634292bc99256a9552f2f}
}]detector in offline state (i.e. no communication to the detector - using only local structure - no data acquisition possible!) \index{ONLINE_FLAG@{ONLINE\_\-FLAG}!slsDetector@{slsDetector}}\index{slsDetector@{slsDetector}!ONLINE_FLAG@{ONLINE\_\-FLAG}}\item[{\em 
ONLINE\_\-FLAG\label{classslsDetector_ac085f1939dcfed328dc6ff4b11fdb44d3b612a2eb0d1029bd260b502afcf632}
}]detector in online state (i.e. communication to the detector updating the local structure) \end{description}
\end{Desc}



\subsection{Constructor \& Destructor Documentation}
\index{slsDetector@{sls\-Detector}!slsDetector@{slsDetector}}
\index{slsDetector@{slsDetector}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}sls\-Detector::sls\-Detector (\bf{detector\-Type} {\em type} = {\tt GENERIC}, int {\em id} = {\tt 0})}\label{classslsDetector_eea9fc044ff9d496e4338efaaf176498}


(default) constructor \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em type}]is needed to define the size of the detector shared memory 9defaults to GENERIC i.e. the largest shared memory needed by any \doxyref{sls\-Detector}{p.}{classslsDetector} is allocated \item[{\em id}]is the detector index which is needed to define the shared memory id. Different physical detectors should have different IDs in order to work independently \end{description}
\end{Desc}


sets online\-Flag to OFFLINE\_\-FLAG

Initlializes shared memory \begin{Desc}
\item[See also:]\doxyref{init\-Shared\-Memory}{p.}{classslsDetector_cb94b9bfa7bbea2d9e1b0289a272bca8}\end{Desc}
if it fails the detector id is incremented until it succeeds

Initializes the detector stucture \begin{Desc}
\item[See also:]\doxyref{initialize\-Detector\-Size}{p.}{classslsDetector_19f1c6d120293c98a0d2dc992e5616f8} \end{Desc}
\index{slsDetector@{sls\-Detector}!~slsDetector@{$\sim$slsDetector}}
\index{~slsDetector@{$\sim$slsDetector}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}sls\-Detector::$\sim$sls\-Detector ()\hspace{0.3cm}{\tt  [inline]}}\label{classslsDetector_7653e532ff88dbf403e270769bccc509}


destructor 

\subsection{Member Function Documentation}
\index{slsDetector@{sls\-Detector}!acquire@{acquire}}
\index{acquire@{acquire}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void sls\-Detector::acquire ()}\label{classslsDetector_b09a80264ca69e51b2c8379124398410}


\index{slsDetector@{sls\-Detector}!addToMerging@{addToMerging}}
\index{addToMerging@{addToMerging}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::add\-To\-Merging (float $\ast$ {\em p1}, float $\ast$ {\em v1}, float $\ast$ {\em e1}, float $\ast$ {\em mp}, float $\ast$ {\em mv}, float $\ast$ {\em me}, int $\ast$ {\em mm})}\label{classslsDetector_ed3ddadb246080ef644b6d1455fa2e32}


not yet implemented merge dataset \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p1}]angular positions of dataset \item[{\em v1}]data \item[{\em e1}]errors \item[{\em mp}]already merged postions \item[{\em mv}]already merged data \item[{\em me}]already merged errors (squared sum) \item[{\em mm}]multiplicity of merged arrays \end{description}
\end{Desc}


Reimplemented in \bf{mythen\-Detector} \doxyref{p.}{classmythenDetector_eaaf7d7e3150f473e3bbcf59d91692c2}.\index{slsDetector@{sls\-Detector}!analogTest@{analogTest}}
\index{analogTest@{analogTest}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int$\ast$ sls\-Detector::analog\-Test (\bf{analog\-Test\-Mode} {\em mode})}\label{classslsDetector_18f91f8cf70d2d4eef9b3488b90bac51}


analog test \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em modte}]test mode \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]pointer to acquired data\end{Desc}
not yet implemented \index{slsDetector@{sls\-Detector}!createFileName@{createFileName}}
\index{createFileName@{createFileName}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}string sls\-Detector::create\-File\-Name ()}\label{classslsDetector_d055c470ae6faa973980f4dbf021132d}


generates file name without extension

always appends to file path and file name the run index.

in case also appends the position index

Filenames will be of the form: filepath/filename(\_\-px)\_\-i where x is the position index and i is the run index \index{slsDetector@{sls\-Detector}!createModule@{createModule}}
\index{createModule@{createModule}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}sls\-Detector::sls\_\-detector\_\-module $\ast$ sls\-Detector::create\-Module ()}\label{classslsDetector_15e6fa87a3c57ff1c8e1943ec72ec6ad}


Allocates the memory for a \doxyref{sls\_\-detector\_\-module}{p.}{structsls__detector__module} structure and initializes it \begin{Desc}
\item[Returns:]my\-Mod the pointer to the allocate dmemory location \end{Desc}
\index{slsDetector@{sls\-Detector}!decodeData@{decodeData}}
\index{decodeData@{decodeData}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}float $\ast$ sls\-Detector::decode\-Data (int $\ast$ {\em datain})}\label{classslsDetector_937d257464bade6dc6d3ab42c86843ba}


decode data from the detector converting them to an array of floats, one for each channle \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em datain}]data from the detector \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]pointer to a float array with a data per channel \end{Desc}


Reimplemented in \bf{mythen\-Detector} \doxyref{p.}{classmythenDetector_77e8c92003fab14da768af660509241d}, and \bf{eiger\-Detector} \doxyref{p.}{classeigerDetector_3e0573baf38c37818c7769fb351010b3}.\index{slsDetector@{sls\-Detector}!deleteModule@{deleteModule}}
\index{deleteModule@{deleteModule}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void sls\-Detector::delete\-Module (\bf{sls\_\-detector\_\-module} $\ast$ {\em my\-Mod})}\label{classslsDetector_48984c8d058355c5249233165bf0c410}


frees the memory for a \doxyref{sls\_\-detector\_\-module}{p.}{structsls__detector__module} structure \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em my\-Mod}]the pointer to the memory to be freed \end{description}
\end{Desc}
\index{slsDetector@{sls\-Detector}!digitalTest@{digitalTest}}
\index{digitalTest@{digitalTest}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::digital\-Test (\bf{digital\-Test\-Mode} {\em mode}, int {\em imod} = {\tt 0})}\label{classslsDetector_40906e79010db5b8082d4855a3824aa7}


Digital test of the modules \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em mode}]test mode \item[{\em imod}]module number for chip test or module firmware test \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]OK or error mask \end{Desc}
\index{slsDetector@{sls\-Detector}!dumpDetectorSetup@{dumpDetectorSetup}}
\index{dumpDetectorSetup@{dumpDetectorSetup}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::dump\-Detector\-Setup (string const  {\em fname})}\label{classslsDetector_dc4f62e536b4ef6d0d2d178e3bfbec5e}


not yet implemented

should dump to a file all the current detector parameters \index{slsDetector@{sls\-Detector}!enableAnalogOutput@{enableAnalogOutput}}
\index{enableAnalogOutput@{enableAnalogOutput}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::enable\-Analog\-Output (int {\em imod}, int {\em ichip}, int {\em ichan})}\label{classslsDetector_b20fef344ee47114fccb4d1bc8c6e5bd}


enable analog output of channel ichan, chip ichip, module imod

not yet implemented \index{slsDetector@{sls\-Detector}!enableAnalogOutput@{enableAnalogOutput}}
\index{enableAnalogOutput@{enableAnalogOutput}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::enable\-Analog\-Output (int {\em ichan})}\label{classslsDetector_a83074759c48f194af2e45d1281cc818}


enable analog output of channel ichan

not yet implemented \index{slsDetector@{sls\-Detector}!execCommand@{execCommand}}
\index{execCommand@{execCommand}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::exec\-Command (string {\em cmd}, string {\em answer})}\label{classslsDetector_9fc0c9161e967094a535cc40bc33cc6b}


executes a system command on the server e.g. mount an nfs disk, reboot and returns answer etc. \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em cmd}]is the command to be executed \item[{\em answer}]is the answer from the detector \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]OK or FAIL depending on the command outcome \end{Desc}
\index{slsDetector@{sls\-Detector}!executeTrimming@{executeTrimming}}
\index{executeTrimming@{executeTrimming}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::execute\-Trimming (\bf{trim\-Mode} {\em mode}, int {\em par1}, int {\em par2}, int {\em imod} = {\tt -1})}\label{classslsDetector_a257317d18965a353679c66b15b0987d}


execute trimming \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em mode}]trim mode \item[{\em par1}]if noise, beam or fixed setting trimming it is count limit, if improve maximum number of iterations \item[{\em par2}]if noise or beam nsigma, if improve par2!=means vthreshold will be optimized, if fixed settings par2$<$0 trimwith median, par2$>$=0 trim with level \item[{\em imod}]module number (-1 all) \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]OK or FAIl (FAIL also if some channel are 0 or 63 \end{Desc}
\index{slsDetector@{sls\-Detector}!exists@{exists}}
\index{exists@{exists}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::exists ()\hspace{0.3cm}{\tt  [inline]}}\label{classslsDetector_bf592960cebe5b3f1e2fdc77f770f17a}


sets the online\-Flag \begin{Desc}
\item[Returns:]1 if the detector structure has already be initlialized, 0 otherwise \end{Desc}
\index{slsDetector@{sls\-Detector}!exitServer@{exitServer}}
\index{exitServer@{exitServer}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::exit\-Server ()}\label{classslsDetector_466e9a65aa0b404c771d70c9f01af8b9}


turns of server \index{slsDetector@{sls\-Detector}!fillBadChannelMask@{fillBadChannelMask}}
\index{fillBadChannelMask@{fillBadChannelMask}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::fill\-Bad\-Channel\-Mask ()\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_6a0ebe013e27c065b2f67158a27f64ac}


fill bad channel mask (0 if channel is good, 1 if bad) \index{slsDetector@{sls\-Detector}!finalizeMerging@{finalizeMerging}}
\index{finalizeMerging@{finalizeMerging}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::finalize\-Merging (float $\ast$ {\em mp}, float $\ast$ {\em mv}, float $\ast$ {\em me}, int $\ast$ {\em mm})}\label{classslsDetector_8f73479f68ca2171fd2108c2f157299e}


calculates the \char`\"{}final\char`\"{} positions, data value and errors for the emrged data \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em mp}]already merged postions \item[{\em mv}]already merged data \item[{\em me}]already merged errors (squared sum) \item[{\em mm}]multiplicity of merged arrays \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]FAIL or the \end{Desc}


Reimplemented in \bf{mythen\-Detector} \doxyref{p.}{classmythenDetector_a919a42bd89fe21c4086bae5f1fb2f32}.\index{slsDetector@{sls\-Detector}!flatFieldCorrect@{flatFieldCorrect}}
\index{flatFieldCorrect@{flatFieldCorrect}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::flat\-Field\-Correct (float $\ast$ {\em datain}, float $\ast$ {\em errin}, float $\ast$ {\em dataout}, float $\ast$ {\em errout})}\label{classslsDetector_1e6633db752222079b39a187e4d0e658}


flat field correct data \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em datain}]data array \item[{\em errin}]error array on data (if NULL will default to sqrt(datain) \item[{\em dataout}]array of corrected data \item[{\em errout}]error on corrected data (if not NULL) \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]0 \end{Desc}
\index{slsDetector@{sls\-Detector}!flatFieldCorrect@{flatFieldCorrect}}
\index{flatFieldCorrect@{flatFieldCorrect}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::flat\-Field\-Correct (float {\em datain}, float {\em errin}, float \& {\em dataout}, float \& {\em errout}, float {\em ffcoefficient}, float {\em fferr})}\label{classslsDetector_24c7dd58e00df0bf62221b7572430740}


flat field correct data \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em datain}]data \item[{\em errin}]error on data (if$<$=0 will default to sqrt(datain) \item[{\em dataout}]corrected data \item[{\em errout}]error on corrected data \item[{\em ffcoefficient}]flat field correction coefficient \item[{\em fferr}]erro on ffcoefficient \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]0 \end{Desc}
\index{slsDetector@{sls\-Detector}!freeSharedMemory@{freeSharedMemory}}
\index{freeSharedMemory@{freeSharedMemory}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::free\-Shared\-Memory ()\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_5de7fb0d82ae2bcc406385373e665c6f}


Frees the shared memory - should not be used \index{slsDetector@{sls\-Detector}!getADC@{getADC}}
\index{getADC@{getADC}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}float sls\-Detector::get\-ADC (\bf{dac\-Index} {\em index}, int {\em imod} = {\tt 0})}\label{classslsDetector_fa99bd04043c23b7ab583159dabebf93}


set dacs value \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em index}]ADC index \item[{\em imod}]module number \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]current ADC value \end{Desc}
\index{slsDetector@{sls\-Detector}!getAngularConversion@{getAngularConversion}}
\index{getAngularConversion@{getAngularConversion}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::get\-Angular\-Conversion (int \& {\em direction}, \bf{angle\-Conversion\-Constant} $\ast$ {\em angconv} = {\tt NULL})}\label{classslsDetector_a146baee5af54b53db0997de02f4779c}


get angular conversion \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em reference}]to diffractometer direction \item[{\em angconv}]array that will be filled with the angular conversion constants \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]0 if angular conversion disabled, $>$0 otherwise \end{Desc}


Reimplemented in \bf{mythen\-Detector} \doxyref{p.}{classmythenDetector_b2b2f17c36883323ad0abf762c63494f}.\index{slsDetector@{sls\-Detector}!getBadChannelCorrections@{getBadChannelCorrections}}
\index{getBadChannelCorrections@{getBadChannelCorrections}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::get\-Bad\-Channel\-Corrections (int $\ast$ {\em bad} = {\tt NULL})}\label{classslsDetector_f80db913b55026bb69d35585b08729cc}


get bad channels correction \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em bad}]pointer to array that if bad!=NULL will be filled with the bad channel list \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]0 if bad channel disabled or no bad channels, $>$0 otherwise \end{Desc}
\index{slsDetector@{sls\-Detector}!getBinSize@{getBinSize}}
\index{getBinSize@{getBinSize}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}float sls\-Detector::get\-Bin\-Size ()\hspace{0.3cm}{\tt  [inline]}}\label{classslsDetector_8a78eda56f5a0c487bbc4e2f962d04db}


return detector bin size used for merging (approx angular resolution) 

Reimplemented in \bf{mythen\-Detector} \doxyref{p.}{classmythenDetector_9fd4e479d7eb3f9c53d5d56a43bbccaf}.\index{slsDetector@{sls\-Detector}!getCalDir@{getCalDir}}
\index{getCalDir@{getCalDir}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ sls\-Detector::get\-Cal\-Dir ()\hspace{0.3cm}{\tt  [inline]}}\label{classslsDetector_102679594e60ed261daff24b4aeac21a}


returns the location of the calibration files \begin{Desc}
\item[See also:]\doxyref{shared\-Sls\-Detector}{p.}{structslsDetector_1_1sharedSlsDetector} \end{Desc}
\index{slsDetector@{sls\-Detector}!getChannel@{getChannel}}
\index{getChannel@{getChannel}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}sls\-Detector::sls\_\-detector\_\-channel sls\-Detector::get\-Channel (int {\em ichan}, int {\em ichip}, int {\em imod})}\label{classslsDetector_bbf8573e249da1f0a436f581d0dc62e4}


get channel \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ichan}]channel number \item[{\em ichip}]chip number \item[{\em imod}]module number \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]current channel structure for channel \end{Desc}
\index{slsDetector@{sls\-Detector}!getChip@{getChip}}
\index{getChip@{getChip}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}sls\-Detector::sls\_\-detector\_\-chip sls\-Detector::get\-Chip (int {\em ichip}, int {\em imod})}\label{classslsDetector_6dd6b42b668610dbd03a7700de84b845}


get chip \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ichip}]chip number \item[{\em imod}]module number \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]current chip structure for channel\end{Desc}
\begin{Desc}
\item[\bf{Bug}]probably does not return corretly! \end{Desc}
\index{slsDetector@{sls\-Detector}!getClockDivider@{getClockDivider}}
\index{getClockDivider@{getClockDivider}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::get\-Clock\-Divider ()\hspace{0.3cm}{\tt  [inline]}}\label{classslsDetector_12b884821edc41fe9821f2ab084a0baf}


get clock divider

not implemented (should be something more general like \char`\"{}set speed including also waitstates, set cycles etc.) \index{slsDetector@{sls\-Detector}!getControlPort@{getControlPort}}
\index{getControlPort@{getControlPort}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::get\-Control\-Port ()\hspace{0.3cm}{\tt  [inline]}}\label{classslsDetector_40ffd69f1c40b26575954e826cdf606a}


returns the detector control port\begin{Desc}
\item[See also:]\doxyref{shared\-Sls\-Detector}{p.}{structslsDetector_1_1sharedSlsDetector} \end{Desc}
\index{slsDetector@{sls\-Detector}!getDataFromDetector@{getDataFromDetector}}
\index{getDataFromDetector@{getDataFromDetector}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int $\ast$ sls\-Detector::get\-Data\-From\-Detector ()\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_b1982e89f8e8de63c807a707ccba594c}


Receives a data frame from the detector socket \begin{Desc}
\item[Returns:]pointer to the data (or NULL if failed) \end{Desc}
\index{slsDetector@{sls\-Detector}!getDataFromDetectorNoWait@{getDataFromDetectorNoWait}}
\index{getDataFromDetectorNoWait@{getDataFromDetectorNoWait}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int $\ast$ sls\-Detector::get\-Data\-From\-Detector\-No\-Wait ()}\label{classslsDetector_5b678231f1a0fafc518a95b6e58f00a8}


receives a data frame from the detector socket \begin{Desc}
\item[Returns:]pointer to the data or NULL. If NULL disconnects the socket \end{Desc}
\begin{Desc}
\item[See also:]\doxyref{get\-Data\-From\-Detector}{p.}{classslsDetector_b1982e89f8e8de63c807a707ccba594c} \end{Desc}
\index{slsDetector@{sls\-Detector}!getDataPort@{getDataPort}}
\index{getDataPort@{getDataPort}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::get\-Data\-Port ()\hspace{0.3cm}{\tt  [inline]}}\label{classslsDetector_35043766eecb3d760fd95d891bed8b16}


returns the detector data port\begin{Desc}
\item[See also:]\doxyref{shared\-Sls\-Detector}{p.}{structslsDetector_1_1sharedSlsDetector} \end{Desc}
\index{slsDetector@{sls\-Detector}!getDetectorType@{getDetectorType}}
\index{getDetectorType@{getDetectorType}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void sls\-Detector::get\-Detector\-Type (char $\ast$ {\em type})}\label{classslsDetector_d63d6420e411ff4b962930d9c4fd615d}


gets detector type normally the detector knows what type of detector it is \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em type}]is the string where the detector type will be written (\char`\"{}Mythen\char`\"{}, \char`\"{}Pilatus\char`\"{}, \char`\"{}XFS\char`\"{}, \char`\"{}Gotthard\char`\"{}, Agipd\char`\"{}) \end{description}
\end{Desc}
\index{slsDetector@{sls\-Detector}!getFileIndex@{getFileIndex}}
\index{getFileIndex@{getFileIndex}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::get\-File\-Index ()\hspace{0.3cm}{\tt  [inline]}}\label{classslsDetector_68b41fa20ddd8c6c67ac00dfea3c9796}


returns the default output file index \begin{Desc}
\item[See also:]\doxyref{shared\-Sls\-Detector}{p.}{structslsDetector_1_1sharedSlsDetector} \end{Desc}
\index{slsDetector@{sls\-Detector}!getFileName@{getFileName}}
\index{getFileName@{getFileName}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ sls\-Detector::get\-File\-Name ()\hspace{0.3cm}{\tt  [inline]}}\label{classslsDetector_717a3c59681f81ceaf5245a073eeacdb}


returns the default output files root name \begin{Desc}
\item[See also:]\doxyref{shared\-Sls\-Detector}{p.}{structslsDetector_1_1sharedSlsDetector} \end{Desc}
\index{slsDetector@{sls\-Detector}!getFilePath@{getFilePath}}
\index{getFilePath@{getFilePath}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ sls\-Detector::get\-File\-Path ()\hspace{0.3cm}{\tt  [inline]}}\label{classslsDetector_b4158bdacd10fccedeab9eacbd1f4304}


returns the default output files path \begin{Desc}
\item[See also:]\doxyref{shared\-Sls\-Detector}{p.}{structslsDetector_1_1sharedSlsDetector} \end{Desc}
\index{slsDetector@{sls\-Detector}!getFineOffset@{getFineOffset}}
\index{getFineOffset@{getFineOffset}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}float sls\-Detector::get\-Fine\-Offset ()\hspace{0.3cm}{\tt  [inline]}}\label{classslsDetector_1a402a849d04190024e9dc87d4dae6dc}


get detector fine offset 

Reimplemented in \bf{mythen\-Detector} \doxyref{p.}{classmythenDetector_00720f1445f3f301fa3316828d978de6}.\index{slsDetector@{sls\-Detector}!getFlatFieldCorrections@{getFlatFieldCorrections}}
\index{getFlatFieldCorrections@{getFlatFieldCorrections}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::get\-Flat\-Field\-Corrections (float $\ast$ {\em corr} = {\tt NULL}, float $\ast$ {\em ecorr} = {\tt NULL})}\label{classslsDetector_af22c79193907e364c6db97f5e55b9fd}


get flat field corrections \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em corr}]if !=NULL will be filled with the correction coefficients \item[{\em ecorr}]if !=NULL will be filled with the correction coefficients errors \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]0 if ff correction disabled, $>$0 otherwise \end{Desc}
\index{slsDetector@{sls\-Detector}!getGlobalOffset@{getGlobalOffset}}
\index{getGlobalOffset@{getGlobalOffset}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}float sls\-Detector::get\-Global\-Offset ()\hspace{0.3cm}{\tt  [inline]}}\label{classslsDetector_42f854256e2900f18b2a17201813b48c}


get detector global offset 

Reimplemented in \bf{mythen\-Detector} \doxyref{p.}{classmythenDetector_b2086f336d7198381453556b520dd556}.\index{slsDetector@{sls\-Detector}!getHostname@{getHostname}}
\index{getHostname@{getHostname}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ sls\-Detector::get\-Hostname ()\hspace{0.3cm}{\tt  [inline]}}\label{classslsDetector_fad06908ad59bfd8a8577899d6aa1843}


returns the detector hostname\begin{Desc}
\item[See also:]\doxyref{shared\-Sls\-Detector}{p.}{structslsDetector_1_1sharedSlsDetector} \end{Desc}
\index{slsDetector@{sls\-Detector}!getId@{getId}}
\index{getId@{getId}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int64\_\-t sls\-Detector::get\-Id (\bf{id\-Mode} {\em mode}, int {\em imod} = {\tt 0})}\label{classslsDetector_92f9261c62652e3643eebfdfa9942099}


get detector ids/versions for module \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em mode}]which id/version has to be read \item[{\em imod}]module number for module serial number \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]id \end{Desc}
\index{slsDetector@{sls\-Detector}!getMaxNumberOfModules@{getMaxNumberOfModules}}
\index{getMaxNumberOfModules@{getMaxNumberOfModules}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::get\-Max\-Number\-Of\-Modules (\bf{dimension} {\em d} = {\tt X})}\label{classslsDetector_d608a77a1c64989ad82175991be0a9b5}


get the maximum size of the detector \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em d}]dimension \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]maximum number of modules that can be installed in direction d \end{Desc}
\index{slsDetector@{sls\-Detector}!getModule@{getModule}}
\index{getModule@{getModule}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}sls\-Detector::sls\_\-detector\_\-module $\ast$ sls\-Detector::get\-Module (int {\em imod})}\label{classslsDetector_d1b14626e602ceaebfcf4321f6f40997}


get module \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em imod}]module number \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]pointer to module structure (which has bee created and must then be deleted) \end{Desc}
\index{slsDetector@{sls\-Detector}!getPositions@{getPositions}}
\index{getPositions@{getPositions}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::get\-Positions (float $\ast$ {\em pos} = {\tt NULL})\hspace{0.3cm}{\tt  [inline]}}\label{classslsDetector_732f6d36456d6e87d70324a4bdc1bbb8}


get positions for the acquisition \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em pos}]array which will contain the encoder positions \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]number of positions \end{Desc}


Reimplemented in \bf{mythen\-Detector} \doxyref{p.}{classmythenDetector_0d306720dced0d3576474978b06b4be4}.\index{slsDetector@{sls\-Detector}!getRateCorrections@{getRateCorrections}}
\index{getRateCorrections@{getRateCorrections}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::get\-Rate\-Corrections ()}\label{classslsDetector_7606366a3cbe280c90dc659036814697}


get rate correction \begin{Desc}
\item[Returns:]0 if rate correction disabled, $>$0 otherwise \end{Desc}
\index{slsDetector@{sls\-Detector}!getRateCorrections@{getRateCorrections}}
\index{getRateCorrections@{getRateCorrections}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::get\-Rate\-Corrections (float \& {\em t})}\label{classslsDetector_6e6212f4bbe0c5df253ec9c535c3f9b1}


get rate correction \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em t}]reference for dead time \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]0 if rate correction disabled, $>$0 otherwise \end{Desc}
\index{slsDetector@{sls\-Detector}!getRunStatus@{getRunStatus}}
\index{getRunStatus@{getRunStatus}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::get\-Run\-Status ()}\label{classslsDetector_567629b942b153a03cfc66d4d26c5daa}


get run status \begin{Desc}
\item[Returns:]status mask \end{Desc}
\index{slsDetector@{sls\-Detector}!getSetLength@{getSetLength}}
\index{getSetLength@{getSetLength}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::get\-Set\-Length ()\hspace{0.3cm}{\tt  [inline]}}\label{classslsDetector_51a88168bf9e4cd2ef7730b973963055}


get length cycles

not implemented (should be something more general like \char`\"{}set speed including also waitstates, set cycles etc.) \index{slsDetector@{sls\-Detector}!getSettings@{getSettings}}
\index{getSettings@{getSettings}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}\bf{sls\-Detector::detector\-Settings} sls\-Detector::get\-Settings (int {\em imod} = {\tt -1})}\label{classslsDetector_d112702360f31a967bfad9fe2aabf6f6}


get detector settings \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em imod}]module number (-1 all) \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]current settings \end{Desc}
\index{slsDetector@{sls\-Detector}!getStopPort@{getStopPort}}
\index{getStopPort@{getStopPort}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::get\-Stop\-Port ()\hspace{0.3cm}{\tt  [inline]}}\label{classslsDetector_80ab8f7f4cc6b2e92017a0c77f961b70}


returns the detector stop port\begin{Desc}
\item[See also:]\doxyref{shared\-Sls\-Detector}{p.}{structslsDetector_1_1sharedSlsDetector} \end{Desc}
\index{slsDetector@{sls\-Detector}!getThresholdEnergy@{getThresholdEnergy}}
\index{getThresholdEnergy@{getThresholdEnergy}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::get\-Threshold\-Energy (int {\em imod} = {\tt -1})}\label{classslsDetector_f2da634bb9551730c12e07e2b772bf06}


get threshold energy \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em imod}]module number (-1 all) \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]current threshold value for imod in ev (-1 failed) \end{Desc}
\index{slsDetector@{sls\-Detector}!getTimeLeft@{getTimeLeft}}
\index{getTimeLeft@{getTimeLeft}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int64\_\-t sls\-Detector::get\-Time\-Left (\bf{timer\-Index} {\em index})}\label{classslsDetector_61f072fcaf0a359148f52ea34769c846}


get current timer value \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em index}]timer index \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]elapsed time value in ns or number of...(e.g. frames, gates, probes) \end{Desc}
\index{slsDetector@{sls\-Detector}!getTrimDir@{getTrimDir}}
\index{getTrimDir@{getTrimDir}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ sls\-Detector::get\-Trim\-Dir ()\hspace{0.3cm}{\tt  [inline]}}\label{classslsDetector_d4a858d9b3a1b31c5d5decdc9d757267}


returns the detector trimbit directory\begin{Desc}
\item[See also:]\doxyref{shared\-Sls\-Detector}{p.}{structslsDetector_1_1sharedSlsDetector} \end{Desc}
\index{slsDetector@{sls\-Detector}!getTrimEn@{getTrimEn}}
\index{getTrimEn@{getTrimEn}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::get\-Trim\-En (int $\ast$ {\em en})\hspace{0.3cm}{\tt  [inline]}}\label{classslsDetector_fa24d8a0ec1393c7e27e4e558e72cf87}


returns the number of trim energies and their value\begin{Desc}
\item[See also:]\doxyref{shared\-Sls\-Detector}{p.}{structslsDetector_1_1sharedSlsDetector} \end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em point}]to the array that will contain the trim energies (in ev) \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]number of trim energies\end{Desc}
\begin{Desc}
\item[See also:]\doxyref{shared\-Sls\-Detector}{p.}{structslsDetector_1_1sharedSlsDetector} \end{Desc}
\index{slsDetector@{sls\-Detector}!giveCalibrationPulse@{giveCalibrationPulse}}
\index{giveCalibrationPulse@{giveCalibrationPulse}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::give\-Calibration\-Pulse (float {\em vcal}, int {\em npulses})}\label{classslsDetector_a8fafd5690120579f484e326dc6fd9be}


give a train of calibration pulses \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em vcal}]pulse amplitude \item[{\em npulses}]number of pulses\end{description}
\end{Desc}
not yet implemented \index{slsDetector@{sls\-Detector}!initializeDetectorSize@{initializeDetectorSize}}
\index{initializeDetectorSize@{initializeDetectorSize}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::initialize\-Detector\-Size (\bf{detector\-Type} {\em type})\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_19f1c6d120293c98a0d2dc992e5616f8}


Initializes the this\-Detector structure \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em type}]is needed to define the number of channels, chips, modules etc. \end{description}
\end{Desc}
\begin{Desc}
\item[See also:]\doxyref{shared\-Sls\-Detector}{p.}{structslsDetector_1_1sharedSlsDetector} \end{Desc}


if the shared memory has newly be created, initialize the detector variables

set hostname to default

set ports to defaults

set this\-Detector-$>$my\-Detector\-Type to type and according to this set n\-Chans, n\-Chips, n\-Dacs, n\-Adcs, n\-Mod\-Max, dynamic\-Range, n\-Mod

number of modules is initally the maximum number of modules

calculates the expected data size

set trim\-Dsdir, cal\-Dir and file\-Path to default to home directory

set file\-Name to default to run

set file\-Index to default to 0

set number of trim energies to 0

set correction mask to 0

set deat time

set number of bad chans to 0

set number of bad flat field chans to 0

set angular direction to 1

set fine offset to 0

set global offset to 0

set number of rois to 0

set readoutflags to none

set current settings to uninitialized

set threshold to -1

set clockdivider to 1

set number of positions to 0

set binsize

calculates the memory offsets for flat field coefficients and errors, module structures, dacs, adcs, chips and channels

also in case this\-Detector alread existed initialize the pointer for flat field coefficients and errors, module structures, dacs, adcs, chips and channels

if this\-Detector is new, initialize its structures \begin{Desc}
\item[See also:]\doxyref{initialize\-Detector\-Structure()}{p.}{classslsDetector_1c39e47efe5d8794b68cb32295cddf3c};\end{Desc}
set this\-Detector-$>$already\-Existing=1

fill the Bad\-Channel\-Mask \begin{Desc}
\item[See also:]\doxyref{fill\-Bad\-Channel\-Mask}{p.}{classslsDetector_6a0ebe013e27c065b2f67158a27f64ac} \end{Desc}
\index{slsDetector@{sls\-Detector}!initializeDetectorStructure@{initializeDetectorStructure}}
\index{initializeDetectorStructure@{initializeDetectorStructure}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::initialize\-Detector\-Structure ()\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_1c39e47efe5d8794b68cb32295cddf3c}


Initializes the module structures in this\-Detector if the detector did not exists before 

for each of the detector modules up to the maximum number which can be installed initlialize the \doxyref{sls\_\-detector\_\-module}{p.}{structsls__detector__module} structure \begin{Desc}
\item[See also:]\doxyref{sls\_\-detector\_\-module}{p.}{structsls__detector__module}\end{Desc}
sets the size of the module to n\-Chans, n\-Chips etc.

initializes the serial number and register to 0

initializes the dacs values to 0

initializes the adc values to 0

initializes the chip registers to 0

initializes the channel registers to 0

initialize gain and offset to -1 \index{slsDetector@{sls\-Detector}!initSharedMemory@{initSharedMemory}}
\index{initSharedMemory@{initSharedMemory}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::init\-Shared\-Memory (\bf{detector\-Type} {\em type} = {\tt GENERIC}, int {\em id} = {\tt 0})\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_cb94b9bfa7bbea2d9e1b0289a272bca8}


Initializes the shared memory \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em type}]is needed to define the size of the shared memory \item[{\em id}]is the detector id needed to define the shared memory id \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]shm\_\-id shared memory id \end{Desc}


the shared memory key is set to DEFAULT\_\-SHM\_\-KEY+id

The size of the shared memory is: size of shared structure + ffcoefficents +fferrors + modules+ dacs+adcs+chips+chans

this\-Detector pointer is set to the memory address of the shared memory

shm\_\-id returns -1 is shared memory initialization fails \index{slsDetector@{sls\-Detector}!popDataQueue@{popDataQueue}}
\index{popDataQueue@{popDataQueue}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int $\ast$ sls\-Detector::pop\-Data\-Queue ()}\label{classslsDetector_ee85bddb6aa7b37c99f1397112e6c8b6}


pops the data from the data queue \begin{Desc}
\item[Returns:]pointer to the popped data or NULL if the queue is empty. \end{Desc}
\begin{Desc}
\item[See also:]\doxyref{data\-Queue}{p.}{classslsDetector_52e9fe9baf37db001cdf58f982ab5dd6} \end{Desc}
\index{slsDetector@{sls\-Detector}!processData@{processData}}
\index{processData@{processData}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void $\ast$ sls\-Detector::process\-Data ()}\label{classslsDetector_717eb12630b1d1f5138f98e5f7ba021f}


function for processing data 

Pop data queue

decode data

write raw data file

rate correction

flat field correction

angular conversion

data merging

file writing \index{slsDetector@{sls\-Detector}!rateCorrect@{rateCorrect}}
\index{rateCorrect@{rateCorrect}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::rate\-Correct (float $\ast$ {\em datain}, float $\ast$ {\em errin}, float $\ast$ {\em dataout}, float $\ast$ {\em errout})}\label{classslsDetector_518feacfa3a1d6156779f8eaacdf86d3}


rate correct data \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em datain}]data array \item[{\em errin}]error array on data (if NULL will default to sqrt(datain) \item[{\em dataout}]array of corrected data \item[{\em errout}]error on corrected data (if not NULL) \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]0 \end{Desc}
\index{slsDetector@{sls\-Detector}!rateCorrect@{rateCorrect}}
\index{rateCorrect@{rateCorrect}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::rate\-Correct (float {\em datain}, float {\em errin}, float \& {\em dataout}, float \& {\em errout}, float {\em tau}, float {\em t})}\label{classslsDetector_e8c2d03ab2c870d2f1ff7a861cfeb6d1}


rate correct data \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em datain}]data \item[{\em errin}]error on data (if$<$=0 will default to sqrt(datain) \item[{\em dataout}]corrected data \item[{\em errout}]error on corrected data \item[{\em tau}]dead time 9in ns) \item[{\em t}]acquisition time (in ns) \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]0 \end{Desc}
\index{slsDetector@{sls\-Detector}!readAll@{readAll}}
\index{readAll@{readAll}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int $\ast$ sls\-Detector::read\-All ()}\label{classslsDetector_87acdd8cd43d30dc3dd88763b6e23d08}


asks and receives all data from the detector and puts them in a data queue \begin{Desc}
\item[Returns:]pointer to the front of the queue or NULL. \end{Desc}
\begin{Desc}
\item[See also:]\doxyref{get\-Data\-From\-Detector}{p.}{classslsDetector_b1982e89f8e8de63c807a707ccba594c} \doxyref{data\-Queue}{p.}{classslsDetector_52e9fe9baf37db001cdf58f982ab5dd6} \end{Desc}
\index{slsDetector@{sls\-Detector}!readAngularConversion@{readAngularConversion}}
\index{readAngularConversion@{readAngularConversion}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::read\-Angular\-Conversion (string {\em fname} = {\tt \char`\"{}\char`\"{}})}\label{classslsDetector_23398787e01e519bf8ac5f313ca5af01}


reads an angular conversion file \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em fname}]file to be read \end{description}
\end{Desc}
\begin{Desc}
\item[See also:]\doxyref{angle\-Conversion\-Constant}{p.}{structangleConversionConstant} \end{Desc}


Reimplemented in \bf{mythen\-Detector} \doxyref{p.}{classmythenDetector_33bf1b939eb877bbd4aa42f400d7ca36}.\index{slsDetector@{sls\-Detector}!readCalibrationFile@{readCalibrationFile}}
\index{readCalibrationFile@{readCalibrationFile}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::read\-Calibration\-File (string {\em fname}, float \& {\em gain}, float \& {\em offset})}\label{classslsDetector_9305060e7499cfcabac23b99c884b92b}


reads a calibration file \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em fname}]file to be read \item[{\em gain}]reference to the gain variable  reference to the offset variable \end{description}
\end{Desc}
\begin{Desc}
\item[See also:]\doxyref{shared\-Sls\-Detector}{p.}{structslsDetector_1_1sharedSlsDetector} \end{Desc}


Reimplemented in \bf{mythen\-Detector} \doxyref{p.}{classmythenDetector_f8f1b7b42012420fc557aacd714140f8}, and \bf{eiger\-Detector} \doxyref{p.}{classeigerDetector_6b1b4b5328a5d8c423e9a7a8a950028f}.\index{slsDetector@{sls\-Detector}!readConfigurationFile@{readConfigurationFile}}
\index{readConfigurationFile@{readConfigurationFile}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::read\-Configuration\-File (string const  {\em fname})}\label{classslsDetector_49c88825b21dc040269f6980e9725a3a}


Every detector should have a basic configuration file containing: type (mythen, pilatus etc.) hostname portnumber communication type (default TCP/IP) eventually secondary portnumber (e.g. mythen stop function) number of modules installed if different from the detector size (x,y)

to be changed \index{slsDetector@{sls\-Detector}!readDataFile@{readDataFile}}
\index{readDataFile@{readDataFile}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::read\-Data\-File (string {\em fname}, int $\ast$ {\em data})}\label{classslsDetector_0d27017bc1140cc9da3e797f03848f2e}


reads a data file \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em name}]of the file to be read \item[{\em data}]array of data values \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]OK or FAIL if it could not read the file or data=NULL \end{Desc}


Reimplemented in \bf{mythen\-Detector} \doxyref{p.}{classmythenDetector_d83819d61ea01148cf18cd3c46f2a9f7}, and \bf{eiger\-Detector} \doxyref{p.}{classeigerDetector_a6afa206101506d7f95d1ec835fbf843}.\index{slsDetector@{sls\-Detector}!readDataFile@{readDataFile}}
\index{readDataFile@{readDataFile}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::read\-Data\-File (string {\em fname}, float $\ast$ {\em data}, float $\ast$ {\em err} = {\tt NULL}, float $\ast$ {\em ang} = {\tt NULL}, char {\em dataformat} = {\tt 'f'}, int {\em nch} = {\tt 0})}\label{classslsDetector_ffd62fa6a3487693316209ea71502b4b}


reads a data file \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em name}]of the file to be read \item[{\em data}]array of data values to be filled \item[{\em err}]array of arrors on the data. If NULL no errors are expected on the file\item[{\em ang}]array of angular values. If NULL data are expected in the form chan-val(-err) otherwise ang-val(-err) \item[{\em dataformat}]format of the data: can be 'i' integer or 'f' float (default) \item[{\em nch}]number of channels to be written to file. if $<$=0 defaults to the number of installed channels of the detector \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]OK or FAIL if it could not read the file or data=NULL \end{Desc}


Reimplemented in \bf{mythen\-Detector} \doxyref{p.}{classmythenDetector_1937a5355eed0dc553cb05d2098f7c47}, and \bf{eiger\-Detector} \doxyref{p.}{classeigerDetector_4d0b7da609b9a0457656bfc8cf0a7997}.\index{slsDetector@{sls\-Detector}!readFrame@{readFrame}}
\index{readFrame@{readFrame}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int $\ast$ sls\-Detector::read\-Frame ()}\label{classslsDetector_b352d85c5a4f415d1ec930d17bae87fa}


asks and receives a data frame from the detector \begin{Desc}
\item[Returns:]pointer to the data or NULL. If NULL disconnects the socket \end{Desc}
\begin{Desc}
\item[See also:]\doxyref{get\-Data\-From\-Detector}{p.}{classslsDetector_b1982e89f8e8de63c807a707ccba594c} \end{Desc}
\index{slsDetector@{sls\-Detector}!readRegister@{readRegister}}
\index{readRegister@{readRegister}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::read\-Register (int {\em addr})}\label{classslsDetector_89ba6d2d8e79a60270e7e1c217df2d79}


read register \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em addr}]address \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]current register value \end{Desc}
\index{slsDetector@{sls\-Detector}!readTrimFile@{readTrimFile}}
\index{readTrimFile@{readTrimFile}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}\bf{sls\_\-detector\_\-module}$\ast$ sls\-Detector::read\-Trim\-File (string {\em fname}, \bf{sls\_\-detector\_\-module} $\ast$ {\em my\-Mod} = {\tt NULL})}\label{classslsDetector_e84b8a7a2b27db3f89a98f9f8a81efca}


reads a trim file \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em fname}]name of the file to be read \item[{\em my\-Mod}]pointer to the module structure which has to be set. \par
 If it is NULL a new module structure will be created \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]the pointer to my\-Mod or NULL if reading the file failed \end{Desc}


Reimplemented in \bf{mythen\-Detector} \doxyref{p.}{classmythenDetector_2120f9105997fd8f8bf9165dbffc55e7}, and \bf{eiger\-Detector} \doxyref{p.}{classeigerDetector_f24af0459e8eb45c1bc9c68a870e5094}.\index{slsDetector@{sls\-Detector}!receiveChannel@{receiveChannel}}
\index{receiveChannel@{receiveChannel}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::receive\-Channel (\bf{sls\_\-detector\_\-channel} $\ast$)\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_39f8959a55e92c7b0817529270be7667}


receive a \doxyref{sls\_\-detector\_\-channel}{p.}{structsls__detector__channel} structure over socket \index{slsDetector@{sls\-Detector}!receiveChip@{receiveChip}}
\index{receiveChip@{receiveChip}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::receive\-Chip (\bf{sls\_\-detector\_\-chip} $\ast$)\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_21d070352bfbf4745543c572bd6ae8f7}


receive a \doxyref{sls\_\-detector\_\-chip}{p.}{structsls__detector__chip} structure over socket \index{slsDetector@{sls\-Detector}!receiveModule@{receiveModule}}
\index{receiveModule@{receiveModule}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::receive\-Module (\bf{sls\_\-detector\_\-module} $\ast$)\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_1356b4fabe6b1aaa9c67939ff9331f98}


receive a \doxyref{sls\_\-detector\_\-module}{p.}{structsls__detector__module} structure over socket \index{slsDetector@{sls\-Detector}!resetMerging@{resetMerging}}
\index{resetMerging@{resetMerging}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::reset\-Merging (float $\ast$ {\em mp}, float $\ast$ {\em mv}, float $\ast$ {\em me}, int $\ast$ {\em mm})}\label{classslsDetector_208c3a5a80ba931056f1f2ff3cb5d0e5}


sets the arrays of the merged data to 0. NB The array should be created with size $>$= 360./get\-Bin\-Size(); \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em mp}]already merged postions \item[{\em mv}]already merged data \item[{\em me}]already merged errors (squared sum) \item[{\em mm}]multiplicity of merged arrays \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]OK or FAIL \end{Desc}


Reimplemented in \bf{mythen\-Detector} \doxyref{p.}{classmythenDetector_7d38c9af0d94bc15571c3c15b38f39a8}.\index{slsDetector@{sls\-Detector}!retrieveDetectorSetup@{retrieveDetectorSetup}}
\index{retrieveDetectorSetup@{retrieveDetectorSetup}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::retrieve\-Detector\-Setup (string const  {\em fname})}\label{classslsDetector_233c3d27e9a946fb42b0aa49717d9251}


not yet implemented

should retrieve from a file all the current detector parameters \index{slsDetector@{sls\-Detector}!sendChannel@{sendChannel}}
\index{sendChannel@{sendChannel}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::send\-Channel (\bf{sls\_\-detector\_\-channel} $\ast$)\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_5cd249f9a287b25af9a3a7e7e675c559}


send a \doxyref{sls\_\-detector\_\-channel}{p.}{structsls__detector__channel} structure over socket \index{slsDetector@{sls\-Detector}!sendChip@{sendChip}}
\index{sendChip@{sendChip}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::send\-Chip (\bf{sls\_\-detector\_\-chip} $\ast$)\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_1e92a814b83501cdef5771c1e5c477aa}


send a \doxyref{sls\_\-detector\_\-chip}{p.}{structsls__detector__chip} structure over socket \index{slsDetector@{sls\-Detector}!sendModule@{sendModule}}
\index{sendModule@{sendModule}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::send\-Module (\bf{sls\_\-detector\_\-module} $\ast$)\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_cc29561aa2b22ee49038c7bdf2be5ad7}


send a \doxyref{sls\_\-detector\_\-module}{p.}{structsls__detector__module} structure over socket \index{slsDetector@{sls\-Detector}!setAngularConversion@{setAngularConversion}}
\index{setAngularConversion@{setAngularConversion}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::set\-Angular\-Conversion (string {\em fname} = {\tt \char`\"{}\char`\"{}})}\label{classslsDetector_30fe39ddd78fa880b6b7815d1d5462ec}


set angular conversion \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em fname}]file with angular conversion constants (\char`\"{}\char`\"{} disable) \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]0 if angular conversion disabled, $>$0 otherwise \end{Desc}


Reimplemented in \bf{mythen\-Detector} \doxyref{p.}{classmythenDetector_78efe554a277de7fb8759307992fc61b}.\index{slsDetector@{sls\-Detector}!setBadChannelCorrection@{setBadChannelCorrection}}
\index{setBadChannelCorrection@{setBadChannelCorrection}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::set\-Bad\-Channel\-Correction (string {\em fname} = {\tt \char`\"{}\char`\"{}})}\label{classslsDetector_45833eb571b8cb20225f4046e2a17e5a}


set bad channels correction \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em fname}]file with bad channel list (\char`\"{}\char`\"{} disable) \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]0 if bad channel disabled, $>$0 otherwise \end{Desc}
\index{slsDetector@{sls\-Detector}!setBinSize@{setBinSize}}
\index{setBinSize@{setBinSize}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}float sls\-Detector::set\-Bin\-Size (float {\em bs})\hspace{0.3cm}{\tt  [inline]}}\label{classslsDetector_96e2fb6fb0aa34bdbe59facf367c4ae1}


set detector bin size used for merging (approx angular resolution) 

Reimplemented in \bf{mythen\-Detector} \doxyref{p.}{classmythenDetector_8f466447f886379204a59eb6785f1ed0}.\index{slsDetector@{sls\-Detector}!setCalDir@{setCalDir}}
\index{setCalDir@{setCalDir}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ sls\-Detector::set\-Cal\-Dir (string {\em s})\hspace{0.3cm}{\tt  [inline]}}\label{classslsDetector_9c4d2c796c176852537ff3cff4f5974b}


sets the location of the calibration files \begin{Desc}
\item[See also:]\doxyref{shared\-Sls\-Detector}{p.}{structslsDetector_1_1sharedSlsDetector} \end{Desc}
\index{slsDetector@{sls\-Detector}!setChannel@{setChannel}}
\index{setChannel@{setChannel}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::set\-Channel (\bf{sls\_\-detector\_\-channel} {\em chan})}\label{classslsDetector_71bf1ef7be9f51c44cf6bc4a0dfea1e2}


configure channel \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em chan}]channel to be set - must contain correct channel, module and chip number \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]current register value \end{Desc}
\index{slsDetector@{sls\-Detector}!setChannel@{setChannel}}
\index{setChannel@{setChannel}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::set\-Channel (int64\_\-t {\em reg}, int {\em ichan} = {\tt -1}, int {\em ichip} = {\tt -1}, int {\em imod} = {\tt -1})}\label{classslsDetector_bed71bb89a69cbf24de31de9f5f478bc}


configure channel \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em reg}]channel register \item[{\em ichan}]channel number (-1 all) \item[{\em ichip}]chip number (-1 all) \item[{\em imod}]module number (-1 all) \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]current register value \end{Desc}
\begin{Desc}
\item[See also:]\doxyref{sls\_\-detector\_\-channel}{p.}{structsls__detector__channel} \end{Desc}
\index{slsDetector@{sls\-Detector}!setChip@{setChip}}
\index{setChip@{setChip}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::set\-Chip (\bf{sls\_\-detector\_\-chip} {\em chip})}\label{classslsDetector_3a327b952866525e1b5c8fe541834c68}


configure chip \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em chip}]chip to be set - must contain correct module and chip number and also channel registers \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]current register value \end{Desc}
\begin{Desc}
\item[See also:]\doxyref{sls\_\-detector\_\-chip}{p.}{structsls__detector__chip} \end{Desc}
\index{slsDetector@{sls\-Detector}!setChip@{setChip}}
\index{setChip@{setChip}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::set\-Chip (int {\em reg}, int {\em ichip} = {\tt -1}, int {\em imod} = {\tt -1})}\label{classslsDetector_18cf730c59f5981fb5e22ebf460b9abc}


configure chip \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em reg}]chip register \item[{\em ichip}]chip number (-1 all) \item[{\em imod}]module number (-1 all) \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]current register value \end{Desc}
\begin{Desc}
\item[See also:]\doxyref{sls\_\-detector\_\-chip}{p.}{structsls__detector__chip} \end{Desc}
\index{slsDetector@{sls\-Detector}!setClockDivider@{setClockDivider}}
\index{setClockDivider@{setClockDivider}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::set\-Clock\-Divider (int {\em i})\hspace{0.3cm}{\tt  [inline]}}\label{classslsDetector_49af64998d4a4d44e965eb0adb1facb2}


set clock divider

not implemented (should be something more general like \char`\"{}set speed including also waitstates, set cycles etc.) \index{slsDetector@{sls\-Detector}!setDAC@{setDAC}}
\index{setDAC@{setDAC}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}float sls\-Detector::set\-DAC (float {\em val}, \bf{dac\-Index} {\em index}, int {\em imod} = {\tt -1})}\label{classslsDetector_cfcce08c547e24dc09968a74e35daf40}


set dacs value \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em val}]value (in V) \item[{\em index}]DAC index \item[{\em imod}]module number (if -1 alla modules) \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]current DAC value \end{Desc}
\index{slsDetector@{sls\-Detector}!setDetectorType@{setDetectorType}}
\index{setDetectorType@{setDetectorType}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::set\-Detector\-Type (string {\em type})}\label{classslsDetector_4bebb4f131fe345fa561428e070a933d}


sets/gets detector type normally the detector knows what type of detector it is \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em type}]is the detector type (\char`\"{}Mythen\char`\"{}, \char`\"{}Pilatus\char`\"{}, \char`\"{}XFS\char`\"{}, \char`\"{}Gotthard\char`\"{}, Agipd\char`\"{}) \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]returns detector type index (1 GENERIC, 2 MYTHEN, 3 PILATUS, 4 XFS, 5 GOTTHARD, 6 AGIPD, -1 command failed) \end{Desc}
\index{slsDetector@{sls\-Detector}!setDetectorType@{setDetectorType}}
\index{setDetectorType@{setDetectorType}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::set\-Detector\-Type (\bf{detector\-Type} {\em type} = {\tt GET\_\-DETECTOR\_\-TYPE})}\label{classslsDetector_e76a665a8d7a6b37d85aff129d3afdef}


sets/gets detector type normally the detector knows what type of detector it is \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em type}]is the detector type (defaults to GET\_\-DETECTOR\_\-TYPE) \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]returns detector type index (1 GENERIC, 2 MYTHEN, 3 PILATUS, 4 XFS, 5 GOTTHARD, 6 AGIPD, -1 command failed) \end{Desc}
\index{slsDetector@{sls\-Detector}!setDynamicRange@{setDynamicRange}}
\index{setDynamicRange@{setDynamicRange}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::set\-Dynamic\-Range (int {\em n} = {\tt -1})}\label{classslsDetector_57d00f77b9c12d9a01407d5a74bacddb}


set/get dynamic range \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em n}]dynamic range (-1 get) \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]current dynamic range updates the size of the data expected from the detector \end{Desc}
\begin{Desc}
\item[See also:]\doxyref{shared\-Sls\-Detector}{p.}{structslsDetector_1_1sharedSlsDetector} \end{Desc}
\index{slsDetector@{sls\-Detector}!setExternalCommunicationMode@{setExternalCommunicationMode}}
\index{setExternalCommunicationMode@{setExternalCommunicationMode}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}\bf{external\-Communication\-Mode} sls\-Detector::set\-External\-Communication\-Mode (\bf{external\-Communication\-Mode} {\em pol} = {\tt GET\_\-EXTERNAL\_\-COMMUNICATION\_\-MODE})}\label{classslsDetector_2f7bac599bf5bb103debcd9342b65edd}


set/get the external communication mode

obsolete\begin{Desc}
\item[See also:]\doxyref{set\-External\-Signal\-Flags}{p.}{classslsDetector_5878c33a1353f1d32c383be4169531e7} \end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em pol}]value to be set\end{description}
\end{Desc}
\begin{Desc}
\item[See also:]\doxyref{external\-Communication\-Mode}{p.}{sls__detector__defs_8h_51d6eb28d9d010319da9ce5da86ed32f} \end{Desc}
\begin{Desc}
\item[Returns:]current external communication mode \end{Desc}
\index{slsDetector@{sls\-Detector}!setExternalSignalFlags@{setExternalSignalFlags}}
\index{setExternalSignalFlags@{setExternalSignalFlags}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}\bf{external\-Signal\-Flag} sls\-Detector::set\-External\-Signal\-Flags (\bf{external\-Signal\-Flag} {\em pol} = {\tt GET\_\-EXTERNAL\_\-SIGNAL\_\-FLAG}, int {\em signalindex} = {\tt 0})}\label{classslsDetector_5878c33a1353f1d32c383be4169531e7}


set/get the use of an external signal \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em pol}]meaning of the signal\end{description}
\end{Desc}
\begin{Desc}
\item[See also:]\doxyref{external\-Signal\-Flag}{p.}{sls__detector__defs_8h_a436b9d7264c77b77021fe6adc33f6ed} \end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em signal\-Index}]index of the signal \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]current meaning of signal signal\-Index \end{Desc}
\index{slsDetector@{sls\-Detector}!setFileIndex@{setFileIndex}}
\index{setFileIndex@{setFileIndex}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::set\-File\-Index (int {\em i})\hspace{0.3cm}{\tt  [inline]}}\label{classslsDetector_22326d5e85503bfd16e4bdb279babb43}


sets the default output file index \begin{Desc}
\item[See also:]\doxyref{shared\-Sls\-Detector}{p.}{structslsDetector_1_1sharedSlsDetector} \end{Desc}
\index{slsDetector@{sls\-Detector}!setFileName@{setFileName}}
\index{setFileName@{setFileName}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ sls\-Detector::set\-File\-Name (string {\em s})\hspace{0.3cm}{\tt  [inline]}}\label{classslsDetector_ec565bab03357d783cccae55232b03ba}


sets the default output files root name \begin{Desc}
\item[See also:]\doxyref{shared\-Sls\-Detector}{p.}{structslsDetector_1_1sharedSlsDetector} \end{Desc}
\index{slsDetector@{sls\-Detector}!setFilePath@{setFilePath}}
\index{setFilePath@{setFilePath}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ sls\-Detector::set\-File\-Path (string {\em s})\hspace{0.3cm}{\tt  [inline]}}\label{classslsDetector_57c4587267e50a21ba13ead83294bdb4}


sets the default output files path \begin{Desc}
\item[See also:]\doxyref{shared\-Sls\-Detector}{p.}{structslsDetector_1_1sharedSlsDetector} \end{Desc}
\index{slsDetector@{sls\-Detector}!setFineOffset@{setFineOffset}}
\index{setFineOffset@{setFineOffset}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}float sls\-Detector::set\-Fine\-Offset (float {\em f})\hspace{0.3cm}{\tt  [inline]}}\label{classslsDetector_fd3b79c59688a7a0f4f72ba5676a2f9b}


set detector fine offset 

Reimplemented in \bf{mythen\-Detector} \doxyref{p.}{classmythenDetector_fe142e36f1a5fa8b2ab5fc45e9f8c781}.\index{slsDetector@{sls\-Detector}!setFlatFieldCorrection@{setFlatFieldCorrection}}
\index{setFlatFieldCorrection@{setFlatFieldCorrection}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::set\-Flat\-Field\-Correction (string {\em fname} = {\tt \char`\"{}\char`\"{}})}\label{classslsDetector_b4e2c11303714d5e62b4fcc22f829d8f}


set flat field corrections \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em fname}]name of the flat field file (or \char`\"{}\char`\"{} if disable) \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]0 if disable (or file could not be read), $>$0 otherwise \end{Desc}
\index{slsDetector@{sls\-Detector}!setGlobalOffset@{setGlobalOffset}}
\index{setGlobalOffset@{setGlobalOffset}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}float sls\-Detector::set\-Global\-Offset (float {\em f})\hspace{0.3cm}{\tt  [inline]}}\label{classslsDetector_84c8dc8017e692d93246cd546e6366c1}


set detector global offset 

Reimplemented in \bf{mythen\-Detector} \doxyref{p.}{classmythenDetector_e24dd88c4eb965687bd656a12bae8ad7}.\index{slsDetector@{sls\-Detector}!setModule@{setModule}}
\index{setModule@{setModule}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::set\-Module (\bf{sls\_\-detector\_\-module} {\em module})}\label{classslsDetector_d659b9a8ae9a29cea616e6333e2e7be4}


configure chip \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em module}]module to be set - must contain correct module number and also channel and chip registers \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]current register value \end{Desc}
\begin{Desc}
\item[See also:]\doxyref{sls\_\-detector\_\-module}{p.}{structsls__detector__module} \end{Desc}
\index{slsDetector@{sls\-Detector}!setModule@{setModule}}
\index{setModule@{setModule}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::set\-Module (int {\em reg}, int {\em imod} = {\tt -1})}\label{classslsDetector_1be9e16689befa0d654345bc30ccd68e}


configure module \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em imod}]module number (-1 all) \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]current register value \end{Desc}
\begin{Desc}
\item[See also:]\doxyref{sls\_\-detector\_\-module}{p.}{structsls__detector__module} \end{Desc}
\index{slsDetector@{sls\-Detector}!setNumberOfModules@{setNumberOfModules}}
\index{setNumberOfModules@{setNumberOfModules}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::set\-Number\-Of\-Modules (int {\em n}, \bf{dimension} {\em d} = {\tt X})}\label{classslsDetector_9e4117c0234d51b22922a2d638e118ab}


set/get the size of the detector \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em n}]number of modules \item[{\em d}]dimension \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]current number of modules in direction d \end{Desc}
\index{slsDetector@{sls\-Detector}!setOnline@{setOnline}}
\index{setOnline@{setOnline}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::set\-Online (int const  {\em online})}\label{classslsDetector_f041f723f702c17de292061d6d609698}


sets the online\-Flag \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em off}]can be: \par
 GET\_\-ONLINE\_\-FLAG, returns wether the detector is in online or offline state;\par
 OFFLINE\_\-FLAG, detector in offline state (i.e. no communication to the detector - using only local structure - no data acquisition possible!);\par
 ONLINE\_\-FLAG detector in online state (i.e. communication to the detector updating the local structure) \end{description}
\end{Desc}
\index{slsDetector@{sls\-Detector}!setPositions@{setPositions}}
\index{setPositions@{setPositions}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::set\-Positions (int {\em n\-Pos}, float $\ast$ {\em pos})\hspace{0.3cm}{\tt  [inline]}}\label{classslsDetector_ed6493ad015660281b14814f9a7f6cb5}


set positions for the acquisition \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em n\-Pos}]number of positions \item[{\em pos}]array with the encoder positions \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]number of positions \end{Desc}


Reimplemented in \bf{mythen\-Detector} \doxyref{p.}{classmythenDetector_1ffb0963f724e6d6d497685e6de62fd6}.\index{slsDetector@{sls\-Detector}!setRateCorrection@{setRateCorrection}}
\index{setRateCorrection@{setRateCorrection}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::set\-Rate\-Correction (float {\em t} = {\tt 0})}\label{classslsDetector_c89f7fc9f9255e573e34f8d3dadf38af}


set rate correction \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em t}]dead time in ns - if 0 disable correction, if $>$0 set dead time to t, if $<$0 set deadtime to default dead time for current settings \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]0 if rate correction disabled, $>$0 otherwise \end{Desc}
\index{slsDetector@{sls\-Detector}!setReadOutFlags@{setReadOutFlags}}
\index{setReadOutFlags@{setReadOutFlags}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::set\-Read\-Out\-Flags (\bf{read\-Out\-Flags} {\em flag})}\label{classslsDetector_e86bd9ff0d87efe9327118b5349321c4}


set/get readout flags \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em flag}]readout flag to be set \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]current flag \end{Desc}
\index{slsDetector@{sls\-Detector}!setROI@{setROI}}
\index{setROI@{setROI}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::set\-ROI (int {\em nroi} = {\tt -1}, int $\ast$ {\em xmin} = {\tt NULL}, int $\ast$ {\em xmax} = {\tt NULL}, int $\ast$ {\em ymin} = {\tt NULL}, int $\ast$ {\em ymax} = {\tt NULL})}\label{classslsDetector_e2a0716ddc050b79a45c552236ff2284}


set roi

not yet implemented \index{slsDetector@{sls\-Detector}!setSetLength@{setSetLength}}
\index{setSetLength@{setSetLength}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::set\-Set\-Length (int {\em i})\hspace{0.3cm}{\tt  [inline]}}\label{classslsDetector_f936cf5840bded81acb3f93b6b5fdd1c}


set length cycles

not implemented (should be something more general like \char`\"{}set speed including also waitstates, set cycles etc.) \index{slsDetector@{sls\-Detector}!setSettings@{setSettings}}
\index{setSettings@{setSettings}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}\bf{detector\-Settings} sls\-Detector::set\-Settings (\bf{detector\-Settings} {\em isettings}, int {\em imod} = {\tt -1})}\label{classslsDetector_765072d5c8aaff56ca79734072607188}


set detector settings \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em isettings}]settings \item[{\em imod}]module number (-1 all) \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]current settings\end{Desc}
in this function trimbits and calibration files are searched in the trim\-Dir and cal\-Dir directories and the detector is initialized \index{slsDetector@{sls\-Detector}!setTCPSocket@{setTCPSocket}}
\index{setTCPSocket@{setTCPSocket}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::set\-TCPSocket (string const  {\em name} = {\tt \char`\"{}\char`\"{}}, int const  {\em control\_\-port} = {\tt -1}, int const  {\em stop\_\-port} = {\tt -1}, int const  {\em data\_\-port} = {\tt -1})}\label{classslsDetector_019a01c4465c5ee572293cb6c00d9904}


configure the socket communication and initializes the socket instances

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em name}]hostname - if \char`\"{}\char`\"{} the current hostname is used \item[{\em control\_\-port}]port for control commands - if -1 the current is used \item[{\em stop\_\-port}]port for stop command - if -1 the current is used \item[{\em data\_\-port}]port for receiving data - if -1 the current is used\end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]OK is connection succeded, FAIL otherwise \end{Desc}
\begin{Desc}
\item[See also:]\doxyref{shared\-Sls\-Detector}{p.}{structslsDetector_1_1sharedSlsDetector} \end{Desc}
\index{slsDetector@{sls\-Detector}!setThresholdEnergy@{setThresholdEnergy}}
\index{setThresholdEnergy@{setThresholdEnergy}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::set\-Threshold\-Energy (int {\em e\_\-e\-V}, int {\em imod} = {\tt -1}, \bf{detector\-Settings} {\em isettings} = {\tt GET\_\-SETTINGS})}\label{classslsDetector_ab00a8eeca28831751121054e35d4c6b}


set threshold energy \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em e\_\-e\-V}]threshold in e\-V \item[{\em imod}]module number (-1 all) \item[{\em isettings}]ev. change settings \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]current threshold value for imod in ev (-1 failed) \end{Desc}
\index{slsDetector@{sls\-Detector}!setTimer@{setTimer}}
\index{setTimer@{setTimer}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int64\_\-t sls\-Detector::set\-Timer (\bf{timer\-Index} {\em index}, int64\_\-t {\em t} = {\tt -1})}\label{classslsDetector_b78e1d801e92a9f5a06008d9e9731549}


set/get timer value \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em index}]timer index \item[{\em t}]time in ns or number of...(e.g. frames, gates, probes) \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]timer set value in ns or number of...(e.g. frames, gates, probes) \end{Desc}
\index{slsDetector@{sls\-Detector}!setTrimDir@{setTrimDir}}
\index{setTrimDir@{setTrimDir}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ sls\-Detector::set\-Trim\-Dir (string {\em s})\hspace{0.3cm}{\tt  [inline]}}\label{classslsDetector_646f389e75c23c2c8627c62fb1df2890}


sets the detector trimbit directory\begin{Desc}
\item[See also:]\doxyref{shared\-Sls\-Detector}{p.}{structslsDetector_1_1sharedSlsDetector} \end{Desc}
\index{slsDetector@{sls\-Detector}!startAcquisition@{startAcquisition}}
\index{startAcquisition@{startAcquisition}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::start\-Acquisition ()}\label{classslsDetector_49f44b9f27ce82d384ddfa0d229a0dee}


start detector acquisition \begin{Desc}
\item[Returns:]OK/FAIL \end{Desc}
\index{slsDetector@{sls\-Detector}!startAndReadAll@{startAndReadAll}}
\index{startAndReadAll@{startAndReadAll}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int $\ast$ sls\-Detector::start\-And\-Read\-All ()}\label{classslsDetector_fb4bb3d4e734c98684b60d283f34f128}


start detector acquisition and read all data putting them a data queue \begin{Desc}
\item[Returns:]pointer to the fron tof the data queue \end{Desc}
\begin{Desc}
\item[See also:]\doxyref{start\-And\-Read\-All\-No\-Wait}{p.}{classslsDetector_2e0a975f982971744ada81d346d84489} \doxyref{get\-Data\-From\-Detector}{p.}{classslsDetector_b1982e89f8e8de63c807a707ccba594c} \doxyref{data\-Queue}{p.}{classslsDetector_52e9fe9baf37db001cdf58f982ab5dd6} \end{Desc}
\index{slsDetector@{sls\-Detector}!startAndReadAllNoWait@{startAndReadAllNoWait}}
\index{startAndReadAllNoWait@{startAndReadAllNoWait}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::start\-And\-Read\-All\-No\-Wait ()}\label{classslsDetector_2e0a975f982971744ada81d346d84489}


start detector acquisition and read out, but does not read data from socket \index{slsDetector@{sls\-Detector}!startReadOut@{startReadOut}}
\index{startReadOut@{startReadOut}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::start\-Read\-Out ()}\label{classslsDetector_8314acd65ffb54f355967a5c6827448e}


start readout (without exposure or interrupting exposure) \begin{Desc}
\item[Returns:]OK/FAIL \end{Desc}
\index{slsDetector@{sls\-Detector}!startThread@{startThread}}
\index{startThread@{startThread}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void sls\-Detector::start\-Thread ()\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_58199d3393aa7eaa606cbb7cbf83469d}


start data processing threas \index{slsDetector@{sls\-Detector}!stopAcquisition@{stopAcquisition}}
\index{stopAcquisition@{stopAcquisition}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::stop\-Acquisition ()}\label{classslsDetector_07a3d8c3c0e03ec8f286a87673911c28}


stop detector acquisition \begin{Desc}
\item[Returns:]OK/FAIL \end{Desc}
\index{slsDetector@{sls\-Detector}!writeAngularConversion@{writeAngularConversion}}
\index{writeAngularConversion@{writeAngularConversion}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::write\-Angular\-Conversion (string {\em fname} = {\tt \char`\"{}\char`\"{}})}\label{classslsDetector_921f212286be085d7e1b8d0d11110d9c}


writes an angular conversion file \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em fname}]file to be written \end{description}
\end{Desc}
\begin{Desc}
\item[See also:]\doxyref{angle\-Conversion\-Constant}{p.}{structangleConversionConstant} \end{Desc}


Reimplemented in \bf{mythen\-Detector} \doxyref{p.}{classmythenDetector_3c5f27709351c49dd715212adc5ba7d2}.\index{slsDetector@{sls\-Detector}!writeCalibrationFile@{writeCalibrationFile}}
\index{writeCalibrationFile@{writeCalibrationFile}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::write\-Calibration\-File (string {\em fname}, float {\em gain}, float {\em offset})}\label{classslsDetector_8eb676a1ab6ef35601ba5cae942ba380}


writes a clibration file \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em fname}]file to be written \item[{\em gain}]\item[{\em offset}]\end{description}
\end{Desc}
\begin{Desc}
\item[See also:]\doxyref{shared\-Sls\-Detector}{p.}{structslsDetector_1_1sharedSlsDetector} \end{Desc}


Reimplemented in \bf{mythen\-Detector} \doxyref{p.}{classmythenDetector_10e7213bb0e7138c07231687e9a6899a}, and \bf{eiger\-Detector} \doxyref{p.}{classeigerDetector_d5fbecfcc46cb151160c6011aa8e33b2}.\index{slsDetector@{sls\-Detector}!writeConfigurationFile@{writeConfigurationFile}}
\index{writeConfigurationFile@{writeConfigurationFile}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::write\-Configuration\-File (string const  {\em fname})}\label{classslsDetector_82628148e11f4890c9d935ec921c1121}


Every detector should have a basic configuration file containing: type (mythen, pilatus etc.) hostname portnumber communication type (default TCP/IP) eventually secondary portnumber (e.g. mythen stop function) number of modules installed if different from the detector size (x,y)

to be changed \index{slsDetector@{sls\-Detector}!writeDataFile@{writeDataFile}}
\index{writeDataFile@{writeDataFile}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::write\-Data\-File (string {\em fname}, int $\ast$ {\em data})}\label{classslsDetector_3e1a8e49fbfb34a54381452abc8b5258}


writes a data file \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em name}]of the file to be written \item[{\em data}]array of data values \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]OK or FAIL if it could not write the file or data=NULL \end{Desc}


Reimplemented in \bf{mythen\-Detector} \doxyref{p.}{classmythenDetector_9a49c84d7ad664f7891b00fba0ce829a}, and \bf{eiger\-Detector} \doxyref{p.}{classeigerDetector_68a740d5e43fcdb00c57f401666c0856}.\index{slsDetector@{sls\-Detector}!writeDataFile@{writeDataFile}}
\index{writeDataFile@{writeDataFile}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::write\-Data\-File (string {\em fname}, float $\ast$ {\em data}, float $\ast$ {\em err} = {\tt NULL}, float $\ast$ {\em ang} = {\tt NULL}, char {\em dataformat} = {\tt 'f'}, int {\em nch} = {\tt -1})}\label{classslsDetector_889c060afb5693830ca2be4fc6a5442c}


writes a data file \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em name}]of the file to be written \item[{\em data}]array of data values \item[{\em err}]array of arrors on the data. If NULL no errors will be written\item[{\em ang}]array of angular values. If NULL data will be in the form chan-val(-err) otherwise ang-val(-err) \item[{\em dataformat}]format of the data: can be 'i' integer or 'f' float (default) \item[{\em nch}]number of channels to be written to file. if -1 defaults to the number of installed channels of the detector \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]OK or FAIL if it could not write the file or data=NULL \end{Desc}


Reimplemented in \bf{mythen\-Detector} \doxyref{p.}{classmythenDetector_42c1d320f594ebd87e2465cc986ee848}, and \bf{eiger\-Detector} \doxyref{p.}{classeigerDetector_5ad2bf5b10d17e8c4ad7ae6e81e647e0}.\index{slsDetector@{sls\-Detector}!writeRegister@{writeRegister}}
\index{writeRegister@{writeRegister}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::write\-Register (int {\em addr}, int {\em val})}\label{classslsDetector_742c8c6b4e7f3cad4f7e60c8c7c0c18b}


write register \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em addr}]address  value \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]current register value \end{Desc}
\index{slsDetector@{sls\-Detector}!writeTrimFile@{writeTrimFile}}
\index{writeTrimFile@{writeTrimFile}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::write\-Trim\-File (string {\em fname}, int {\em imod})}\label{classslsDetector_afe675432bf8e5dcb47774da3cc81106}


writes a trim file for module number imod - the values will be read from the current detector structure \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em fname}]name of the file to be written \item[{\em imod}]module number \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]OK or FAIL if the file could not be written \end{Desc}
\begin{Desc}
\item[See also:]\doxyref{sls\_\-detector\_\-module}{p.}{structsls__detector__module} \doxyref{shared\-Sls\-Detector}{p.}{structslsDetector_1_1sharedSlsDetector} \end{Desc}


Reimplemented in \bf{mythen\-Detector} \doxyref{p.}{classmythenDetector_94179431a737bbceb20f27ca1fd30349}, and \bf{eiger\-Detector} \doxyref{p.}{classeigerDetector_df3a0dff0fc3111e10af0363bdd15a6a}.\index{slsDetector@{sls\-Detector}!writeTrimFile@{writeTrimFile}}
\index{writeTrimFile@{writeTrimFile}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int sls\-Detector::write\-Trim\-File (string {\em fname}, \bf{sls\_\-detector\_\-module} {\em mod})}\label{classslsDetector_9cbb1f97b8e48bd4b108a2dfa992c6af}


writes a trim file \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em fname}]name of the file to be written \item[{\em mod}]module structure which has to be written to file \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]OK or FAIL if the file could not be written\end{Desc}
\begin{Desc}
\item[See also:]\doxyref{sls\_\-detector\_\-module}{p.}{structsls__detector__module} \end{Desc}


Reimplemented in \bf{mythen\-Detector} \doxyref{p.}{classmythenDetector_0b137abd78bd3d03653cd21436eb6c4d}, and \bf{eiger\-Detector} \doxyref{p.}{classeigerDetector_8380366bf7112021c49be8e6f29f18d8}.

\subsection{Member Data Documentation}
\index{slsDetector@{sls\-Detector}!adcs@{adcs}}
\index{adcs@{adcs}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}float$\ast$ \bf{sls\-Detector::adcs}\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_f370b8466441491d8496bb8130b8c5e7}


pointer to adc valuse \index{slsDetector@{sls\-Detector}!badChannelMask@{badChannelMask}}
\index{badChannelMask@{badChannelMask}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int$\ast$ \bf{sls\-Detector::bad\-Channel\-Mask}\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_614c98f77a8a3ec6cff57aa59e671123}


pointer to bad channel mask 0 is channel is good 1 if it is bad\begin{Desc}
\item[See also:]\doxyref{fill\-Bad\-Channel\-Mask()}{p.}{classslsDetector_6a0ebe013e27c065b2f67158a27f64ac} \end{Desc}
\index{slsDetector@{sls\-Detector}!chanregs@{chanregs}}
\index{chanregs@{chanregs}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int$\ast$ \bf{sls\-Detector::chanregs}\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_44335474559f7321f0309fbda304caf8}


pointer to channal registers \index{slsDetector@{sls\-Detector}!chipregs@{chipregs}}
\index{chipregs@{chipregs}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int$\ast$ \bf{sls\-Detector::chipregs}\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_0eb24981d044632eccba507bd15871a6}


pointer to chip registers \index{slsDetector@{sls\-Detector}!controlSocket@{controlSocket}}
\index{controlSocket@{controlSocket}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}\bf{My\-Socket\-TCP}$\ast$ \bf{sls\-Detector::control\-Socket}\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_07f3943ab8a65f061bbe1c1e1d22b700}


socket for control commands \index{slsDetector@{sls\-Detector}!currentI0@{currentI0}}
\index{currentI0@{currentI0}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}float \bf{sls\-Detector::current\-I0}\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_4bba77b0de9f911c87d48d12c15a632b}


I0 measured \index{slsDetector@{sls\-Detector}!currentPosition@{currentPosition}}
\index{currentPosition@{currentPosition}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}float \bf{sls\-Detector::current\-Position}\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_9f64e866250e916299048c9816c9ef28}


current position of the detector \index{slsDetector@{sls\-Detector}!currentPositionIndex@{currentPositionIndex}}
\index{currentPositionIndex@{currentPositionIndex}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}float \bf{sls\-Detector::current\-Position\-Index}\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_9a6cd8787f618c147faacc1f3602bcf5}


current position index of the detector \index{slsDetector@{sls\-Detector}!dacs@{dacs}}
\index{dacs@{dacs}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}float$\ast$ \bf{sls\-Detector::dacs}\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_dc1b3f867b97136fca83f86c83b7ae14}


pointer to dac valuse \index{slsDetector@{sls\-Detector}!dataProcessingThread@{dataProcessingThread}}
\index{dataProcessingThread@{dataProcessingThread}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}pthread\_\-t \bf{sls\-Detector::data\-Processing\-Thread}\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_8257cca09e23b601764e57f5a8bdaacd}


data processing thread??? \index{slsDetector@{sls\-Detector}!dataQueue@{dataQueue}}
\index{dataQueue@{dataQueue}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}queue$<$int$\ast$$>$ \bf{sls\-Detector::data\-Queue}\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_52e9fe9baf37db001cdf58f982ab5dd6}


data queue \index{slsDetector@{sls\-Detector}!dataSocket@{dataSocket}}
\index{dataSocket@{dataSocket}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}\bf{My\-Socket\-TCP}$\ast$ \bf{sls\-Detector::data\-Socket}\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_1629e3c46678ae201f6797e4d827cb32}


socket for data acquisition \index{slsDetector@{sls\-Detector}!detectorModules@{detectorModules}}
\index{detectorModules@{detectorModules}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}\bf{sls\_\-detector\_\-module}$\ast$ \bf{sls\-Detector::detector\-Modules}\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_b78d6f2abc185b2bde2c550b31e0ff72}


pointer to detector module structures \index{slsDetector@{sls\-Detector}!detId@{detId}}
\index{detId@{detId}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int \bf{sls\-Detector::det\-Id}\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_37f4af284283e7a18a28cec3f4e4532f}


detector ID \index{slsDetector@{sls\-Detector}!ffcoefficients@{ffcoefficients}}
\index{ffcoefficients@{ffcoefficients}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}float$\ast$ \bf{sls\-Detector::ffcoefficients}\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_a3c6e93198a2f8b072b7b84ba9af7c4b}


pointer to flat field coefficients \index{slsDetector@{sls\-Detector}!fferrors@{fferrors}}
\index{fferrors@{fferrors}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}float$\ast$ \bf{sls\-Detector::fferrors}\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_636168b92509e96418c9134d6d82ad4c}


pointer to flat field coefficient errors \index{slsDetector@{sls\-Detector}!mergingBins@{mergingBins}}
\index{mergingBins@{mergingBins}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}float$\ast$ \bf{sls\-Detector::merging\-Bins}\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_81751fd6e87f9659a8b6afe13efec2cf}


merging bins \index{slsDetector@{sls\-Detector}!mergingCounts@{mergingCounts}}
\index{mergingCounts@{mergingCounts}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}float$\ast$ \bf{sls\-Detector::merging\-Counts}\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_fc173dcaeda2bbd7bbd6a874b5b5726c}


merging counts \index{slsDetector@{sls\-Detector}!mergingErrors@{mergingErrors}}
\index{mergingErrors@{mergingErrors}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}float$\ast$ \bf{sls\-Detector::merging\-Errors}\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_f357d3b5961ead7ec263a47aa51c4c11}


merging errors \index{slsDetector@{sls\-Detector}!mergingMultiplicity@{mergingMultiplicity}}
\index{mergingMultiplicity@{mergingMultiplicity}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int$\ast$ \bf{sls\-Detector::merging\-Multiplicity}\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_91c5e22042997d86c2c4d16ef1be9150}


merging multiplicity \index{slsDetector@{sls\-Detector}!onlineFlag@{onlineFlag}}
\index{onlineFlag@{onlineFlag}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int \bf{sls\-Detector::online\-Flag}\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_7572bba8e53f900d4126657827bec3cf}


\begin{Desc}
\item[See also:]\doxyref{set\-Online}{p.}{classslsDetector_f041f723f702c17de292061d6d609698} \end{Desc}
\index{slsDetector@{sls\-Detector}!shmId@{shmId}}
\index{shmId@{shmId}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int \bf{sls\-Detector::shm\-Id}\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_53a78c7fe99f93b9bba8d0c2cb32a181}


shared memeory ID \index{slsDetector@{sls\-Detector}!stopSocket@{stopSocket}}
\index{stopSocket@{stopSocket}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}\bf{My\-Socket\-TCP}$\ast$ \bf{sls\-Detector::stop\-Socket}\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_efee578cdd732339788a38707e5ce531}


socket for emergency stop \index{slsDetector@{sls\-Detector}!thisDetector@{thisDetector}}
\index{thisDetector@{thisDetector}!slsDetector@{sls\-Detector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}\bf{shared\-Sls\-Detector}$\ast$ \bf{sls\-Detector::this\-Detector}\hspace{0.3cm}{\tt  [private]}}\label{classslsDetector_fe0da5c1491ebf18f187f0a26c5ded11}


address of the detector structure in shared memory 

The documentation for this class was generated from the following files:\begin{CompactItemize}
\item 
sls\-Detector/\bf{sls\-Detector.h}\item 
sls\-Detector/\bf{sls\-Detector.cpp}\end{CompactItemize}
