BPhysBlindingTool.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
 
/*
  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
*/

 
// $Id: $
#ifndef BPHYSTOOLS_BPHYSBLINDINGTOOL_H
#define BPHYSTOOLS_BPHYSBLINDINGTOOL_H
 
// Framework includes
#include "AsgTools/AsgTool.h"
 
// System include(s):
#include <memory>
 
// Local includes
#include "BPhysTools/IBPhysBlindingTool.h"
#include "BPhysTools/SimpleEncrypter.h"
 
 
// EDM includes
#include "xAODTracking/VertexAuxContainer.h"
 
namespace xAOD {
  class BPhysBlindingTool :
    public asg::AsgTool, virtual public xAOD::IBPhysBlindingTool {
    
    ASG_TOOL_CLASS( BPhysBlindingTool, xAOD::IBPhysBlindingTool )
    
   public:
    BPhysBlindingTool(const std::string& name = "BPhysBlindingTool");
    virtual StatusCode initialize() override;

    virtual StatusCode finalize() override;

    virtual float doBlind(const float& val) override;

    virtual float doUnblind(const float& val) override;

    virtual float doBlind(const float& val,
                          const bool&  negativeSign,
                          const float& offset,
                          const float& factor) override;

    virtual float doUnblind(const float& val,
                            const bool&  negativeSign,
                            const float& offset,
                            const float& factor) override;

    virtual StatusCode doBlind() override;

    virtual StatusCode doUnblind() override;
 
  protected:
    virtual StatusCode doBlindingAction(bool unblind=false);
    virtual bool pass(const SG::AuxElement& em, std::string hypo);
    
    virtual std::vector<std::string> getTokens(std::string input,
                                               std::string seperators);
    virtual std::string vecToString(const std::vector<float>& v) const;
    virtual std::string vecToString(const std::vector<bool>& v) const;
    virtual StatusCode cacheEvent();
    
  protected:      
    std::string m_vertexContainerName;
    std::string m_varToBlindNames;
    std::string m_blindingFlag;
    std::vector<float> m_vOffsets;
    std::vector<float> m_vFactors;
    std::vector<bool> m_vNegSigns;
    std::string m_blindKey;
    std::string m_unblindKey;

    xAOD::VertexContainer*    m_vtxContainer;    
    xAOD::VertexAuxContainer* m_vtxAuxContainer; 

    int m_cachedRun;    
    int m_cachedEvent;  

    long m_eventsForBlindingSeen;       
    long m_candidatesForBlindingSeen;   
    long m_eventsForUnblindingSeen;     
    long m_candidatesForUnblindingSeen; 
    long m_eventsBlinded;               
    long m_candidatesBlinded;           
    long m_eventsUnblinded;             
    long m_candidatesUnblinded;         
  private:
    std::vector<std::string> m_vVarNames; 

    SimpleEncrypter m_senc; 
    
  }; // class BPhysBlindingTool
 
} // namespace xAOD
 
#endif // BPHYSTOOLS_BPHYSBLINDINGTOOL_H