IntegrationExpert.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2006 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/Base/Classes/Pulsar/IntegrationExpert.h
 
#ifndef __Pulsar_IntegrationExpert_h
#define __Pulsar_IntegrationExpert_h
 
#include "Pulsar/Integration.h"
#include "Pulsar/Archive.h"
 
namespace Pulsar {
 
 
  class Integration::Expert : public Reference::Able {
 
  public:
 
    Expert (Integration* inst)
    { instance = inst; }
 
    void set_nbin (unsigned numbins)
    { instance->set_nbin (numbins); }
    unsigned get_nbin () const { return instance->get_nbin(); }
 
    void set_nchan (unsigned numchan)
    { instance->set_nchan (numchan); }
    unsigned get_nchan () const { return instance->get_nchan(); }
    
    void set_npol (unsigned numpol)
    { instance->set_npol (numpol); }
    unsigned get_npol () const { return instance->get_npol(); }
 
    void resize (unsigned npol=0, unsigned nchan=0, unsigned nbin=0)
    { instance->resize (npol, nchan, nbin); }
 
    void remove (unsigned ichan)
    { instance->remove (ichan); }
 
    void insert (Integration* from)
    { instance->insert (from); }
 
    void rotate (double time)
    { instance->rotate (time); }
 
    void rotate_phase (double phase)
    { instance->rotate_phase (phase); }
 
    void fscrunch (unsigned nscrunch = 0)
    { instance->fscrunch (nscrunch); }
 
    void pscrunch ()
    { instance->pscrunch (); }
 
    void dedisperse (unsigned ichan, unsigned kchan, double f0)
    { instance->dedisperse (ichan, kchan, f0); }
 
    void defaraday (unsigned ichan, unsigned kchan, double f0)
    { instance->defaraday (ichan, kchan, f0); }
 
    void swap_profiles (unsigned ipol, unsigned ichan,
                        unsigned jpol, unsigned jchan)
    { instance->swap_profiles (ipol, ichan, jpol, jchan); }
 
    void copy (const Integration* subint, bool management = true)
    { instance->copy (subint, management); }
 
    void combine (const Integration* from)
    { instance->combine (from); }
 
    void transform (const Jones<float>& response)
    { instance->transform (response); }
 
    void transform (const std::vector< Jones<float> >& response)
    { instance->transform (response); }
 
    void convert_state (Signal::State state)
    { instance->convert_state (state); }
 
    void set_zero_phase_aligned (bool flag)
    { instance->zero_phase_aligned = flag; }
 
    std::vector< std::vector< Reference::To<Profile> > >& profiles ()
    { return instance->profiles; }
 
    bool has_parent () const
    { return instance->parent; }
 
    const Archive* get_parent () const
    { return instance->parent; }
 
  private:
 
    Reference::To<Integration, false> instance;
  };
 
}
 
#endif