xml/XsilFSpectrum.hh

/*----------------------------------------------------------------------*/
/*                                                                      */
/* Module Name: xsilFSpectrum                                           */
/*                                                                      */
/* Module Description: Classes for LIGO-LW input/output to DMT objects. */
/*                                                                      */
/* Revision History:                                                    */
/* Rel   Date     Programmer    Comments                                */
/* (testing-- R. Rahkola)       Initial revision                        */
/*                                                                      */
/* Documentation References:                                            */
/*      Man Pages: none                                                 */
/*      References: none                                                */
/*                                                                      */
/* Author Information:                                                  */
/* Name          Telephone       Fax             e-mail                 */
/* Rauha Rahkola (509) 372-8141  (509) 372-8137  rrahkola@darkwing.     */
/*                                                        uoregon.edu   */
/*                                                                      */
/*                                                                      */
/*                      -------------------                             */
/*                                                                      */
/*                             LIGO                                     */
/*                                                                      */
/*        THE LASER INTERFEROMETER GRAVITATIONAL WAVE OBSERVATORY.      */
/*                                                                      */
/*                     (C) The LIGO Project, 2001.                      */
/*                                                                      */
/*                                                                      */
/* Caltech                              MIT                             */
/* LIGO Project MS 51-33                LIGO Project NW-17 161          */
/* Pasadena CA 91125                    Cambridge MA 01239              */
/*                                                                      */
/* LIGO Hanford Observatory             LIGO Livingston Observatory     */
/* P.O. Box 1970 S9-02                  19100 LIGO Lane Rd.             */
/* Richland WA 99352                    Livingston, LA 70754            */
/*                                                                      */
/*----------------------------------------------------------------------*/

#ifndef _GDS_XSILFSPECTRUM_HH
#define _GDS_XSILFSPECTRUM_HH

#include <complex>
#include <string>
#include <iosfwd>
//=============  xml common header file
#include "xml/Xsil.hh"
//=============  DMT C++ header files
#include "FSpectrum.hh"
#include "FSeries.hh"
#include "Complex.hh"

namespace xml {

   class xsilFSpectrum {
   protected:
      int              fLevel;
      const FSeries   *fData0;
      const FSpectrum *fData1;
      const int        fSubtype;
      std::ostream& writeFSpectrum (std::ostream &os) const;
      std::ostream& writeFSeries (std::ostream &os) const;
   
   public:
      xsilFSpectrum(int level = 1): fLevel(level),fData0(0),fData1(0),
      fSubtype(-1) {
      }
      xsilFSpectrum(const FSpectrum* fs, int level = 1):
      fLevel(level),fData0(0),fData1(fs),fSubtype(1) {
      }
      xsilFSpectrum(const FSpectrum& fs, int level = 1):
      fLevel(level),fData0(0),fData1(&fs),fSubtype(1) {
      }
      xsilFSpectrum(const FSeries* fs, int level = 1):
      fLevel(level),fData0(fs),fData1(0),fSubtype(0) {
      }
      xsilFSpectrum(const FSeries& fs, int level = 1):
      fLevel(level),fData0(&fs),fData1(0),fSubtype(0) {
      }
      std::ostream& write (std::ostream &os) const;
   };

   typedef xsilFSpectrum xsilFSeries;

   inline std::ostream& operator<< (std::ostream &os, const xsilFSpectrum &fs) {
      return fs.write(os); }

   class xsilHandlerFSpectrum: public xsilHandler {
   protected:
      std::vector<FSpectrum>     *fSpectrums;
      std::vector<FSeries>       *fSeries;
      std::string                 fName;
      int                         fSubtype;
      unsigned long               fSec;
      unsigned long               fNsec;
      double                      fDt;
      float                       fF0;
      double                      fDf;
      int                         fAverages;
      double                      fBW;
      bool                        fComplex;
      float*                      fData;
      int                         fDim1;
      int                         fDim2;
   
   public:
      explicit xsilHandlerFSpectrum (std::vector<FSpectrum> *specs, 
                        std::vector<FSeries> *sers,
                        const attrlist *attr=0, bool ignore=false);
      virtual ~xsilHandlerFSpectrum();
      virtual bool HandleParameter (const std::string& name,
                        const attrlist& attr,
                        const bool& p, int N = 1) {
         return false; }
      virtual bool HandleParameter (const std::string& name,
                        const attrlist& attr,
                        const char& p, int N = 1) {
         return false; }
      virtual bool HandleParameter (const std::string& name,
                        const attrlist& attr,
                        const short& p, int N = 1) {
         return false; }
      virtual bool HandleParameter(const std::string& name, 
                        const attrlist& attr, const int& p, int N=1);
   #ifndef __CINT__
      virtual bool HandleParameter (const std::string& name,
                        const attrlist& attr,
                        const long long& p, int N = 1) {
         return false; }
   #endif
      virtual bool HandleParameter (const std::string& name,
                        const attrlist& attr,
                        const float& p, int N = 1) {
         return false; }
      virtual bool HandleParameter(const std::string& name, 
                        const attrlist& attr, 
                        const double& p, int N=1);
      virtual bool HandleParameter (const std::string& name,
                        const attrlist& attr,
                        const std::complex<float>& p, int N = 1) {
         return false; }
      virtual bool HandleParameter (const std::string& name,
                        const attrlist& attr,
                        const std::complex<double>& p, int N = 1) {
         return false; }
      virtual bool HandleParameter(const std::string& name, 
                        const attrlist& attr, const std::string& p);
      virtual bool HandleTime (const std::string& name, const attrlist& attr,
                        unsigned long sec, unsigned long nsec);
      virtual bool HandleData (const std::string& name, float* x, 
                        int dim1, int dim2=0, int dim3=0, int dim4=0);
      virtual bool HandleData (const std::string& name, std::complex<float>* x,
                        int dim1, int dim2=0, int dim3=0, int dim4=0);
      virtual bool HandleData (const std::string& name, double* x, 
                        int dim1, int dim2=0, int dim3=0, int dim4=0) {
         return false; }                             
      virtual bool HandleData (const std::string& name, std::complex<double>* x,
                        int dim1, int dim2=0, int dim3=0, int dim4=0) {
         return false; }
   };

   typedef xsilHandlerFSpectrum xsilHandlerFSeries;

   class xsilHandlerQueryFSpectrum: public xsilHandlerQuery {
   protected:
      std::vector<FSpectrum>     *fSpectrum;
      std::vector<FSeries>       *fSeries;
   
   public:
      explicit xsilHandlerQueryFSpectrum(std::vector<FSeries> &sers)
      : fSpectrum(NULL),fSeries(&sers) {
      }
      explicit xsilHandlerQueryFSpectrum (std::vector<FSpectrum> &specs)
      : fSpectrum(&specs), fSeries(NULL) {
      }
      xsilHandlerQueryFSpectrum (std::vector<FSpectrum> &specs, 
                        std::vector<FSeries> &sers)
      : fSpectrum(&specs), fSeries(&sers) {
      }
      ~xsilHandlerQueryFSpectrum (void) {
      }
      virtual xsilHandler* GetHandler(const attrlist& attr);
   };

   typedef xsilHandlerQueryFSpectrum xsilHandlerQueryFSeries;

} // namespace xml

#endif // define GDS_XSILFSPECTRUM_HH

---