Extract2D.h

Go to the documentation of this file.

#ifndef _nidas_dynld_raf_extract2d_h_
#define _nidas_dynld_raf_extract2d_h_
 
 
#include <nidas/core/Project.h>
#include <nidas/core/FileSet.h>
#include <nidas/dynld/SampleInputStream.h>
#include <nidas/dynld/SampleOutputStream.h>
#include <nidas/core/XMLParser.h>
#include <nidas/core/DSMConfig.h>
#include <nidas/core/DSMSensor.h>
#include <nidas/core/SampleInputHeader.h>
#include <nidas/core/HeaderSource.h>
#include <nidas/util/UTime.h>
#include <nidas/util/util.h>
#include <nidas/util/EOFException.h>
#include <nidas/util/Process.h>
 
namespace nidas { namespace dynld { namespace raf {
 
 
#define TWOD_BUFFER_SIZE    (4096)
 
// PADS record format.  This is what we will repackage the records into.
struct PADS_rec
{
  int16_t year;
  int16_t month;
  int16_t day;
  int16_t hour;
  int16_t minute;
  int16_t second;
  int16_t msec;                         // msec of this record
  int16_t wday;                         // overload time, msec
  unsigned char data[TWOD_BUFFER_SIZE]; // image buffer
};
typedef struct PADS_rec PADS_rec;
 
 
// ADS record format.  This is what we will repackage the records into.
struct P2d_rec
{
  short id;                             // 'P1','C1','P2','C2', H1, H2
  short hour;
  short minute;
  short second;
  short year;
  short month;
  short day;
  short tas;                            // true air speed
  short msec;                           // msec of this record
  short overld;                         // overload time, msec
  unsigned char data[TWOD_BUFFER_SIZE]; // image buffer
};
typedef struct P2d_rec P2d_rec;
 
 
using namespace nidas::core;
using namespace nidas::dynld;
using namespace std;
 
 
class Probe
{
public:
  Probe() :
      sensor(0), resolution(0), resolutionM(0.0), id(0), serialNumber(),
      clockFreq(12.0), waveLength(658), hasOverloadCount(0), nDiodes(64),
      recordCount(0), rejectRecordCount(0), rejectTooFewParticleCount(0),
      rejectTooFewDiodesCount(0), diodeCount(), particleCount(),
      totalParticles(0), inDOF(0)
    {
    memset(diodeCount, 0, sizeof(diodeCount));
    memset(particleCount, 0, sizeof(particleCount));
    }
 
  // Input info.
  DSMSensor * sensor;
 
  // Output info.
  size_t resolution;    // in micron
  float resolutionM;    // in meters
  short id;
  string serialNumber;
  float clockFreq;  // in Mhz
  int waveLength;   // laser wave length in nanometers
 
  // File info.
  size_t hasOverloadCount;
 
  // Number of diodes, 64 for Fast2D, 32 for old probes.
  size_t nDiodes;
 
  // Total number of records found in file.
  size_t recordCount;
 
  // Total number of records rejected.
  size_t rejectRecordCount;
  size_t rejectTooFewParticleCount;
  size_t rejectTooFewDiodesCount;
 
  /* Count of each diode value of 1 for the entire flight, sync words excluded.
   * This diagnostic output helps find which diode is bad when the probe runs away.
   */
  size_t diodeCount[64];        // 64 is max possible diodes.
 
  /* Count of number of particles per record.
   * This diagnostic output helps find which diode is bad when the probe runs away.
   */
  size_t particleCount[512];    // 512 is max possible slices/record.
 
  size_t totalParticles;
  size_t inDOF;
 
private:
    Probe(const Probe&);
    Probe& operator=(const Probe&);
};
 
 
 
class Extract2D : public HeaderSource
{
public:
 
    Extract2D();
 
    virtual int parseRunstring(int argc, char** argv) throw();
 
    virtual int usage(const char* argv0);
 
    virtual int run() throw() = 0;
 
// static functions
    static void sigAction(int sig, siginfo_t* siginfo, void*);
 
    static void setupSignals();
 
    void sendHeader(dsm_time_t,SampleOutput* out);
 
protected:
 
    virtual size_t countParticles(Probe * probe, const unsigned char * record) = 0;
 
    virtual size_t computeDiodeCount(Probe * probe, const unsigned char * record) = 0;
 
    void setTimeStamp(P2d_rec & record, Sample *samp);
    void setTimeStamp(PADS_rec & record, Sample *samp);
 
    static bool interrupted;
 
    bool outputHeader;
 
    bool outputDiodeCount;
 
    bool outputParticleCount;
 
    bool copyAllRecords;
 
    string xmlFileName;
 
    list<string> inputFileNames;
 
    string outputFileName;
 
    int outputFileLength;
 
    SampleInputHeader header;
 
    set<dsm_sample_id_t> includeIds;
 
    set<dsm_sample_id_t> excludeIds;
 
    map<dsm_sample_id_t,dsm_sample_id_t> newids;
 
    size_t minNumberParticlesRequired;
};
 
}}}
#endif