HcalLedAnalysis.h

Go to the documentation of this file.

#ifndef HcalLedAnalysis_H
#define HcalLedAnalysis_H

#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"

#include "DataFormats/HcalDigi/interface/HcalDigiCollections.h"

#include "TH1F.h"
#include "TF1.h"
#include "TProfile.h"

#include <memory>
//#include <iostream>
#include <fstream>
#include <vector>
#include <string>

class HcalPedestal;
class HcalDbService;
class HcalQIEShape;
class HcalQIECoder;
class TFile;

class HcalLedAnalysis {
public:
  HcalLedAnalysis(const edm::ParameterSet& ps);
  ~HcalLedAnalysis();
  void LedSetup(const std::string& m_outputFileROOT);
  //void doPeds(const HcalPedestals* fInputPedestals);
  void LedSampleAnalysis();
  void LedDone();
  void processLedEvent(const HBHEDigiCollection& hbhe,
                       const HODigiCollection& ho,
                       const HFDigiCollection& hf,
                       const HcalCalibDigiCollection& calib,
                       const HcalDbService& cond);

protected:
private:
  //###
  //#  LEDBUNCH is used in map<HcalDetId,map<int, LEDBUNCH > > LEDTRENDS;
  //#  For each HcalDetId (channel) a map<int, LEDBUNCH> is associated;
  //#  int was originally cap-id and now is just dummy;
  //#  LEDBUNCH is a pair - first element is the main
  //#  histo with the ADC values and second one is another pair;
  //#  this pair contains map<int, std::vector<double> > as a first element;
  //#  vector contains some useful variables;
  //#  the second element is a vector of histos (pointers);
  //#  for the "trend" analysis the main histo (with ADC values) is reset every
  //#  m_nevtsample events and info is put in the other part of the LEDBUNCH;
  //#  so at the end we have the trends for the variables in concern
  //#  which are written in THE vector<TH1F*>;
  //###
  typedef std::pair<TH1F*, std::pair<std::map<int, std::vector<double> >, std::vector<TH1F*> > > LEDBUNCH;
  typedef struct {
    TProfile* avePulse;
    TH1F* thisPulse;
    TH1F* integPulse;
  } CALIBBUNCH;
  TFile* m_file;
  void LedHBHEHists(const HcalDetId& detid,
                    const HBHEDataFrame& ledDigi,
                    std::map<HcalDetId, std::map<int, LEDBUNCH> >& toolT,
                    const HcalDbService& cond);
  void LedHOHists(const HcalDetId& detid,
                  const HODataFrame& ledDigi,
                  std::map<HcalDetId, std::map<int, LEDBUNCH> >& toolT,
                  const HcalDbService& cond);
  void LedHFHists(const HcalDetId& detid,
                  const HFDataFrame& ledDigi,
                  std::map<HcalDetId, std::map<int, LEDBUNCH> >& toolT,
                  const HcalDbService& cond);
  void SetupLEDHists(int id, const HcalDetId detid, std::map<HcalDetId, std::map<int, LEDBUNCH> >& toolT);
  void GetLedConst(std::map<HcalDetId, std::map<int, LEDBUNCH> >& toolT);
  void LedTrendings(std::map<HcalDetId, std::map<int, LEDBUNCH> >& toolT);
  void ProcessCalibEvent(int fiberChan, HcalCalibDetId calibId, const HcalCalibDataFrame& digi);
  float BinsizeCorr(float time);

  std::string m_outputFileROOT;
  std::string m_outputFileText;
  std::string m_outputFileX;
  std::ofstream m_outFile;
  std::ofstream m_outputFileXML;

  int m_startTS;
  int m_endTS;
  int m_nevtsample;
  int m_hiSaveflag;
  bool m_usecalib;
  // analysis flag:
  //  m_fitflag = 0  - take mean TS value of averaged pulse shape
  //              1  - take peak from landau fit to averaged pulse shape
  //              2  - take average of mean TS values per event
  //                     (preferred for laser & HF LED)
  //              3  - take average of peaks from landau fits per event
  //                     (preferred for LED)
  //              4  - 0+1+2+3 REMOVED in 1_6
  int m_fitflag;

  const HcalQIEShape* m_shape;
  const HcalQIECoder* m_coder;
  const HcalPedestal* m_ped;
  struct {
    std::map<HcalDetId, std::map<int, LEDBUNCH> > LEDTRENDS;
    TH1F* ALLLEDS;
    TH1F* LEDRMS;
    TH1F* LEDMEAN;
    TH1F* CHI2;
  } hbHists, hfHists, hoHists;
  std::map<HcalDetId, std::map<int, LEDBUNCH> >::iterator _meol;
  std::map<HcalDetId, std::map<int, float> > m_AllPedVals;
  std::map<HcalDetId, std::map<int, float> >::iterator _meee;

  std::map<HcalCalibDetId, CALIBBUNCH> calibHists;
  std::map<HcalCalibDetId, CALIBBUNCH>::iterator _meca;

  //const HcalPedestal* pedCan;
  int evt;
  int sample;
  int evt_curr;
  std::vector<bool> state;
};

#endif