DataSetManager.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2022 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/More/Polarimetry/Pulsar/DataSetManager.h
 
#ifndef __Pulsar_DataSetManager_H
#define __Pulsar_DataSetManager_H
 
#include "Pulsar/Database.h"
 
namespace Pulsar
{
  class DataSet : public Reference::Able
  {
  public:
 
    DataSet ();

    bool matches (const Archive* data);

    void add (const Archive* data);

    void integrate (const Archive* data);
    
    const std::string& get_name () { return name; }

    Archive* get_total () { return total; }
    
    MJD get_start_epoch () const;

    MJD get_end_epoch () const;
 
    double get_integration_length () const { return total_integration_length; }
    
    const std::vector< std::string >& get_calibrator_filenames () const
    { return calibrator_filenames; }
 
  protected:
 
    friend class DataSetManager;
 
    void update (const Archive* archive, const char* method);
 
    std::string name;
    double total_integration_length;
    
    std::vector< Reference::To<const Archive> > data;
    Reference::To<Archive> total;
    
    MJD start_time;
    MJD end_time;
 
    std::vector< std::string > calibrator_filenames;
  };
  

 
  class DataSetManager : public Reference::Able
  {
 
  public:

    DataSetManager ();

    void manage (DataSet*);

    unsigned get_nset () const;
    
    DataSet* get (const Archive* data);

    DataSet* get_set (unsigned i);
    
    void set_database (Pulsar::Database* db) { database = db; }
    
    MJD get_epoch () const;


    void add (const Archive* data);


    void integrate (const Archive* data);

    void load ( std::vector<std::string>& filenames );
      
    MJD get_start_epoch () const;

    MJD get_end_epoch () const;
 
    double get_integration_length () const { return total_integration_length; }

    void add_polncals (DataSet*);

    void set_polncal_hours (float hours) { polncal_hours = hours;}
 
    // days from mid-time within which FluxCalOn observations will be selected
    void set_fluxcal_days (float days) { fluxcal_days = days;}
 
    // look for PolnCal observations with nearby sky coordinates
    void set_check_coordinates (bool f) { check_coordinates = f; }
 
    void find_poln_calibrators ();
    void find_on_flux_calibrators ();
    void find_off_flux_calibrators ();
 
    unsigned get_polncal_count () const { return npolncal; }
    
  protected:

    std::vector< Reference::To<DataSet> > datasets;

    Reference::To<Pulsar::Database> database;
 
    // hours from mid-time within which PolnCal observations will be selected
    float polncal_hours;
 
    // days from mid-time within which FluxCalOn observations will be selected
    float fluxcal_days;
 
    // look for PolnCal observations with nearby sky coordinates
    bool check_coordinates;
 
    MJD start_time;
    MJD end_time;
 
    double total_integration_length;
 
    void find_flux_calibrators (Signal::Source, const char* short_names);
 
    template <class Method>
    void incorporate (const Archive* data, Method method);
 
    // total number of PolnCal observations
    unsigned npolncal;
  };
 
}
 
#endif