EvenlyWeighted.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2007 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/More/General/Pulsar/EvenlyWeighted.h
 
#ifndef __Pulsar_EvenlyWeighted_h
#define __Pulsar_EvenlyWeighted_h
 
#include "Pulsar/Divided.h"
#include "debug.h"
 
namespace Pulsar {
 
  template<class C>
  class Integrate<C>::EvenlyWeighted : public Integrate<C>::Divided
  {

    void initialize (Integrate*, C*);

    unsigned get_nrange () { return stop_indeces.size(); }
 
    void get_range (unsigned irange, unsigned& start, unsigned& stop);

    virtual double get_weight (const C*, unsigned ielement) = 0;
 
  protected:

    std::vector<unsigned> stop_indeces;
 
  };
 
}
 
 
template<class C>
void Pulsar::Integrate<C>::EvenlyWeighted::initialize (Integrate*, 
                                                       C* container)
{
  unsigned container_size = this->get_size( container );
 
  unsigned good_elements = 0;
 
  // count the number of good channels
  for (unsigned ielement=0; ielement < container_size; ielement++)
    if (get_weight(container,ielement) != 0)
      good_elements ++;
 
  DEBUG("EvenlyWeighted::initialize good_elements=" << good_elements);
 
  // divide them up
  unsigned output_elements = 0;
  unsigned spacing = 0;
  this->divide (good_elements, output_elements, spacing);
 
  stop_indeces.resize (output_elements);
 
  // and count off 'spacing' good channels per range
  unsigned ielement = 0;
  for (unsigned irange=0; irange < output_elements; irange++)
  {
    for (good_elements=0;
         good_elements < spacing && ielement < container_size; ielement++)
      if (get_weight(container,ielement) != 0)
        good_elements ++;
 
    DEBUG("  stop[" << irange << "] = " << ielement);
 
    stop_indeces[irange] = ielement;
 
  }
 
}
 
template<class C>
void Pulsar::Integrate<C>::EvenlyWeighted::get_range (unsigned irange, 
                                                      unsigned& start, 
                                                      unsigned& stop)
{
  if (irange >= stop_indeces.size())
    throw Error (InvalidParam, 
                 "Pulsar::Integrate::Divide::EvenlyWeighted::get_range",
                 "irange=%u >= output_elements=%u", irange, stop_indeces.size());
 
  if (irange > 0)
    start = stop_indeces[irange-1];
  else
    start = 0;
 
  stop = stop_indeces[irange];
}
 
 
 
#endif