JRunsetups.hh

Go to the documentation of this file.

#ifndef __JDB_JRUNSETUPS__
#define __JDB_JRUNSETUPS__
 
#include <string>
#include <vector>
#include <map>
#include <algorithm>
 
#include "JDB/JRuns.hh"
#include "Jeep/JeepToolkit.hh"
 
 
/**
 * \author mdejong
 */
namespace JDATABASE {}
namespace JPP { using namespace JDATABASE; }
 
namespace JDATABASE {
 
  /**
   * Auxiliary data structure for run setup information.
   */
  struct JRunsetup_t {
    std::string name;
    float       value;
  };
  
  /**
   * Auxiliary class for run setup evaluation.
   *
   * The run number is mapped to a unique floating point value according the setup name.
   */
  struct JRunsetups :
    public std::map<int, JRunsetup_t>
  {
 
    static const char SEPARATOR            = '.';        //!< separator between tokens in setup name
    static const int  MAX_NUMBER_OF_SETUPS = 1000;       //!< maximal number of setups for a main category
 
 
    /**
     * Main run setup category.
     */
    enum JRuntype_t {
      CALIB       =   100,    //!< Calibration
      NANOCALIB   =   200,    //!< Nano-beacon calibration
      TEST        =   300,    //!< Test
      WRONG_TEST  =   400,    //!< Wrong test
      PHYS        =  1000,    //!< Physics
      OTHER       =    -1     //!< Other
    };
 
 
    /**
     * Get run setup type.
     *
     * \param  setup         run setup name
     * \return               type
     */
    static inline int getType(const std::string& setup) 
    {
      using namespace std;
      using namespace JPP;
 
      static std::map<std::string, int> buffer;
 
      if (buffer.empty()) {
 
#define MAKE_ENTRY(A) std::make_pair(getClassname(#A), A)
 
        buffer.insert(MAKE_ENTRY(CALIB));
        buffer.insert(MAKE_ENTRY(NANOCALIB));
        buffer.insert(MAKE_ENTRY(TEST));
        buffer.insert(MAKE_ENTRY(WRONG_TEST));
        buffer.insert(MAKE_ENTRY(PHYS));
        buffer.insert(MAKE_ENTRY(OTHER));
 
#undef MAKE_ENTRY
      }
 
      string key = setup;
 
      string::size_type pos = key.find(SEPARATOR);
 
      if (pos != string::npos) {
        key = key.substr(0,pos);
      }
 
      std::map<std::string, int>::const_iterator i = buffer.find(key);
 
      if (i != buffer.end())
        return i->second;
      else
        return OTHER;
    }
 
 
    /**
     * Put run parameters.
     *
     * \param  run           run number
     * \param  setup         run setup name
     */    
    void put(const int         run,
             const std::string setup)
    {
      using namespace std;
      using namespace JPP;
 
      const int       type   = getType(setup);
      vector<string>& buffer = data[type];
 
      vector<string>::iterator p = std::find(buffer.begin(), buffer.end(), setup);
 
      if (p == buffer.end()) {
 
        buffer.push_back(setup);
 
        p = buffer.rbegin().base();
      }
 
      const int index = distance(buffer.begin(),p) + 1;
 
      if (index >= MAX_NUMBER_OF_SETUPS) {
        cerr << "Index of " << setup << ' ' << index << " >= " << MAX_NUMBER_OF_SETUPS << endl;
      }
 
      if (type > 0) 
        (*this)[run]  =  { setup, type  +  (float) index / (float) MAX_NUMBER_OF_SETUPS };
      else
        (*this)[run]  =  { setup, type  -  (float) index / (float) MAX_NUMBER_OF_SETUPS };
    }
 
 
    /**
     * Put run parameters.
     *
     * \param  parameters    run parameters
     */    
    void put(const JRuns& parameters)
    {
      put(parameters.RUN, parameters.RUNSETUPNAME);
    }
 
 
    /**
     * Check if run setup is vailable.
     *
     * \param  run           run number
     * \return               true if available; else false
     */
    bool has(const int run) const
    {
      return this->find(run) != this->end();
    }
 
 
    /**
     * Get run setup value.
     *
     * \param  run           run number
     * \return               value
     */
    float get(const int run) const
    {
      const_iterator p = this->find(run);
 
      if (p != this->end())
        return p->second.value;
      else
        return 0.0;
    }
 
  protected:
    mutable std::map<int, std::vector<std::string> > data;   // run type -> run setup names
  };
}
 
#endif