completenessbins.cc

Go to the documentation of this file.

#define TF_COMPLETENESSBINS_CC_VERSION \
  "TF_COMPLETENESSBINS_CC   V1.0   "

#include <tfxx/error.h>
#include "completenessbins.h"

CompletenessBins::CompletenessBins(const libtime::TAbsoluteTime& earliest,
                                   const libtime::TAbsoluteTime& latest,
                                   const libtime::TRelativeTime& binsize)
{
  Mlatest=latest;
  Mearliest=earliest;
  this->Mbinsize=binsize;

  // initialize beginning of first bin
  // align to midnight
  this->Mfirstbin=libtime::TAbsoluteTime(earliest.year(),
                                         earliest.month(),
                                         earliest.day());
  // find appropriate first bin
  while (Mfirstbin < earliest)
  {
    Mfirstbin += binsize;
  }

  // find number of bins required to span the entire interval
  Mnbins=1; 
  libtime::TAbsoluteTime current=Mfirstbin+binsize;
  while (current <= latest)
  {
    Mnbins++;
    current += binsize;
  }
} // CompletenessBins::CompletenessBins

/*----------------------------------------------------------------------*/

libtime::TAbsoluteTime CompletenessBins::bin(const unsigned int& i) const
{
  TFXX_assert((i>=0) && (i<this->nbins()), "illegal bin index");
  libtime::TAbsoluteTime retval=this->firstbin();
  retval += i*this->binsize();
  return(retval);
} // libtime::TAbsoluteTime CompletenessBins::bin(const unsigned int& i) const

/*----------------------------------------------------------------------*/

libtime::TAbsoluteTime CompletenessBins::nextbin(const unsigned int& i) const
{
  libtime::TAbsoluteTime nextbin=this->bin(i)+this->binsize();
  return(nextbin);
} // libtime::TAbsoluteTime CompletenessBins::nextbin(const unsigned int& i)
  //  const
    
/*----------------------------------------------------------------------*/

bool CompletenessBins::isinbin(const libtime::TAbsoluteTime& d,
                               const unsigned int& i) const
{
  libtime::TAbsoluteTime thisbin=this->bin(i);
  libtime::TAbsoluteTime nextbin=this->nextbin(i);
  return((d>=thisbin) && (d<nextbin));
} // bool CompletenessBins::isinbin(const libtime::TAbsoluteTime& d, 
  // const unsigned int& i) const

/*----------------------------------------------------------------------*/

unsigned int CompletenessBins::bin(const libtime::TAbsoluteTime& d) const
{
  TFXX_assert((d >= this->earliest()) && (d <= this->latest()),
              "date is out of range");
  unsigned int retval=0;
  while ((retval<Mnbins) && !this->isinbin(d, retval)) { ++retval; }
  return(retval);
} // unsigned int CompletenessBins::bin(const libtime::TAbsoluteTime& d) const

/*----------------------------------------------------------------------*/

unsigned int
CompletenessBins::samplesinbin(const unsigned int& i,
                               const libtime::TRelativeTime dt) const
{
  libtime::TRelativeTime binsize=this->binsize();
  if (i==0)
  {
    binsize=this->nextbin(i)-this->earliest();
  }
  else if ((i+1)==this->nbins())
  {
    binsize=dt+this->latest()-this->bin(i);
  }
  unsigned int nsamples=binsize/dt;
  nsamples = nsamples > 0 ? nsamples : 1;
  return(nsamples);
} // unsigned int
  // CompletenessBins::samplesinbin(const unsigned int& i,
  //   const libtime::TRelativeTime dt) const

/*----------------------------------------------------------------------*/

unsigned int
CompletenessBins::samplesinbin(const libtime::TRelativeTime dt) const
{
  libtime::TRelativeTime binsize=this->binsize();
  unsigned int nsamples=binsize/dt;
  nsamples = nsamples > 0 ? nsamples : 1;
  return(nsamples);
} // unsigned int
  // CompletenessBins::samplesinbin(const libtime::TRelativeTime dt) const

/* ----- END OF completenessbins.cc ----- */