#ifndef EWANALYSISTOOLS_EWTOOLBASE_H
 #define EWANALYSISTOOLS_EWTOOLBASE_H
 
 #ifndef EWPA_STANDALONE
 // Athena include(s):
 #include "GaudiKernel/ISvcLocator.h"
 #include "StoreGate/StoreGateSvc.h"
 #endif
 
 // EWPA includes
 #include "EWCore/EventLibrary.h"
 
 // ROOT includes
 #include "TFile.h"
 #include "TH1F.h"
 #include "TH2F.h"
 #include "TH3F.h"
 #include "TProfile.h"
 #include "TTree.h"
 #include "TCanvas.h"
 #include "TMath.h"
 #include "TMarker.h"
 #include "TLine.h"
 #include "TPave.h"
 #include "TLatex.h"
 #include "TLegend.h"
 #include "TPaveText.h"
 #include "TText.h"
 #include "TF1.h"
 
 /**
  * The EWToolBase class.
  * This class is designed as base class for all analysis tools in EWPA.
  */
 
 class EWToolBase {
   
  public:
   
   /**
    * Constructor
    * @param[in] source Name of analysis class, to be displayed in log messages
    * passed to EWMessage constructor
    */
   EWToolBase(std::string name="EWToolBase");
   virtual ~EWToolBase();
   
   void declareProperty(std::string name, std::string& val) 
     {m_stringProperty.insert(std::pair<std::string, std::string*>(name,&val));}
   void declareProperty(std::string name, int& val)         
     {m_intProperty.insert(std::pair<std::string, int*>(name,&val));}
   void declareProperty(std::string name, float& val)       
     {m_floatProperty.insert(std::pair<std::string, float*>(name,&val));}
   void declareProperty(std::string name, double& val)       
     {m_doubleProperty.insert(std::pair<std::string, double*>(name,&val));}
   void declareProperty(std::string name, bool& val)        
     {m_boolProperty.insert(std::pair<std::string, bool*>(name,&val));}
   void declareProperty(std::string name, std::vector<int>& val) 
     {m_intVecProperty.insert(std::pair<std::string, std::vector<int>*>(name,&val));}
   void declareProperty(std::string name, std::vector<float>& val) 
     {m_floatVecProperty.insert(std::pair<std::string, std::vector<float>*>(name,&val));}
   void declareProperty(std::string name, std::vector<double>& val) 
     {m_doubleVecProperty.insert(std::pair<std::string, std::vector<double>*>(name,&val));}
   void declareProperty(std::string name, std::vector<bool>& val) 
     {m_boolVecProperty.insert(std::pair<std::string, std::vector<bool>*>(name,&val));}
   void declareProperty(std::string name, std::vector<std::string>& val) 
     {m_stringVecProperty.insert(std::pair<std::string, std::vector<std::string>*>(name,&val));}
 
   void getProperty(std::map<std::string, std::string*>& prop) {prop = m_stringProperty;}
   void getProperty(std::map<std::string, int*>& prop)         {prop = m_intProperty;}
   void getProperty(std::map<std::string, float*>& prop)       {prop = m_floatProperty;}
   void getProperty(std::map<std::string, double*>& prop)       {prop = m_doubleProperty;}
   void getProperty(std::map<std::string, bool*>& prop)        {prop = m_boolProperty;}
   void getProperty(std::map<std::string, std::vector<int>*>& prop)   {prop = m_intVecProperty;}
   void getProperty(std::map<std::string, std::vector<float>*>& prop) {prop = m_floatVecProperty;}
   void getProperty(std::map<std::string, std::vector<double>*>& prop) {prop = m_doubleVecProperty;}
   void getProperty(std::map<std::string, std::vector<bool>*>& prop)  {prop = m_boolVecProperty;}
   void getProperty(std::map<std::string, std::vector<std::string>*>& prop) {prop = m_stringVecProperty;}
 
   virtual StatusCode initialize();       
   virtual StatusCode execute(EventLibrary* evtLib);
   virtual StatusCode finalize()          {return StatusCode::SUCCESS;} //!< pure virtual finalize
 
   /**
    * return the name of the dual tool.
    * @return m_name name of the dual tool, used in log messages 
    */
   std::string name() {return m_name;}
 
   /**
    * set the name of the dual tool.
    * @param[in] name name of the dual tool, used in log messages 
    */
   void setName(std::string name);
   
   /**
    * set the pointer to the transient events store in ROOT (the ARA tree).
    * @param[in] araGate name of the pointer to the ARA tree
    */
   void setAraGate(TTree* araGate) {m_araGate = araGate;}
 
   /**
    * Print the ATLAS label on the plot
    * @param[in] x,y coordinates of the label
    * @param[in] color (optional) color
    * @param[in] tsize size of the label
    */
   void ATLAS_LABEL(double x, double y, double tsize, int color);
 
   /**
    * Print text label on the plot
    * @param[in] x,y coordinates of the label
    * @param[in] color (optional) color
    * @param[in] text text of the label
    * @param[in] tsize size of the label
    */
   void myText(double x, double y, int color, double tsize, const char *text, double angle=0);
 
   /**
    * Print text box label on the plot
    * @param[in] x,y coordinates of the label
    * @param[in] color (optional) color
    * @param[in] boxsize dimension of the box
    * @param[in] text text of the label
    * @param[in] tsize size of the label (in pixel!)
    * @param[in] angle angle of the label (default = 0)
    */
   void myBoxText(double x, double y, double boxsize, int mcolor, double tsize, const char *text);
 
   /**
    * Print text beside marker label on the plot
    * @param[in] x,y coordinates of the label
    * @param[in] color (optional) color
    * @param[in] mystyle style of the marker
    * @param[in] text text of the label
    * @param[in] tsize size of the label
    */
   void myMarkerText(double x, double y, int color, int mstyle, double tsize, const char *text);
 
   /** To set and get the data type*/
   void setDataType(std::string dataType);
   bool dataType(std::string type);
 
   /** To set/get if code is running inside Athena */
   bool isAthenaAware() {return m_athenaAware;}
   void setAthenaAware(bool aware) {m_athenaAware = aware;}
 
   //!< skimming tool 
   virtual bool skimmingTest(EventLibrary* evtLib) {
     m_Log << WARNING << "SkimmingTest always TRUE : not defined for " << m_name << endmsg;
     m_Log << WARNING << "EventLibrary version : " << evtLib->version() << endmsg;
     return true;
   } 
   
   /**
    * Method to get production vertex for MC truth particles
    * @param[in] part EventObject pointer
    * @param[out] vx x-coordinate for the vertex
    * @param[out] vy y-coordinate for the vertex
    * @param[out] vz z-coordinate for the vertex
    * @param[out] vbarcode barcode of the vertex
    * @return error code (0=fine, 11=no genParticle, 12=no genVertex)
    */
   int getProdVertex(EventObject *part, double& vx, double& vy, double& vz, int& vbarcode);
 
   int getEndVertex(EventObject *part, double& vx, double& vy, double& vz, int& vbarcode);
   /**
    * Method to get end vertex for MC truth particles
    * @param[in] part EventObject pointer
    * @param[out] vx x-coordinate for the vertex
    * @param[out] vy y-coordinate for the vertex
    * @param[out] vz z-coordinate for the vertex
    * @param[out] vbarcode barcode of the vertex
    * @return error code (0=fine, 11=no genParticle, 12=no genVertex)
    */
 
 #ifndef EWPA_STANDALONE
   int getProdVertex(const TruthParticle *par, double& vx, double& vy, double& vz, int& vbarcode); 
   /**
    * Method to get production vertex for MC truth particles
    * @param[in] part TruthParticle pointer
    * @param[out] vx x-coordinate for the vertex
    * @param[out] vy y-coordinate for the vertex
    * @param[out] vz z-coordinate for the vertex
    * @param[out] vbarcode barcode of the vertex
    * @return error code (0=fine, 11=no genParticle, 12=no genVertex)
    */
 
   int getEndVertex(const TruthParticle *par, double& vx, double& vy, double& vz, int& vbarcode);
   /**
    * Method to get end vertex for MC truth particles
    * @param[in] part TruthParticle pointer
    * @param[out] vx x-coordinate for the vertex
    * @param[out] vy y-coordinate for the vertex
    * @param[out] vz z-coordinate for the vertex
    * @param[out] vbarcode barcode of the vertex
    * @return error code (0=fine, 11=no genParticle, 12=no genVertex)
    */
 #endif
 
   void splitString(const std::string& str,
                    std::vector<std::string>& tokens,
                    const std::string& delimiters);
 
  protected:
   
 #ifndef EWPA_STANDALONE
   StoreGateSvc* m_storeGate;
 #endif
  
   bool m_athenaAware;
   std::string m_name;            //!< name of the dual tool (used in log messages)
   std::string m_dataType;        //!< type of data (REAL or SIMUL)
 
   std::map<std::string, std::string*> m_stringProperty;
   std::map<std::string, int*> m_intProperty;
   std::map<std::string, float*> m_floatProperty;
   std::map<std::string, double*> m_doubleProperty;
   std::map<std::string, bool*> m_boolProperty;
   std::map<std::string, std::vector<std::string>*> m_stringVecProperty;
   std::map<std::string, std::vector<int>*> m_intVecProperty;
   std::map<std::string, std::vector<float>*> m_floatVecProperty;
   std::map<std::string, std::vector<double>*> m_doubleVecProperty;
   std::map<std::string, std::vector<bool>*> m_boolVecProperty;
  
   //  EWStatManager* m_StatMgr;      //!< the Statistical Manager
   TTree *m_araGate;              //!< the ARA transient tree
   EWMessage m_Log;               //!< the log stream
 };
 
 #ifndef EWPA_STANDALONE
 CLASS_DEF(EWToolBase, 259593343, 1)
 #endif
 
 #endif // end of EWToolBase
 

Due to the LXR bug, the updates fail sometimes to remove references to deleted files. The Saturday's full rebuilds fix these problems
This page was automatically generated by the LXR engine.