#ifndef Global_H
#define Global_H

#include <string>
#include <map>

#include "TObject.h"
#include "Vertex.hpp"

class Global : public TObject{

public:

//default constructor

Global();

//copy constructor

Global(const Global& orig);

//assignment operator

Global& operator=(const Global& orig);

//destructor

virtual ~Global(){}

//Set and get methods

void Set_name(const std::string& val);
void Set_type(const std::string& val);
void Set_sigma(const float& val);
void Set_err_sigma(const float& val);
void Set_nevts(const float& val);
void Set_runno(const int& val);
void Set_evtno(const int& val);
void Set_cal_empty_crate(bool val);
void Set_cal_coherent_noise(bool val);
void Set_cal_ring_of_fire(bool val);
void Set_cal_noon_noise(bool val);
void Set_cal_remove_from_analysis(bool val);
  //void Set_trigger_probability(double val);
  /*
void Set_emcorr_weight(const double& val);
void Set_emcorr_weight_cc(const double& val);
void Set_emcorr_weight_ecn(const double& val);
void Set_emcorr_weight_ecs(const double& val);
void Set_zpt_weight(const double& val);
void Set_zpt_weight_njet(const double& val);
  */
void Set_sigma_tmb_tree(const float& val);
void Set_M_DY(const float& val);
void Set_Pt_DY(const float& val);
void Set_set(const float& val);
  //void Set_met(const float& val);
  //void Set_metx(const float& val);
  //void Set_mety(const float& val);
void Set_met(const std::map<std::string, float>& themap);
void Set_Vertex(const std::vector<Vertex>& vert);
void Set_cormet(const float& val);
void Set_cormetx(const float& val);
void Set_cormety(const float& val);
void Set_metsig(const float& val);
  /*
void Set_lumireweight(const float& val);
void Set_beamreweight(const float& val);
void Set_alpgen_corr(const float& val);
  */
void Set_weights(const std::map<std::string, double>& theweights);
void Set_instlum(const float& val);
void Set_avglum(const float& val);
void Set_lumblk(const int& val);

const  std::string& name() const;
const  std::string& type() const;
float sigma() const;
float err_sigma() const;
float nevts() const;
int runno() const;
int evtno() const;
  /*
double emcorr_weight() const;
double emcorr_weight_cc() const;
double emcorr_weight_ecn() const;
double emcorr_weight_ecs() const;
double zpt_weight() const;
double zpt_weight_njet() const;
  */
bool cal_empty_crate() const;
bool cal_coherent_noise() const;
bool cal_ring_of_fire() const;
bool cal_noon_noise() const;
bool cal_remove_from_analysis() const;
float sigma_tmb_tree() const;
float M_DY() const;
float Pt_DY() const; 
float set() const;
  //float met() const;
  //float metx() const;
  //float mety() const;
const std::map<std::string, float>& met_map() const;
  //double trigger_probability() const;
const std::vector<Vertex>& vertex() const;
float cormet() const;
float cormetx() const;
float cormety() const;
float metsig() const;
  //float lumireweight() const;
  //float beamreweight() const;
  //float alpgen_corr() const;
const std::map<std::string, double> weights() const;
float instlum() const;
float avglum() const;
int lumblk() const;

private:


  std::string _name,_type;
  float _sigma,_err_sigma;
  float _nevts;
  int _runno;
  int _evtno;
  //double _emcorr_weight,_emcorr_weight_cc,_emcorr_weight_ecn,_emcorr_weight_ecs; 
  //double _zpt_weight,_zpt_weight_njet,_trigger_probability;
  bool _cal_empty_crate,_cal_coherent_noise,_cal_ring_of_fire,_cal_noon_noise,_cal_remove_from_analysis;
  float _xsect,_m_DY,_Pt_DY;
  //float _set,_met,_metx,_mety;
  float _set;
  std::vector<Vertex> _vertex;
  float _cormet,_cormetx,_cormety,_metsig;
  std::map<std::string, float> _metmap;
  //float _lumireweight,_beamreweight;
  //float _alpgen_corr;
  std::map<std::string, double> _weights;
  float _instlum,_avglum;
  int _lumblk;

ClassDef(Global,1)

};

inline void Global::Set_name(const std::string& val){_name = val;}
inline void Global::Set_type(const std::string& val){_type = val;}
inline void Global::Set_sigma(const float& val){_sigma = val;}
inline void Global::Set_err_sigma(const float& val){_err_sigma = val;}
inline void Global::Set_nevts(const float& val){_nevts = val;}
inline void Global::Set_runno(const int& val){_runno = val;}
inline void Global::Set_evtno(const int& val){_evtno = val;}
inline void Global::Set_cal_empty_crate(bool val){ _cal_empty_crate=val;}
inline void Global::Set_cal_coherent_noise(bool val) {_cal_coherent_noise=val;}
inline void Global::Set_cal_ring_of_fire(bool val) {_cal_ring_of_fire=val;}
inline void Global::Set_cal_noon_noise(bool val) {_cal_noon_noise=val;}
inline void Global::Set_cal_remove_from_analysis(bool val) {_cal_remove_from_analysis=val;}
/*
inline void Global::Set_emcorr_weight(const double& val){_emcorr_weight=val;}
inline void Global::Set_emcorr_weight_cc(const double& val){_emcorr_weight_cc=val;}
inline void Global::Set_emcorr_weight_ecn(const double& val){_emcorr_weight_ecn=val;}
inline void Global::Set_emcorr_weight_ecs(const double& val){_emcorr_weight_ecs=val;}
inline void Global::Set_trigger_probability(double val){_trigger_probability=val;}
inline void Global::Set_zpt_weight(const double& val) {_zpt_weight=val;}
inline void Global::Set_zpt_weight_njet(const double& val) {_zpt_weight_njet=val;}
*/
inline void Global::Set_sigma_tmb_tree(const float& val) {_xsect=val;}
inline void Global::Set_M_DY(const float& val) {_m_DY=val;}
inline void Global::Set_Pt_DY(const float& val) {_Pt_DY=val;}
inline void Global::Set_set(const float& val) {_set=val;}
//inline void Global::Set_met(const float& val) {_met=val;}
//inline void Global::Set_metx(const float& val) {_metx=val;}
//inline void Global::Set_mety(const float& val) {_mety=val;}
inline void Global::Set_met(const std::map<std::string, float>& themap) {_metmap=themap;}
inline void Global::Set_Vertex(const std::vector<Vertex>& vert) {_vertex=vert;}
inline void Global::Set_cormet(const float& val) {_cormet=val;}
inline void Global::Set_cormetx(const float& val) {_cormetx=val;}
inline void Global::Set_cormety(const float& val) {_cormety=val;}
inline void Global::Set_metsig(const float& val) {_metsig=val;}
//inline void Global::Set_lumireweight(const float& val) {_lumireweight=val;}
//inline void Global::Set_beamreweight(const float& val) {_beamreweight=val;}
//inline void Global::Set_alpgen_corr(const float& val){_alpgen_corr=val;}
inline void Global::Set_weights(const std::map<std::string, double>& theweights){_weights=theweights;}
inline void Global::Set_instlum(const float& val){_instlum=val;}
inline void Global::Set_avglum(const float& val){_avglum=val;};
inline void Global::Set_lumblk(const int& val){_lumblk=val;}

inline const  std::string& Global::name() const { return _name;}
inline const  std::string& Global::type() const { return _type;}
inline float Global::sigma() const{ return _sigma;}
inline float Global::err_sigma() const{ return _err_sigma;}
inline float Global::nevts() const{ return _nevts;}
inline int Global::runno() const{ return _runno;}
inline int Global::evtno() const{ return _evtno;}
/*
inline double Global::emcorr_weight() const{return _emcorr_weight;}
inline double Global::emcorr_weight_cc() const{return _emcorr_weight_cc;}
inline double Global::emcorr_weight_ecn() const{return _emcorr_weight_ecn;}
inline double Global::emcorr_weight_ecs() const{return _emcorr_weight_ecs;}
inline double Global::zpt_weight() const {return _zpt_weight;}
inline double Global::zpt_weight_njet() const {return _zpt_weight_njet;}
*/
inline bool Global::cal_empty_crate() const {return _cal_empty_crate;}
inline bool Global::cal_coherent_noise() const {return _cal_coherent_noise;}
inline bool Global::cal_ring_of_fire() const {return _cal_ring_of_fire;}
inline bool Global::cal_noon_noise() const {return _cal_noon_noise;}
inline bool Global::cal_remove_from_analysis() const {return _cal_remove_from_analysis;}
inline float Global::sigma_tmb_tree() const {return _xsect;}
inline float Global::M_DY() const {return _m_DY;}
inline float Global::Pt_DY() const {return _Pt_DY;}
inline float Global::set() const {return _set;}
//inline float Global::met() const {return _met;}
//inline float Global::metx() const {return _metx;}
//inline float Global::mety() const {return _mety;}
inline const std::map<std::string, float>& Global::met_map() const {return _metmap;}
//inline double Global::trigger_probability() const{return _trigger_probability;}
inline const std::vector<Vertex>& Global::vertex() const {return _vertex;}
inline float Global::cormet() const {return _cormet;}
inline float Global::cormetx() const {return _cormetx;}
inline float Global::cormety() const {return _cormety;}
inline float Global::metsig() const {return _metsig;}
/*
inline float Global::lumireweight() const {return _lumireweight;}
inline float Global::beamreweight() const {return _beamreweight;}
inline float Global::alpgen_corr() const {return _alpgen_corr;}
*/
inline const std::map<std::string, double> Global::weights() const{return _weights;}
inline float Global::instlum() const{return _instlum;}
inline float Global::avglum() const{return _avglum;}
inline int Global::lumblk() const {return _lumblk;}

#endif // Global_H