ScrunchFactor.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2021 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/More/General/Pulsar/ScrunchFactor.h
 
#ifndef __Pulsar_ScrunchFactor_h
#define __Pulsar_ScrunchFactor_h
 
#include "Pulsar/Pulsar.h"
#include "Error.h"
 
namespace Pulsar {
 
  class ScrunchFactor 
  {
    unsigned n_result;
    unsigned n_scrunch;
 
  public:
 
    static const ScrunchFactor none;
    
    ScrunchFactor (unsigned nresult = 1) { set_nresult (nresult); }
 
    unsigned get_nresult () const { return n_result; }
    void set_nresult (unsigned value) { n_result = value; n_scrunch = 0; }
 
    unsigned get_nscrunch () const { return n_scrunch; }
    void set_nscrunch (unsigned value) { n_scrunch = value; n_result = 0; }
 
    bool scrunch_enabled () const { return n_scrunch || n_result; }
 
    void disable_scrunch () { n_scrunch = n_result = 0; }
 
    unsigned get_nresult (unsigned size) const;
 
    unsigned get_nscrunch (unsigned size) const;
  };
 
  std::ostream& operator << (std::ostream& os, const ScrunchFactor&);
  std::istream& operator >> (std::istream& is, ScrunchFactor&);
 
  template<class Container>
  void fscrunch (Container*, const ScrunchFactor&);
 
  template<class Container>
  void tscrunch (Container*, const ScrunchFactor&);
 
  template<class Container>
  void bscrunch (Container*, const ScrunchFactor&);
 
}
 
template<class Container, class getN, class doScrunch>
void scrunch (Container* container, getN get_size, doScrunch scrunch,
              const Pulsar::ScrunchFactor& factor)
{
  if (factor.get_nresult())
  {
    unsigned size = (container->*get_size) ();
    unsigned new_size = factor.get_nresult();
 
    if (size % new_size)    
      Pulsar::warning << "scrunch: requested size=" << new_size << " does not divide current size=" << size << std::endl;
 
    unsigned nscrunch = size / new_size;
    (container->*scrunch) ( nscrunch );
  }
  else if (factor.get_nscrunch())
  {
    (container->*scrunch) ( factor.get_nscrunch() );
  }
  else
    throw Error (InvalidState, "scrunch (ScrunchFactor) template",
                 "neither nresult nor nscrunch set");
}
 
template<class Container>
void Pulsar::fscrunch (Container* container, const ScrunchFactor& factor)
{
  scrunch (container, &Container::get_nchan, &Container::fscrunch, factor);
}
 
template<class Container>
void Pulsar::tscrunch (Container* container, const ScrunchFactor& factor)
{
  scrunch (container, &Container::get_nsubint, &Container::tscrunch, factor);
}
 
template<class Container>
void Pulsar::bscrunch (Container* container, const ScrunchFactor& factor)
{
  scrunch (container, &Container::get_nbin, &Container::bscrunch, factor);
}
 
#endif