ConfigurableProjection.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2022 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
#ifndef __Pulsar_ConfigurableProjection_h
#define __Pulsar_ConfigurableProjection_h
 
#include "Pulsar/VariableProjectionCorrection.h"
#include "Pulsar/VariableTransformation.h"
 
#include "Pulsar/ConfigurableProjectionExtension.h"
 
#include "MEAL/Axis.h"
 
namespace Pulsar 
{
  class ConfigurableProjection : public VariableTransformationManager
  {
  public:

    ConfigurableProjection (const std::string& filename);

    ConfigurableProjection (const ConfigurableProjectionExtension*);

    void construct (const std::string&);

    void set_archive (const Archive* _archive);

    void set_subint (unsigned _subint);

    void set_chan (unsigned _chan);
 
    class Transformation;

    void set_nchan (unsigned nchan) override;

    Transformation* get_transformation (unsigned ichan) override;

    MEAL::Argument::Value* new_value () override;

    const Transformation* get_transformation (unsigned ichan) const;

    bool get_transformation_valid (unsigned ichan) const;

    unsigned get_nchan () const;

    unsigned get_ndim () const;

    double get_value (const std::string& name);

    const std::vector<std::string>& get_abscissa_names (unsigned index) { return parameters.at(index); }

    const std::string& get_configuration() const { return configuration; }

    class Info;


    void calibrate (Archive*);

    void transform (Archive*);

    void set_projection (KnownVariableTransformation* known) { projection = known; }

    KnownVariableTransformation* get_projection () { return projection; }
 
  protected:

    std::string configuration;

    Reference::To<KnownVariableTransformation> projection;


    Reference::To< Calibration::VariableTransformation > transformation;

    std::map< unsigned, std::vector<std::string> > parameters;
 
    std::vector< Reference::To<Transformation> > xforms;

    unsigned effective_ndim = 0;
    
    void transform_work (Archive* arch, const std::string& name, bool invert);
 
  public:
 
    class Transformation : public VariableTransformationManager::Transformation
    {
    protected:
  
      MEAL::Axis< Calibration::VariableTransformation::Argument > argument;
  
      Reference::To<Calibration::VariableTransformation> transformation;
 
    public:
  
      Transformation (Calibration::VariableTransformation* xform)
      {
        transformation = xform;
        argument.signal.connect (xform, &Calibration::VariableTransformation::set_argument);
      }
  
      Calibration::VariableTransformation* get_transformation ()
      { return transformation; }
 
      const Calibration::VariableTransformation* get_transformation () const
      { return transformation; }
 
      MEAL::Argument* get_argument () { return &argument; }
    };
 
  };
 
  void copy (MEAL::Complex2* to, const ConfigurableProjectionExtension::Transformation* from);
 
  void copy (ConfigurableProjectionExtension::Transformation* to, const MEAL::Complex2* from);
 
}
 
#endif