LoadToFold1.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2007-2011 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// dspsr/Signal/Pulsar/dsp/LoadToFold1.h
 
#ifndef __dspsr_LoadToFold_h
#define __dspsr_LoadToFold_h
 
#include "dsp/SingleThread.h"
#include "dsp/Filterbank.h"
#include "dsp/InverseFilterbank.h"
 
namespace dsp {
 
  class TimeSeries;
 
  class PlasmaResponse;
  class Dedispersion;
  class Derotation;
 
  class Convolution;
  class Detection;
  class Fold;
  class Archiver;
  class FoldManager;
 
  class Response;
  class RFIFilter;
  class ResponseProduct;
 
  class OperationThread;
  class SKFilterbank;
  class SpectralKurtosis;
  class Resize;
  class SampleDelay;
  class PhaseLockedFilterbank;
 
  class PhaseSeriesUnloader;
  class SignalPath;
 
  class LoadToFoldN;
 
  class LoadToFold : public SingleThread
  {
 
  public:
 
    class Config;
 
    void set_configuration (Config*);
 
    LoadToFold (Config* config = 0);
 
    ~LoadToFold ();
 
    void construct ();
 
    void prepare ();
 
    void run ();
 
    void finish ();
 
    friend class LoadToFoldN;
 
    void share (SingleThread*);
 
    void end_of_data ();
 
    bool output_subints () const;
 
    Reference::To<PlasmaResponse> kernel;
 
    Reference::To<Dedispersion> dedisp;
 
    Reference::To<Derotation> derotate;
 
    std::vector< Reference::To<Fold> > fold;
 
    Reference::To<FoldManager> fold_manager;
 
    std::vector< Reference::To<OperationThread> > asynch_fold;
 
    std::vector< Reference::To<PhaseSeriesUnloader> > unloader;
 
    std::vector< Reference::To<SignalPath> > path;
 
    bool manage_archiver;
 
    Reference::To<RFIFilter> rfi_filter;
 
    Reference::To<Config> config;
 
    Reference::To<Response> passband;
 
    Reference::To<Response> frequency_response;
 
    Reference::To<Apodization> temporal_apodization;
 
    Reference::To<Apodization> spectral_apodization;
 
    // Reference::To<SKFilterbank> skfilterbank;
 
    Reference::To<SpectralKurtosis> skestimator;
 
    Reference::To<TimeSeries> zero_DM_time_series;
 
    Reference::To<Resize> skresize;
 
    Reference::To<Filterbank> filterbank;
 
    Reference::To<Filterbank::Engine> filterbank_engine;
 
    Reference::To<InverseFilterbank> inverse_filterbank;
 
    Reference::To<InverseFilterbank::Engine> inverse_filterbank_engine;
 
    Reference::To<Convolution> convolution;
 
    Reference::To<ResponseProduct> response_product;
 
    Reference::To<SampleDelay> sample_delay;
 
 
    Reference::To<PhaseLockedFilterbank> phased_filterbank;
 
    Reference::To<Detection> detect;
 
    TimeSeries* construct_inverse_filterbank (TimeSeries*, bool run_on_gpu=false);
 
    TimeSeries* construct_filterbank (TimeSeries*, bool run_on_gpu=false);
 
    TimeSeries* construct_convolution (TimeSeries*, bool run_on_gpu=false);
 
    TimeSeries* construct_interchan (TimeSeries*, bool run_on_gpu=false);
 
    TimeSeries* construct_spectral_kurtosis (TimeSeries* data, bool run_on_gpu=false);
 
    void construct_phased_filterbank(TimeSeries *input);
 
    void build_fold (TimeSeries*);
    void build_fold (Reference::To<Fold>&, PhaseSeriesUnloader*);
    void configure_fold (unsigned ifold, TimeSeries* to_fold);
    void configure_detection (Detection*, unsigned);
 
    PhaseSeriesUnloader* get_unloader (unsigned ifold);
 
    void prepare_fold ();
    bool fold_prepared;
 
    void prepare_archiver (Archiver*);
 
    MJD parse_epoch (const std::string&);
  };
 
}
 
#endif // !defined(__LoadToFold_h)