RingerDiscriminatorWrapper.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
// $Id: RingerDiscriminatorWrapper.h 713527 2015-12-09 08:58:16Z wsfreund $
#ifndef RINGERSELECTORTOOLS_PROCEDURES_RINGERDISCRIMINATIONWRAPPER_H
#define RINGERSELECTORTOOLS_PROCEDURES_RINGERDISCRIMINATIONWRAPPER_H
 
#define RINGER_PROCEDURE_INCLUDE
#include "RingerProcedureWrapper.h"
#undef RINGER_PROCEDURE_INCLUDE
 
//#undef NDEBUG
 
#define RINGER_DISCRIMINATOR_WRAPPER_INCLUDE
// We are also dependent on the PreProcessorWrapper, but we want only to define
// the collection for now:
#include "RingerPreProcessorWrapper.h"
#undef RINGER_DISCRIMINATOR_WRAPPER_INCLUDE
 
#include "RingerSelectorTools/procedures/Normalizations.h"
#include "RingerSelectorTools/ExtraDescriptionPatterns.h"
#include <type_traits>
 
namespace Ringer {
 
template<>
class IRingerProcedureWrapper< Discrimination::IDiscriminator > :
  virtual public IRedirectMsgStream,
  virtual public IRingerProcedureWrapperBase
{
  public:
    typedef typename std::vector< IRingerProcedureWrapper* > WrapperCollection;
 
#ifndef RINGER_STANDALONE
 
    virtual void execute(
        const DepVarStruct &depVar,
        const xAOD::CaloRings *clrings,
        const TrackPatternsHolder *trackPat,
        std::vector<float> &output) const = 0;
 
    virtual void setRawConfCol(
        const xAOD::RingSetConf::RawConfCollection *crRawConfCol) = 0;
 
    virtual void getRawConfCol(
        const xAOD::RingSetConf::RawConfCollection *&crRawConfCol) const = 0;
 
    virtual SegmentationType getSegType() const = 0;
 
    virtual const Ringer::ExtraDescriptionPatterns& getExtraDescriptionPatterns() const = 0;
 
#endif
 
    virtual void execute(
        const DepVarStruct &depVar,
        const std::vector<float> &input,
        std::vector<float> &output) const = 0;
 
    virtual const char* name() const final override {
      return wrapName;
    }
 
    static constexpr const char* wrapName = "RingerDiscriminatorWrapper";
 
    virtual bool hasPP() const = 0;
 
    static void writeCol(const WrapperCollection &discrWrapperCol,
        const char *fileName);
 
    static void read(WrapperCollection &discrWrapperCol,
        const char* fileName);
 
  protected:
 
    IRingerProcedureWrapper(){;}
 
};
 
typedef IRingerProcedureWrapper< Discrimination::IDiscriminator >
  IDiscrWrapper;
 
typedef IDiscrWrapper::WrapperCollection IDiscrWrapperCollection;
 
template < class procedure_t,
  /*EtaDependency*/int etaDependency,
  /*EtDependency*/int etDependency,
  /*SegmentationType*/int segType>
class RingerProcedureWrapper<
  procedure_t,
  etaDependency,
  etDependency,
  segType,
  false,     // isPreProcessor
  true,      // isDiscriminator
  false> :   // isThreshold
    public IDiscrWrapper,
    public RedirectMsgStream
{
    static_assert(
        (std::is_base_of<VariableDependency,procedure_t>::value),
        "RingerProcedureWrapper procedure_t type must have IVariableDependecy inheritance.");
  public:
 
    //typedef typename RingerProcedureWrapper::template
    //    IRingerProcedureWrapper< Discrimination::IDiscriminator >
    //    wrapper_t;
 
    typedef typename std::vector<
        std::vector <
        std::vector < procedure_t* > >
      > DiscrDepProcCollection;
 
    typedef typename std::vector<
        std::vector< Ringer::PreProcessing::Norm::ExtraPatternsNorm* >
      > ExtraPatternsNormCollection;
 
 
    RingerProcedureWrapper(
        const DiscrDepProcCollection &discrDepCol):
      m_ppWrapperCol(IPreProcWrapperCollection(0)),
      m_discrCol(discrDepCol),
      m_discr(nullptr),
      m_rsRawConfCol(nullptr),
      m_nRings(0)
    {
      checkDiscrCol();
    }
 
    RingerProcedureWrapper(
        const IPreProcWrapperCollection &ppCol,
        const DiscrDepProcCollection &discrDepCol):
      m_ppWrapperCol(ppCol),
      m_discrCol(discrDepCol),
      m_discr(nullptr),
      m_rsRawConfCol(nullptr),
      m_nRings(0)
    {
      checkPPWrapperCol();
      checkDiscrCol();
    }
 
#ifndef RINGER_STANDALONE
 
    virtual void execute(
        const DepVarStruct &depVar,
        const xAOD::CaloRings *clrings,
        const TrackPatternsHolder *trackPat,
        std::vector<float> &output) const override final;
#endif
 
    virtual void execute(
        const DepVarStruct &depVar,
        const std::vector<float> &input,
        std::vector<float> &output) const override final;
 
#ifndef RINGER_STANDALONE
 
    virtual void setRawConfCol(
        const xAOD::RingSetConf::RawConfCollection *crRawConfCol)
      final override
    {
      for ( auto &ppWrapper : m_ppWrapperCol ) {
        ppWrapper->setRawConfCol( crRawConfCol );
      }
      m_rsRawConfCol = crRawConfCol;
      m_nRings = xAOD::RingSetConf::totalNumberOfRings( *crRawConfCol );
    }
 
    virtual void getRawConfCol(
        const xAOD::RingSetConf::RawConfCollection *&crRawConfCol) const override final
    {
      crRawConfCol = m_rsRawConfCol;
    }
#endif
 
    virtual const Ringer::ExtraDescriptionPatterns& getExtraDescriptionPatterns() const override final
    {
      return m_extraDescriptionPatterns;
    }
 
    void setExtraDescriptionPatterns( const Ringer::ExtraDescriptionPatterns &extraPat )
    {
      m_extraDescriptionPatterns = extraPat;
    }
 
    ExtraPatternsNormCollection& getExtraDescriptionNorms() { return m_extraDescriptionNorms; }
 
    void setExtraDescriptionNorms( const ExtraPatternsNormCollection& extraNorms ){
      m_extraDescriptionNorms = extraNorms;
      checkExtraPatNorm();
    }
 
    virtual SegmentationType getSegType() const override final
    {
      return static_cast<SegmentationType>(segType);
    }
 
    virtual bool empty() const override { return m_discrCol.empty();}
 
    virtual bool hasPP() const override { return !m_ppWrapperCol.empty();}
 
    virtual void setMsgStream(MsgStream *msg) const override;
 
    void write(TDirectory *baseDir, const char *idxStr = "") const override final;
 
    EtaDependency etaDep() const override final
    {
      return static_cast<EtaDependency>(etaDependency);
    }
 
    EtDependency etDep() const override final
    {
      return static_cast<EtDependency>(etDependency);
    }
 
    void releaseMemory() override final;
 
    static std::string staticFullName();
 
    void print(MSG::Level lvl = MSG::DEBUG) const override final;
 
    std::string fullName() const override final;
 
    static RingerProcedureWrapper* read(TDirectory *configDir,
        unsigned version);
 
  private:
 
    void checkPPWrapperCol() const;
    void checkExtraPatNorm() const;
    void checkDiscrCol() const;
 
    const IPreProcWrapperCollection m_ppWrapperCol;
    DiscrDepProcCollection m_discrCol;
    ExtraPatternsNormCollection m_extraDescriptionNorms;
    ExtraDescriptionPatterns m_extraDescriptionPatterns;
    procedure_t *m_discr;
 
#ifndef RINGER_STANDALONE
    const xAOD::RingSetConf::RawConfCollection *m_rsRawConfCol;
    unsigned m_nRings;
#endif
 
};
 
} // namespace Ringer
 
#endif // RINGERSELECTORTOOLS_PROCEDURES_RINGERDISCRIMINATIONWRAPPER_H
 
#ifndef INCLUDE_HEADER_ONLY // Use to avoid circular includes
#include "RingerDiscriminatorWrapper.icc"
#endif // INCLUDE_HEADER_ONLY