WeightedTimeSeries.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2002 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// dspsr/Kernel/Classes/dsp/WeightedTimeSeries.h
 
#ifndef __WeightedTimeSeries_h
#define __WeightedTimeSeries_h
 
#include "dsp/TimeSeries.h"
 
namespace dsp {
  
  /* The WeightedTimeSeries class contains floating point data that
     may be flagged as bad in the time domain. */
  class WeightedTimeSeries : public TimeSeries {
 
  public:
 
    WeightedTimeSeries ();
 
    WeightedTimeSeries (const WeightedTimeSeries&);
 
    virtual WeightedTimeSeries& operator = (const WeightedTimeSeries& copy);
 
    virtual WeightedTimeSeries& operator += (const WeightedTimeSeries& data);
 
 
    void set_ndat_per_weight (unsigned ndat_per_weight);
 
    unsigned get_ndat_per_weight () const { return ndat_per_weight; }
 
    void set_npol_weight (unsigned npol_weight);
 
    unsigned get_npol_weight () const { return npol_weight; }
 
    void set_nchan_weight (unsigned nchan_weight);
 
    unsigned get_nchan_weight () const { return nchan_weight; }
 
    virtual WeightedTimeSeries* clone() const;
 
    virtual WeightedTimeSeries* null_clone() const;
 
    void set_reserve_kludge_factor (unsigned);
 
    virtual void copy_configuration (const Observation* copy);
 
    virtual void copy_data (const TimeSeries* data, 
                            uint64_t idat_start = 0, uint64_t ndat = 0);
 
    virtual void resize (uint64_t nsamples);
    
    virtual void seek (int64_t offset);
 
    virtual void zero ();
 
    void copy_weights (const Observation* copy);
 
    void mask_weights ();
 
    void check_weights ();
 
    void neutral_weights ();
 
    uint64_t get_nweights () const;
 
    uint64_t get_nweights (uint64_t nsample) const;
 
    void set_weight_idat (uint64_t weight_idat);
 
    uint64_t get_weight_idat () const { return weight_idat; }
 
    uint64_t get_nzero () const;
 
    unsigned* get_weights (unsigned ichan=0, unsigned ipol=0);
 
    const unsigned* get_weights (unsigned ichan=0, unsigned ipol=0) const;
 
    void convolve_weights (unsigned nfft, unsigned nkeep);
 
    void scrunch_weights (unsigned nscrunch);
 
  protected:
 
    unsigned npol_weight = 1;
 
    unsigned nchan_weight = 1;
 
    unsigned ndat_per_weight = 0;
 
    unsigned reserve_kludge_factor = 1;
 
    void copy_weights (const WeightedTimeSeries* copy,
                       uint64_t idat_start = 0, uint64_t copy_ndat = 0);
 
    void resize_weights (uint64_t nsamples);
 
    uint64_t have_nweights () const;
 
    void prepend_checks (const TimeSeries*, uint64_t pre_ndat);
 
  private:
 
    unsigned* base = nullptr;
 
    unsigned* weights = nullptr;
 
    uint64_t weight_idat = 0;
 
    uint64_t weight_size = 0;
 
    uint64_t weight_subsize = 0;
  };
 
}
 
#endif