detectors/slsDetectorPackage
25
0
Fork 0
mirror of https://github.com/slsdetectorgroup/slsDetectorPackage.git synced 2025-06-11 12:27:14 +02:00
Code Issues Actions Packages Releases Activity

After some speed optimization...

Browse Source 
git-svn-id: file:///afs/psi.ch/project/sls_det_software/svn/slsDetectorSoftware@171 951219d9-93cf-4727-9268-0efd64621fa3
This commit is contained in:
bergamaschi
2012-04-13 13:03:53 +00:00
parent 3ddafe3baf
commit ab4e569b6c
18 changed files with 714 additions and 362 deletions
Download Patch File Download Diff File Expand all files Collapse all files

258
slsDetectorSoftware/slsDetectorAnalysis/angularConversion.h
View File

@ -15,7 +15,7 @@
using namespace std;
/**
angular conversion constant for a module
@short Angular conversion constants needed for a detector module
*/
typedef struct {
float center; /**< center of the module (channel at which the radius is perpendicular to the module surface) */
@ -30,14 +30,20 @@ typedef struct {
/**
class containing the methods to set/unset the angular conversion and merge the data
The angular conversion itself is stored in the slsDetector/multiSlsDetector class!
@short methods to set/unset the angular conversion and merge the data
class containing the methods to set/unset the angular conversion and merge the data
The angular conversion itself is defined by the angle() function defined in usersFunctions.cpp
*/
class angularConversion : public slsDetectorDefs {
public:
/** default constructor */
angularConversion();
/** virtual destructor */
virtual ~angularConversion();
@ -51,45 +57,68 @@ class angularConversion : public slsDetectorDefs {
reads an angular conversion file
\param fname file to be read
\param nmod number of modules (maximum) to be read
\param angOff pointer to array of angleConversionConstants
\returns OK or FAIL
*/
static int readAngularConversion(string fname, int nmod, angleConversionConstant *angOff);
/**
MOVE TO ANGULAR CALIBRATION?!?!??!?
reads an angular conversion file
\param fname file to be read
\param ifstream input file stream to be read
\param nmod number of modules (maximum) to be read
\param angOff pointer to array of angleConversionConstants
\returns OK or FAIL
*/
static int readAngularConversion(ifstream& ifs, int nmod, angleConversionConstant *angOff);
/**
MOVE TO ANGULAR CALIBRATION?!?!??!?
writes an angular conversion file
\param fname file to be written
\sa angleConversionConstant mythenDetector::writeAngularConversion
\param nmod number of modules to be written
\param angOff pointer to array of angleConversionConstants
\returns OK or FAIL
*/
static int writeAngularConversion(string fname, int nmod, angleConversionConstant *angOff);
/**
MOVE TO ANGULAR CALIBRATION?!?!??!?
writes an angular conversion file
\param fname file to be written
\sa angleConversionConstant mythenDetector::writeAngularConversion
\param ofstream output file stream
\param nmod number of modules to be written
\param angOff pointer to array of angleConversionConstants
\returns OK or FAIL
*/
static int writeAngularConversion(ofstream& ofs, int nmod, angleConversionConstant *angOff);
/**
pure virtual function
\param file name to be written (nmod and array of angular conversion constants default to the ones ot the slsDetector
*/
virtual int writeAngularConversion(string fname)=0;
/**
MOVE TO ANGULAR CALIBRATION?!?!??!?
sets the arrays of the merged data to 0. NB The array should be created with size >= 360./getBinSize();
\param mp already merged postions
\param mv already merged data
\param me already merged errors (squared sum)
\param mm multiplicity of merged arrays
\returns OK or FAIL
\sa mythenDetector::resetMerging
*/
sets the arrays of the merged data to 0. NB The array should be created with size nbins >= 360./getBinSize();
\param mp already merged postions
\param mv already merged data
\param me already merged errors (squared sum)
\param mm multiplicity of merged arrays
\param nbins number of bins
\returns OK or FAIL
*/
static int resetMerging(float *mp, float *mv,float *me, int *mm, int nbins);
/**
sets the arrays of the merged data to 0. NB The array should be created with size >= 360./getBinSize();
\param mp already merged postions
\param mv already merged data
\param me already merged errors (squared sum)
\param mm multiplicity of merged arrays
\returns OK or FAIL
*/
int resetMerging(float *mp, float *mv,float *me, int *mm);
/**
creates the arrays for merging the data and sets them to 0.
*/
int resetMerging();
/**
@ -110,92 +139,152 @@ class angularConversion : public slsDetectorDefs {
static int addToMerging(float *p1, float *v1, float *e1, float *mp, float *mv,float *me, int *mm, int nchans, float binsize,int nb, int *badChanMask );
/**
merge dataset
\param p1 angular positions of dataset
\param v1 data
\param e1 errors
\param mp already merged postions
\param mv already merged data
\param me already merged errors (squared sum)
\param mm multiplicity of merged arrays
\param badChanMask badchannelmask (if NULL does not correct for bad channels)
\returns OK or FAIL
*/
int addToMerging(float *p1, float *v1, float *e1, float *mp, float *mv,float *me, int *mm, int *badChanMask);
/**
merge dataset
\param p1 angular positions of dataset
\param v1 data
\param e1 errors
\param badChanMask badchannelmask (if NULL does not correct for bad channels)
\returns OK or FAIL
*/
int addToMerging(float *p1, float *v1, float *e1,int *badChanMask);
/**
MOVE TO ANGULAR CALIBRATION?!?!??!?
calculates the "final" positions, data value and errors for the emrged data
calculates the "final" positions, data value and errors for the merged data
\param mp already merged postions
\param mv already merged data
\param me already merged errors (squared sum)
\param mm multiplicity of merged arrays
\param nb number of bins
\returns FAIL or the number of non empty bins (i.e. points belonging to the pattern)
*/
static int finalizeMerging(float *mp, float *mv,float *me, int *mm, int nb);
/**
calculates the "final" positions, data value and errors for the merged data
\param mp already merged postions
\param mv already merged data
\param me already merged errors (squared sum)
\param mm multiplicity of merged arrays
\returns FAIL or the number of non empty bins (i.e. points belonging to the pattern)
\sa mythenDetector::finalizeMerging
*/
static int finalizeMerging(float *mp, float *mv,float *me, int *mm, int nb);
int finalizeMerging(float *mp, float *mv,float *me, int *mm);
/**
calculates the "final" positions, data value and errors for the merged data
\returns FAIL or the number of non empty bins (i.e. points belonging to the pattern)
*/
int finalizeMerging(float *mp, float *mv,float *me, int *mm);
int finalizeMerging();
/**
pure virtual function
set detector global offset
\sa mythenDetector::setGlobalOffset
\param f global offset to be set
\returns actual global offset
*/
float setGlobalOffset(float f){return setAngularConversionParameter(GLOBAL_OFFSET,f);};
/**
pure virtual function
set detector fine offset
\sa mythenDetector::setFineOffset
\param f global fine to be set
\returns actual fine offset
*/
float setFineOffset(float f){return setAngularConversionParameter(FINE_OFFSET,f);};
/**
pure virtual function
get detector fine offset
\sa mythenDetector::getFineOffset
\returns actual fine offset
*/
float getFineOffset(){return getAngularConversionParameter(FINE_OFFSET);};
/**
pure virtual function
get detector global offset
\sa mythenDetector::getGlobalOffset
\returns actual global offset
*/
float getGlobalOffset(){return getAngularConversionParameter(GLOBAL_OFFSET);};
/**
set detector bin size used for merging (approx angular resolution)
\param bs bin size in degrees
\returns current bin size
\sa mythenDetector::setBinSize
*/
set detector bin size
\param bs bin size to be set
\returns actual bin size
*/
float setBinSize(float bs){return setAngularConversionParameter(BIN_SIZE,bs);};
/**
return detector bin size used for merging (approx angular resolution)
\sa mythenDetector::getBinSize
get detector bin size
\returns detector bin size used for merging (approx angular resolution)
*/
float getBinSize() {return getAngularConversionParameter(BIN_SIZE);};
/**
get angular direction
\returns actual angular direction (1 is channel number increasing with angle, -1 decreasing)
*/
int getAngularDirection(){return (int)getAngularConversionParameter(ANGULAR_DIRECTION);};
/**
set angular direction
\param d angular direction to be set (1 is channel number increasing with angle, -1 decreasing)
\returns actual angular direction (1 is channel number increasing with angle, -1 decreasing)
*/
int setAngularDirection(int d){return (int)setAngularConversionParameter(ANGULAR_DIRECTION, (float)d);};
/**
\returns number of angular bins in the merging (360./binsize)
*/
int getNumberOfAngularBins(){return nBins;};
/**
get angular conversion
\param direction reference to diffractometer direction
get angular conversion
\param direction reference to diffractometer direction
\param angconv array that will be filled with the angular conversion constants
\returns 0 if angular conversion disabled, >0 otherwise
*/
virtual int getAngularConversion(int &direction, angleConversionConstant *angconv=NULL)=0;
float setAngularConversionParameter(angleConversionParameter c, float v);
/**
set angular conversion parameter
\param c parameter type (globaloffset, fineoffset, binsize, angular direction, move flag)
\param v value to be set
\returns actual value
*/
float setAngularConversionParameter(angleConversionParameter c, float v);
/**
get angular conversion parameter
\param c parameter type (globaloffset, fineoffset, binsize, angular direction, move flag)
\returns actual value
*/
float getAngularConversionParameter(angleConversionParameter c);
/**
pure virtual function
\returns total number of channels of the (multi)detector
*/
virtual int getTotalNumberOfChannels()=0;
@ -214,10 +303,23 @@ class angularConversion : public slsDetectorDefs {
*/
virtual int getPositions(float *pos=NULL);
/**
deletes the array of merged data
\returns OK
*/
int deleteMerging();
/**
\returns pointer to the array o merged positions
*/
float *getMergedPositions(){return mergingBins;};
/**
\returns pointer to the array of merged counts
*/
float *getMergedCounts(){return mergingCounts;};
/**
\returns pointer to the array of merged errors
*/
float *getMergedErrors(){return mergingErrors;};
@ -237,42 +339,86 @@ class angularConversion : public slsDetectorDefs {
string getAngularConversionFile(){if (setAngularCorrectionMask()) return string(angConvFile); else return string("none");};
/**
reads teh angular conversion file for the (multi)detector and writes it to shared memory
*/
virtual int readAngularConversionFile(string fname="")=0;
// int setAngularConversionPointer(angleConversionConstant *p, int *nm, int nch, int idet=0);
/**
\returns number of modules of the (multi)detector
*/
virtual int getNMods()=0;
/**
returns number of channels in the module
\param imod module number
\returns number of channels in the module
*/
virtual int getChansPerMod(int imod=0)=0;
/**
get the angular conversion contant of one modules
\param imod module number
\returns pointer to the angular conversion constant
*/
virtual angleConversionConstant *getAngularConversionPointer(int imod=0)=0;
/**
converts channel number to angle
\param pos encoder position
\returns array of angles corresponding to the channels
*/
float* convertAngles(float pos);
/**
converts channel number to angle for the current encoder position
\returns array of angles corresponding to the channels
*/
float *convertAngles(){return convertAngles(currentPosition);};
/**
\param imod module number
\returns move flag of the module (1 encoder is added to the angle, 0 not)
*/
virtual int getMoveFlag(int imod)=0;
/**
returns current position index
*/
int getCurrentPositionIndex() {return currentPositionIndex;};
/**
returns number of positions
*/
int getNumberOfPositions() {return *numberOfPositions;};
protected:
/** pointer to number of positions for the acquisition*/
int *numberOfPositions;
/** pointer to the detector positions for the acquisition*/
float *detPositions;
/** pointer to angular conversion file name*/
char *angConvFile;
/** pointer to angular bin size*/
float *binSize;
/** pointer to beamlien fine offset*/
float *fineOffset;
/** pointer to beamlien global offset*/
float *globalOffset;
/** pointer to beamlien angular direction*/
int *angDirection;
/** pointer to detector move flag (1 moves with encoder, 0 not)*/
int *moveFlag;
/** number of bins for angular conversion (360./binsize)*/
int nBins;
@ -287,6 +433,12 @@ class angularConversion : public slsDetectorDefs {
*/
int currentPositionIndex;
/**
enables/disable the angular conversion
\param i 1 sets, 0 unsets,, -1 gets
\returns actual angular conversion flag
*/
virtual int setAngularCorrectionMask(int i=-1)=0;
@ -303,12 +455,6 @@ class angularConversion : public slsDetectorDefs {
/** merging multiplicity */
int *mergingMultiplicity;
/** pointer to the angular conversion constants for the (multi)detector class*/
/* angleConversionConstant *angOff[MAXDET]; */
/* int *nMods[MAXDET]; */
/* int nCh[MAXDET]; */
};