Normalizations.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
// $Id: Normalizations.h 704615 2015-10-29 18:50:12Z wsfreund $
#ifndef RINGERSELECTORTOOLS_PROCEDURES_NORMALIZATIONS_H
#define RINGERSELECTORTOOLS_PROCEDURES_NORMALIZATIONS_H
 
//#undef NDEBUG
 
// STL includes:
#include <vector>
#include <stdexcept>
#include <string>
#include <cmath>
#include <iostream>
 
// Gaudi includes:
#if !defined(XAOD_STANDALONE) && !defined(RINGER_STANDALONE)
# include "GaudiKernel/SystemOfUnits.h"
#endif
 
 
// Local includes:
#include "RingerSelectorTools/procedures/IRingerProcedure.h"
#include "RingerSelectorTools/tools/RingerIOVarDepObj.h"
#include "RingerSelectorTools/tools/VariableDependency.h"

namespace Ringer
{

namespace PreProcessing
{

namespace Norm {

class Norm1 : virtual public IPreProcessor,
              public RedirectMsgStream
{
 
  RINGER_IO_VARDEP_BASE_NOMEMBER( Norm1 )
 
  public:
    Norm1(){;}
 
    virtual void execute(std::vector<float> &inputSpace) const final override;
 
  private:
    Norm1(Norm1&&);

    //ClassDef(Norm1,1)
};
 
RINGER_DEFINE_PROCEDURE_DEFAULT_METHODS( Norm1 )
 
class Norm2 : public virtual IPreProcessor,
              public RedirectMsgStream
{
 
  RINGER_IO_VARDEP_BASE_NOMEMBER( Norm2 )
 
  public:
    Norm2(){;}
 
    virtual void execute(std::vector<float> &inputSpace) const final override;
 
  private:
    Norm2(Norm2&&);

    //ClassDef(Norm2,0)
};
 
RINGER_DEFINE_PROCEDURE_DEFAULT_METHODS( Norm2 )
 
class Sqrt : public virtual IPreProcessor,
             public RedirectMsgStream
{
 
  RINGER_IO_VARDEP_BASE_NOMEMBER( Sqrt )
 
  public:
    Sqrt(){};
 
    virtual void execute(std::vector<float> &inputSpace) const final override;
 
  private:
    Sqrt(Sqrt&&);

    //ClassDef(Sqrt,0)
};
 
RINGER_DEFINE_PROCEDURE_DEFAULT_METHODS( Sqrt )
 
class ConstantValue : public virtual IPreProcessor,
                      public RedirectMsgStream
{
 
  RINGER_IO_VARDEP_BASE( ConstantValue )
 
  public:
 
    ConstantValue()
      : m_constantInv(1){;}
    ConstantValue(
        const float constantValue)
      : m_constantInv(1/constantValue)
    {
      if (!m_constantInv) {
        throw std::runtime_error(
            std::string("Initialized ConstantValueVarDep norm with zero constant"));
      }
    }
 
    virtual void execute(std::vector<float> &inputSpace) const final override;
 
  private:
    ConstantValue(ConstantValue&&);
    float m_constantInv;

    //ClassDef(ConstantValue,0)
};
 
RINGER_DEFINE_PROCEDURE_DEFAULT_METHODS( ConstantValue )
 
class Sequential : public virtual IPreProcessor,
                   public RedirectMsgStream
{
  RINGER_IO_VARDEP_BASE( Sequential )
 
  public:
 
    Sequential()
      : m_stopEnergy(0),
        m_energyThres(0){;}
 
    Sequential(
        const float stopEnergy,
        const float energyThres)
      : m_stopEnergy(stopEnergy),
        m_energyThres(energyThres){;}
 
    virtual void execute(std::vector<float> &inputSpace) const final override;
 
  private:
    Sequential(Sequential&&);
    float m_stopEnergy;
    float m_energyThres;

    //ClassDef(Sequential,0)
};
 
RINGER_DEFINE_PROCEDURE_DEFAULT_METHODS( Sequential )
 
class Spherization : public virtual IPreProcessor,
                     public RedirectMsgStream
{
  RINGER_IO_VARDEP_BASE( Spherization )
 
  public:
 
    Spherization()
        : m_dim(0){;}
 
    Spherization(
        const std::vector<float> &dataMean,
        const std::vector<float> &dataStd);
 
    virtual void execute(std::vector<float> &inputSpace) const final override;
 
  private:
    Spherization(Spherization&&);
    std::vector<float> m_deslocation;
    std::vector<float> m_normInv;
    size_t m_dim;

    //ClassDef(Spherization,0)
};
 
RINGER_DEFINE_PROCEDURE_DEFAULT_METHODS( Spherization )
 
class MinMax : public virtual IPreProcessor,
               public RedirectMsgStream
{
  RINGER_IO_VARDEP_BASE( MinMax )
 
  public:
    MinMax()
      : m_dim(0){;}
 
    MinMax(
        const std::vector<float>& min,
        const std::vector<float>& max);
 
    virtual void execute(std::vector<float> &inputSpace) const final override;
 
  private:
    MinMax(MinMax&&);
    std::vector<float> m_deslocation;
    std::vector<float> m_normInv;
    size_t m_dim;

    //ClassDef(MinMax,0)
};
RINGER_DEFINE_PROCEDURE_DEFAULT_METHODS( MinMax )
 

class ExtraPatternsNorm : public virtual IPreProcessor,
                          public RedirectMsgStream,
                          public RingerIOVarDepObj < ExtraPatternsNorm >
{
 
  RINGER_IO_VARDEP_BASE( ExtraPatternsNorm )
 
  public:
 
    ExtraPatternsNorm( const float etMin = 0., const float etMax = 1.
                     , const float etaMin = 0., const float etaMax = 1.
                     , const float pileupEstimationMax = 1. ):
                     m_etMin{etMin}, m_etMax{etMax},
                     m_etaMin{etaMin}, m_etaMax{etaMax},
                     m_pileupEstimationMax{pileupEstimationMax}
                     {;}

    ExtraPatternsNorm& setEtNormParams( float min, float max ) { m_etMin = min; m_etMax = max; return *this; }

    ExtraPatternsNorm& setEtaNormParams( float min, float max ) { m_etaMin = min; m_etaMax = max; return *this; }

    ExtraPatternsNorm& setPileupEstimationParams( float max ) { m_pileupEstimationMax = max; return *this; }

    float normEta(float eta) const;

    float normEt(float et) const;

    float normPileupEstimation(float pileupEstimation) const;
 
 
  private:
    float m_etMin, m_etMax;
    float m_etaMin, m_etaMax;
    float m_pileupEstimationMax;

    virtual void execute(std::vector<float> &inputSpace) const final override;
    //ClassDef(ExtraDescriptionPatterns,0)
};
RINGER_DEFINE_PROCEDURE_DEFAULT_METHODS( ExtraPatternsNorm )
 

 


class Norm1VarDep : virtual public IPreProcessorVarDep,
                    public RingerIOVarDepObj < Norm1VarDep >,
                    public Norm1
{
  RINGER_IO_VARDEP_OBJ(Norm1VarDep, Norm1)
 
  public:
 
    Norm1VarDep(){;}

    //ClassDef(Norm1VarDep,1)
};

class Norm2VarDep : virtual public IPreProcessorVarDep,
                    public RingerIOVarDepObj < Norm2VarDep >,
                    public Norm2
{
 
  RINGER_IO_VARDEP_OBJ(Norm2VarDep, Norm2)
 
  public:
 
    Norm2VarDep(){;}

    //ClassDef(Norm2VarDep,1)
};

class SqrtVarDep : virtual public IPreProcessorVarDep,
                   public RingerIOVarDepObj < SqrtVarDep >,
                   public Sqrt
{
 
  RINGER_IO_VARDEP_OBJ(SqrtVarDep, Sqrt)
 
  public:
 
    SqrtVarDep(){;}

    //ClassDef(SqrtVarDep,1)
};

class ConstantValueVarDep : virtual public IPreProcessorVarDep,
                            public RingerIOVarDepObj < ConstantValueVarDep >,
                            public ConstantValue
{
 
  RINGER_IO_VARDEP_OBJ(ConstantValueVarDep, ConstantValue)
 
  public:
 
    ConstantValueVarDep(){;}
 
    ConstantValueVarDep(const float constantValue)
      : ConstantValue(constantValue){;}

    //ClassDef(ConstantValueVarDep,1)
};

class MevToGevVarDep: virtual public IPreProcessorVarDep,
                      public RingerIOVarDepObj < MevToGevVarDep >,
                      public ConstantValue
{
 
  RINGER_IO_VARDEP_OBJ(MevToGevVarDep, ConstantValue)
 
  public:
 
    // Normalization is the inverse of the Units transformation (MeV -> GeV)
#if !defined(XAOD_STANDALONE) && !defined(RINGER_STANDALONE)
    MevToGevVarDep()
      : ConstantValue( (Gaudi::Units::GeV) / (Gaudi::Units::MeV) ){;}
#else // We suppose that we are working with MeV as reference unit.
    MevToGevVarDep()
      : ConstantValue( 1000 / 1 ){;}
#endif

    //ClassDef(MevToGevVarDep,1)
};

class SequentialVarDep : virtual public IPreProcessorVarDep,
                         public RingerIOVarDepObj < SequentialVarDep >,
                         public Sequential
{
 
  RINGER_IO_VARDEP_OBJ(SequentialVarDep, Sequential)
 
  public:
 
    SequentialVarDep(){;}
 
    SequentialVarDep(
        const float stopEnergy,
        const float energyThres):
      Sequential(stopEnergy,energyThres){;}

    //ClassDef(SequentialVarDep,1)
};

class SpherizationVarDep : virtual public IPreProcessorVarDep,
                           public RingerIOVarDepObj < SpherizationVarDep >,
                           public Spherization
{
 
  RINGER_IO_VARDEP_OBJ(SpherizationVarDep, Spherization)
 
  public:
 
    SpherizationVarDep(){;}
 
    SpherizationVarDep(
        const std::vector<float> &dataMean,
        const std::vector<float> &dataStd):
      Spherization(dataMean,dataStd){;}

    //ClassDef(SpherizationVarDep,1)
};

class MinMaxVarDep : virtual public IPreProcessorVarDep,
                     public RingerIOVarDepObj < MinMaxVarDep >,
                     public MinMax
{
  RINGER_IO_VARDEP_OBJ(MinMaxVarDep, MinMax)
 
  public:
 
    MinMaxVarDep(){;}
 
    MinMaxVarDep(
        const std::vector<float> &min,
        const std::vector<float> &max):
      MinMax(min,max){;}

    //ClassDef(MinMaxVarDep,1)
};

class ExtraPatternsNormVarDep : virtual public IPreProcessorVarDep,
                                public RingerIOVarDepObj < ExtraPatternsNormVarDep >,
                                public ExtraPatternsNorm
{
  RINGER_IO_VARDEP_OBJ(ExtraPatternsNormVarDep, ExtraPatternsNorm)
 
};

 
} // Norm namespace;
} // Pre-processing namespace;
} // Ringer namespace
 
 
#endif // RINGERSELECTORTOOLS_PROCEDURES_NORMALIZATIONS_H
 
// Include inline and template declarations:
#ifndef INCLUDE_HEADER_ONLY // Protect against circular includes
#include "Normalizations.icc"
#endif // INCLUDE_HEADER_ONLY