Archiver.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2002 - 2023 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// dspsr/Signal/Pulsar/dsp/Archiver.h
 
#ifndef __Archiver_h
#define __Archiver_h
 
#include "dsp/PhaseSeriesUnloader.h"
#include "Pulsar/Archive.h"
 
namespace Pulsar
{
  class Interpreter;
  class Integration;
  class Profile;
 
  class MoreProfiles;
  class dspReduction;
  class TwoBitStats;
  class DigitiserCounts;
  class Passband;
  class Backend;
}
 
namespace dsp
{
  class Response;
  class Operation;
  class ExcisionUnpacker;
  class HistUnpacker;
  class SpectralKurtosis;
 
 
  class Archiver : public PhaseSeriesUnloader {
 
  public:
 
    static unsigned verbose;
 
    Archiver ();
    
    Archiver (const Archiver&);
    
    virtual ~Archiver ();
 
    Archiver* clone () const;
 
    void set_archive_class (const std::string& archive_class_name);
    void set_force_archive_class (bool);
 
    void set_command_line (const std::string&);
 
    void set_script (const std::vector<std::string>& jobs);
 
    void set_archive (Pulsar::Archive* archive);
 
    bool postprocess (Pulsar::Archive* archive);
 
    void set_minimum_integration_length (double seconds);
 
    Pulsar::Archive* get_archive ();
 
    bool has_archive() const;
 
    void add_extension (Pulsar::Archive::Extension* extension);
 
    void unload (const PhaseSeries*);
 
    void finish ();
 
    unsigned get_npol (const PhaseSeries* phase) const;
 
    void set (Pulsar::Archive* archive, const PhaseSeries* phase);
 
    void add (Pulsar::Archive* archive, const PhaseSeries* phase);
 
    void set_archive_dedispersed (bool _archive_dedispersed)
    { archive_dedispersed = _archive_dedispersed; }
    
    bool get_archive_dedispersed() const
    { return archive_dedispersed; }
 
    void set_archive_software(std::string _archive_software)
    { archive_software = _archive_software; }
 
    std::string get_archive_software()
    { return archive_software; }
 
    void set_store_dynamic_extensions (bool flag)
    { store_dynamic_extensions = flag; }
 
    void set_use_single_archive (bool flag)
    { use_single_archive = flag; }
 
    void set_subints_per_file (unsigned nsub)
    { subints_per_file = nsub; }
 
  protected:
    
    double minimum_integration_length;
 
    bool unload_profiles_with_zero_hits {true};
 
    std::string command_line;
    
    std::string archive_class_name;
 
    bool force_archive_class;
 
    bool use_single_archive;
 
    Reference::To<Pulsar::Archive> single_archive;
 
    unsigned subints_per_file;
 
    std::vector<std::string> script;
 
    Reference::To<Pulsar::Interpreter> interpreter;
 
    Reference::To<const Response> passband;
 
    Reference::To<const ExcisionUnpacker> excision_unpacker;
 
    Reference::To<const HistUnpacker> hist_unpacker;
 
    Reference::To<SpectralKurtosis> spectral_kurtosis;
 
    std::vector< Reference::To<Pulsar::Archive::Extension> > extensions;
 
    bool store_dynamic_extensions;
 
    void set (Pulsar::Integration* integration, const PhaseSeries* phase,
              unsigned isub=0, unsigned nsub=1);
 
    void set (Pulsar::Profile* profile, const PhaseSeries* phase, double scale,
              unsigned ichan, unsigned ipol, unsigned idim);
 
    void set (Pulsar::Backend*);
 
    void set (Pulsar::dspReduction*);
 
    void pack (Pulsar::dspReduction*, Operation*);
 
    void pack (Pulsar::Integration*);
 
    void set_coherent_dedispersion (Signal::State state, const Response* response);
 
    void set (Pulsar::TwoBitStats*);
 
    void set (Pulsar::DigitiserCounts* dig_cnts, unsigned isub=0);
 
    void set (Pulsar::Passband*);
 
    void raw_to_central (unsigned ichan,
                         Pulsar::MoreProfiles* moments,
                         const Pulsar::Integration* means,
                         const unsigned* hits);
 
    Pulsar::Archive* new_Archive() const;
 
  private:
 
    bool archive_dedispersed;
 
    std::string archive_software;
 
    Reference::To<const PhaseSeries> profiles;
 
    Reference::To<Pulsar::Archive> archive;
 
    unsigned corrupted_profiles;
 
    mutable unsigned fourth_moments;
  };
 
}
 
#endif // !defined(__Archiver_h)