JPMTThreshold.hh

Go to the documentation of this file.

#ifndef __JDB_JPMTTHRESHOLD__
#define __JDB_JPMTTHRESHOLD__

#include <ostream>
#include <sstream>
#include <string>
#include <map>

#include "JDB/JDB.hh"
#include "JDB/JSelector.hh"
#include "JDB/JSelectorSupportkit.hh"
#include "JDB/JDBToolkit.hh"
#include "JDB/JRuns.hh"
#include "JDB/JAllParams.hh"
#include "JDB/JRunsetupParams.hh"
#include "JDB/JUPI_t.hh"


/**
 * \author mdejong
 */
namespace JDATABASE {}
namespace JPP { using namespace JDATABASE; }

namespace JDATABASE {

  const char* const OPTICS_t         =  "OPTICS";          //!< sub-system of PMT
  const char* const PMT_THRESHOLD_t  =  "PMT_THRESHOLD";   //!< name of PMT threshold


  /**
   * Auxiliary class for PMT thresholds.
   */
  class JPMTThreshold :
    public std::map<std::string, int>
  {
  public:
    /**
     * Type definition of PMT threshold.
     */
    struct threshold_type {
      bool  is_default;      //!< true by default; else false
      int   value;           //!< value [DAC]
    };


    /**
     * Default constructor.
     */
    JPMTThreshold()
    {}


    /**
     * Constructor.
     *
     * \param  id             detector identifier
     * \param  run            run number
     */
    JPMTThreshold(const int id, const int run)
    {
      configure(id, run);
    }


    /**
     * Configure PMT thresholds for given detector and run.
     *
     * \param  id             detector identifier
     * \param  run            run number
     */
    void configure(const int id, const int run)
    {
      using namespace std;
      using namespace JPP;

      this->clear();

      string     rs_oid;
      JAllParams upars;

      {
        ResultSet& rs = getResultSet(getTable<JRuns>(), getSelector<JRuns>(id, run));

        JRuns parameters;

        if (rs >> parameters) {
          rs_oid = parameters.RUNSETUPID;
        }

        rs.Close();
      }
      {
        ResultSet& rs = getResultSet(getTable<JAllParams>(), getSelector<JAllParams>(OPTICS_t));

        for (JAllParams parameters; rs >> parameters; ) {
          if (parameters.NAME == PMT_THRESHOLD_t) {
            upars = parameters;
          }
        }

        rs.Close();
      }
      {
        ResultSet& rs = getResultSet(getTable<JRunsetupParams>(), getSelector<JRunsetupParams>(getDetector(id), rs_oid));

        for (JRunsetupParams parameters; rs >> parameters; ) {
          if (parameters.PAR_OID == upars.OID && parameters.ISINPUT == 'Y') {
            if (parameters.VALUE != "") {
              istringstream(parameters.VALUE) >> (*this)[parameters.UPIFILTER];
            }
          }
        }
      
        rs.Close();
      }
    }


    /**
     * Get PMT threshold for given %UPI of PMT.
     *
     * \param  upi            %UPI
     * \return                PMT threshold
     */
    threshold_type operator()(const JUPI_t& upi) const
    {
      const_iterator p = this->find(upi.toString());
  
      const bool is_default = (p == this->end());

      if (is_default) {

        std::ostringstream os;

        os << upi.getPBS() 
           << JUPI_t::SEPARATOR 
           << upi.getVariant() 
           << JUPI_t::SEPARATOR 
           << JUPI_t::DOT;

        p = this->find(os.str());
      }

      if (p != this->end())
        return { is_default, p->second };
      else
        THROW(JDatabaseException, "Invalid UPI " << upi);
    }

    
    /**
     * Write PMT thresholds to output stream.
     *
     * \param  out            output stream
     * \param  object         PMT thresholds
     * \return                output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JPMTThreshold& object)
    {
      using namespace std;

      for (JPMTThreshold::const_iterator i = object.begin(); i != object.end(); ++i) {
        out << left << setw(32) << i->first << ' ' << right << setw(3) << i->second << endl;
      }

      return out;
    }
  };
}

#endif