CompareWith.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2021 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/More/General/Pulsar/CompareWith.h
 
#ifndef __CompareWith_h
#define __CompareWith_h
 
#include "Pulsar/HasArchive.h"
#include "Pulsar/TimeDomainCovariance.h"
#include "Pulsar/ScrunchFactor.h"
 
#include "ChiSquared.h"
#include "ndArray.h"
 
class BinaryStatistic;
class UnaryStatistic;
 
namespace Pulsar {


  class CompareWith : public Reference::Able
  {
  protected:
    
    Reference::To<BinaryStatistic> statistic;

    HasArchive* data;

    void (HasArchive::* primary) (Index);
    unsigned nprimary;
    
    void (HasArchive::* compare) (Index);
    unsigned ncompare;

    bool compare_all;


    bool model_residual;
    bool use_null_space;
    
    bool transpose;

    virtual void setup (unsigned start_primary, unsigned nprimary = 1);

    bool setup_completed;

    bool is_setup;
 
    void set (ndArray<2,double>& result,
              unsigned iprimary, unsigned icompare,
              double value);

    void check ();

    void compute_mean (unsigned start_primary, unsigned nprimary);
    Reference::To<Profile> mean;
 
    Reference::To<TimeDomainCovariance> covar;

    ScrunchFactor bscrunch_factor;

    void get_amps (std::vector<double>& amps, const Profile* profile);

    void get_residual (std::vector<double>& amps,
                       const std::vector<double>& mamps);

    Reference::To<Profile> temp;

    BinaryStatistics::ChiSquared chi;

    virtual void compute (unsigned iprimary, ndArray<2,double>& result) = 0;

    std::vector<bool> compute_mask;

    FILE* fptr;
 
  public:
 
    CompareWith ();
 
    void set_statistic (BinaryStatistic*);
    void set_data (HasArchive*);

    void set_setup_data (const Archive*);
    
    void set_bscrunch (const ScrunchFactor& f) { bscrunch_factor = f; }
    
    const ScrunchFactor get_bscrunch () const { return bscrunch_factor; }

    /* Not all comparisons require a global set up */
    bool get_setup () { return is_setup; }
 
    void set_transpose (bool);
    void set_primary (unsigned n, void (HasArchive::*) (Index));
    void set_compare (unsigned n, void (HasArchive::*) (Index));
 
    void set_compare_all (bool flag = true) { compare_all = flag; }
    
    void set_compute_mask (const std::vector<bool>& flags)
    { compute_mask = flags; }
                           
    virtual void compute (ndArray<2,double>& result);

    void set_file (FILE* f) { fptr = f; }
 
  };
}
 
#endif