RemoveBaseline.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2009 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/More/General/Pulsar/RemoveBaseline.h
 
#ifndef _Pulsar_RemoveBaseline_H
#define _Pulsar_RemoveBaseline_H
 
#include "Pulsar/Transformation.h"
#include "Pulsar/Archive.h"
 
namespace Pulsar
{
  class RemoveBaseline : public Transformation<Archive>
  {
  public:
 
    RemoveBaseline ();
 
    /* Two simple baseline removal algorithms
       (Not every child of RemoveBaseline needs to be nested.) */
 
    class Total;
    class Each;
 
 
    class Operation : public Reference::Able
    {
    public:
      static Operation* factory (const std::string&);
 
      virtual void operate (Profile*, const PhaseWeight*) = 0;
    };
 
    /* Some simple baseline removal operations
       (Not every child of RemoveBaseline::Operation needs to be nested.) */
 
    class SubtractMean;
    class SubtractMedian;
    class NormalizeByMean;
    class NormalizeByMedian;
    class NormalizeByStdDev;
    class NormalizeByMedAbsDif;
 
    void set_operation (Operation*);
 
  protected:
    Reference::To<Operation> profile_operation;
  };
 
 
  class RemoveBaseline::Total : public RemoveBaseline
  {
  public:
 
    void transform (Archive*);
 
    void operate (Integration*, const PhaseWeight*);
  };
 
 
  class RemoveBaseline::Each : public RemoveBaseline
  {
  public:
 
    void transform (Archive*);
  };
 
  class RemoveBaseline::SubtractMean
    : public RemoveBaseline::Operation
  {
  public:
    virtual void operate (Profile*, const PhaseWeight*);
  };
 
  class RemoveBaseline::SubtractMedian
    : public RemoveBaseline::Operation
  {
  public:
    virtual void operate (Profile*, const PhaseWeight*);
  };
 
  class RemoveBaseline::NormalizeByMean
    : public RemoveBaseline::Operation
  {
  public:
    virtual void operate (Profile*, const PhaseWeight*);
  };
 
  class RemoveBaseline::NormalizeByMedian
    : public RemoveBaseline::Operation
  {
  public:
    virtual void operate (Profile*, const PhaseWeight*);
  };
 
  class RemoveBaseline::NormalizeByStdDev
    : public RemoveBaseline::Operation
  {
  public:
    virtual void operate (Profile*, const PhaseWeight*);
  };
 
  class RemoveBaseline::NormalizeByMedAbsDif
    : public RemoveBaseline::Operation
  {
  public:
    virtual void operate (Profile*, const PhaseWeight*);
  };
 
  
}
 
#endif