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

virtual, master all works, still to do rewriting file in an acquisition

Browse Source
This commit is contained in:
Dhanya Maliakal
2017-02-21 15:13:59 +01:00
parent 2cd38fefcd
commit 9e21583331
17 changed files with 855 additions and 252 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
slsReceiverSoftware/include/BinaryFile.h
View File

@ -21,6 +21,7 @@ class BinaryFile : private virtual slsReceiverDefs, public File {
* Constructor * Constructor
* creates the File Writer * creates the File Writer
* @param ind self index * @param ind self index
* @param nd pointer to number of detectors in each dimension
* @param fname pointer to file name prefix * @param fname pointer to file name prefix
* @param fpath pointer to file path * @param fpath pointer to file path
* @param findex pointer to file index * @param findex pointer to file index
@ -32,7 +33,7 @@ class BinaryFile : private virtual slsReceiverDefs, public File {
* @param dr dynamic range * @param dr dynamic range
* @param maxf max frames per file * @param maxf max frames per file
*/ */
BinaryFile(int ind, char* fname, char* fpath, uint64_t* findex, BinaryFile(int ind, int* nd, char* fname, char* fpath, uint64_t* findex,
bool* frindexenable, bool* owenable, int* dindex, int* nunits, uint64_t* nf, uint32_t* dr, uint32_t maxf); bool* frindexenable, bool* owenable, int* dindex, int* nunits, uint64_t* nf, uint32_t* dr, uint32_t maxf);
/** /**
@ -119,7 +120,7 @@ class BinaryFile : private virtual slsReceiverDefs, public File {
static int WriteDataFile(FILE* fd, char* buf, int bsize, uint64_t fnum); static int WriteDataFile(FILE* fd, char* buf, int bsize, uint64_t fnum);
/** /**
* Create common files * Create master file
* @param en ten giga enable * @param en ten giga enable
* @param size image size * @param size image size
* @param nx number of pixels in x direction * @param nx number of pixels in x direction
@ -128,7 +129,7 @@ class BinaryFile : private virtual slsReceiverDefs, public File {
* @param ap acquisition period * @param ap acquisition period
* @returns OK or FAIL * @returns OK or FAIL
*/ */
int CreateCommonFiles(bool en, uint32_t size, int CreateMasterFile(bool en, uint32_t size,
uint32_t nx, uint32_t ny, uint64_t at, uint64_t ap); uint32_t nx, uint32_t ny, uint64_t at, uint64_t ap);
@ -140,32 +141,21 @@ class BinaryFile : private virtual slsReceiverDefs, public File {
*/ */
fileFormat GetFileType(); fileFormat GetFileType();
/** Maximum frames per file */
uint32_t maxFramesPerFile;
/** File Descriptor */
FILE* filefd;
/** Master File Descriptor */
static FILE* masterfd;
/** /**
* Create file names for master and virtual file * Create file names for master file
* @param m master file name
* @param fpath file path * @param fpath file path
* @param fnameprefix file name prefix (includes scan and position variables) * @param fnameprefix file name prefix (includes scan and position variables)
* @param findex file index * @param findex file index
*/ */
void CreateCommonFileNames(std::string& m, char* fpath, char* fnameprefix, uint64_t findex); void CreateMasterFileName(char* fpath, char* fnameprefix, uint64_t findex);
/* /*
* Close master and virtual files * Close master file
*/ */
void CloseCommonDataFiles(); void CloseMasterDataFile();
/** /**
* Create master and virtual files * Create master files
* @param m master file name
* @param owenable overwrite enable * @param owenable overwrite enable
* @param tengigaEnable ten giga enable * @param tengigaEnable ten giga enable
* @param imageSize image size * @param imageSize image size
@ -175,11 +165,21 @@ class BinaryFile : private virtual slsReceiverDefs, public File {
* @param acquisitionPeriod acquisition period * @param acquisitionPeriod acquisition period
* @returns OK or FAIL * @returns OK or FAIL
*/ */
int CreateCommonDataFiles(std::string m, bool owenable, int CreateMasterDataFile(bool owenable,
bool tengigaEnable, uint32_t imageSize, uint32_t nPixelsX, uint32_t nPixelsY, bool tengigaEnable, uint32_t imageSize, uint32_t nPixelsX, uint32_t nPixelsY,
uint64_t acquisitionTime, uint64_t acquisitionPeriod); uint64_t acquisitionTime, uint64_t acquisitionPeriod);
/** Maximum frames per file */
uint32_t maxFramesPerFile;
/** File Descriptor */
FILE* filefd;
/** Master File Descriptor */
static FILE* masterfd;
}; };
#endif #endif

6
slsReceiverSoftware/include/DataProcessor.h
View File

@ -133,6 +133,7 @@ class DataProcessor : private virtual slsReceiverDefs, public ThreadObject {
/** /**
* Set up file writer object and call backs * Set up file writer object and call backs
* @param nd pointer to number of detectors in each dimension
* @param fname pointer to file name prefix * @param fname pointer to file name prefix
* @param fpath pointer to file path * @param fpath pointer to file path
* @param findex pointer to file index * @param findex pointer to file index
@ -144,7 +145,7 @@ class DataProcessor : private virtual slsReceiverDefs, public ThreadObject {
* @param dr dynamic range * @param dr dynamic range
* @param g address of GeneralData (Detector Data) pointer * @param g address of GeneralData (Detector Data) pointer
*/ */
void SetupFileWriter(char* fname, char* fpath, uint64_t* findex, void SetupFileWriter(int* nd, char* fname, char* fpath, uint64_t* findex,
bool* frindexenable, bool* owenable, int* dindex, int* nunits, uint64_t* nf, uint32_t* dr, GeneralData* g = 0); bool* frindexenable, bool* owenable, int* dindex, int* nunits, uint64_t* nf, uint32_t* dr, GeneralData* g = 0);
@ -163,6 +164,9 @@ class DataProcessor : private virtual slsReceiverDefs, public ThreadObject {
*/ */
void CloseFiles(); void CloseFiles();
void CreateFinalFile();
private: private:
/** /**

27
slsReceiverSoftware/include/File.h
View File

@ -22,6 +22,7 @@ class File : private virtual slsReceiverDefs {
* Constructor * Constructor
* creates the File Writer * creates the File Writer
* @param ind self index * @param ind self index
* @param nd pointer to number of detectors in each dimension
* @param fname pointer to file name prefix * @param fname pointer to file name prefix
* @param fpath pointer to file path * @param fpath pointer to file path
* @param findex pointer to file index * @param findex pointer to file index
@ -32,7 +33,7 @@ class File : private virtual slsReceiverDefs {
* @param nf pointer to number of images in acquisition * @param nf pointer to number of images in acquisition
* @param dr dynamic range * @param dr dynamic range
*/ */
File(int ind, char* fname, char* fpath, uint64_t* findex, File(int ind, int* nd, char* fname, char* fpath, uint64_t* findex,
bool* frindexenable, bool* owenable, int* dindex, int* nunits, uint64_t* nf, uint32_t* dr); bool* frindexenable, bool* owenable, int* dindex, int* nunits, uint64_t* nf, uint32_t* dr);
/** /**
@ -59,6 +60,7 @@ class File : private virtual slsReceiverDefs {
/** /**
* Get Member Pointer Values before the object is destroyed * Get Member Pointer Values before the object is destroyed
* @param nd pointer to number of detectors in each dimension
* @param fname pointer to file name prefix * @param fname pointer to file name prefix
* @param fpath pointer to file path * @param fpath pointer to file path
* @param findex pointer to file index * @param findex pointer to file index
@ -69,8 +71,8 @@ class File : private virtual slsReceiverDefs {
* @param nf pointer to number of images in acquisition * @param nf pointer to number of images in acquisition
* @param dr dynamic range * @param dr dynamic range
*/ */
void GetMemberPointerValues(char*& fname, char*& fpath, uint64_t*& findex, void GetMemberPointerValues(int* nd, char*& fname, char*& fpath, uint64_t*& findex,
bool*& frindexenable, bool*& owenable, int*& dindex, int*& nunits, uint64_t*& nf, uint32_t* dr); bool*& frindexenable, bool*& owenable, int*& dindex, int*& nunits, uint64_t*& nf, uint32_t*& dr);
/** /**
* Create file * Create file
@ -108,7 +110,7 @@ class File : private virtual slsReceiverDefs {
} }
/** /**
* Create common files * Create master file
* @param en ten giga enable * @param en ten giga enable
* @param size image size * @param size image size
* @param nx number of pixels in x direction * @param nx number of pixels in x direction
@ -117,9 +119,9 @@ class File : private virtual slsReceiverDefs {
* @param ap acquisition period * @param ap acquisition period
* @returns OK or FAIL * @returns OK or FAIL
*/ */
virtual int CreateCommonFiles(bool en, uint32_t size, virtual int CreateMasterFile(bool en, uint32_t size,
uint32_t nx, uint32_t ny, uint64_t at, uint64_t ap) { uint32_t nx, uint32_t ny, uint64_t at, uint64_t ap) {
cprintf(RED,"This is a generic function CreateCommonFiles that should be overloaded by a derived class\n"); cprintf(RED,"This is a generic function CreateMasterFile that should be overloaded by a derived class\n");
return OK; return OK;
} }
@ -143,7 +145,9 @@ class File : private virtual slsReceiverDefs {
cprintf(RED,"This is a generic function SetNumberofPixels that should be overloaded by a derived class\n"); cprintf(RED,"This is a generic function SetNumberofPixels that should be overloaded by a derived class\n");
} }
virtual void CreateFinalFile(){
;
}
protected: protected:
@ -153,6 +157,15 @@ class File : private virtual slsReceiverDefs {
/** Self Index */ /** Self Index */
int index; int index;
/** Number of Detectors in X dimension */
int numDetX;
/** Number of Detectors in Y dimension */
int numDetY;
/** Master File Name */
std::string masterFileName;
/** File Name Prefix */ /** File Name Prefix */
char* fileNamePrefix; char* fileNamePrefix;

187
slsReceiverSoftware/include/HDF5File.h
View File

@ -27,6 +27,7 @@ class HDF5File : private virtual slsReceiverDefs, public File {
* Constructor * Constructor
* creates the File Writer * creates the File Writer
* @param ind self index * @param ind self index
* @param nd pointer to number of detectors in each dimension
* @param fname pointer to file name prefix * @param fname pointer to file name prefix
* @param fpath pointer to file path * @param fpath pointer to file path
* @param findex pointer to file index * @param findex pointer to file index
@ -39,7 +40,7 @@ class HDF5File : private virtual slsReceiverDefs, public File {
* @param nx number of pixels in x direction * @param nx number of pixels in x direction
* @param ny number of pixels in y direction * @param ny number of pixels in y direction
*/ */
HDF5File(int ind, char* fname, char* fpath, uint64_t* findex, HDF5File(int ind, int* nd, char* fname, char* fpath, uint64_t* findex,
bool* frindexenable, bool* owenable, int* dindex, int* nunits, uint64_t* nf, uint32_t* dr, bool* frindexenable, bool* owenable, int* dindex, int* nunits, uint64_t* nf, uint32_t* dr,
int nx, int ny); int nx, int ny);
@ -84,7 +85,25 @@ class HDF5File : private virtual slsReceiverDefs, public File {
* @param fnum current image number * @param fnum current image number
* @returns OK or FAIL * @returns OK or FAIL
*/ */
int WriteToFile(char* buffer, int bsize, uint64_t fnum); int WriteToFile(char* buffer, int bsize, uint64_t fnum);
/**
* Create master file
* @param en ten giga enable
* @param size image size
* @param nx number of pixels in x direction
* @param ny number of pixels in y direction
* @param at acquisition time
* @param ap acquisition period
* @returns OK or FAIL
*/
int CreateMasterFile(bool en, uint32_t size,
uint32_t nx, uint32_t ny, uint64_t at, uint64_t ap);
//*** static functions ***
/** /**
* Create File Name in format fpath/fnameprefix_fx_dy_z.raw, * Create File Name in format fpath/fnameprefix_fx_dy_z.raw,
@ -103,31 +122,46 @@ class HDF5File : private virtual slsReceiverDefs, public File {
uint64_t fnum = 0, int dindex = -1, int numunits = 1, int unitindex = 0); uint64_t fnum = 0, int dindex = -1, int numunits = 1, int unitindex = 0);
/** /**
* Create File * Create master file name
* @param ind object index for debugging * @param fpath file path
* @param owenable overwrite enable * @param fnameprefix file name prefix (includes scan and position variables)
* @param numf number of images * @param findex file index
* @param fname complete file name * @returns master file name
* @param fnum current image number
* @param nx number of pixels in x dir
* @param ny number of pixels in y dir
* @param dtype data type
* @param fd file pointer
* @param dspace dataspace pointer
* @param dset dataset pointer
* @returns OK or FAIL
*/ */
static int CreateDataFile(int ind, bool owenable, uint64_t numf, std::string fname, uint64_t fnum, int nx, int ny, static std::string CreateMasterFileName(char* fpath, char* fnameprefix, uint64_t findex);
DataType dtype, H5File*& fd, DataSpace*& dspace, DataSet*& dset);
/**
* Create virtual file name
* @param fpath file path
* @param fnameprefix file name prefix (includes scan and position variables)
* @param fnum current frame number
* @param findex file index
* @param frindexenable frame index enable
* @param fnum frame number index
* @returns virtual file name
*/
static std::string CreateVirtualFileName(char* fpath, char* fnameprefix, uint64_t findex, bool frindexenable,
uint64_t fnum);
/** /**
* Close File * Close File
* @param ind index for debugging
* @param fd file pointer * @param fd file pointer
* @param dp dataspace pointer * @param dp dataspace pointer
* @param ds dataset pointer * @param ds dataset pointer
*/ */
static void CloseDataFile(H5File*& fd, DataSpace*& dp, DataSet*& ds); static void CloseDataFile(int ind, H5File*& fd, DataSpace*& dp, DataSet*& ds);
/*
* Close master file
*/
void CloseMasterDataFile();
/*
* Close virtual file
*/
void CloseVirtualDataFile();
/** /**
* Write data to file * Write data to file
@ -146,19 +180,89 @@ class HDF5File : private virtual slsReceiverDefs, public File {
DataSpace* dspace, DataSet* dset, DataType dtype); DataSpace* dspace, DataSet* dset, DataType dtype);
/** /**
* Create common files * Create master file
* @param en ten giga enable * @param fname master file name
* @param owenable overwrite enable
* @param dr dynamic range
* @param tenE ten giga enable
* @param size image size * @param size image size
* @param nx number of pixels in x direction * @param nx number of pixels in x direction
* @param ny number of pixels in y direction * @param ny number of pixels in y direction
* @param at acquisition time * @param nf number of images
* @param ap acquisition period * @param acquisitionTime acquisition time
* @param acquisitionPeriod acquisition period
* @returns OK or FAIL * @returns OK or FAIL
*/ */
int CreateCommonFiles(bool en, uint32_t size, int CreateMasterDataFile(std::string fname, bool owenable,
uint32_t nx, uint32_t ny, uint64_t at, uint64_t ap); uint32_t dr, bool tenE, uint32_t size, uint32_t nx, uint32_t ny, uint64_t nf,
uint64_t acquisitionTime, uint64_t acquisitionPeriod);
/**
* Create Virtual File
* @param fnum frame number
*/
int CreateVirtualFile(uint64_t fnum);
/**
* Create File
* @param ind object index for debugging
* @param owenable overwrite enable
* @param numf number of images
* @param fname complete file name
* @param frindexenable frame index enable
* @param fnum current image number
* @param nx number of pixels in x dir
* @param ny number of pixels in y dir
* @param dtype data type
* @param fd file pointer
* @param dspace dataspace pointer
* @param dset dataset pointer
* @returns OK or FAIL
*/
static int CreateDataFile(int ind, bool owenable, uint64_t numf, std::string fname, bool frindexenable, uint64_t fnum, int nx, int ny,
DataType dtype, H5File*& fd, DataSpace*& dspace, DataSet*& dset);
/**
* Create virtual file
* @param virtualfname virtual file name
* @param virtualDatasetname virtual dataset name
* @param srcDatasetname source dataset name
* @param numFiles number of files
* @param fileNames array of file names
* @param owenable overwrite enable
* @param fnum current frame number
* @param dtype datatype
* @param srcNDimx source number of objects in x dimension (Number of images)
* @param srcNDimy source number of objects in y dimension (Number of pixels in y dir)
* @param srcNDimz source number of objects in z dimension (Number of pixels in x dir)
* @param dstNDimx destination number of objects in x dimension (Number of images)
* @param dstNDimy destination number of objects in y dimension (Number of pixels in y dir)
* @param dstNDimz destination number of objects in z dimension (Number of pixels in x dir)
* @returns OK or FAIL
*/
static int CreateVirtualDataFile(std::string virtualfname, std::string virtualDatasetname, std::string srcDatasetname,
int numFiles, std::string fileNames[], bool owenable, uint64_t fnum, hid_t dtype,
int srcNDimx, int srcNDimy, int srcNDimz, int dstNDimx, int dstNDimy, int dstNDimz);
/**
* Copy file to another file (mainly to view virutal files in hdfviewer)
* @param owenable overwrite enable
* @param oldFileName file name including path of file to copy
* @param oldDatasetName dataset name to copy
* @param newFileName file name including path of file to copy to
* @param newDatasetName dataset name to copy to
* @param nDimx Number of objects in x dimension
* @param nDimy Number of objects in y dimension
* @param nDimz Number of objects in z dimension
* @param dataType data type
* @returns OK or FAIL
*/
template <typename T>
static int CopyVirtualFile(bool owenable, std::string oldFileName, std::string oldDatasetName,
std::string newFileName, std::string newDatasetName, int nDimx, int nDimy, int nDimz, T datatype);
void CreateFinalFile();
private: private:
/** /**
@ -172,37 +276,7 @@ class HDF5File : private virtual slsReceiverDefs, public File {
*/ */
void UpdateDataType(); void UpdateDataType();
/**
* Create file names for master and virtual file
* @param m master file name
* @param v virtual file name
* @param fpath file path
* @param fnameprefix file name prefix (includes scan and position variables)
* @param findex file index
*/
void CreateCommonFileNames(std::string& m, std::string& v, char* fpath, char* fnameprefix, uint64_t findex);
/*
* Close master and virtual files
*/
void CloseCommonDataFiles();
/**
* Create master and virtual files
* @param m master file name
* @param v virtual file name
* @param owenable overwrite enable
* @param tengigaEnable ten giga enable
* @param imageSize image size
* @param nPixelsX number of pixels in x direction
* @param nPixelsY number of pixels in y direction
* @param acquisitionTime acquisition time
* @param acquisitionPeriod acquisition period
* @returns OK or FAIL
*/
int CreateCommonDataFiles(std::string m, std::string v, bool owenable,
bool tengigaEnable, uint32_t imageSize, uint32_t nPixelsX, uint32_t nPixelsY,
uint64_t acquisitionTime, uint64_t acquisitionPeriod);
/** mutex to update static items among objects (threads)*/ /** mutex to update static items among objects (threads)*/
@ -211,8 +285,8 @@ class HDF5File : private virtual slsReceiverDefs, public File {
/** Master File handle */ /** Master File handle */
static H5File* masterfd; static H5File* masterfd;
/** Virtual File handle */ /** Virtual File handle ( only file name because code in C as H5Pset_virtual doesnt exist yet in C++) */
static H5File* virtualfd; static hid_t virtualfd;
/** File handle */ /** File handle */
H5File* filefd; H5File* filefd;
@ -231,6 +305,7 @@ class HDF5File : private virtual slsReceiverDefs, public File {
/** Number of pixels in y direction */ /** Number of pixels in y direction */
int nPixelsY; int nPixelsY;
}; };
//#endif //#endif

29
slsReceiverSoftware/include/UDPBaseImplementation.h
View File

@ -44,6 +44,19 @@ class UDPBaseImplementation : protected virtual slsReceiverDefs, public UDPInter
*************************************************************************/ *************************************************************************/
//**initial parameters*** //**initial parameters***
/*
* Get multi detector size
* @return pointer to array of multi detector size in every dimension
*/
int* getMultiDetectorSize() const;
/*
* Get detector position id
* @return detector position id
*/
int getDetectorPositionId() const;
/* /*
* Get detector hostname * Get detector hostname
* @return NULL or hostname or NULL if uninitialized (max of 1000 characters) * @return NULL or hostname or NULL if uninitialized (max of 1000 characters)
@ -245,6 +258,12 @@ class UDPBaseImplementation : protected virtual slsReceiverDefs, public UDPInter
*/ */
void configure(map<string, string> config_map); void configure(map<string, string> config_map);
/*
* Set multi detector size
* @param pointer to array of multi detector size in every dimension
*/
void setMultiDetectorSize(const int* size);
/* /*
* Get flipped data across 'axis' * Get flipped data across 'axis'
* @return if data is flipped across 'axis' * @return if data is flipped across 'axis'
@ -419,6 +438,12 @@ class UDPBaseImplementation : protected virtual slsReceiverDefs, public UDPInter
*/ */
int setDetectorType(const detectorType d); int setDetectorType(const detectorType d);
/**
* Set detector position id
* @param i position id
*/
void setDetectorPositionId(const int i);
/** /**
* Sets detector hostname (and corresponding detector variables in derived REST class) * Sets detector hostname (and corresponding detector variables in derived REST class)
* It is second function called by the client when connecting to receiver. * It is second function called by the client when connecting to receiver.
@ -532,6 +557,10 @@ class UDPBaseImplementation : protected virtual slsReceiverDefs, public UDPInter
//**detector parameters*** //**detector parameters***
/** detector type */ /** detector type */
detectorType myDetectorType; detectorType myDetectorType;
/** Number of Detectors in each dimension direction */
int numDet[MAX_DIMENSIONS];
/*Detector Readout ID*/
int detID;
/** detector hostname */ /** detector hostname */
char detHostname[MAX_STR_LENGTH]; char detHostname[MAX_STR_LENGTH];
/** Acquisition Period */ /** Acquisition Period */

25
slsReceiverSoftware/include/UDPInterface.h
View File

@ -104,6 +104,19 @@ class UDPInterface {
*************************************************************************/ *************************************************************************/
//**initial/detector parameters*** //**initial/detector parameters***
/*
* Get multi detector size
* @return pointer to array of multi detector size in every dimension
*/
virtual int* getMultiDetectorSize() const = 0;
/*
* Get detector position id
* @return detector position id
*/
virtual int getDetectorPositionId() const = 0;
/* /*
* Get detector hostname * Get detector hostname
* @return hostname or NULL if uninitialized, must be released by calling function (max of 1000 characters) * @return hostname or NULL if uninitialized, must be released by calling function (max of 1000 characters)
@ -304,6 +317,12 @@ class UDPInterface {
*/ */
virtual void configure(map<string, string> config_map) = 0; virtual void configure(map<string, string> config_map) = 0;
/*
* Set multi detector size
* @param pointer to array of multi detector size in every dimension
*/
virtual void setMultiDetectorSize(const int* size) = 0;
/* /*
* Get flipped data across 'axis' * Get flipped data across 'axis'
* @return if data is flipped across 'axis' * @return if data is flipped across 'axis'
@ -476,6 +495,12 @@ class UDPInterface {
*/ */
virtual int setDetectorType(const slsReceiverDefs::detectorType d) = 0; virtual int setDetectorType(const slsReceiverDefs::detectorType d) = 0;
/**
* Set detector position id
* @param i position id
*/
virtual void setDetectorPositionId(const int i) = 0;
/** /**
* Sets detector hostname (and corresponding detector variables in derived REST class) * Sets detector hostname (and corresponding detector variables in derived REST class)
* It is second function called by the client when connecting to receiver. * It is second function called by the client when connecting to receiver.

10
slsReceiverSoftware/include/UDPStandardImplementation.h
View File

@ -140,6 +140,12 @@ class UDPStandardImplementation: private virtual slsReceiverDefs, public UDPBase
*/ */
int setDetectorType(const detectorType d); int setDetectorType(const detectorType d);
/**
* Set detector position id and construct filewriter
* @param i position id
*/
void setDetectorPositionId(const int i);
/** /**
* Reset acquisition parameters such as total frames caught for an entire acquisition (including all scans) * Reset acquisition parameters such as total frames caught for an entire acquisition (including all scans)
*/ */
@ -244,10 +250,6 @@ private:
//*** Class Members *** //*** Class Members ***
//*** detector parameters ***
/*Detector Readout ID*/
int detID;
//*** receiver parameters *** //*** receiver parameters ***
/** Number of Threads */ /** Number of Threads */
int numThreads; int numThreads;

1
slsReceiverSoftware/include/receiver_defs.h
View File

@ -4,6 +4,7 @@
#include "sls_receiver_defs.h" #include "sls_receiver_defs.h"
#include <stdint.h> #include <stdint.h>
#define MAX_DIMENSIONS 2
//socket //socket
#define GOODBYE -200 #define GOODBYE -200
#define RECEIVE_SOCKET_BUFFER_SIZE (100*1024*1024) #define RECEIVE_SOCKET_BUFFER_SIZE (100*1024*1024)

4
slsReceiverSoftware/include/slsReceiverTCPIPInterface.h
View File

@ -221,7 +221,11 @@ private:
/** set file format */ /** set file format */
int set_file_format(); int set_file_format();
/** set position id */
int set_detector_posid();
/** set multi detector size */
int set_multi_detector_size();
//General Functions //General Functions
/** Locks Receiver */ /** Locks Receiver */

6
slsReceiverSoftware/include/sls_receiver_funcs.h
View File

@ -53,12 +53,12 @@ enum {
F_ACTIVATE, /** < activate/deactivate readout */ F_ACTIVATE, /** < activate/deactivate readout */
F_STREAM_DATA_FROM_RECEIVER, /**< stream data from receiver to client */ F_STREAM_DATA_FROM_RECEIVER, /**< stream data from receiver to client */
F_READ_RECEIVER_TIMER, /** < sets the timer between each data stream in receiver */ F_READ_RECEIVER_TIMER, /** < sets the timer between each data stream in receiver */
F_SET_FLIPPED_DATA_RECEIVER, /** < sets the enable to flip data across x/y axis (bottom/top) */ F_SET_FLIPPED_DATA_RECEIVER, /** < sets the enable to flip data across x/y axis (bottom/top) */
F_SET_RECEIVER_FILE_FORMAT, /** < sets the receiver file format */
F_SET_RECEIVER_FILE_FORMAT /** < sets the receiver file format */ F_SEND_RECEIVER_DETPOSID, /** < sets the detector position id in the reveiver */
F_SEND_RECEIVER_MULTIDETSIZE /** < sets the multi detector size to the receiver */
/* Always append functions hereafter!!! */ /* Always append functions hereafter!!! */
}; };

40
slsReceiverSoftware/src/BinaryFile.cpp
View File

@ -15,9 +15,9 @@ using namespace std;
FILE* BinaryFile::masterfd = 0; FILE* BinaryFile::masterfd = 0;
BinaryFile::BinaryFile(int ind, char* fname, char* fpath, uint64_t* findex, BinaryFile::BinaryFile(int ind, int* nd, char* fname, char* fpath, uint64_t* findex,
bool* frindexenable, bool* owenable, int* dindex, int* nunits, uint64_t* nf, uint32_t* dr, uint32_t maxf): bool* frindexenable, bool* owenable, int* dindex, int* nunits, uint64_t* nf, uint32_t* dr, uint32_t maxf):
File(ind, fname, fpath, findex, frindexenable, owenable, dindex, nunits, nf, dr), File(ind, nd, fname, fpath, findex, frindexenable, owenable, dindex, nunits, nf, dr),
maxFramesPerFile(maxf), maxFramesPerFile(maxf),
filefd(0) filefd(0)
{ {
@ -27,6 +27,7 @@ BinaryFile::BinaryFile(int ind, char* fname, char* fpath, uint64_t* findex,
} }
BinaryFile::~BinaryFile() { BinaryFile::~BinaryFile() {
CloseAllFiles();
} }
void BinaryFile::PrintMembers() { void BinaryFile::PrintMembers() {
@ -59,8 +60,8 @@ void BinaryFile::CloseCurrentFile() {
void BinaryFile::CloseAllFiles() { void BinaryFile::CloseAllFiles() {
CloseDataFile(filefd); CloseDataFile(filefd);
if (master) if (master && (*detIndex==0))
CloseCommonDataFiles(); CloseMasterDataFile();
} }
int BinaryFile::WriteToFile(char* buffer, int buffersize, uint64_t fnum) { int BinaryFile::WriteToFile(char* buffer, int buffersize, uint64_t fnum) {
@ -71,15 +72,11 @@ int BinaryFile::WriteToFile(char* buffer, int buffersize, uint64_t fnum) {
} }
int BinaryFile::CreateCommonFiles(bool en, uint32_t size, int BinaryFile::CreateMasterFile(bool en, uint32_t size,
uint32_t nx, uint32_t ny, uint64_t at, uint64_t ap) { uint32_t nx, uint32_t ny, uint64_t at, uint64_t ap) {
if (master) { if (master && (*detIndex==0)) {
string masterFileName=""; CreateMasterFileName(filePath, fileNamePrefix, *fileIndex);
CreateCommonFileNames(masterFileName, filePath, fileNamePrefix, *fileIndex); return CreateMasterDataFile(*overWriteEnable,en, size, nx, ny, at, ap);
printf("Master HDF5 File: %s\n", masterFileName.c_str());
//create common files
return CreateCommonDataFiles(masterFileName, *overWriteEnable,
en, size, nx, ny, at, ap);
} }
return OK; return OK;
} }
@ -128,33 +125,34 @@ int BinaryFile::WriteDataFile(FILE* fd, char* buf, int bsize, uint64_t fnum) {
return fwrite(buf, 1, bsize, fd); return fwrite(buf, 1, bsize, fd);
} }
void BinaryFile::CreateCommonFileNames(string& m, char* fpath, char* fnameprefix, uint64_t findex) { void BinaryFile::CreateMasterFileName(char* fpath, char* fnameprefix, uint64_t findex) {
ostringstream osfn; ostringstream osfn;
osfn << fpath << "/" << fnameprefix; osfn << fpath << "/" << fnameprefix;
osfn << "_master"; osfn << "_master";
osfn << "_" << findex; osfn << "_" << findex;
osfn << ".raw"; osfn << ".raw";
m = osfn.str(); masterFileName = osfn.str();
printf("Master HDF5 File: %s\n", masterFileName.c_str());
} }
void BinaryFile::CloseCommonDataFiles() { void BinaryFile::CloseMasterDataFile() {
if(masterfd) if(masterfd)
delete masterfd; delete masterfd;
masterfd = 0; masterfd = 0;
} }
int BinaryFile::CreateCommonDataFiles(string m, bool owenable, int BinaryFile::CreateMasterDataFile(bool owenable,
bool tengigaEnable, uint32_t imageSize, uint32_t nPixelsX, uint32_t nPixelsY, bool tengigaEnable, uint32_t imageSize, uint32_t nPixelsX, uint32_t nPixelsY,
uint64_t acquisitionTime, uint64_t acquisitionPeriod) { uint64_t acquisitionTime, uint64_t acquisitionPeriod) {
if(!owenable){ if(!owenable){
if (NULL == (masterfd = fopen((const char *) m.c_str(), "wx"))){ if (NULL == (masterfd = fopen((const char *) masterFileName.c_str(), "wx"))){
cprintf(RED,"Error in creating binary master file %s\n",m.c_str()); cprintf(RED,"Error in creating binary master file %s\n",masterFileName.c_str());
masterfd = 0; masterfd = 0;
return FAIL; return FAIL;
} }
}else if (NULL == (masterfd = fopen((const char *) m.c_str(), "w"))){ }else if (NULL == (masterfd = fopen((const char *) masterFileName.c_str(), "w"))){
cprintf(RED,"Error in creating binary master file %s\n",m.c_str()); cprintf(RED,"Error in creating binary master file %s\n",masterFileName.c_str());
masterfd = 0; masterfd = 0;
return FAIL; return FAIL;
} }
@ -177,7 +175,7 @@ int BinaryFile::CreateCommonDataFiles(string m, bool owenable,
imageSize, imageSize,
nPixelsX, nPixelsX,
nPixelsY, nPixelsY,
(long long int)numImages, (long long int)*numImages,
(long long int)acquisitionTime, (long long int)acquisitionTime,
(long long int)acquisitionPeriod, (long long int)acquisitionPeriod,
ctime(&t)); ctime(&t));

35
slsReceiverSoftware/src/DataProcessor.cpp
View File

@ -175,14 +175,12 @@ void DataProcessor::SetGeneralData(GeneralData* g) {
#ifdef VERY_VERBOSE #ifdef VERY_VERBOSE
generalData->Print(); generalData->Print();
#endif #endif
if (!file) { if (file) {
cprintf(RED, "Error Calling SetGeneralData with no file object. Should not be here\n"); if (file->GetFileType() == BINARY)
return; file->SetMaxFramesPerFile(generalData->maxFramesPerFile);
} else if (file->GetFileType() == HDF5) {
if (file->GetFileType() == BINARY) file->SetNumberofPixels(generalData->nPixelsX, generalData->nPixelsY);
file->SetMaxFramesPerFile(generalData->maxFramesPerFile); }
else if (file->GetFileType() == HDF5) {
file->SetNumberofPixels(generalData->nPixelsX, generalData->nPixelsY);
} }
} }
@ -190,17 +188,18 @@ void DataProcessor::SetGeneralData(GeneralData* g) {
void DataProcessor::SetFileFormat(const fileFormat f) { void DataProcessor::SetFileFormat(const fileFormat f) {
if (file->GetFileType() != f) { if (file->GetFileType() != f) {
//remember the pointer values before they are destroyed //remember the pointer values before they are destroyed
int nd[MAX_DIMENSIONS];nd[0] = 0; nd[1] = 0;
char* fname=0; char* fpath=0; uint64_t* findex=0; bool* frindexenable=0; char* fname=0; char* fpath=0; uint64_t* findex=0; bool* frindexenable=0;
bool* owenable=0; int* dindex=0; int* nunits=0; uint64_t* nf = 0; uint32_t* dr = 0; bool* owenable=0; int* dindex=0; int* nunits=0; uint64_t* nf = 0; uint32_t* dr = 0;
file->GetMemberPointerValues(fname, fpath, findex, frindexenable, owenable, dindex, nunits, nf, dr); file->GetMemberPointerValues(nd, fname, fpath, findex, frindexenable, owenable, dindex, nunits, nf, dr);
//create file writer with same pointers //create file writer with same pointers
SetupFileWriter(fname, fpath, findex, frindexenable, owenable, dindex, nunits, nf, dr); SetupFileWriter(nd, fname, fpath, findex, frindexenable, owenable, dindex, nunits, nf, dr);
} }
} }
void DataProcessor::SetupFileWriter(char* fname, char* fpath, uint64_t* findex, void DataProcessor::SetupFileWriter(int* nd, char* fname, char* fpath, uint64_t* findex,
bool* frindexenable, bool* owenable, int* dindex, int* nunits, uint64_t* nf, uint32_t* dr, GeneralData* g) bool* frindexenable, bool* owenable, int* dindex, int* nunits, uint64_t* nf, uint32_t* dr, GeneralData* g)
{ {
if (g) if (g)
@ -212,12 +211,12 @@ void DataProcessor::SetupFileWriter(char* fname, char* fpath, uint64_t* findex,
switch(*fileFormatType){ switch(*fileFormatType){
#ifdef HDF5C #ifdef HDF5C
case HDF5: case HDF5:
file = new HDF5File(index, fname, fpath, findex, file = new HDF5File(index, nd, fname, fpath, findex,
frindexenable, owenable, dindex, nunits, nf, dr, generalData->nPixelsX, generalData->nPixelsY); frindexenable, owenable, dindex, nunits, nf, dr, generalData->nPixelsX, generalData->nPixelsY);
break; break;
#endif #endif
default: default:
file = new BinaryFile(index, fname, fpath, findex, file = new BinaryFile(index, nd, fname, fpath, findex,
frindexenable, owenable, dindex, nunits, nf, dr, generalData->maxFramesPerFile); frindexenable, owenable, dindex, nunits, nf, dr, generalData->maxFramesPerFile);
break; break;
} }
@ -226,7 +225,7 @@ void DataProcessor::SetupFileWriter(char* fname, char* fpath, uint64_t* findex,
int DataProcessor::CreateNewFile(bool en, uint64_t nf, uint64_t at, uint64_t ap) { int DataProcessor::CreateNewFile(bool en, uint64_t nf, uint64_t at, uint64_t ap) {
file->CloseAllFiles(); file->CloseAllFiles();
if (file->CreateCommonFiles(en, generalData->imageSize, generalData->nPixelsX, generalData->nPixelsY, if (file->CreateMasterFile(en, generalData->imageSize, generalData->nPixelsX, generalData->nPixelsY,
at, ap) == FAIL) at, ap) == FAIL)
return FAIL; return FAIL;
if (file->CreateFile(currentFrameIndex) == FAIL) if (file->CreateFile(currentFrameIndex) == FAIL)
@ -288,7 +287,13 @@ void DataProcessor::ProcessAnImage(char* buf) {
RecordFirstIndices(fnum); RecordFirstIndices(fnum);
} }
/** bunch id pass as well and then do what with it */
if (fileWriteEnable && *callbackAction == DO_EVERYTHING) if (fileWriteEnable && *callbackAction == DO_EVERYTHING)
file->WriteToFile(buf + FIFO_HEADER_NUMBYTES, generalData->fifoBufferSize + FILE_FRAME_HEADER_SIZE, fnum-firstMeasurementIndex); file->WriteToFile(buf, generalData->fifoBufferSize + FILE_FRAME_HEADER_SIZE, fnum-firstMeasurementIndex);
} }
void DataProcessor::CreateFinalFile(){
if(file->GetFileType() == HDF5)
file->CreateFinalFile();
}

10
slsReceiverSoftware/src/File.cpp
View File

@ -10,9 +10,11 @@
using namespace std; using namespace std;
File::File(int ind, char* fname, char* fpath, uint64_t* findex, File::File(int ind, int* nd, char* fname, char* fpath, uint64_t* findex,
bool* frindexenable, bool* owenable, int* dindex, int* nunits, uint64_t* nf, uint32_t* dr): bool* frindexenable, bool* owenable, int* dindex, int* nunits, uint64_t* nf, uint32_t* dr):
index(ind), index(ind),
numDetX(nd[0]),
numDetY(nd[1]),
fileNamePrefix(fname), fileNamePrefix(fname),
filePath(fpath), filePath(fpath),
fileIndex(findex), fileIndex(findex),
@ -53,9 +55,11 @@ void File::PrintMembers() {
} }
void File::GetMemberPointerValues(char*& fname, char*& fpath, uint64_t*& findex, void File::GetMemberPointerValues(int* nd, char*& fname, char*& fpath, uint64_t*& findex,
bool*& frindexenable, bool*& owenable, int*& dindex, int*& nunits, uint64_t*& nf, uint32_t* dr) bool*& frindexenable, bool*& owenable, int*& dindex, int*& nunits, uint64_t*& nf, uint32_t*& dr)
{ {
nd[0] = numDetX;
nd[1] = numDetY;
fname = fileNamePrefix; fname = fileNamePrefix;
fpath = filePath; fpath = filePath;
findex = fileIndex; findex = fileIndex;

492
slsReceiverSoftware/src/HDF5File.cpp
View File

@ -12,17 +12,18 @@
#include <iostream> #include <iostream>
#include <iomanip> #include <iomanip>
#include <stdlib.h> //malloc
using namespace std; using namespace std;
pthread_mutex_t HDF5File::Mutex = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_t HDF5File::Mutex = PTHREAD_MUTEX_INITIALIZER;
H5File* HDF5File::masterfd = 0; H5File* HDF5File::masterfd = 0;
H5File* HDF5File::virtualfd = 0; hid_t HDF5File::virtualfd = 0;
HDF5File::HDF5File(int ind, char* fname, char* fpath, uint64_t* findex, HDF5File::HDF5File(int ind, int* nd, char* fname, char* fpath, uint64_t* findex,
bool* frindexenable, bool* owenable, int* dindex, int* nunits, uint64_t* nf, uint32_t* dr, bool* frindexenable, bool* owenable, int* dindex, int* nunits, uint64_t* nf, uint32_t* dr,
int nx, int ny): int nx, int ny):
File(ind, fname, fpath, findex, frindexenable, owenable, dindex, nunits, nf, dr), File(ind, nd, fname, fpath, findex, frindexenable, owenable, dindex, nunits, nf, dr),
filefd(0), filefd(0),
dataspace(0), dataspace(0),
dataset(0), dataset(0),
@ -30,7 +31,6 @@ HDF5File::HDF5File(int ind, char* fname, char* fpath, uint64_t* findex,
nPixelsX(nx), nPixelsX(nx),
nPixelsY(ny) nPixelsY(ny)
{ {
printf("%d HDF5File constructor\n",index);
#ifdef VERBOSE #ifdef VERBOSE
PrintMembers(); PrintMembers();
#endif #endif
@ -38,7 +38,7 @@ HDF5File::HDF5File(int ind, char* fname, char* fpath, uint64_t* findex,
HDF5File::~HDF5File() { HDF5File::~HDF5File() {
printf("%d HDF5File destructor\n",index); CloseAllFiles();
} }
void HDF5File::PrintMembers() { void HDF5File::PrintMembers() {
@ -66,12 +66,22 @@ slsReceiverDefs::fileFormat HDF5File::GetFileType() {
void HDF5File::UpdateDataType() { void HDF5File::UpdateDataType() {
switch(*dynamicRange){ switch(*dynamicRange){
case 4: datatype = PredType::STD_U8LE; break; case 4:
case 8: datatype = PredType::STD_U8LE; break; datatype = PredType::STD_U8LE;
case 16: datatype = PredType::STD_U16LE; break; break;
case 32: datatype = PredType::STD_U32LE; break; case 8:
default: cprintf(BG_RED,"unknown dynamic range\n"); datatype = PredType::STD_U8LE;
datatype = PredType::STD_U16LE; break; break;
case 16:
datatype = PredType::STD_U16LE;
break;
case 32:
datatype = PredType::STD_U32LE;
break;
default:
cprintf(BG_RED,"unknown dynamic range\n");
datatype = PredType::STD_U16LE;
break;
} }
} }
@ -79,30 +89,37 @@ int HDF5File::CreateFile(uint64_t fnum) {
currentFileName = CreateFileName(filePath, fileNamePrefix, *fileIndex, currentFileName = CreateFileName(filePath, fileNamePrefix, *fileIndex,
*frameIndexEnable, fnum, *detIndex, *numUnitsPerDetector, index); *frameIndexEnable, fnum, *detIndex, *numUnitsPerDetector, index);
//create file
UpdateDataType(); UpdateDataType();
if (CreateDataFile(index, *overWriteEnable, *numImages, currentFileName, fnum,
if (CreateDataFile(index, *overWriteEnable, *numImages, currentFileName, *frameIndexEnable, fnum,
((*dynamicRange==4) ? (nPixelsX/2) : nPixelsX), nPixelsY, ((*dynamicRange==4) ? (nPixelsX/2) : nPixelsX), nPixelsY,
datatype, filefd, dataspace, dataset) == FAIL) datatype, filefd, dataspace, dataset) == FAIL)
return FAIL; return FAIL;
printf("%d HDF5 File: %s\n", index, currentFileName.c_str()); printf("%d HDF5 File: %s\n", index, currentFileName.c_str());
//virtual file
if (master && (*detIndex==0))
return CreateVirtualFile(fnum);
return OK; return OK;
} }
void HDF5File::CloseCurrentFile() { void HDF5File::CloseCurrentFile() {
CloseDataFile(filefd, dataspace, dataset); CloseDataFile(index, filefd, dataspace, dataset);
} }
void HDF5File::CloseAllFiles() { void HDF5File::CloseAllFiles() {
CloseDataFile(filefd, dataspace, dataset); CloseDataFile(index, filefd, dataspace, dataset);
if (master) if (master && (*detIndex==0)) {
CloseCommonDataFiles(); CloseMasterDataFile();
CloseVirtualDataFile();
}
} }
int HDF5File::WriteToFile(char* buffer, int buffersize, uint64_t fnum) { int HDF5File::WriteToFile(char* buffer, int buffersize, uint64_t fnum) {
if (WriteDataFile(index, buffer, *numImages,
if (WriteDataFile(index, buffer + FILE_FRAME_HEADER_SIZE, *numImages, /** ignoring bunchid?????????? */
((*dynamicRange==4) ? (nPixelsX/2) : nPixelsX), nPixelsY, fnum, ((*dynamicRange==4) ? (nPixelsX/2) : nPixelsX), nPixelsY, fnum,
dataspace, dataset, datatype) == OK) dataspace, dataset, datatype) == OK)
return OK; return OK;
@ -111,20 +128,72 @@ int HDF5File::WriteToFile(char* buffer, int buffersize, uint64_t fnum) {
} }
int HDF5File::CreateCommonFiles(bool en, uint32_t size, int HDF5File::CreateMasterFile(bool en, uint32_t size,
uint32_t nx, uint32_t ny, uint64_t at, uint64_t ap) { uint32_t nx, uint32_t ny, uint64_t at, uint64_t ap) {
if (master) { if (master && (*detIndex==0)) {
string masterFileName="", virtualFileName=""; masterFileName = CreateMasterFileName(filePath, fileNamePrefix, *fileIndex);
CreateCommonFileNames(masterFileName, virtualFileName, filePath, fileNamePrefix, *fileIndex); printf("Master File: %s\n", masterFileName.c_str());
printf("Master HDF5 File: %s\nVirtual HDF5 File: %s\n", masterFileName.c_str(), virtualFileName.c_str()); return CreateMasterDataFile(masterFileName, *overWriteEnable, *dynamicRange, en, size, nx, ny, *numImages, at, ap);
//create common files
return CreateCommonDataFiles(masterFileName, virtualFileName, *overWriteEnable,
en, size, nx, ny, at, ap);
} }
return OK; return OK;
} }
/*** static function ***/
int HDF5File::CreateVirtualFile(uint64_t fnum) {
if (master && (*detIndex==0)) {
//file name
string virtualFileName = CreateVirtualFileName(filePath, fileNamePrefix, *fileIndex, *frameIndexEnable, fnum);
printf("Virtual File: %s\n", virtualFileName.c_str());
//source file names
int numReadouts = numDetX * numDetY;
string fileNames[numReadouts];
for (int i = 0; i < numReadouts; ++i) {
fileNames[i] = CreateFileName(filePath, fileNamePrefix, *fileIndex,
*frameIndexEnable, fnum, *detIndex, *numUnitsPerDetector, i);
#ifdef VERBOSE
printf("%d: File Name: %s\n", i, fileNames[i].c_str());
#endif
}
//datatype
hid_t cdatatype;
switch(*dynamicRange){
case 16:
cdatatype = H5T_STD_U16LE;
break;
case 32:
cdatatype = H5T_STD_U32LE;
break;
default:
cdatatype = H5T_STD_U16LE;
break;
}
//source dataset name
ostringstream osfn;
osfn << "/data";
if (*frameIndexEnable) osfn << "_f" << setfill('0') << setw(12) << fnum;
string srcDatasetName = osfn.str();
//virtual dataset name
osfn.str(""); osfn.clear();
osfn << "/virtual_data";
if (*frameIndexEnable) osfn << "_f" << setfill('0') << setw(12) << fnum;
string virtualDatasetName = osfn.str();
//create virtual file
return CreateVirtualDataFile(virtualFileName, virtualDatasetName, srcDatasetName,
numReadouts, fileNames, *overWriteEnable, fnum, cdatatype,
*numImages, nPixelsY, ((*dynamicRange==4) ? (nPixelsX/2) : nPixelsX),
*numImages, numDetY * nPixelsY, numDetX * ((*dynamicRange==4) ? (nPixelsX/2) : nPixelsX));
}
return OK;
}
/*** static functions ***/
string HDF5File::CreateFileName(char* fpath, char* fnameprefix, uint64_t findex, string HDF5File::CreateFileName(char* fpath, char* fnameprefix, uint64_t findex,
bool frindexenable, uint64_t fnum, int dindex, int numunits, int unitindex) { bool frindexenable, uint64_t fnum, int dindex, int numunits, int unitindex) {
ostringstream osfn; ostringstream osfn;
@ -136,59 +205,29 @@ string HDF5File::CreateFileName(char* fpath, char* fnameprefix, uint64_t findex,
return osfn.str(); return osfn.str();
} }
/*** static function ***/
int HDF5File::CreateDataFile(int ind, bool owenable, uint64_t numf, string fname, uint64_t fnum, int nx, int ny,
DataType dtype, H5File*& fd, DataSpace*& dspace, DataSet*& dset) {
pthread_mutex_lock(&Mutex);
try {
Exception::dontPrint(); //to handle errors
//file string HDF5File::CreateMasterFileName(char* fpath, char* fnameprefix, uint64_t findex) {
FileAccPropList flist; ostringstream osfn;
flist.setFcloseDegree(H5F_CLOSE_STRONG); osfn << fpath << "/" << fnameprefix;
if(!owenable) osfn << "_master";
fd = new H5File( fname.c_str(), H5F_ACC_EXCL, NULL,flist ); osfn << "_" << findex;
else osfn << ".h5";
fd = new H5File( fname.c_str(), H5F_ACC_TRUNC, NULL, flist ); return osfn.str();
//attributes - version
double dValue=HDF5_WRITER_VERSION;
DataSpace dataspace_attr = DataSpace (H5S_SCALAR);
Attribute attribute = fd->createAttribute("version",PredType::NATIVE_DOUBLE, dataspace_attr);
attribute.write(PredType::NATIVE_DOUBLE, &dValue);
//dataspace
char dsetname[100];
hsize_t srcdims[3] = {numf,ny,nx};
dspace = new DataSpace (3,srcdims);
sprintf(dsetname, "/data_%012lld", (long long int)fnum);
//dataset
//create chunked dataset if greater than max_chunked_images
if(numf > MAX_CHUNKED_IMAGES){
DSetCreatPropList plist;
hsize_t chunk_dims[3] ={MAX_CHUNKED_IMAGES, ny, nx};
plist.setChunk(3, chunk_dims);
dset = new DataSet (fd->createDataSet(dsetname, dtype, *dspace, plist));
}else
dset = new DataSet (fd->createDataSet(dsetname, dtype, *dspace));
}
catch(Exception error){
cprintf(RED,"Error in creating HDF5 handles in object %d\n",ind);
error.printError();
fd->close();
pthread_mutex_unlock(&Mutex);
return FAIL;
}
pthread_mutex_unlock(&Mutex);
return OK;
} }
string HDF5File::CreateVirtualFileName(char* fpath, char* fnameprefix, uint64_t findex, bool frindexenable, uint64_t fnum) {
ostringstream osfn;
osfn << fpath << "/" << fnameprefix;
osfn << "_virtual";
if (frindexenable) osfn << "_f" << setfill('0') << setw(12) << fnum;
osfn << "_" << findex;
osfn << ".h5";
return osfn.str();
}
/*** static function ***/
void HDF5File::CloseDataFile(H5File*& fd, DataSpace*& dp, DataSet*& ds) { void HDF5File::CloseDataFile(int ind, H5File*& fd, DataSpace*& dp, DataSet*& ds) {
pthread_mutex_lock(&Mutex); pthread_mutex_lock(&Mutex);
try { try {
Exception::dontPrint(); //to handle errors Exception::dontPrint(); //to handle errors
@ -202,12 +241,37 @@ void HDF5File::CloseDataFile(H5File*& fd, DataSpace*& dp, DataSet*& ds) {
pthread_mutex_unlock(&Mutex); pthread_mutex_unlock(&Mutex);
} }
/*** static function ***/
void HDF5File::CloseMasterDataFile() {
pthread_mutex_lock(&Mutex);
try {
Exception::dontPrint(); //to handle errors
if(masterfd) {delete masterfd; masterfd = 0;}
} catch(Exception error) {
cprintf(RED,"Error in closing master HDF5 handles\n");
error.printError();
}
pthread_mutex_unlock(&Mutex);
}
/**(in C because H5Pset_virtual doesnt exist yet in C++)*/
void HDF5File::CloseVirtualDataFile() {
pthread_mutex_lock(&Mutex);
if(virtualfd) {
if (H5Fclose(virtualfd) < 0 )
cprintf(RED,"Error in closing virtual HDF5 handles\n");
virtualfd = 0;
}
pthread_mutex_unlock(&Mutex);
}
int HDF5File::WriteDataFile(int ind, char* buf, uint64_t numImages, int nx, int ny, uint64_t fnum, int HDF5File::WriteDataFile(int ind, char* buf, uint64_t numImages, int nx, int ny, uint64_t fnum,
DataSpace* dspace, DataSet* dset, DataType dtype) { DataSpace* dspace, DataSet* dset, DataType dtype) {
pthread_mutex_lock(&Mutex); pthread_mutex_lock(&Mutex);
hsize_t count[3] = {1, ny,nx}; hsize_t count[3] = {1,ny,nx};
hsize_t start[3] = {fnum%numImages, 0 , 0}; hsize_t start[3] = {fnum%numImages,0,0};
hsize_t dims2[2]={ny,nx}; hsize_t dims2[2]={ny,nx};
try{ try{
Exception::dontPrint(); //to handle errors Exception::dontPrint(); //to handle errors
@ -227,44 +291,22 @@ int HDF5File::WriteDataFile(int ind, char* buf, uint64_t numImages, int nx, int
return OK; return OK;
} }
void HDF5File::CreateCommonFileNames(string& m, string& v, char* fpath, char* fnameprefix, uint64_t findex) {
ostringstream osfn;
osfn << fpath << "/" << fnameprefix;
osfn << "_master";
osfn << "_" << findex;
osfn << ".h5";
m = osfn.str();
v.assign(m);
v.replace(v.find("_master", 0), 7, "_virtual");
}
void HDF5File::CloseCommonDataFiles() {
pthread_mutex_lock(&Mutex);
try {
Exception::dontPrint(); //to handle errors
if(masterfd) {delete masterfd; masterfd = 0;}
if(virtualfd) {delete virtualfd; virtualfd = 0;}
} catch(Exception error) {
cprintf(RED,"Error in closing common HDF5 handles\n");
error.printError();
}
pthread_mutex_unlock(&Mutex);
}
int HDF5File::CreateCommonDataFiles(string m, string v, bool owenable,
bool tengigaEnable, uint32_t imageSize, uint32_t nPixelsX, uint32_t nPixelsY, int HDF5File::CreateMasterDataFile(string fname, bool owenable,
uint32_t dr, bool tenE, uint32_t size, uint32_t nx, uint32_t ny, uint64_t nf,
uint64_t acquisitionTime, uint64_t acquisitionPeriod) { uint64_t acquisitionTime, uint64_t acquisitionPeriod) {
pthread_mutex_lock(&Mutex); pthread_mutex_lock(&Mutex);
try { try {
//Exception::dontPrint(); //to handle errors Exception::dontPrint(); //to handle errors
FileAccPropList flist; FileAccPropList flist;
flist.setFcloseDegree(H5F_CLOSE_STRONG); flist.setFcloseDegree(H5F_CLOSE_STRONG);
if(!owenable) if(!owenable)
masterfd = new H5File( m.c_str(), H5F_ACC_EXCL, NULL, flist ); masterfd = new H5File( fname.c_str(), H5F_ACC_EXCL, NULL, flist );
else else
masterfd = new H5File( m.c_str(), H5F_ACC_TRUNC, NULL, flist ); masterfd = new H5File( fname.c_str(), H5F_ACC_TRUNC, NULL, flist );
//variables //variables
DataSpace dataspace = DataSpace (H5S_SCALAR); DataSpace dataspace = DataSpace (H5S_SCALAR);
@ -290,37 +332,45 @@ int HDF5File::CreateCommonDataFiles(string m, string v, bool owenable,
//Dynamic Range //Dynamic Range
dataset = group5.createDataSet ( "dynamic range", PredType::NATIVE_INT, dataspace ); dataset = group5.createDataSet ( "dynamic range", PredType::NATIVE_INT, dataspace );
dataset.write ( dynamicRange, PredType::NATIVE_INT); dataset.write ( &dr, PredType::NATIVE_INT);
attribute = dataset.createAttribute("unit",strdatatype, dataspace); attribute = dataset.createAttribute("unit",strdatatype, dataspace);
attribute.write(strdatatype, string("bits")); attribute.write(strdatatype, string("bits"));
//Ten Giga //Ten Giga
iValue = tengigaEnable; iValue = tenE;
dataset = group5.createDataSet ( "ten giga enable", PredType::NATIVE_INT, dataspace ); dataset = group5.createDataSet ( "ten giga enable", PredType::NATIVE_INT, dataspace );
dataset.write ( &iValue, PredType::NATIVE_INT); dataset.write ( &iValue, PredType::NATIVE_INT);
//Image Size //Image Size
dataset = group5.createDataSet ( "image size", PredType::NATIVE_INT, dataspace ); dataset = group5.createDataSet ( "image size", PredType::NATIVE_INT, dataspace );
dataset.write ( &imageSize, PredType::NATIVE_INT); dataset.write ( &size, PredType::NATIVE_INT);
attribute = dataset.createAttribute("unit",strdatatype, dataspace); attribute = dataset.createAttribute("unit",strdatatype, dataspace);
attribute.write(strdatatype, string("bytes")); attribute.write(strdatatype, string("bytes"));
//x //x
dataset = group5.createDataSet ( "number of pixels in x axis", PredType::NATIVE_INT, dataspace ); dataset = group5.createDataSet ( "number of pixels in x axis", PredType::NATIVE_INT, dataspace );
dataset.write ( &nPixelsX, PredType::NATIVE_INT); dataset.write ( &nx, PredType::NATIVE_INT);
//y //y
dataset = group5.createDataSet ( "number of pixels in y axis", PredType::NATIVE_INT, dataspace ); dataset = group5.createDataSet ( "number of pixels in y axis", PredType::NATIVE_INT, dataspace );
dataset.write ( &nPixelsY, PredType::NATIVE_INT); dataset.write ( &ny, PredType::NATIVE_INT);
//Total Frames //Total Frames
dataset = group5.createDataSet ( "total frames", PredType::STD_U64LE, dataspace ); dataset = group5.createDataSet ( "total frames", PredType::STD_U64LE, dataspace );
dataset.write ( &numImages, PredType::STD_U64LE); dataset.write ( &nf, PredType::STD_U64LE);
//Exptime //Exptime
dataset = group5.createDataSet ( "exposure time", PredType::STD_U64LE, dataspace ); dataset = group5.createDataSet ( "exposure time", PredType::STD_U64LE, dataspace );
dataset.write ( &acquisitionTime, PredType::STD_U64LE); dataset.write ( &acquisitionTime, PredType::STD_U64LE);
attribute = dataset.createAttribute("unit",strdatatype, dataspace); attribute = dataset.createAttribute("unit",strdatatype, dataspace);
attribute.write(strdatatype, string("ns")); attribute.write(strdatatype, string("ns"));
//Period //Period
dataset = group5.createDataSet ( "acquisition period", PredType::STD_U64LE, dataspace ); dataset = group5.createDataSet ( "acquisition period", PredType::STD_U64LE, dataspace );
dataset.write ( &acquisitionPeriod, PredType::STD_U64LE); dataset.write ( &acquisitionPeriod, PredType::STD_U64LE);
attribute = dataset.createAttribute("unit",strdatatype, dataspace); attribute = dataset.createAttribute("unit",strdatatype, dataspace);
attribute.write(strdatatype, string("ns")); attribute.write(strdatatype, string("ns"));
//Timestamp //Timestamp
time_t t = time(0); time_t t = time(0);
dataset = group5.createDataSet ( "timestamp", strdatatype, dataspace ); dataset = group5.createDataSet ( "timestamp", strdatatype, dataspace );
@ -329,7 +379,7 @@ int HDF5File::CreateCommonDataFiles(string m, string v, bool owenable,
masterfd->close(); masterfd->close();
} catch(Exception error) { } catch(Exception error) {
cprintf(RED,"Error in creating common HDF5 handles\n"); cprintf(RED,"Error in creating master HDF5 handles\n");
error.printError(); error.printError();
pthread_mutex_unlock(&Mutex); pthread_mutex_unlock(&Mutex);
return FAIL; return FAIL;
@ -340,4 +390,218 @@ int HDF5File::CreateCommonDataFiles(string m, string v, bool owenable,
} }
int HDF5File::CreateDataFile(int ind, bool owenable, uint64_t numf, string fname, bool frindexenable, uint64_t fnum, int nx, int ny,
DataType dtype, H5File*& fd, DataSpace*& dspace, DataSet*& dset) {
pthread_mutex_lock(&Mutex);
try {
Exception::dontPrint(); //to handle errors
//file
FileAccPropList fapl;
fapl.setFcloseDegree(H5F_CLOSE_STRONG);
if(!owenable)
fd = new H5File( fname.c_str(), H5F_ACC_EXCL, NULL,fapl );
else
fd = new H5File( fname.c_str(), H5F_ACC_TRUNC, NULL, fapl );
//attributes - version
double dValue=HDF5_WRITER_VERSION;
DataSpace dataspace_attr = DataSpace (H5S_SCALAR);
Attribute attribute = fd->createAttribute("version",PredType::NATIVE_DOUBLE, dataspace_attr);
attribute.write(PredType::NATIVE_DOUBLE, &dValue);
//dataspace
hsize_t srcdims[3] = {numf,ny,nx};
dspace = new DataSpace (3,srcdims);
//dataset name
ostringstream osfn;
osfn << "/data";
if (frindexenable) osfn << "_f" << setfill('0') << setw(12) << fnum;
string dsetname = osfn.str();
//dataset
//chunked dataset if greater than max_chunked_images
if(numf > MAX_CHUNKED_IMAGES){
DSetCreatPropList plist;
hsize_t chunk_dims[3] ={MAX_CHUNKED_IMAGES, ny, nx};
plist.setChunk(3, chunk_dims);
dset = new DataSet (fd->createDataSet(dsetname.c_str(), dtype, *dspace, plist));
}else
dset = new DataSet (fd->createDataSet(dsetname.c_str(), dtype, *dspace));
}
catch(Exception error){
cprintf(RED,"Error in creating HDF5 handles in object %d\n",ind);
error.printError();
fd->close();
pthread_mutex_unlock(&Mutex);
return FAIL;
}
pthread_mutex_unlock(&Mutex);
return OK;
}
/**(in C because H5Pset_virtual doesnt exist yet in C++)*/
int HDF5File::CreateVirtualDataFile(string virtualfname, string virtualDatasetname, string srcDatasetname,
int numFiles, string fileNames[], bool owenable, uint64_t fnum, hid_t dtype,
int srcNDimx, int srcNDimy, int srcNDimz, int dstNDimx, int dstNDimy, int dstNDimz) {
pthread_mutex_lock(&Mutex);
//file
hid_t dfal = H5Pcreate (H5P_FILE_ACCESS);
if (dfal >= 0) {
if (H5Pset_fclose_degree (dfal, H5F_CLOSE_STRONG) >= 0) {
if(!owenable) virtualfd = H5Fcreate( virtualfname.c_str(), H5F_ACC_EXCL, H5P_DEFAULT, dfal);
else virtualfd = H5Fcreate( virtualfname.c_str(), H5F_ACC_TRUNC, H5P_DEFAULT, dfal);
if (virtualfd >= 0) {
//attributes - version
hid_t dataspace_attr = H5Screate (H5S_SCALAR);
if (dataspace_attr >= 0) {
hid_t attrid = H5Acreate2 (virtualfd, "version", H5T_NATIVE_DOUBLE, dataspace_attr, H5P_DEFAULT, H5P_DEFAULT);
if (attrid >= 0) {
double attr_data = HDF5_WRITER_VERSION;
if (H5Awrite (attrid, H5T_NATIVE_DOUBLE, &attr_data) >= 0) {
if (H5Aclose (attrid) >= 0) {
//dataspace
hsize_t vdsdims[3] = {dstNDimx, dstNDimy, dstNDimz};
hid_t vdsDataspace = H5Screate_simple(3, vdsdims ,NULL);
if (vdsDataspace >= 0) {
hsize_t srcdims[3] = {srcNDimx, srcNDimy, srcNDimz};
hid_t srcDataspace = H5Screate_simple(3, srcdims, NULL);
if (srcDataspace >= 0) {
//fill values
hid_t dcpl = H5Pcreate (H5P_DATASET_CREATE);
if (dcpl >= 0) {
int fill_value = -1;
if (H5Pset_fill_value (dcpl, dtype, &fill_value) >= 0) {
//hyperslab
hsize_t offset[3]={0,0,0},count[3]={srcNDimx,srcNDimy, srcNDimz};
bool error = false;
for (int i = 0; i < numFiles; i++) {
//cout<<"("<<offset[0]<<","<<offset[1]<<","<<offset[2]<<")"<<endl;
if (H5Sselect_hyperslab (vdsDataspace, H5S_SELECT_SET, offset, NULL, count, NULL) < 0) {
cprintf(RED,"could not select hyperslab\n");
error = true;
break;
}
if (H5Pset_virtual(dcpl, vdsDataspace, fileNames[i].c_str(), srcDatasetname.c_str(), srcDataspace) < 0) {
cprintf(RED,"could not set mapping\n");
error = true;
break;
}
offset[2] += srcNDimz;
if(offset[2] >= (unsigned int) dstNDimz){
offset[2] = 0;
offset[1] += srcNDimy;
}
}
if (!error) {
//dataset
hid_t vdsdataset = H5Dcreate2 (virtualfd, virtualDatasetname.c_str(), dtype, vdsDataspace, H5P_DEFAULT, dcpl, H5P_DEFAULT);
if (vdsdataset >= 0){
H5Sclose(vdsDataspace);
H5Sclose(srcDataspace);
H5Dclose(vdsdataset);
H5Fclose(virtualfd);
pthread_mutex_unlock(&Mutex);
return OK;
} else cprintf(RED, "could not create virtual dataset in virtual file %s\n", virtualfname.c_str());
} else cprintf(RED, "could not map files in virtual file %s\n", virtualfname.c_str());
} else cprintf(RED, "could not fill values in virtual file %s\n", virtualfname.c_str());
} else cprintf(RED, "could not create dcpl in virtual file %s\n", virtualfname.c_str());
} else cprintf(RED, "could not create source dataspace in virtual file %s\n", virtualfname.c_str());
} else cprintf(RED, "could not create virtual dataspace in virtual file %s\n", virtualfname.c_str());
} else cprintf(RED, "could not close attribute in virtual file %s\n", virtualfname.c_str());
} else cprintf(RED, "could not write attribute in virtual file %s\n", virtualfname.c_str());
} else cprintf(RED, "could not create attribute in virtual file %s\n", virtualfname.c_str());
} else cprintf(RED, "could not create dataspace for attribute in virtual file %s\n", virtualfname.c_str());
} else cprintf(RED, "could not create virtual file %s\n", virtualfname.c_str());
} else cprintf(RED, "could not set strong file close degree for virtual file %s\n", virtualfname.c_str());
} else cprintf(RED, "could not create dfal for virtual file %s\n", virtualfname.c_str());
H5Fclose(virtualfd);
pthread_mutex_unlock(&Mutex);
return FAIL;
}
template <typename T>
int HDF5File::CopyVirtualFile(bool owenable, string oldFileName, string oldDatasetName,
string newFileName, string newDatasetName, int nDimx, int nDimy, int nDimz, T datatype) {
T *data_out = (T*)malloc(sizeof(T)*(nDimx*nDimy*nDimz));
H5File* oldfd;
H5File* newfd;
pthread_mutex_lock(&Mutex);
try {
Exception::dontPrint(); //to handle errors
//open old file
oldfd = new H5File( oldFileName.c_str(), H5F_ACC_RDONLY);
DataSet oldDataset = oldfd->openDataSet( oldDatasetName.c_str());
//read dataset
oldDataset.read( data_out, datatype);
//new file
FileAccPropList fapl;
fapl.setFcloseDegree(H5F_CLOSE_STRONG);
if(!owenable)
newfd = new H5File( newFileName.c_str(), H5F_ACC_EXCL, NULL,fapl );
else
newfd = new H5File( newFileName.c_str(), H5F_ACC_TRUNC, NULL, fapl );
//dataspace and dataset
hsize_t dims[3] = {nDimx, nDimy, nDimz};
DataSpace* newDataspace = new DataSpace (3,dims);
DataSet* newDataset = new DataSet( newfd->createDataSet(newDatasetName.c_str(), datatype, *newDataspace));
//write and close
newDataset->write(data_out,datatype);
newDataspace->close();
newDataset->close();
newfd->close();
oldDataset.close();
oldfd->close();
} catch(Exception error){
cprintf(RED,"Error in copying virtual files\n");
error.printError();
free(data_out);
oldfd->close();
newfd->close();
pthread_mutex_unlock(&Mutex);
return FAIL;
}
free(data_out);
pthread_mutex_unlock(&Mutex);
return OK;
}
void HDF5File::CreateFinalFile() {
if (master && (*detIndex==0)) {
CopyVirtualFile(*overWriteEnable, "/home/l_maliakal_d/Software/scratch/run_virtual_f000000000000_0.h5",
"virtual_data_f000000000000",
"/home/l_maliakal_d/Software/scratch/copy.h5",
"run_copy",
*numImages, numDetY * nPixelsY, numDetX * ((*dynamicRange==4) ? (nPixelsX/2) : nPixelsX),
datatype);
}
}
//#endif //#endif

31
slsReceiverSoftware/src/UDPBaseImplementation.cpp
View File

@ -37,6 +37,9 @@ void UDPBaseImplementation::initializeMembers(){
FILE_LOG(logDEBUG) << "Info: Initializing base members"; FILE_LOG(logDEBUG) << "Info: Initializing base members";
//**detector parameters*** //**detector parameters***
for (int i = 0; i < MAX_DIMENSIONS; ++i)
numDet[i] = 0;
detID = 0;
myDetectorType = GENERIC; myDetectorType = GENERIC;
strcpy(detHostname,""); strcpy(detHostname,"");
acquisitionPeriod = 0; acquisitionPeriod = 0;
@ -85,6 +88,10 @@ UDPBaseImplementation::~UDPBaseImplementation(){}
*************************************************************************/ *************************************************************************/
/**initial parameters***/ /**initial parameters***/
int* UDPBaseImplementation::getMultiDetectorSize() const{ FILE_LOG(logDEBUG) << __AT__ << " starting"; return (int*) numDet;}
int UDPBaseImplementation::getDetectorPositionId() const{ FILE_LOG(logDEBUG) << __AT__ << " starting"; return detID;}
char *UDPBaseImplementation::getDetectorHostname() const{ char *UDPBaseImplementation::getDetectorHostname() const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG) << __AT__ << " starting";
@ -208,6 +215,23 @@ void UDPBaseImplementation::configure(map<string, string> config_map){
FILE_LOG(logERROR) << __AT__ << " must be overridden by child classes"; FILE_LOG(logERROR) << __AT__ << " must be overridden by child classes";
} }
void UDPBaseImplementation::setMultiDetectorSize(const int* size) {
FILE_LOG(logDEBUG) << __AT__ << " starting";
char message[100];
strcpy(message, "Detector Size: (");
for (int i = 0; i < MAX_DIMENSIONS; ++i) {
if (myDetectorType == EIGER && (!i))
numDet[i] = size[i]*2;
else
numDet[i] = size[i];
sprintf(message,"%s%d",message,numDet[i]);
if (i < MAX_DIMENSIONS-1 )
strcat(message,",");
}
strcat(message,")");
FILE_LOG(logINFO) << message;
}
void UDPBaseImplementation::setFlippedData(int axis, int enable){ void UDPBaseImplementation::setFlippedData(int axis, int enable){
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG) << __AT__ << " starting";
if(axis<0 || axis>1) return; if(axis<0 || axis>1) return;
@ -445,6 +469,13 @@ int UDPBaseImplementation::setDetectorType(const detectorType d){
return OK; return OK;
} }
void UDPBaseImplementation::setDetectorPositionId(const int i){
FILE_LOG(logDEBUG) << __AT__ << " starting";
detID = i;
FILE_LOG(logINFO) << "Detector Position Id:" << detID;
}
void UDPBaseImplementation::initialize(const char *c){ void UDPBaseImplementation::initialize(const char *c){
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG) << __AT__ << " starting";

29
slsReceiverSoftware/src/UDPStandardImplementation.cpp
View File

@ -56,9 +56,6 @@ void UDPStandardImplementation::InitializeMembers() {
UDPBaseImplementation::initializeMembers(); UDPBaseImplementation::initializeMembers();
acquisitionPeriod = SAMPLE_TIME_IN_NS; acquisitionPeriod = SAMPLE_TIME_IN_NS;
//*** detector parameters ***
detID = -1;
//*** receiver parameters *** //*** receiver parameters ***
numThreads = 1; numThreads = 1;
numberofJobs = 1; numberofJobs = 1;
@ -154,7 +151,7 @@ void UDPStandardImplementation::setFileName(const char c[]) {
if (strlen(c)) { if (strlen(c)) {
strcpy(fileName, c); //automatically update fileName in Filewriter (pointer) strcpy(fileName, c); //automatically update fileName in Filewriter (pointer)
int detindex = -1; /*int detindex = -1;
string tempname(fileName); string tempname(fileName);
size_t uscore=tempname.rfind("_"); size_t uscore=tempname.rfind("_");
if (uscore!=string::npos) { if (uscore!=string::npos) {
@ -165,7 +162,7 @@ void UDPStandardImplementation::setFileName(const char c[]) {
} }
} }
if (detindex == -1) if (detindex == -1)
detID = 0; detID = 0;*/
} }
FILE_LOG (logINFO) << "File name:" << fileName; FILE_LOG (logINFO) << "File name:" << fileName;
} }
@ -437,8 +434,7 @@ int UDPStandardImplementation::setDetectorType(const detectorType d) {
for (vector<Listener*>::const_iterator it = listener.begin(); it != listener.end(); ++it) for (vector<Listener*>::const_iterator it = listener.begin(); it != listener.end(); ++it)
(*it)->SetGeneralData(generalData); (*it)->SetGeneralData(generalData);
for (vector<DataProcessor*>::const_iterator it = dataProcessor.begin(); it != dataProcessor.end(); ++it) { for (vector<DataProcessor*>::const_iterator it = dataProcessor.begin(); it != dataProcessor.end(); ++it) {
(*it)->SetupFileWriter(fileName, filePath, &fileIndex, &frameIndexEnable, (*it)->SetGeneralData(generalData);
&overwriteEnable, &detID, &numThreads, &numberOfFrames, &dynamicRange, generalData);
} }
FILE_LOG (logDEBUG) << " Detector type set to " << getDetectorType(d); FILE_LOG (logDEBUG) << " Detector type set to " << getDetectorType(d);
return OK; return OK;
@ -446,6 +442,19 @@ int UDPStandardImplementation::setDetectorType(const detectorType d) {
void UDPStandardImplementation::setDetectorPositionId(const int i){
FILE_LOG(logDEBUG) << __AT__ << " starting";
detID = i;
FILE_LOG(logINFO) << "Detector Position Id:" << detID;
for (vector<DataProcessor*>::const_iterator it = dataProcessor.begin(); it != dataProcessor.end(); ++it) {
(*it)->SetupFileWriter((int*)numDet, fileName, filePath, &fileIndex, &frameIndexEnable,
&overwriteEnable, &detID, &numThreads, &numberOfFrames, &dynamicRange, generalData);
}
}
void UDPStandardImplementation::resetAcquisitionCount() { void UDPStandardImplementation::resetAcquisitionCount() {
@ -515,6 +524,9 @@ int UDPStandardImplementation::startReceiver(char *c) {
cout << "Data will not be saved" << endl; cout << "Data will not be saved" << endl;
cout << "Processor Ready ..." << endl; cout << "Processor Ready ..." << endl;
//for(int i=0;i<dataProcessor.size(); ++i)
//dataProcessor[i]->CreateFinalFile();
//status //status
pthread_mutex_lock(&statusMutex); pthread_mutex_lock(&statusMutex);
status = RUNNING; status = RUNNING;
@ -545,6 +557,9 @@ void UDPStandardImplementation::stopReceiver(){
usleep(5000); usleep(5000);
} }
for(unsigned int i=0;i<dataProcessor.size(); ++i)
dataProcessor[i]->CreateFinalFile();
pthread_mutex_lock(&statusMutex); pthread_mutex_lock(&statusMutex);
status = RUN_FINISHED; status = RUN_FINISHED;
pthread_mutex_unlock(&(statusMutex)); pthread_mutex_unlock(&(statusMutex));

135
slsReceiverSoftware/src/slsReceiverTCPIPInterface.cpp
View File

@ -263,7 +263,8 @@ int slsReceiverTCPIPInterface::function_table(){
flist[F_READ_RECEIVER_TIMER] = &slsReceiverTCPIPInterface::set_read_receiver_timer; flist[F_READ_RECEIVER_TIMER] = &slsReceiverTCPIPInterface::set_read_receiver_timer;
flist[F_SET_FLIPPED_DATA_RECEIVER] = &slsReceiverTCPIPInterface::set_flipped_data; flist[F_SET_FLIPPED_DATA_RECEIVER] = &slsReceiverTCPIPInterface::set_flipped_data;
flist[F_SET_RECEIVER_FILE_FORMAT] = &slsReceiverTCPIPInterface::set_file_format; flist[F_SET_RECEIVER_FILE_FORMAT] = &slsReceiverTCPIPInterface::set_file_format;
flist[F_SEND_RECEIVER_DETPOSID] = &slsReceiverTCPIPInterface::set_detector_posid;
flist[F_SEND_RECEIVER_MULTIDETSIZE] = &slsReceiverTCPIPInterface::set_multi_detector_size;
#ifdef VERYVERBOSE #ifdef VERYVERBOSE
@ -2246,6 +2247,138 @@ int slsReceiverTCPIPInterface::set_file_format() {
int slsReceiverTCPIPInterface::set_detector_posid() {
ret=OK;
int retval=-1;
int arg=-1;
strcpy(mess,"Could not set detector position id\n");
// receive arguments
if(mySock->ReceiveDataOnly(&arg,sizeof(arg)) < 0 ){
strcpy(mess,"Error reading from socket\n");
ret = FAIL;
}
// execute action if the arguments correctly arrived
#ifdef SLS_RECEIVER_UDP_FUNCTIONS
if (ret==OK) {
if (lockStatus==1 && mySock->differentClients==1){
sprintf(mess,"Receiver locked by %s\n", mySock->lastClientIP);
ret=FAIL;
}
else if (receiverBase == NULL){
strcpy(mess,SET_RECEIVER_ERR_MESSAGE);
ret=FAIL;
}
else if(receiverBase->getStatus()!= IDLE){
strcpy(mess,"Can not set position file id while receiver not idle\n");
cprintf(RED,"%s",mess);
ret = FAIL;
}
else{
if(arg >= 0)
receiverBase->setDetectorPositionId(arg);
retval=receiverBase->getDetectorPositionId();
if(arg>=0 && retval!=arg)
ret = FAIL;
}
}
#ifdef VERYVERBOSE
if(ret!=FAIL)
cout << "Position Id:" << retval << endl;
else
cout << mess << endl;
#endif
#endif
if(ret==OK && mySock->differentClients){
FILE_LOG(logDEBUG) << "Force update";
ret=FORCE_UPDATE;
}
// send answer
mySock->SendDataOnly(&ret,sizeof(ret));
if(ret==FAIL){
cprintf(RED, "%s\n", mess);
mySock->SendDataOnly(mess,sizeof(mess));
}
mySock->SendDataOnly(&retval,sizeof(retval));
//return ok/fail
return ret;
}
int slsReceiverTCPIPInterface::set_multi_detector_size() {
ret=OK;
int retval=-1;
int arg[2];
arg[0]=-1;
arg[1]=-1;
strcpy(mess,"Could not set multi detector size\n");
// receive arguments
if(mySock->ReceiveDataOnly(arg,sizeof(arg)) < 0 ){
strcpy(mess,"Error reading from socket\n");
ret = FAIL;
}
// execute action if the arguments correctly arrived
#ifdef SLS_RECEIVER_UDP_FUNCTIONS
if (ret==OK) {
if (lockStatus==1 && mySock->differentClients==1){
sprintf(mess,"Receiver locked by %s\n", mySock->lastClientIP);
ret=FAIL;
}
else if (receiverBase == NULL){
strcpy(mess,SET_RECEIVER_ERR_MESSAGE);
ret=FAIL;
}
else if(receiverBase->getStatus()!= IDLE){
strcpy(mess,"Can not set position file id while receiver not idle\n");
cprintf(RED,"%s",mess);
ret = FAIL;
}
else{
if((arg[0] > 0) && (arg[1] > 0))
receiverBase->setMultiDetectorSize(arg);
}
}
#ifdef VERYVERBOSE
if(ret!=FAIL)
cout << "Multi Detector Size:" << retval << endl;
else
cout << mess << endl;
#endif
#endif
if(ret==OK && mySock->differentClients){
FILE_LOG(logDEBUG) << "Force update";
ret=FORCE_UPDATE;
}
// send answer
mySock->SendDataOnly(&ret,sizeof(ret));
if(ret==FAIL){
cprintf(RED, "%s\n", mess);
mySock->SendDataOnly(mess,sizeof(mess));
}
mySock->SendDataOnly(&retval,sizeof(retval));
//return ok/fail
return ret;
}