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