EventFeature.h

Go to the documentation of this file.

// -*- c++ -*-
 
/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef EVENTSHAPEEVENT_EVENTFEATURE_H
#define EVENTSHAPEEVENT_EVENTFEATURE_H
 
//#include "EventShapeEvent/EventShapes.h"
 
#include <string>
#include <vector>
#include <algorithm>
#include <map>
 
class EventFeature
{
public:
 
  enum FeatureType 
    { ETDENSITY             = 0x1000, 
      ETDENSITY_JETAREA     = 0x1100,  
      ETDENSITY_JETAREA_ETA = 0x1101,  
      ETDENSITY_ETA_WINDOWS = 0x1201, 
      ETDENSITY_USER    = 0x0010,     
      UNKNOWN           = 0x0000,     
      DEFAULT           = 0xffff      
  };
 
  enum FeatureStructureMask { NDATAWORDS  = 0x0000007f, /*<! Mask for number of
                              data words/block (max 
                              accomodation 128)*/
                  NDATABLOCKS = 0x00003f80, /*<! Mask for number of
                              data blocks (max 
                              accommodation 128)*/
                  TAGBITS     = 0x0000c000, /*<! Mask for additional
                              tag bits (2 bits)*/
                  MASKLENGTH  = 0x0000ffff, /*<! Mask for total
                              used bit range (16)*/
                  BITSHIFT    = 0x00000007 }; /*<! Shift step */    
 
  EventFeature();
  EventFeature(FeatureType                type,
           const std::string&         tag,
           const std::vector<double>& dataList);
  EventFeature(FeatureType                type,
           const std::string&         tag,
           unsigned int               dataStructure,
           const std::vector<double>& dataList);
  EventFeature(FeatureType                type,
           const std::string&         tag,
           unsigned int               dataStructure);
  EventFeature(const EventFeature& feature);
 
  virtual ~EventFeature();
 
  EventFeature& operator=(const EventFeature& feature);
 
  const std::string& tag() const;
  FeatureType type() const;
  unsigned int featureStructure() const;
  size_t numberDataBlocks();
  size_t numberDataWords()  const;
  const std::vector<double>& dataList() const;
  std::vector<double>& dataList();
 
  bool dataBlock(size_t blockIdx,std::vector<double>& data);
 
  void setTag(const std::string& tag);
  void setType(FeatureType type);
  void setNumberDataBlocks(size_t nBlocks);
  void setNumberDataWords(size_t nWords);
 
  void setDataList(const std::vector<double>& data);
  bool setDataBlock(size_t blockIdx,const std::vector<double>& data,
            bool replace=true);
  bool addDataBlock(const std::vector<double>& data);
 
  // /*! @brief Binned scalar data model 
  //  *
  //  *  @param[in] lmin minimum 
  //  */
  // void setBinnedData(double lmin,double lmax,double data);
 
  static FeatureType featureType(const std::string& typeTag);
  static FeatureType featureType();
  static const std::string& featureTag(FeatureType type);
  static const std::string& featureTag();
 
  unsigned int buildFeatureStructure();
 
private:
 
  typedef std::pair<size_t,size_t> index_t;
 
  // enum FeatureStructure 
  //   { SCALAR               = 0x1000,
  //     SCALAR_BINNED_SPARSE = 0x1001,
  //     SCALAR_BINNED_CONT   = 0x1002,
  //     VECTOR               = 0x0100,
  //     VECTOR_BINNED_SPARSE = 0x0101,
  //     VECTOR_BINNED_CONT   = 0x0102
  //   };
  //
  // b00000000000000000000000001111111  = 0x007f (0...127) N_datawords
  // b00000000000000000011111110000000  = 0x03f8 (0...127) N_datablocks
  // b0000000000000000________________  = 16 bits
  //
 
  FeatureType          m_type;
  std::string          m_tag;
  unsigned int         m_dataWords;
  unsigned int m_dataBlocks;
  unsigned int m_featureStructure;
  std::vector<double>  m_dataList;
 
  bool m_structureFixed;
 
  static const std::map<FeatureType,std::string> m_featureTags;
 
  void setFeatureStructure(bool updateCache=false);
 
  bool insertDataBlock(size_t startIdx,size_t endIdx,
               const std::vector<double>& data); 
  bool addDataBlock(size_t startIdx,size_t endIdx,const std::vector<double>& 
            data);
 
  bool indexRange(size_t startIdx,index_t& idx);
};
 
// Three simple structural patterns are provided by 
//  *  the data object, for convenience: 
//  *  
//  *  - type <tt>ETDENSITY_JETAREA</tt> implied structure type <tt>SCALAR</tt>
//  *    - stores one number/event (global event transverse energy density
//  *    - uses @c m_data cache, @c m_dataList is empty
//  *  - type <tt>ETDENSITY_JETAREA_ETA</tt> implied structure 
//  *    <tt>SCALAR_BINNED</tt> 
//  *  - type <tt>ETDENSITY_ETA_WINDOWS</tt> implied structure 
//  *    <tt>FUNCTION_PARAMETERS</tt>
//  */
 
inline const std::string& EventFeature::tag() const
{ return m_tag; }
 
inline EventFeature::FeatureType EventFeature::type() const
{ return m_type; }
 
inline unsigned int EventFeature::featureStructure() const 
{ return m_featureStructure; }
 
inline const std::vector<double>& EventFeature::dataList() const
{ return m_dataList; }
 
inline std::vector<double>& EventFeature::dataList()
{ return m_dataList; }
 
inline void EventFeature::setType(FeatureType type)
{ m_type = type; }
 
inline void EventFeature::setTag(const std::string& tag) 
{ m_tag = tag; }
 
inline void EventFeature::setDataList(const std::vector<double>& data)
{ 
  m_dataList.resize(data.size()); 
  std::copy(data.begin(),data.end(),m_dataList.begin());
  this->setFeatureStructure();
}
 
inline size_t EventFeature::numberDataWords() const
{ return m_dataWords; }
 
inline size_t EventFeature::numberDataBlocks()
{ this->setFeatureStructure(); return m_dataBlocks; }
#endif