ZeroReverse.h

#ifndef ZeroReverse_h
#define ZeroReverse_h
 
/* SPDX-License-Identifier: CC0-1.0 */
                                                                      
#include <cmath>
#include <string>
#include <vector>
#include <iostream>
#include <sstream>
 
 
#include "IString.h"
#include "HiCalTypes.h"
#include "HiCalUtil.h"
#include "HiCalConf.h"
#include "Module.h"
#include "SplineFill.h"
#include "Statistics.h"
#include "SpecialPixel.h"
#include "IException.h"
 
namespace Isis {
 
  class ZeroReverse : public Module {
 
    public:
      //  Constructors and Destructor
      ZeroReverse() : Module("ZeroReverse") { }
      ZeroReverse(HiCalData &cal, const HiCalConf &conf) :
                  Module("ZeroReverse") {
        init(cal, conf);
      }
 
      virtual ~ZeroReverse() { }
 
      const Statistics &Stats() const { return (_stats); }
 
      bool wasTriggered() const { return (_triggered); }
 
    private:
      HiVector   _revClock;
      Statistics _stats;
      bool       _triggered;
 
 
      void init(HiCalData &cal, const HiCalConf &conf) {
        DbProfile prof = conf.getMatrixProfile();
        _history.clear();
        _history.add("Profile["+ prof.Name()+"]");
 
        int line0 = toInt(ConfKey(prof,"ZeroReverseFirstLine",QString("0")));
        int lineN = toInt(ConfKey(prof,"ZeroReverseLastLine",QString("19")));
        QString tfile= conf.getMatrixSource("ReverseClockStatistics",prof);
 
        HiMatrix revclk = cropLines(cal.getReverseClock(), line0, lineN);
        _stats.Reset();
        _stats.AddData(revclk[0], revclk.dim1()*revclk.dim2());
 
        _revClock = averageLines(revclk);
       _history.add("RevClock(CropLines["+ToString(line0)+","+ToString(lineN) +
                    "],Mean["+ToString(_stats.Average()) +
                     "],StdDev["+ToString(_stats.StandardDeviation()) +
                     "],LisPixels["+ToString(_stats.LisPixels())+
                     "],HisPixels["+ToString(_stats.HisPixels()) +
                     "],NulPixels["+ToString(_stats.NullPixels())+ "])");
 
       DbAccess triggers(Pvl(tfile).findObject("ReverseClockStatistics"));
       QString tprofName = conf.resolve("{FILTER}{CCD}_{CHANNEL}_{BIN}",prof);
       _history.add("ReverseClockStatistics(File["+tfile+
                    "],Profile["+tprofName+"])");
 
       _triggered= false;
       if (triggers.profileExists(tprofName)) {
         DbProfile tprof(prof, triggers.getProfile(tprofName), tprofName);
         double revmean = toDouble(ConfKey(tprof,"RevMeanTrigger", toString(_stats.Average())));
         double revstddev = toDouble(ConfKey(tprof,"RevStdDevTrigger", toString(DBL_MAX)));
         int lisTol = toInt(ConfKey(tprof, "RevLisTolerance", toString(1)));
         int hisTol = toInt(ConfKey(tprof, "RevHisTolerance", toString(1)));
         int nulTol = toInt(ConfKey(tprof, "RevNulTolerance", toString(1)));
 
         _history.add("TriggerLimits(RevMeanTrigger["+ToString(revmean) +
                      "],RevStdDevTrigger["+ToString(revstddev)+
                      "],RevLisTolerance["+ToString(lisTol)+
                      "],RevHisTolerance["+ToString(hisTol)+
                      "],RevNulTolerance["+ToString(nulTol)+ "])");
 
         if ((_stats.LisPixels() > lisTol) || (_stats.HisPixels() > hisTol) ||
             (_stats.NullPixels() > nulTol) ||
             (_stats.StandardDeviation() > revstddev)) {
           _triggered = true;
           _data = HiVector(_revClock.dim1(), revmean);
           _history.add("Trigger(True - Reverse Clock set to constant,"
                        "ReverseClock["+ToString(revmean)+"])");
         }
         else {
           _history.add("Trigger(False - Reverse Clock processing invoked)");
           _triggered = false;
         }
       }
       else {
         _history.add("Trigger(Profile["+tprofName+"],NotFound!)");
         _triggered = false;
       }
 
       if (!_triggered) {
        SplineFill spline(_revClock, _history);
        _data = spline.ref();
        _history = spline.History();
       }
 
        return;
      }
 
      virtual void printOn(std::ostream &o) const {
        o << "#  History = " << _history << std::endl;
        //  Write out the header
        o << std::setw(_fmtWidth)   << "RevClock"
          << std::setw(_fmtWidth+1) << "Applied\n";
 
        for (int i = 0 ; i < _data.dim() ; i++) {
          o << formatDbl(_revClock[i]) << " "
            << formatDbl(_data[i]) << std::endl;
        }
        return;
      }
 
  };
 
}     // namespace Isis
#endif