SplittingConfigurableHisto Class Reference

#include <ConfigurableHisto.h>

Inheritance diagram for SplittingConfigurableHisto:

Public Member Functions
void	book (TFileDirectory *dir) override
ConfigurableHisto *	clone () const override
void	complete ()
void	fill (const edm::Event &e) override
	SplittingConfigurableHisto (HType t, std::string name, edm::ParameterSet &pset)
Public Member Functions inherited from ConfigurableHisto
void	complete ()
	ConfigurableHisto (HType t, std::string name, edm::ParameterSet &iConfig)
TH1 *	h ()
const HType &	type ()
virtual	~ConfigurableHisto ()

Private Types
typedef std::map< const Splitter *, std::vector< ConfigurableHisto * > >	SubHistoMap
typedef std::map< const Splitter *, THStack * >	SubHistoStacks

Private Member Functions
	SplittingConfigurableHisto (const SplittingConfigurableHisto &master)

Private Attributes
const Splitter *	splitter_
THStack *	stack_
SubHistoMap	subHistoMap_
std::vector< ConfigurableHisto * >	subHistos_
SubHistoStacks	subHistoStacks_

Additional Inherited Members
Public Types inherited from ConfigurableHisto
enum	HType { h1, h2, prof }
Protected Member Functions inherited from ConfigurableHisto
	ConfigurableHisto (const ConfigurableHisto &master)
Protected Attributes inherited from ConfigurableHisto
edm::ParameterSet	conf_
TH1 *	h_
std::string	name_
HType	type_
const CachingVariable *	w_
const CachingVariable *	x_
const CachingVariable *	y_
const CachingVariable *	z_

Detailed Description

Definition at line 225 of file ConfigurableHisto.h.

Member Typedef Documentation

typedef std::map<const Splitter *, std::vector<ConfigurableHisto* > > SplittingConfigurableHisto::SubHistoMap

private

Definition at line 375 of file ConfigurableHisto.h.

typedef std::map<const Splitter *, THStack *> SplittingConfigurableHisto::SubHistoStacks

private

Definition at line 376 of file ConfigurableHisto.h.

Constructor & Destructor Documentation

SplittingConfigurableHisto::SplittingConfigurableHisto ( HType  t, std::string  name, edm::ParameterSet &  pset  )

inline

Definition at line 227 of file ConfigurableHisto.h.

References MillePedeFileConverter_cfg::e, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), mps_fire::i, edm::ParameterSet::insert(), label, Splitter::label(), Splitter::maxSlots(), CachingVariable::name(), muonDTDigis_cfi::pset, alignCSCRings::s, Splitter::shortLabel(), confdb::splitter(), AlCaHLTBitMon_QueryRunRegistry::string, runGCPTkAlMap::title, and findQualityFiles::v.

                                                                              :
    ConfigurableHisto(t,name,pset) , splitter_(nullptr) {
    std::string title=pset.getParameter<std::string>("title");

    //allow for many splitters ...
    if (pset.exists("splitters")){
      //you want more than one splitter
      std::vector<std::string> splitters = pset.getParameter<std::vector<std::string> >("splitters");
      for (unsigned int s=0;s!=splitters.size();++s){
    const CachingVariable * v=edm::Service<VariableHelperService>()->get().variable(splitters[s]);
    const Splitter * splitter = dynamic_cast<const Splitter*>(v);
    if (!splitter){
      edm::LogError("SplittingConfigurableHisto")<<"for: "<<name_<<" the splitting variable: "<<splitters[s]<<" is not a Splitter";
      continue;
    }

    //insert in the map
    std::vector<ConfigurableHisto*> & insertedHisto=subHistoMap_[splitter];
    //now configure the histograms
    unsigned int mSlots=splitter->maxSlots();
    for (unsigned int i=0;i!=mSlots;++i){
      //---   std::cout<<" slot: "<<i<<std::endl;
      const std::string & slabel=splitter->shortLabel(i);
      const std::string & label=splitter->label(i);
      edm::ParameterSet mPset=pset;
      edm::Entry e("string",title+" for "+label,true);
      mPset.insert(true,"title",e);
      insertedHisto.push_back(new ConfigurableHisto(t,name+slabel ,mPset));
    }//loop on slots
      }//loop on splitters

    }//if splitters exists
    else{
      //single splitter
      //get the splitting variable
      const CachingVariable * v=edm::Service<VariableHelperService>()->get().variable(pset.getParameter<std::string>("splitter"));
      splitter_ = dynamic_cast<const Splitter*>(v);
      if (!splitter_){
    edm::LogError("SplittingConfigurableHisto")<<"for: "<<name_<<" the splitting variable: "<<v->name()<<" is not a Splitter";
      }
      else{
    //configure the splitted plots
    unsigned int mSlots=splitter_->maxSlots();
    for (unsigned int i=0;i!=mSlots;i++){
      const std::string & slabel=splitter_->shortLabel(i);
      const std::string & label=splitter_->label(i);
      edm::ParameterSet mPset=pset;
      edm::Entry e("string",title+" for "+label,true);
      mPset.insert(true,"title",e);
      subHistos_.push_back(new ConfigurableHisto(t,name+slabel, mPset));
    }
      }
    }
  }//end of ctor

SplittingConfigurableHisto::SplittingConfigurableHisto ( const SplittingConfigurableHisto &  master )

inlineprivate

Definition at line 360 of file ConfigurableHisto.h.

References clone(), mps_fire::i, splitter_, subHistoMap_, and subHistos_.

                                                                        : ConfigurableHisto(master){
    splitter_ = master.splitter_;
    if (!master.subHistoMap_.empty()){
      SubHistoMap::const_iterator i=master.subHistoMap_.begin();
      SubHistoMap::const_iterator i_end=master.subHistoMap_.end();
      for (;i!=i_end;++i){
    const std::vector<ConfigurableHisto*> & masterHistos=i->second;
    std::vector<ConfigurableHisto*> & clonedHistos=subHistoMap_[i->first];
    for (unsigned int i=0;i!=masterHistos.size();i++){clonedHistos.push_back(masterHistos[i]->clone());}
      }
    }else{
      for (unsigned int i=0;i!=master.subHistos_.size();i++){subHistos_.push_back(master.subHistos_[i]->clone());}
    }
  }

Member Function Documentation

void SplittingConfigurableHisto::book ( TFileDirectory *  dir )

inlineoverridevirtual

Reimplemented from ConfigurableHisto.

Definition at line 282 of file ConfigurableHisto.h.

References ConfigurableHisto::book(), h, mps_fire::i, TFileDirectory::make(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                         {
    //book the base histogram
    ConfigurableHisto::book(dir);

    if (!subHistoMap_.empty()){
      SubHistoMap::iterator i=subHistoMap_.begin();
      SubHistoMap::iterator i_end=subHistoMap_.end();
      for (;i!=i_end;++i){for (unsigned int h=0;h!=i->second.size();++h){ 
      i->second[h]->book(dir);}
    //book the THStack
    std::string sName= name_+"_"+i->first->name();
    std::string sTitle="Stack histogram of "+name_+" for splitter "+i->first->name();
    subHistoStacks_[i->first]= dir->make<THStack>(sName.c_str(),sTitle.c_str());
      }
    }else{
      for (unsigned int h=0;h!=subHistos_.size();h++){subHistos_[h]->book(dir);}
      //book a THStack
      std::string sName= name_+"_"+splitter_->name();
      std::string sTitle="Stack histogram of "+name_+" for splitter "+splitter_->name();
      stack_ = dir->make<THStack>(sName.c_str(),sTitle.c_str());
    }
    
  }

ConfigurableHisto* SplittingConfigurableHisto::clone ( void  ) const

inlineoverridevirtual

Reimplemented from ConfigurableHisto.

Definition at line 306 of file ConfigurableHisto.h.

{    return new SplittingConfigurableHisto(*this);  }

void SplittingConfigurableHisto::complete ( )

inline

Definition at line 340 of file ConfigurableHisto.h.

References h, and mps_fire::i.

                 {
    if (!subHistoMap_.empty()){
      //fill up the stacks
      SubHistoMap::iterator i=subHistoMap_.begin();
      SubHistoMap::iterator i_end=subHistoMap_.end();
      for (;i!=i_end;++i){
    for (unsigned int h=0;h!=i->second.size();h++){
      //      if (i->second[h]->h()->Integral==0) continue;// do not add empty histograms. NO, because it will be tough to merge two THStack
      subHistoStacks_[i->first]->Add(i->second[h]->h(), i->first->label(h).c_str());
    }
      }

    }else{
      //fill up the only stack
      for (unsigned int i=0;i!=subHistos_.size();i++){  stack_->Add(subHistos_[i]->h(), splitter_->label(i).c_str());      }
    }


  }

void SplittingConfigurableHisto::fill ( const edm::Event &  e )

inlineoverridevirtual

Reimplemented from ConfigurableHisto.

Definition at line 308 of file ConfigurableHisto.h.

References CachingVariable::compute(), MillePedeFileConverter_cfg::e, ConfigurableHisto::fill(), mps_fire::i, and createfilelist::int.

                                         {
    //fill the base histogram
    ConfigurableHisto::fill(e);
    
    if (!subHistoMap_.empty()){
      SubHistoMap::iterator i=subHistoMap_.begin();
      SubHistoMap::iterator i_end=subHistoMap_.end();
      for (;i!=i_end;++i){
    const Splitter * splitter=i->first;
    if (!splitter) continue;
    if (!splitter->compute(e)) continue;
    unsigned int slot=(unsigned int)  (*splitter)(e);
    if (slot>=i->second.size()){
      edm::LogError("SplittingConfigurableHisto")<<"slot index: "<<slot<<" is bigger than slots size: "<<i->second.size()<<" from variable value: "<<(*splitter)(e);
      continue;}
    //fill in the proper slot
    i->second[slot]->fill(e);
      }
    }
    else{
      //fill the component histograms
      if (!splitter_) return;
      if (!splitter_->compute(e)){
    return;}
      unsigned int slot=(unsigned int) (*splitter_)(e);
      if (slot>=subHistos_.size()){
    edm::LogError("SplittingConfigurableHisto")<<"slot index: "<<slot<<" is bigger than slots size: "<< subHistos_.size() <<" from variable value: "<<(*splitter_)(e);
    return;}
      subHistos_[slot]->fill(e);
    }
  }

Member Data Documentation

const Splitter* SplittingConfigurableHisto::splitter_

private

Definition at line 380 of file ConfigurableHisto.h.

Referenced by SplittingConfigurableHisto().

THStack* SplittingConfigurableHisto::stack_

private

Definition at line 383 of file ConfigurableHisto.h.

SubHistoMap SplittingConfigurableHisto::subHistoMap_

private

Definition at line 378 of file ConfigurableHisto.h.

Referenced by SplittingConfigurableHisto().

std::vector<ConfigurableHisto* > SplittingConfigurableHisto::subHistos_

private

Definition at line 381 of file ConfigurableHisto.h.

Referenced by SplittingConfigurableHisto().

SubHistoStacks SplittingConfigurableHisto::subHistoStacks_

private

Definition at line 377 of file ConfigurableHisto.h.