TimerArchive.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2003 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/Base/Formats/Timer/Pulsar/TimerArchive.h
 
#ifndef __Timer_Archive_h
#define __Timer_Archive_h
 
#include "Pulsar/Archive.h"
#include "Pulsar/Agent.h"
#include "timer.h"
 
namespace Pulsar {
 
  class TapeInfo;
  class CalInfoExtension;

  class TimerArchive : public Archive {
 
  public:
 
    static bool big_endian;

    TimerArchive ();

    TimerArchive (const TimerArchive& archive);

    ~TimerArchive ();

    const TimerArchive& operator = (const TimerArchive& archive);
    
    TimerArchive (const Archive& archive);

    void copy (const Archive& archive);
 
    // //////////////////////////////////////////////////////////////////
    //
    // implement the pure virtual methods of the Archive base class
    //

    TimerArchive* clone () const;

    virtual std::string get_telescope () const;
    virtual void set_telescope (const std::string& telescope);

    virtual Signal::State get_state () const;
    virtual void set_state (Signal::State state);

    virtual Signal::Scale get_scale () const;
    virtual void set_scale (Signal::Scale scale);

    virtual Signal::Source get_type () const;
    virtual void set_type (Signal::Source type);

    virtual std::string get_source () const;
    virtual void set_source (const std::string& source);

    virtual sky_coord get_coordinates () const;
    virtual void set_coordinates (const sky_coord& coordinates);


    virtual unsigned get_nbin () const;


    virtual unsigned get_nchan () const;


    virtual unsigned get_npol () const;


    virtual unsigned get_nsubint () const;

    virtual double get_bandwidth () const;
    virtual void set_bandwidth (double bw);

    virtual double get_centre_frequency () const;
    virtual void set_centre_frequency (double cf);

    virtual double get_dispersion_measure () const;
    virtual void set_dispersion_measure (double dm);

    virtual double get_rotation_measure () const;
    virtual void set_rotation_measure (double rm);

    virtual bool get_dedispersed () const;
    virtual void set_dedispersed (bool done = true);

    virtual bool get_faraday_corrected () const;
    virtual void set_faraday_corrected (bool done = true);

    virtual bool get_poln_calibrated () const;
    virtual void set_poln_calibrated (bool done = true);

    int hydra_obstype ();

    virtual void correct ();
 
  protected:
 
    friend class Archive::Advocate<TimerArchive>;
 
    // Advocates the use of the TimerArchive plugin
    class Agent : public Archive::Advocate<TimerArchive> {
    
      public:

        Agent () {}

        bool advocate (const char* filename);

        std::string get_name () { return "Timer"; }

        std::string get_description ();
 
    }; 

    virtual void load_header (const char* filename);

    virtual Integration*
    load_Integration (const char* filename, unsigned subint);

    bool can_unload () const { return true; }

    virtual void unload_file (const char* filename) const;

    struct timer hdr;


    bool valid;

    virtual void set_nbin (unsigned numbins);

    virtual void set_nchan (unsigned numchan);

    virtual void set_npol (unsigned numpol);

    virtual void set_nsubint (unsigned nsubint);

    virtual Integration* new_Integration (const Integration* copy_this = 0);

    void set_corrected (int code, bool done);

    void set_calibrated (int code, bool done);

    void load (FILE* fptr);

    void unload (FILE* fptr) const;
 
    // loading is broken up into the following steps, so that inherited
    // types can use the building blocks to do different things

    void hdr_load (FILE* fptr);

    virtual void backend_load (FILE* fptr);

    void psr_load (FILE* fptr);

    void subint_load (FILE* fptr);
 
    // unloading is broken up into the following steps, so that inherited
    // types can use the building blocks to do different things

    void hdr_unload (FILE* fptr) const;

    virtual void set_be_data_size ();

    virtual void backend_unload (FILE* fptr) const;

    void psr_unload (FILE* fptr) const;

    void subint_unload (FILE* fptr) const;

    void correct_Integrations ();

    void unpack_extensions ();

    void pack_extensions ();

    void unpack (Receiver* receiver);

    void pack (const Receiver* receiver);

    void unpack (TapeInfo* tape);

    void pack (const TapeInfo* tape);

    void unpack (CalInfoExtension* cal);

    double dispersion_measure;
    double rotation_measure;
  };
 
 
 
}
 
#endif