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 update_absolute_dispersion()
    { instance->update_absolute_dispersion(); }


    void update_absolute_rotation()
    { instance->update_absolute_rotation(); }
    
    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