Database.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2004 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/More/Polarimetry/Pulsar/Database.h
 
#ifndef __Pulsar_Database_h
#define __Pulsar_Database_h
 
#include "Pulsar/Calibrator.h"
#include "Pulsar/Config.h"
 
#include "MEAL/Complex2.h"
 
#include "sky_coord.h"
#include "MJD.h"
#include "Types.h"
 
#include <iostream>
 
namespace Pulsar {
 
  // forward declarations
  class FluxCalibrator;
  class PolnCalibrator;
  class HybridCalibrator;
  class ReferenceCalibrator;
  class Archive;
 
  class Database : public Reference::Able {
 
  public:
 
    static bool cache_last_cal;
 
    static bool match_verbose;
 
    static Option<double> long_time_scale;
 
    static Option<double> short_time_scale;
 
    static Option<double> max_angular_separation;
 
    static Option<double> max_centre_frequency_difference;
 
    static Option<double> max_bandwidth_difference;
 
    static const Pulsar::Archive* any;
 
 
    enum Sequence {
      Any,
      CalibratorBefore,
      CalibratorAfter
    };
 
    Database ();
    
    Database (const std::string& path, const std::string& metafile);
 
    Database (const std::string& path, const std::vector<std::string>& exts);
 
    Database (const std::string& filename);
    
    ~Database ();
 
    void merge (const Database*);
 
    void construct (const std::vector<std::string>& filenames);
 
    void unload (const std::string& dbase_filename);
 
    void load (const std::string& dbase_filename);
    
    void add (const Pulsar::Archive* archive);
 
    PolnCalibrator* generatePolnCalibrator (Archive*,
                                            const Calibrator::Type* m);
 
    FluxCalibrator* generateFluxCalibrator (Archive*, bool allow_raw=false);
    
    HybridCalibrator* generateHybridCalibrator (ReferenceCalibrator*,Archive*);
 
    void set_feed (MEAL::Complex2* xform) { feed = xform; }
 
    std::string get_path () const;
    
    unsigned size () const { return entries.size(); }
 
    class Entry : public Reference::Able
    {
      
    public:
      
      Reference::To<const Calibrator::Type> calType;
 
      Signal::Source   obsType;      // FluxCal, PolnCal, Pulsar, etc.
      sky_coord        position;     // Where the telescope was pointing
      double           bandwidth;    // Bandwidth of observation
      double           frequency;    // Centre frequency of observation
 
      std::string      instrument;   // name of backend
      std::string      receiver;     // name of receiver
      std::string      filename;     // full path of file
      
      Entry (const Archive* arch);
 
      ~Entry();
      
      // factory constructs new Entry from ascii string
      static Entry* load (const std::string& str);
 
      // factory constructs new Entry from Archive
      static Entry* create (const Archive*);
 
      // unload ascii string
      virtual void unload (std::string& str);
 
      // return full path to filename
      std::string get_filename () const;
 
      virtual bool less_than (const Entry*) const;
      virtual bool equals (const Entry*) const;
 
      virtual MJD get_effective_time () const = 0;
      virtual std::string get_time_str () const = 0;
      virtual std::string get_nchan_str () const = 0;
 
    protected:
      
      void init ();
    };
 
    class StaticEntry : public Entry
    {
    public:
      MJD      time;         // Mid time of observation
      unsigned nchan;        // Number of channels across bandwidth
 
      StaticEntry (const Archive* arch = 0);
 
      bool equals (const Entry*) const;
 
      MJD get_effective_time () const { return time; }
      std::string get_time_str () const;
      std::string get_nchan_str () const;
 
    protected:
      
      void init ();
    };
 
    class InterpolatorEntry : public Entry
    {
    public:
      MJD  start_time;   // earliest time spanned by interpolator
      MJD  end_time;     // latest time spanned by interpolator
 
      InterpolatorEntry (const Archive* arch = 0);
 
      bool equals (const Entry*) const;
 
      MJD get_effective_time () const { return start_time; }
      std::string get_time_str () const;
      std::string get_nchan_str () const;
    };
    
    class Criteria : public Reference::Able {
      
    public:
      
      Reference::To<StaticEntry> entry;
 
      void set_sequence (Sequence s) { sequence = s; }
      Sequence get_sequence () const { return sequence; }
 
      double minutes_apart;
      double deg_apart;
      
      bool check_receiver;
      bool check_instrument;
      bool check_frequency;
      bool check_bandwidth;
      bool check_obs_type;
      bool check_time;
      bool check_coordinates;
      bool check_frequency_array;
 
      Criteria ();
      
      void no_data ();
 
      bool match (const Entry* entry) const;
      
 
      mutable std::string match_report;
 
      mutable unsigned match_count;
 
      mutable double diff_minutes;
 
      mutable double diff_degrees;
 
 
      const Entry* best (const Entry* a, const Entry* b) const;
 
      static Criteria closest (const Criteria& a, const Criteria& b);
 
    protected:
 
      Sequence sequence;
 
      template<typename T, typename U, typename Predicate>
      void compare (const std::string& name,
                    const T& want, const U& have,
                    Predicate equal ) const
      {
        match_report += "\t" + name
          + " want=" + tostring(want) + " have=" + tostring(have) + " ... ";
        
        if ( equal (want, have) )
        {
          match_report += "match \n";
          match_count ++;
        }
        else
        {
          match_report += "no match \n";
          throw false;
        }
      }
 
      template<typename T>
      void compare (const std::string& name,
                    const T& want, const T& have) const
      {
        compare (name, want, have, std::equal_to<T>());
      }
 
      bool compare_times (const MJD& want, 
                          const MJD& have) const;
 
      bool bracketed_time (const MJD& want,
                           const std::pair<MJD,MJD>& have) const;
 
      bool compare_coordinates (const sky_coord& want,
                                const sky_coord& have) const;
    };
    
    
    static Criteria get_default_criteria ();
 
    static void set_default_criteria (const Criteria&);
 
    const Entry* best_match (const Criteria&) const;
 
    void all_matching (const Criteria&,
                       std::vector<const Entry*>& matches) const;
    
    Criteria criteria (const Pulsar::Archive* arch,
                       Signal::Source obsType) const;
    
    Criteria criteria (const Pulsar::Archive* archive,
                       const Calibrator::Type* calType) const;
 
    std::string get_filename (const Entry*) const;
    
    void add (Entry* entry);
 
    void shorten_filename (Entry* entry);
 
    void expand_filename (Entry* entry);
 
    std::string get_closest_match_report () const;
 
  protected:
 
    // list of entries in the database
    std::vector< Reference::To<Entry> > entries;
    std::string path;
 
    template<class Cal> class Cache
    {
    public:
      Reference::To<const Entry> entry;
      Reference::To<Cal> calibrator;
 
      void cache (const Entry* _entry, Cal* cal)
      { entry = _entry; calibrator = cal; }
    };
 
    Cache<PolnCalibrator> lastPolnCal;
    Cache<HybridCalibrator> lastHybridCal;
    Cache<FluxCalibrator> lastFluxCal;
 
    FluxCalibrator* rawFluxCalibrator (Archive* a);
 
    Reference::To<MEAL::Complex2> feed;
 
    mutable Criteria closest_match;
  };
 
  std::ostream& operator << (std::ostream& os, Database::Sequence);
    
  std::istream& operator >> (std::istream& is, Database::Sequence&);
}
 
#endif