d5/dbc/DQMStore_8h_source.html

 #ifndef DQMSERVICES_CORE_DQM_STORE_H

 # define DQMSERVICES_CORE_DQM_STORE_H


 # if __GNUC__ && ! defined DQM_DEPRECATED

 #  define DQM_DEPRECATED __attribute__((deprecated))

 # endif


 # include "DQMServices/Core/interface/DQMDefinitions.h"

 # include "classlib/utils/Regexp.h"

 # include <vector>

 # include <string>

 # include <list>

 # include <map>

 # include <set>

 # include <execinfo.h>

 # include <stdio.h>

 # include <stdlib.h>

 # include <cxxabi.h>


 namespace edm { class DQMHttpSource; class ParameterSet; class ActivityRegistry;}

 namespace lat { class Regexp; }


 class MonitorElement;

 class QCriterion;

 class TFile;

 class TObject;

 class TH1;

 class TObjString;

 class TH1F;

 class TH1S;

 class TH1D;

 class TH2F;

 class TH2S;

 class TH2D;

 class TH3F;

 class TProfile;

 class TProfile2D;


 class fastmatch

 {

 private:

   enum MatchingHeuristicEnum { UseFull, OneStarStart, OneStarEnd, TwoStar };


 public:

   fastmatch (std::string const& _fastString);

   ~fastmatch();


   bool match (std::string const& s) const;


 private:

   // checks if two strings are equal, starting at the back of the strings

   bool compare_strings_reverse (std::string const& pattern,

                 std::string const& input) const;

   // checks if two strings are equal, starting at the front of the strings

   bool compare_strings (std::string const& pattern,

             std::string const& input) const;


   lat::Regexp * regexp_;

   std::string fastString_;

   MatchingHeuristicEnum matching_;

 };


 class DQMStore

 {

 public:

   enum SaveReferenceTag

   {

     SaveWithoutReference,

     SaveWithReference,

     SaveWithReferenceForQTest

   };

   enum OpenRunDirs

   {

     KeepRunDirs,

     StripRunDirs

   };


   //-------------------------------------------------------------------------

   // ---------------------- Constructors ------------------------------------

   DQMStore(const edm::ParameterSet &pset, edm::ActivityRegistry&);

   DQMStore(const edm::ParameterSet &pset);

   ~DQMStore(void);


   //-------------------------------------------------------------------------

   void              setVerbose(unsigned level);


   // ---------------------- public navigation -------------------------------

   const std::string &       pwd(void) const;

   void              cd(void);

   void              cd(const std::string &subdir);

   void              setCurrentFolder(const std::string &fullpath);

   void              goUp(void);


   bool              dirExists(const std::string &path) const;


   //-------------------------------------------------------------------------

   // ---------------------- public ME booking -------------------------------


   MonitorElement *      bookInt      (const char *name);

   MonitorElement *      bookInt      (const std::string &name);


   MonitorElement *      bookFloat    (const char *name);

   MonitorElement *      bookFloat    (const std::string &name);


   MonitorElement *      bookString   (const char *name,

                           const char *value);

   MonitorElement *      bookString   (const std::string &name,

                           const std::string &value);


   MonitorElement *      book1D       (const char *name,

                           const char *title,

                           int nchX, double lowX, double highX);

   MonitorElement *      book1D       (const std::string &name,

                           const std::string &title,

                           int nchX, double lowX, double highX);

   MonitorElement *      book1D       (const char *name,

                           const char *title,

                           int nchX, float *xbinsize);

   MonitorElement *      book1D       (const std::string &name,

                           const std::string &title,

                           int nchX, float *xbinsize);

   MonitorElement *      book1D       (const char *name, TH1F *h);

   MonitorElement *      book1D       (const std::string &name, TH1F *h);


   MonitorElement *      book1S       (const char *name,

                           const char *title,

                           int nchX, double lowX, double highX);

   MonitorElement *      book1S       (const std::string &name,

                           const std::string &title,

                           int nchX, double lowX, double highX);

   MonitorElement *      book1S       (const char *name,

                           const char *title,

                           int nchX, float *xbinsize);

   MonitorElement *      book1S       (const std::string &name,

                           const std::string &title,

                           int nchX, float *xbinsize);

   MonitorElement *      book1S       (const char *name, TH1S *h);

   MonitorElement *      book1S       (const std::string &name, TH1S *h);


   MonitorElement *      book1DD       (const char *name,

                            const char *title,

                            int nchX, double lowX, double highX);

   MonitorElement *      book1DD       (const std::string &name,

                            const std::string &title,

                            int nchX, double lowX, double highX);

   MonitorElement *      book1DD       (const char *name,

                            const char *title,

                            int nchX, float *xbinsize);

   MonitorElement *      book1DD       (const std::string &name,

                            const std::string &title,

                            int nchX, float *xbinsize);

   MonitorElement *      book1DD       (const char *name, TH1D *h);

   MonitorElement *      book1DD       (const std::string &name, TH1D *h);


   MonitorElement *      book2D       (const char *name,

                           const char *title,

                           int nchX, double lowX, double highX,

                           int nchY, double lowY, double highY);

   MonitorElement *      book2D       (const std::string &name,

                           const std::string &title,

                           int nchX, double lowX, double highX,

                           int nchY, double lowY, double highY);

   MonitorElement *      book2D       (const char *name,

                           const char *title,

                           int nchX, float *xbinsize,

                           int nchY, float *ybinsize);

   MonitorElement *      book2D       (const std::string &name,

                           const std::string &title,

                           int nchX, float *xbinsize,

                           int nchY, float *ybinsize);

   MonitorElement *      book2D       (const char *name, TH2F *h);

   MonitorElement *      book2D       (const std::string &name, TH2F *h);


   MonitorElement *      book2S       (const char *name,

                           const char *title,

                           int nchX, double lowX, double highX,

                           int nchY, double lowY, double highY);

   MonitorElement *      book2S       (const std::string &name,

                           const std::string &title,

                           int nchX, double lowX, double highX,

                           int nchY, double lowY, double highY);

   MonitorElement *      book2S       (const char *name,

                           const char *title,

                           int nchX, float *xbinsize,

                           int nchY, float *ybinsize);

   MonitorElement *      book2S       (const std::string &name,

                           const std::string &title,

                           int nchX, float *xbinsize,

                           int nchY, float *ybinsize);

   MonitorElement *      book2S       (const char *name, TH2S *h);

   MonitorElement *      book2S       (const std::string &name, TH2S *h);


   MonitorElement *      book2DD       (const char *name,

                            const char *title,

                            int nchX, double lowX, double highX,

                            int nchY, double lowY, double highY);

   MonitorElement *      book2DD       (const std::string &name,

                            const std::string &title,

                            int nchX, double lowX, double highX,

                            int nchY, double lowY, double highY);

   MonitorElement *      book2DD       (const char *name,

                            const char *title,

                            int nchX, float *xbinsize,

                            int nchY, float *ybinsize);

   MonitorElement *      book2DD       (const std::string &name,

                            const std::string &title,

                            int nchX, float *xbinsize,

                            int nchY, float *ybinsize);

   MonitorElement *      book2DD       (const char *name, TH2D *h);

   MonitorElement *      book2DD       (const std::string &name, TH2D *h);


   MonitorElement *      book3D       (const char *name,

                           const char *title,

                           int nchX, double lowX, double highX,

                           int nchY, double lowY, double highY,

                           int nchZ, double lowZ, double highZ);

   MonitorElement *      book3D       (const std::string &name,

                           const std::string &title,

                           int nchX, double lowX, double highX,

                           int nchY, double lowY, double highY,

                           int nchZ, double lowZ, double highZ);

   MonitorElement *      book3D       (const char *name, TH3F *h);

   MonitorElement *      book3D       (const std::string &name, TH3F *h);


   MonitorElement *      bookProfile  (const char *name,

                           const char *title,

                           int nchX, double lowX, double highX,

                           int nchY, double lowY, double highY,

                           const char *option = "s");

   MonitorElement *      bookProfile  (const std::string &name,

                           const std::string &title,

                           int nchX, double lowX, double highX,

                           int nchY, double lowY, double highY,

                           const char *option = "s");

   MonitorElement *      bookProfile  (const char *name,

                           const char *title,

                           int nchX, double lowX, double highX,

                           double lowY, double highY,

                           const char *option = "s");

   MonitorElement *      bookProfile  (const std::string &name,

                           const std::string &title,

                           int nchX, double lowX, double highX,

                           double lowY, double highY,

                           const char *option = "s");

   MonitorElement *      bookProfile  (const char *name,

                           const char *title,

                           int nchX, double *xbinsize,

                           int nchY, double lowY, double highY,

                           const char *option = "s");

   MonitorElement *      bookProfile  (const std::string &name,

                           const std::string &title,

                           int nchX, double *xbinsize,

                           int nchY, double lowY, double highY,

                           const char *option = "s");

   MonitorElement *      bookProfile  (const char *name,

                           const char *title,

                           int nchX, double *xbinsize,

                           double lowY, double highY,

                           const char *option = "s");

   MonitorElement *      bookProfile  (const std::string &name,

                           const std::string &title,

                           int nchX, double *xbinsize,

                           double lowY, double highY,

                           const char *option = "s");

   MonitorElement *      bookProfile  (const char *name, TProfile *h);

   MonitorElement *      bookProfile  (const std::string &name, TProfile *h);


   MonitorElement *      bookProfile2D(const char *name,

                           const char *title,

                           int nchX, double lowX, double highX,

                           int nchY, double lowY, double highY,

                           int nchZ, double lowZ, double highZ,

                           const char *option = "s");

   MonitorElement *      bookProfile2D(const std::string &name,

                           const std::string &title,

                           int nchX, double lowX, double highX,

                           int nchY, double lowY, double highY,

                           int nchZ, double lowZ, double highZ,

                           const char *option = "s");

   MonitorElement *      bookProfile2D(const char *name,

                           const char *title,

                           int nchX, double lowX, double highX,

                           int nchY, double lowY, double highY,

                           double lowZ, double highZ,

                           const char *option = "s");

   MonitorElement *      bookProfile2D(const std::string &name,

                           const std::string &title,

                           int nchX, double lowX, double highX,

                           int nchY, double lowY, double highY,

                           double lowZ, double highZ,

                           const char *option = "s");

   MonitorElement *      bookProfile2D(const char *name, TProfile2D *h);

   MonitorElement *      bookProfile2D(const std::string &name, TProfile2D *h);


   //-------------------------------------------------------------------------

   // ---------------------- public tagging ----------------------------------

   void              tag(MonitorElement *me, unsigned int myTag);

   void              tag(const std::string &path, unsigned int myTag);

   void              tagContents(const std::string &path, unsigned int myTag);

   void              tagAllContents(const std::string &path, unsigned int myTag);


   //-------------------------------------------------------------------------

   // ---------------------- public ME getters -------------------------------

   std::vector<std::string>  getSubdirs(void) const;

   std::vector<std::string>  getMEs(void) const;

   bool              containsAnyMonitorable(const std::string &path) const;


   MonitorElement *      get(const std::string &path) const;

   std::vector<MonitorElement *> get(unsigned int tag) const;

   std::vector<MonitorElement *> getContents(const std::string &path) const;

   std::vector<MonitorElement *> getContents(const std::string &path, unsigned int tag) const;

   void              getContents(std::vector<std::string> &into, bool showContents = true) const;


   // ---------------------- softReset methods -------------------------------

   void              softReset(MonitorElement *me);

   void              disableSoftReset(MonitorElement *me);


   // ---------------------- Public deleting ---------------------------------

   void              rmdir(const std::string &fullpath);

   void              removeContents(void);

   void              removeContents(const std::string &dir);

   void              removeElement(const std::string &name);

   void              removeElement(const std::string &dir, const std::string &name, bool warning = true);


   //-------------------------------------------------------------------------

   // ---------------------- public I/O --------------------------------------

   void              save(const std::string &filename,

                      const std::string &path = "",

                      const std::string &pattern = "",

                      const std::string &rewrite = "",

                      SaveReferenceTag ref = SaveWithReference,

                                      int minStatus = dqm::qstatus::STATUS_OK,

                      const std::string &fileupdate = "RECREATE");

   bool              open(const std::string &filename,

                      bool overwrite = false,

                      const std::string &path ="",

                      const std::string &prepend = "",

                      OpenRunDirs stripdirs = KeepRunDirs,

                      bool fileMustExist = true);

   bool                          load(const std::string &filename,

                      OpenRunDirs stripdirs = StripRunDirs,

                      bool fileMustExist = true);


   //-------------------------------------------------------------------------

   // ---------------------- Public print methods -----------------------------

   void              showDirStructure(void) const;


   // ---------------------- Public check options -----------------------------

   bool                         isCollate(void) const;


   //-------------------------------------------------------------------------

   // ---------------------- Quality Test methods -----------------------------

   QCriterion *          getQCriterion(const std::string &qtname) const;

   QCriterion *          createQTest(const std::string &algoname, const std::string &qtname);

   void              useQTest(const std::string &dir, const std::string &qtname);

   int               useQTestByMatch(const std::string &pattern, const std::string &qtname);

   void              runQTests(void);

   int               getStatus(const std::string &path = "") const;

   void        scaleElements(void);


 private:

   // ---------------- Navigation -----------------------

   bool              cdInto(const std::string &path) const;


   // ------------------- Reference ME -------------------------------

   bool              isCollateME(MonitorElement *me) const;


   // ------------------- Private "getters" ------------------------------

   bool              readFile(const std::string &filename,

                      bool overwrite = false,

                      const std::string &path ="",

                      const std::string &prepend = "",

                      OpenRunDirs stripdirs = StripRunDirs,

                      bool fileMustExist = true);

   void              makeDirectory(const std::string &path);

   unsigned int          readDirectory(TFile *file,

                           bool overwrite,

                           const std::string &path,

                           const std::string &prepend,

                           const std::string &curdir,

                           OpenRunDirs stripdirs);


   MonitorElement *      findObject(const std::string &dir, const std::string &name) const;


 public:

   void              getAllTags(std::vector<std::string> &into) const;

   std::vector<MonitorElement*>  getAllContents(const std::string &path) const;

   std::vector<MonitorElement*>  getMatchingContents(const std::string &pattern, lat::Regexp::Syntax syntaxType = lat::Regexp::Wildcard) const;

 private:


   // ---------------- Miscellaneous -----------------------------

   void        initializeFrom(const edm::ParameterSet&);

   void              reset(void);

   void        forceReset(void);


   bool              extract(TObject *obj, const std::string &dir, bool overwrite);


   // ---------------------- Booking ------------------------------------

   MonitorElement *      initialise(MonitorElement *me, const std::string &path);

   MonitorElement *      book(const std::string &dir,

                      const std::string &name,

                      const char *context);

   template <class HISTO, class COLLATE>

   MonitorElement *      book(const std::string &dir, const std::string &name,

                      const char *context, int kind,

                      HISTO *h, COLLATE collate);


   MonitorElement *      bookInt(const std::string &dir, const std::string &name);

   MonitorElement *      bookFloat(const std::string &dir, const std::string &name);

   MonitorElement *      bookString(const std::string &dir, const std::string &name, const std::string &value);

   MonitorElement *      book1D(const std::string &dir, const std::string &name, TH1F *h);

   MonitorElement *      book1S(const std::string &dir, const std::string &name, TH1S *h);

   MonitorElement *      book1DD(const std::string &dir, const std::string &name, TH1D *h);

   MonitorElement *      book2D(const std::string &dir, const std::string &name, TH2F *h);

   MonitorElement *      book2S(const std::string &dir, const std::string &name, TH2S *h);

   MonitorElement *      book2DD(const std::string &dir, const std::string &name, TH2D *h);

   MonitorElement *      book3D(const std::string &dir, const std::string &name, TH3F *h);

   MonitorElement *      bookProfile(const std::string &dir, const std::string &name, TProfile *h);

   MonitorElement *      bookProfile2D(const std::string &folder, const std::string &name, TProfile2D *h);


   static bool                   checkBinningMatches(MonitorElement *me, TH1 *h);


   static void           collate1D(MonitorElement *me, TH1F *h);

   static void           collate1S(MonitorElement *me, TH1S *h);

   static void           collate1DD(MonitorElement *me, TH1D *h);

   static void           collate2D(MonitorElement *me, TH2F *h);

   static void           collate2S(MonitorElement *me, TH2S *h);

   static void           collate2DD(MonitorElement *me, TH2D *h);

   static void           collate3D(MonitorElement *me, TH3F *h);

   static void           collateProfile(MonitorElement *me, TProfile *h);

   static void           collateProfile2D(MonitorElement *me, TProfile2D *h);


   // --- Operations on MEs that are normally reset at end of monitoring cycle ---

   void              setAccumulate(MonitorElement *me, bool flag);


   void print_trace(const std::string &dir, const std::string &name);


   // ----------------------- Unavailable ---------------------------------------

   DQMStore(const DQMStore&);

   const DQMStore& operator=(const DQMStore&);


   //-------------------------------------------------------------------------------

   //-------------------------------------------------------------------------------

   typedef std::pair<fastmatch *, QCriterion *>          QTestSpec;

   typedef std::list<QTestSpec>                      QTestSpecs;

   typedef std::set<MonitorElement>                  MEMap;

   typedef std::map<std::string, QCriterion *>               QCMap;

   typedef std::map<std::string, QCriterion *(*)(const std::string &)>   QAMap;


   unsigned          verbose_;

   unsigned          verboseQT_;

   bool              reset_;

   double                scaleFlag_;

   bool              collateHistograms_;

   std::string           readSelectedDirectory_;


   std::string           pwd_;

   MEMap             data_;

   std::set<std::string>     dirs_;


   QCMap             qtests_;

   QAMap             qalgos_;

   QTestSpecs            qtestspecs_;


   friend class edm::DQMHttpSource;

   friend class DQMService;

   friend class DQMNet;

   friend class DQMArchiver;

   friend class DQMStoreExample; // for get{All,Matching}Contents -- sole user of this method!

 };


 #endif // DQMSERVICES_CORE_DQM_STORE_H

DQMStore::collateProfile2D
static void collateProfile2D(MonitorElement *me, TProfile2D *h)
Definition: DQMStore.cc:1345

indexGen.title
title
Definition: indexGen.py:48

DQMStore::getQCriterion
QCriterion * getQCriterion(const std::string &qtname) const
Definition: DQMStore.cc:2602

fastmatch::compare_strings_reverse
bool compare_strings_reverse(std::string const &pattern, std::string const &input) const
Definition: DQMStore.cc:198

DQMStore::QTestSpec
std::pair< fastmatch *, QCriterion * > QTestSpec
Definition: DQMStore.h:448

warning
Definition: MessageDispatcher.h:11

DQMStore::DQMStore
DQMStore(const edm::ParameterSet &pset, edm::ActivityRegistry &)
Definition: DQMStore.cc:259

DQMStore::book2S
MonitorElement * book2S(const char *name, const char *title, int nchX, double lowX, double highX, int nchY, double lowY, double highY)
Book 2S histogram.
Definition: DQMStore.cc:872

DQMStore::QCMap
std::map< std::string, QCriterion * > QCMap
Definition: DQMStore.h:451

DQMStore::containsAnyMonitorable
bool containsAnyMonitorable(const std::string &path) const
Definition: DQMStore.cc:1463

DQMStore::isCollateME
bool isCollateME(MonitorElement *me) const
Definition: DQMStore.cc:2795

flag
long int flag
Definition: mlp_lapack.h:47

DQMStore::cdInto
bool cdInto(const std::string &path) const
Definition: DQMStore.cc:2071

QCriterion
Definition: QTest.h:45

mergeVDriftHistosByStation.file
tuple file
Definition: mergeVDriftHistosByStation.py:54

DQMStore::getStatus
int getStatus(const std::string &path="") const
Definition: DQMStore.cc:2708

DQMStore::getSubdirs
std::vector< std::string > getSubdirs(void) const
Definition: DQMStore.cc:1424

edm::DQMHttpSource
Definition: DQMHttpSource.h:32

DQMStore::book1D
MonitorElement * book1D(const char *name, const char *title, int nchX, double lowX, double highX)
Book 1D histogram.
Definition: DQMStore.cc:722

DQMStore::rmdir
void rmdir(const std::string &fullpath)
Definition: DQMStore.cc:2535

fastmatch::match
bool match(std::string const &s) const
Definition: DQMStore.cc:240

DQMStore::readFile
bool readFile(const std::string &filename, bool overwrite=false, const std::string &path="", const std::string &prepend="", OpenRunDirs stripdirs=StripRunDirs, bool fileMustExist=true)
Definition: DQMStore.cc:2477

DQMStore::collate3D
static void collate3D(MonitorElement *me, TH3F *h)
Definition: DQMStore.cc:1328

ParameterSet
Definition: Functions.h:16

DQMStore::book3D
MonitorElement * book3D(const char *name, const char *title, int nchX, double lowX, double highX, int nchY, double lowY, double highY, int nchZ, double lowZ, double highZ)
Book 3D histogram.
Definition: DQMStore.cc:984

DQMStore::collate1D
static void collate1D(MonitorElement *me, TH1F *h)
Definition: DQMStore.cc:1286

fastmatch::MatchingHeuristicEnum
MatchingHeuristicEnum
Definition: DQMStore.h:46

DQMNet
Definition: DQMNet.h:22

relativeConstraints.value
tuple value
Definition: relativeConstraints.py:54

DQMStore::cd
void cd(void)
go to top directory (ie. root)
Definition: DQMStore.cc:411

DQMStore::book2DD
MonitorElement * book2DD(const char *name, const char *title, int nchX, double lowX, double highX, int nchY, double lowY, double highY)
Book 2D double histogram.
Definition: DQMStore.cc:894

DQMStore::collate1DD
static void collate1DD(MonitorElement *me, TH1D *h)
Definition: DQMStore.cc:1300

fastmatch::OneStarEnd
Definition: DQMStore.h:46

DQMStore::save
void save(const std::string &filename, const std::string &path="", const std::string &pattern="", const std::string &rewrite="", SaveReferenceTag ref=SaveWithReference, int minStatus=dqm::qstatus::STATUS_OK, const std::string &fileupdate="RECREATE")
Definition: DQMStore.cc:2118

LaserDQM_cfg.input
tuple input
Definition: LaserDQM_cfg.py:38

DQMStore::SaveWithReference
Definition: DQMStore.h:73

getHLTPrescaleColumns.path
list path
Definition: getHLTPrescaleColumns.py:16

DQMStore::getMatchingContents
std::vector< MonitorElement * > getMatchingContents(const std::string &pattern, lat::Regexp::Syntax syntaxType=lat::Regexp::Wildcard) const
Definition: DQMStore.cc:1696

fastmatch::matching_
MatchingHeuristicEnum matching_
Definition: DQMStore.h:64

DQMStore::reset_
bool reset_
Definition: DQMStore.h:456

DQMStore::KeepRunDirs
Definition: DQMStore.h:78

DQMDefinitions.h

DQMStore::book1DD
MonitorElement * book1DD(const char *name, const char *title, int nchX, double lowX, double highX)
Book 1S histogram.
Definition: DQMStore.cc:754

DQMStore::DQMArchiver
friend class DQMArchiver
Definition: DQMStore.h:472

DQMStore::initializeFrom
void initializeFrom(const edm::ParameterSet &)
Definition: DQMStore.cc:296

getGTfromDQMFile.obj
tuple obj
Definition: getGTfromDQMFile.py:31

DQMStore::OpenRunDirs
OpenRunDirs
Definition: DQMStore.h:76

mergeVDriftHistosByStation.name
string name
Definition: mergeVDriftHistosByStation.py:77

AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255

DQMStore::qtests_
QCMap qtests_
Definition: DQMStore.h:465

DQMStore::book
MonitorElement * book(const std::string &dir, const std::string &name, const char *context)
Definition: DQMStore.cc:577

DQMStore::bookFloat
MonitorElement * bookFloat(const char *name)
Book float.
Definition: DQMStore.cc:659

DQMStore::SaveReferenceTag
SaveReferenceTag
Definition: DQMStore.h:70

DQMStore::getAllContents
std::vector< MonitorElement * > getAllContents(const std::string &path) const
Definition: DQMStore.cc:1677

DQMStore::tag
void tag(MonitorElement *me, unsigned int myTag)
Definition: DQMStore.cc:1359

DQMStore::~DQMStore
~DQMStore(void)
Definition: DQMStore.cc:285

DQMStore::disableSoftReset
void disableSoftReset(MonitorElement *me)
Definition: DQMStore.cc:2747

DQMStore::collateProfile
static void collateProfile(MonitorElement *me, TProfile *h)
Definition: DQMStore.cc:1335

fastmatch::TwoStar
Definition: DQMStore.h:46

listBenchmarks.pattern
list pattern
Definition: listBenchmarks.py:26

DQMStore::forceReset
void forceReset(void)
Definition: DQMStore.cc:1756

fastmatch::fastmatch
fastmatch(std::string const &_fastString)
Definition: DQMStore.cc:122

DQMStore::verboseQT_
unsigned verboseQT_
Definition: DQMStore.h:455

fastmatch::OneStarStart
Definition: DQMStore.h:46

DQMStore::extract
bool extract(TObject *obj, const std::string &dir, bool overwrite)
Definition: DQMStore.cc:1776

DQMStore
Definition: DQMStore.h:67

DQMStore::qtestspecs_
QTestSpecs qtestspecs_
Definition: DQMStore.h:467

DQMStore::removeContents
void removeContents(void)
erase all monitoring elements in current directory (not including subfolders);
Definition: DQMStore.cc:2569

DQMStore::scaleFlag_
double scaleFlag_
Definition: DQMStore.h:457

DQMStore::bookString
MonitorElement * bookString(const char *name, const char *value)
Book string.
Definition: DQMStore.cc:688

DQMStore::MEMap
std::set< MonitorElement > MEMap
Definition: DQMStore.h:450

DQMStore::collate1S
static void collate1S(MonitorElement *me, TH1S *h)
Definition: DQMStore.cc:1293

DQMStore::isCollate
bool isCollate(void) const
Definition: DQMStore.cc:2786

DQMStore::removeElement
void removeElement(const std::string &name)
Definition: DQMStore.cc:2577

DQMStore::checkBinningMatches
static bool checkBinningMatches(MonitorElement *me, TH1 *h)
Definition: DQMStore.cc:1262

DQMStore::findObject
MonitorElement * findObject(const std::string &dir, const std::string &name) const
Definition: DQMStore.cc:1603

DQMStore::bookProfile
MonitorElement * bookProfile(const char *name, const char *title, int nchX, double lowX, double highX, int nchY, double lowY, double highY, const char *option="s")
Definition: DQMStore.cc:1036

DQMStore::setVerbose
void setVerbose(unsigned level)
Definition: DQMStore.cc:398

DQMStore::softReset
void softReset(MonitorElement *me)
Definition: DQMStore.cc:2739

DQMStore::pwd_
std::string pwd_
Definition: DQMStore.h:461

PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi.minStatus
tuple minStatus
Definition: PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi.py:16

DQMStore::runQTests
void runQTests(void)
Definition: DQMStore.cc:2687

fastmatch::regexp_
lat::Regexp * regexp_
Definition: DQMStore.h:62

DQMStore::qalgos_
QAMap qalgos_
Definition: DQMStore.h:466

DQMStore::getContents
std::vector< MonitorElement * > getContents(const std::string &path) const
Definition: DQMStore.cc:1502

DQMStore::readSelectedDirectory_
std::string readSelectedDirectory_
Definition: DQMStore.h:459

fastmatch::fastString_
std::string fastString_
Definition: DQMStore.h:63

ActivityRegistry

DQMStore::dirExists
bool dirExists(const std::string &path) const
true if directory exists
Definition: DQMStore.cc:498

DQMStore::getAllTags
void getAllTags(std::vector< std::string > &into) const
Definition: DQMStore.cc:1624

DQMStore::operator=
const DQMStore & operator=(const DQMStore &)

MonitorElement
Definition: MonitorElement.h:34

DQMStore::load
bool load(const std::string &filename, OpenRunDirs stripdirs=StripRunDirs, bool fileMustExist=true)
Definition: DQMStore.cc:2452

DQMStore::scaleElements
void scaleElements(void)
Definition: DQMStore.cc:2803

fastmatch::~fastmatch
~fastmatch()
Definition: DQMStore.cc:192

DQMStore::tagAllContents
void tagAllContents(const std::string &path, unsigned int myTag)
Definition: DQMStore.cc:1402

DQMStore::initialise
MonitorElement * initialise(MonitorElement *me, const std::string &path)

DQMStore::StripRunDirs
Definition: DQMStore.h:79

DQMStore::SaveWithoutReference
Definition: DQMStore.h:72

h
The Signals That Services Can Subscribe To This is based on ActivityRegistry h
Helper function to determine trigger accepts.
Definition: Activities.doc:4

DQMStore::verbose_
unsigned verbose_
Definition: DQMStore.h:454

DQMStore::QTestSpecs
std::list< QTestSpec > QTestSpecs
Definition: DQMStore.h:449

DQMStore::collate2S
static void collate2S(MonitorElement *me, TH2S *h)
Definition: DQMStore.cc:1314

DQMStore::data_
MEMap data_
Definition: DQMStore.h:462

DQMStore::collate2D
static void collate2D(MonitorElement *me, TH2F *h)
Definition: DQMStore.cc:1307

DQMStore::print_trace
void print_trace(const std::string &dir, const std::string &name)
Definition: DQMStore.cc:347

DQMStore::useQTestByMatch
int useQTestByMatch(const std::string &pattern, const std::string &qtname)
attach quality test &lt;qc&gt; to monitor elements matching &lt;pattern&gt;.
Definition: DQMStore.cc:2652

alignCSCRings.s
list s
Definition: alignCSCRings.py:91

DQMStore::getMEs
std::vector< std::string > getMEs(void) const
get list of (non-dir) MEs of current directory
Definition: DQMStore.cc:1447

DQMStore::DQMStoreExample
friend class DQMStoreExample
Definition: DQMStore.h:473

DQMStore::readDirectory
unsigned int readDirectory(TFile *file, bool overwrite, const std::string &path, const std::string &prepend, const std::string &curdir, OpenRunDirs stripdirs)
Definition: DQMStore.cc:2282

DQMStore::collate2DD
static void collate2DD(MonitorElement *me, TH2D *h)
Definition: DQMStore.cc:1321

fastmatch
Definition: DQMStore.h:43

DQMStore::tagContents
void tagContents(const std::string &path, unsigned int myTag)
tag all children of folder (does NOT include subfolders)
Definition: DQMStore.cc:1390

DQMStore::QAMap
std::map< std::string, QCriterion *(*)(const std::string &)> QAMap
Definition: DQMStore.h:452

fastmatch::UseFull
Definition: DQMStore.h:46

DQMStore::useQTest
void useQTest(const std::string &dir, const std::string &qtname)
Definition: DQMStore.cc:2634

lut2db_cfg.filename
tuple filename
Definition: lut2db_cfg.py:20

DQMStore::goUp
void goUp(void)
equivalent to &quot;cd ..&quot;
Definition: DQMStore.cc:445

DQMStore::open
bool open(const std::string &filename, bool overwrite=false, const std::string &path="", const std::string &prepend="", OpenRunDirs stripdirs=KeepRunDirs, bool fileMustExist=true)
Definition: DQMStore.cc:2437

dqm::qstatus::STATUS_OK
static const int STATUS_OK
Definition: DQMDefinitions.h:17

edm::ParameterSet
Definition: ParameterSet.h:35

DQMStore::setAccumulate
void setAccumulate(MonitorElement *me, bool flag)
Definition: DQMStore.cc:2756

testEve_cfg.level
tuple level
Definition: testEve_cfg.py:34

DQMStore::createQTest
QCriterion * createQTest(const std::string &algoname, const std::string &qtname)
Definition: DQMStore.cc:2613

dir
dbl *** dir
Definition: mlp_gen.cc:35

DQMStore::showDirStructure
void showDirStructure(void) const
Definition: DQMStore.cc:2766

DQMStore::reset
void reset(void)
Definition: DQMStore.cc:1732

DQMStore::bookInt
MonitorElement * bookInt(const char *name)
Book int.
Definition: DQMStore.cc:629

DQMStore::book2D
MonitorElement * book2D(const char *name, const char *title, int nchX, double lowX, double highX, int nchY, double lowY, double highY)
Book 2D histogram.
Definition: DQMStore.cc:850

DQMService
Definition: DQMService.h:13

DQMStore::dirs_
std::set< std::string > dirs_
Definition: DQMStore.h:463

DQMStore::collateHistograms_
bool collateHistograms_
Definition: DQMStore.h:458

DQMStore::book1S
MonitorElement * book1S(const char *name, const char *title, int nchX, double lowX, double highX)
Book 1S histogram.
Definition: DQMStore.cc:738

DQMStore::makeDirectory
void makeDirectory(const std::string &path)
get folder corresponding to inpath wrt to root (create subdirs if necessary)
Definition: DQMStore.cc:457

edm::ActivityRegistry
Definition: ActivityRegistry.h:46

fastmatch::compare_strings
bool compare_strings(std::string const &pattern, std::string const &input) const
Definition: DQMStore.cc:219

DQMStore::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:434

DQMStore::SaveWithReferenceForQTest
Definition: DQMStore.h:74

DQMStore::pwd
const std::string & pwd(void) const
Definition: DQMStore.cc:406

DQMStore::bookProfile2D
MonitorElement * bookProfile2D(const char *name, const char *title, int nchX, double lowX, double highX, int nchY, double lowY, double highY, int nchZ, double lowZ, double highZ, const char *option="s")
Definition: DQMStore.cc:1180