mirror of
https://github.com/slsdetectorgroup/slsDetectorPackage.git
synced 2025-04-23 15:00:02 +02:00
421 lines
11 KiB
C++
421 lines
11 KiB
C++
#ifndef FILEIO_H
|
|
#define FILEIO_H
|
|
|
|
#include "slsDetectorBase.h"
|
|
#include "fileIOStatic.h"
|
|
|
|
#include <iostream>
|
|
#include <fstream>
|
|
#include <iomanip>
|
|
#include <cstring>
|
|
#include <string>
|
|
#include <sstream>
|
|
#include <queue>
|
|
#include <math.h>
|
|
#include <semaphore.h>
|
|
|
|
//
|
|
/**
|
|
@short class handling the data file I/O flags
|
|
*/
|
|
|
|
class fileIO : public fileIOStatic, public virtual slsDetectorBase {
|
|
|
|
|
|
public:
|
|
|
|
/* enum rawFileFormat { */
|
|
/* ASCII, */
|
|
/* BINARY */
|
|
/* } */
|
|
|
|
|
|
/** default constructor */
|
|
fileIO(): fileIOStatic(){
|
|
currentFrameIndex=-1;
|
|
frameIndex=-1;
|
|
detIndex=-1;
|
|
framesPerFile=&nframes;
|
|
nframes=1;
|
|
filefd = NULL;
|
|
pthread_mutex_t mp1 = PTHREAD_MUTEX_INITIALIZER;
|
|
mf=mp1;
|
|
pthread_mutex_init(&mf, NULL);
|
|
};
|
|
|
|
/** virtual destructor */
|
|
virtual ~fileIO(){};
|
|
|
|
using fileIOStatic::readDataFile;
|
|
using fileIOStatic::writeDataFile;
|
|
using fileIOStatic::createFileName;
|
|
|
|
int getFileIndexFromFileName(std::string fname){
|
|
int ret;
|
|
pthread_mutex_lock(&mf);
|
|
ret=fileIOStatic::getFileIndexFromFileName(fname);
|
|
pthread_mutex_unlock(&mf);
|
|
return ret;
|
|
};
|
|
int getIndicesFromFileName(std::string fname, int &index){
|
|
int ret;
|
|
pthread_mutex_lock(&mf);
|
|
ret=fileIOStatic::getIndicesFromFileName(fname,index);
|
|
pthread_mutex_unlock(&mf);
|
|
return ret;
|
|
};
|
|
|
|
|
|
|
|
int getVariablesFromFileName(std::string fname, int &index, int &p_index, double &sv0, double &sv1){
|
|
|
|
int ret;
|
|
pthread_mutex_lock(&mf);
|
|
ret=fileIOStatic::getVariablesFromFileName(fname, index, p_index, sv0, sv1);
|
|
pthread_mutex_unlock(&mf);
|
|
return ret;
|
|
};
|
|
|
|
int getVariablesFromFileName(std::string fname, int &index, int &f_index, int &p_index, double &sv0, double &sv1, int &detindex){
|
|
|
|
|
|
int ret;
|
|
pthread_mutex_lock(&mf);
|
|
ret=fileIOStatic::getVariablesFromFileName(fname, f_index, index, p_index, sv0, sv1, detindex);
|
|
pthread_mutex_unlock(&mf);
|
|
return ret;
|
|
};
|
|
|
|
/**
|
|
sets the default output files path
|
|
\param s file path
|
|
\return actual file path
|
|
*/
|
|
virtual std::string setFilePath(std::string s) {
|
|
pthread_mutex_lock(&mf);
|
|
sprintf(filePath, s.c_str());
|
|
pthread_mutex_unlock(&mf);
|
|
return std::string(filePath);
|
|
};
|
|
|
|
/**
|
|
sets the default output files root name
|
|
\param s file name to be set
|
|
\returns actual file name
|
|
*/
|
|
virtual std::string setFileName(std::string s) {
|
|
pthread_mutex_lock(&mf);
|
|
sprintf(fileName, s.c_str());
|
|
pthread_mutex_unlock(&mf);
|
|
return std::string(fileName);};
|
|
|
|
/**
|
|
sets the default output file index
|
|
\param i start file index to be set
|
|
\returns actual file index
|
|
*/
|
|
virtual int setFileIndex(int i) {
|
|
pthread_mutex_lock(&mf);
|
|
*fileIndex=i;
|
|
pthread_mutex_unlock(&mf);
|
|
return *fileIndex;
|
|
};
|
|
|
|
/**
|
|
sets the default output file frame index
|
|
\param i file frame index to be set
|
|
\returns actual file frame index
|
|
*/
|
|
virtual int setFrameIndex(int i) {
|
|
pthread_mutex_lock(&mf);
|
|
frameIndex=i;
|
|
pthread_mutex_unlock(&mf);
|
|
return frameIndex;};
|
|
|
|
/**
|
|
sets the default output current frame index
|
|
\param i current frame index to be set
|
|
\returns actual current frame index
|
|
*/
|
|
virtual int setCurrentFrameIndex(int i) {
|
|
pthread_mutex_lock(&mf);
|
|
currentFrameIndex=i;
|
|
pthread_mutex_unlock(&mf);
|
|
return currentFrameIndex;
|
|
};
|
|
|
|
/**
|
|
sets the default output file index
|
|
\param i frame index to be set
|
|
\returns actual frame index
|
|
*/
|
|
virtual int setFramesPerFile(int i) {
|
|
pthread_mutex_lock(&mf);
|
|
if (i>0) *framesPerFile=i;
|
|
pthread_mutex_unlock(&mf);
|
|
return *framesPerFile;};
|
|
|
|
/**
|
|
sets the default output file index
|
|
\param i detector index to be set
|
|
\returns actual detector index
|
|
*/
|
|
virtual int setDetectorIndex(int i) {
|
|
pthread_mutex_lock(&mf);
|
|
detIndex=i;
|
|
pthread_mutex_unlock(&mf);
|
|
return detIndex;};
|
|
|
|
/**
|
|
sets the default file format
|
|
\param i file format to be set
|
|
\returns actual file frame format
|
|
*/
|
|
virtual fileFormat setFileFormat(int i) {
|
|
pthread_mutex_lock(&mf);
|
|
*fileFormatType=(fileFormat)i;
|
|
pthread_mutex_unlock(&mf);
|
|
return *fileFormatType; };
|
|
|
|
|
|
|
|
/**
|
|
\returns the output files path
|
|
|
|
*/
|
|
virtual std::string getFilePath() {return std::string(filePath);};
|
|
/**
|
|
\returns the output files root name
|
|
*/
|
|
virtual std::string getFileName() {return std::string(fileName);};
|
|
|
|
/**
|
|
\returns the output file index
|
|
*/
|
|
virtual int getFileIndex() {return *fileIndex;};
|
|
|
|
/**
|
|
\returns the output file frame index
|
|
*/
|
|
virtual int getFrameIndex() {return frameIndex;};
|
|
|
|
/**
|
|
\returns the output current frame index
|
|
*/
|
|
virtual int getCurrentFrameIndex() {return currentFrameIndex;};
|
|
|
|
/**
|
|
\returns the detector index
|
|
*/
|
|
virtual int getDetectorIndex() {return detIndex;};
|
|
|
|
/**
|
|
\returns the max frames per file
|
|
*/
|
|
virtual int getFramesPerFile() {return *framesPerFile;};
|
|
|
|
/**
|
|
\returns the max frames per file
|
|
*/
|
|
virtual fileFormat getFileFormat() {return *fileFormatType;};
|
|
|
|
|
|
std::string createFileName();
|
|
|
|
std::string createReceiverFilePrefix();
|
|
|
|
|
|
/**
|
|
writes a data file
|
|
\param fname of the file to be written
|
|
\param data array of data values
|
|
\param err array of arrors on the data. If NULL no errors will be written
|
|
\param ang array of angular values. If NULL data will be in the form chan-val(-err) otherwise ang-val(-err)
|
|
\param dataformat format of the data: can be 'i' integer or 'f' double (default)
|
|
\param nch number of channels to be written to file. if -1 defaults to the number of installed channels of the detector
|
|
\returns OK or FAIL if it could not write the file or data=NULL
|
|
*/
|
|
virtual int writeDataFile(std::string fname, double *data, double *err=NULL, double *ang=NULL, char dataformat='f', int nch=-1);
|
|
|
|
|
|
/**
|
|
|
|
writes a data file
|
|
\param outfile output file stream
|
|
\param data array of data values
|
|
\param err array of arrors on the data. If NULL no errors will be written
|
|
|
|
\param ang array of angular values. If NULL data will be in the form chan-val(-err) otherwise ang-val(-err)
|
|
\param dataformat format of the data: can be 'i' integer or 'f' double (default)
|
|
\param nch number of channels to be written to file. if -1 defaults to the number of installed channels of the detector
|
|
\param offset start channel number
|
|
\returns OK or FAIL if it could not write the file or data=NULL
|
|
|
|
*/
|
|
virtual int writeDataFile(std::ofstream &outfile, double *data, double *err=NULL, double *ang=NULL, char dataformat='f', int nch=-1, int offset=0);
|
|
|
|
|
|
/**
|
|
writes a data file
|
|
\param fname of the file to be written
|
|
\param data array of data values
|
|
\returns OK or FAIL if it could not write the file or data=NULL
|
|
*/
|
|
virtual int writeDataFile(std::string fname, int *data);
|
|
|
|
|
|
virtual int writeDataFile(void *data, int iframe=-1);
|
|
|
|
int closeDataFile();
|
|
/**
|
|
writes a data file
|
|
\param outfile output file stream
|
|
\param data array of data values
|
|
\param offset start channel number
|
|
\returns OK or FAIL if it could not write the file or data=NULL
|
|
*/
|
|
virtual int writeDataFile(std::ofstream &outfile, int *data, int offset=0);
|
|
|
|
|
|
|
|
/**
|
|
writes a data file of short ints
|
|
\param fname of the file to be written
|
|
\param data array of data values
|
|
\returns OK or FAIL if it could not write the file or data=NULL
|
|
*/
|
|
virtual int writeDataFile(std::string fname, short int *data);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
writes a data file of short ints
|
|
\param outfile output file stream
|
|
\param data array of data values
|
|
\param offset start channel number
|
|
\returns OK or FAIL if it could not write the file or data=NULL
|
|
*/
|
|
virtual int writeDataFile(std::ofstream &outfile, short int *data, int offset=0);
|
|
|
|
|
|
/**
|
|
reads a data file
|
|
\param fname of the file to be read
|
|
\param data array of data values to be filled
|
|
\param err array of arrors on the data. If NULL no errors are expected on the file
|
|
|
|
\param ang array of angular values. If NULL data are expected in the form chan-val(-err) otherwise ang-val(-err)
|
|
\param dataformat format of the data: can be 'i' integer or 'f' double (default)
|
|
\returns OK or FAIL if it could not read the file or data=NULL
|
|
*/
|
|
virtual int readDataFile(std::string fname, double *data, double *err=NULL, double *ang=NULL, char dataformat='f');
|
|
|
|
/**
|
|
reads a data file
|
|
\param ifstream input file stream
|
|
\param data array of data values to be filled
|
|
\param err array of arrors on the data. If NULL no errors are expected on the file
|
|
|
|
\param ang array of angular values. If NULL data are expected in the form chan-val(-err) otherwise ang-val(-err)
|
|
\param offset start channel number to be expected
|
|
\returns OK or FAIL if it could not read the file or data=NULL
|
|
*/
|
|
int readDataFile(std::ifstream& infile, double *data, double *err=NULL, double *ang=NULL, char dataformat='f', int offset=0);
|
|
|
|
/**
|
|
reads a raw data file
|
|
\param fname of the file to be read
|
|
\param data array of data values
|
|
\returns OK or FAIL if it could not read the file or data=NULL
|
|
yes */
|
|
virtual int readDataFile(std::string fname, int *data);
|
|
|
|
/**
|
|
reads a raw data file
|
|
\param infile input file stream
|
|
\param data array of data values
|
|
\param offset first channel number to be expected
|
|
\returns OK or FAIL if it could not read the file or data=NULL
|
|
*/
|
|
int readDataFile(std::ifstream &infile, int *data, int offset=0);
|
|
|
|
/**
|
|
|
|
reads a short int raw data file
|
|
\param fname of the file to be read
|
|
\param data array of data values
|
|
\returns OK or FAIL if it could not read the file or data=NULL
|
|
*/
|
|
virtual int readDataFile(std::string fname, short int *data);
|
|
/**
|
|
reads a short int raw data file
|
|
\param infile input file stream
|
|
\param data array of data values
|
|
\param offset first channel number to be expected
|
|
\returns OK or FAIL if it could not read the file or data=NULL
|
|
*/
|
|
int readDataFile(std::ifstream &infile, short int *data, int offset=0);
|
|
|
|
virtual int getDataBytes ( )=0;
|
|
friend class slsDetector;
|
|
|
|
std::string getCurrentFileName(){return currentFileName;};
|
|
protected:
|
|
|
|
|
|
void incrementFileIndex() { (*fileIndex)++; };
|
|
|
|
void incrementFrameIndex(int i) { frameIndex=frameIndex+i; };
|
|
|
|
void incrementCurrentFrameIndex() { (currentFrameIndex)++; };
|
|
|
|
void incrementDetectorIndex() { (detIndex)++; };
|
|
|
|
|
|
std::string getCurrentReceiverFilePrefix(){return currentReceiverFilePrefix;};
|
|
|
|
|
|
std::string currentFileName;
|
|
|
|
std::string currentReceiverFilePrefix;
|
|
|
|
|
|
/** output directory */
|
|
char *filePath;
|
|
/** file root name */
|
|
char *fileName;
|
|
/** file index */
|
|
int *fileIndex;
|
|
/** file frame index */
|
|
int frameIndex;
|
|
/** current frame index */
|
|
int currentFrameIndex;
|
|
/** detector id */
|
|
int detIndex;
|
|
/** frames per file */
|
|
int *framesPerFile;
|
|
/** file format */
|
|
fileFormat *fileFormatType;
|
|
|
|
private:
|
|
|
|
|
|
FILE *filefd;
|
|
std::ofstream fstream;
|
|
|
|
int nframes;
|
|
// int fformat;
|
|
|
|
|
|
int nBytes;
|
|
|
|
/** mutex to synchronize read/write fname */
|
|
pthread_mutex_t mf;
|
|
};
|
|
|
|
#endif
|