RingerPreProcessorWrapper.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
// $Id: RingerPreProcessorWrapper.h 704615 2015-10-29 18:50:12Z wsfreund $
#ifndef RINGERSELECTORTOOLS_PROCEDURES_RINGERPREPROCESSORWRAPPER_H
#define RINGERSELECTORTOOLS_PROCEDURES_RINGERPREPROCESSORWRAPPER_H
 
#define RINGER_PROCEDURE_INCLUDE
#include "RingerProcedureWrapper.h"
#undef RINGER_PROCEDURE_INCLUDE
 
#include <type_traits>
 
//#undef NDEBUG

namespace Ringer {

template<>
class IRingerProcedureWrapper< PreProcessing::IPreProcessor > :
  virtual public IRedirectMsgStream,
  virtual public IRingerProcedureWrapperBase
{
  public:
    typedef typename std::vector< IRingerProcedureWrapper* > WrapperCollection;
 
#ifndef RINGER_STANDALONE
    virtual void applyPreProcessing(
        const DepVarStruct &depVar,
        const xAOD::CaloRings *clrings,
        const TrackPatternsHolder *trackPat,
        std::vector<float> &transformVec) 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;
#endif

    virtual void applyPreProcessing(
        const DepVarStruct &depVar,
        std::vector<float> &transformVec) const = 0;

    virtual const char* name() const final override {
      return wrapName;
    }

    static void writeCol(const WrapperCollection &ppWrapperCol,
        TDirectory *configDir);

    static void read(WrapperCollection &ppWrapperCol,
        TDirectory *configDir,
        unsigned version);
 
    static constexpr const char* wrapName = "RingerPreProcessorWrapper";

    virtual ~IRingerProcedureWrapper(){;}
 
  protected:
    IRingerProcedureWrapper(){;}
 
};

typedef IRingerProcedureWrapper< PreProcessing::IPreProcessor > IPreProcWrapper;
typedef IPreProcWrapper::WrapperCollection IPreProcWrapperCollection;

template < class procedure_t,
  /*EtaDependency*/int etaDependency,
  /*EtDependency*/int etDependency,
  /*SegmentationType*/int segType>
class RingerProcedureWrapper<
  procedure_t,
  etaDependency,
  etDependency,
  segType,
  true,    // isPreProcessor
  false,   // isDiscriminator
  false> : // isThreshold
    public IPreProcWrapper,
    public RedirectMsgStream
{
    static_assert(
        (std::is_base_of<VariableDependency,procedure_t>::value),
        "RingerProcedureWrapper procedure_t type must have IVariableDependecy inheritance.");
  public:

    typedef typename std::vector <
        std::vector <
        std::vector < procedure_t* > >
      > PPDepProcCollection;


    RingerProcedureWrapper(
        const PPDepProcCollection &ppDepCol):
      m_ppCol(ppDepCol),
      m_pp(nullptr),
      m_rsRawConfCol(nullptr),
      m_nRings(0)
    {
      checkPPCol();
      m_pp = m_ppCol[0][0][0];
    }


#ifndef RINGER_STANDALONE
    virtual void applyPreProcessing(
        const DepVarStruct &depVar,
        const xAOD::CaloRings *clrings,
        const TrackPatternsHolder *trackPat,
        std::vector<float> &transformVec) const final override;
 
#endif

    virtual void applyPreProcessing(
        const DepVarStruct &depVar,
        std::vector<float> &transformVec) const final override;

#ifndef RINGER_STANDALONE
    virtual void setRawConfCol(
        const xAOD::RingSetConf::RawConfCollection *crRawConfCol) final override
    {
      m_rsRawConfCol = crRawConfCol;
      m_nRings = xAOD::RingSetConf::totalNumberOfRings( *crRawConfCol );
    }

    virtual void getRawConfCol(
        const xAOD::RingSetConf::RawConfCollection *&crRawConfCol) const final override
    {
      crRawConfCol = m_rsRawConfCol;
    }
#endif

    virtual SegmentationType getSegType() const final override
    {
      return static_cast<SegmentationType>(segType);
    }

    virtual bool empty() const final override
    {
      return m_ppCol.empty();
    }

    EtaDependency etaDep() const override final
    {
      return static_cast<EtaDependency>(etaDependency);
    }

    EtDependency etDep() const override final
    {
      return static_cast<EtDependency>(etDependency);
    }

    void releaseMemory() override final;
 

    virtual void setMsgStream(MsgStream *msg) const override final;

    static std::string staticFullName();

    std::string fullName() const override final;

    void print(MSG::Level lvl = MSG::DEBUG) const override final;

    void write(TDirectory *baseDir, const char *idxStr = "") const override final;

    static RingerProcedureWrapper* read(TDirectory *configDir,
        unsigned version);
 
  private:

    void checkPPCol();

    PPDepProcCollection m_ppCol;
    procedure_t *m_pp;
 
#ifndef RINGER_STANDALONE
    const xAOD::RingSetConf::RawConfCollection *m_rsRawConfCol;
    unsigned m_nRings;
#endif
 
};
 
} // namespace Ringer
 
#endif // RINGERSELECTORTOOLS_PROCEDURES_RINGERPREPROCESSORWRAPPER_H
 
#ifndef INCLUDE_HEADER_ONLY // Use to avoid circular includes
#ifndef RINGER_DISCRIMINATOR_WRAPPER_INCLUDE
#include "RingerPreProcessorWrapper.icc"
#endif // RINGER_DISCRIMINATOR_WRAPPER_INCLUDE
#endif // INCLUDE_HEADER_ONLY