Logo ROOT   6.14/05
Reference Guide
Measurement.cxx
Go to the documentation of this file.
1 // @(#)root/roostats:$Id$
2 // Author: Kyle Cranmer, George Lewis
3 /*************************************************************************
4  * Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
5  * All rights reserved. *
6  * *
7  * For the licensing terms see $ROOTSYS/LICENSE. *
8  * For the list of contributors see $ROOTSYS/README/CREDITS. *
9  *************************************************************************/
10 
11 ////////////////////////////////////////////////////////////////////////////////
12 
13 /*
14 BEGIN_HTML
15 <p>
16 The RooStats::HistFactory::Measurement class can be used to construct a model
17 by combining multiple RooStats::HistFactory::Channel objects. It also allows
18 to set some general properties like the integrated luminosity, its relative
19 uncertainty or the functional form of constraints on nuisance parameters.
20 </p>
21 END_HTML
22 */
23 //
24 
25 
26 #include <ctime>
27 #include <iostream>
28 #include <algorithm>
29 #include <sys/stat.h>
30 #include "TSystem.h"
31 #include "TTimeStamp.h"
32 
35 
36 using namespace std;
37 
39 
40 
42  fPOI(), fLumi( 1.0 ), fLumiRelErr( .10 ),
43  fBinLow( 0 ), fBinHigh( 1 ), fExportOnly( false )
44 {
45  // standard constructor
46 }
47 
48 /*
49 RooStats::HistFactory::Measurement::Measurement(const Measurement& other) :
50  POI( other.POI ), Lumi( other.Lumi ), LumiRelErr( other.LumiRelErr ),
51  BinLow( other.BinLow ), BinHigh( other.BinHigh ), ExportOnly( other.ExportOnly ),
52  channels( other.channels ), OutputFilePrefix( other.outputFilePrefix ),
53  constantParams( other.constantParams ), { ; }
54 */
55 
57  TNamed( Name, Title ),
58  fPOI(), fLumi( 1.0 ), fLumiRelErr( .10 ),
59  fBinLow( 0 ), fBinHigh( 1 ), fExportOnly( false )
60 {
61  // standard constructor specifying name and title of measurement
62 }
63 
64 
66 {
67  // set a parameter in the model to be constant
68  // the parameter does not have to exist yet, the information will be used when
69  // the model is actually created
70 
71  // Check if the parameter is already set constant
72  // We don't need to set it constant twice,
73  // and we issue a warning in case this is a hint
74  // of a possible bug
75 
76  if( std::find(fConstantParams.begin(), fConstantParams.end(), param) != fConstantParams.end() ) {
77  std::cout << "Warning: Setting parameter: " << param
78  << " to constant, but it is already listed as constant. "
79  << "You may ignore this warning."
80  << std::endl;
81  return;
82  }
83 
84  fConstantParams.push_back( param );
85 
86 }
87 
88 void RooStats::HistFactory::Measurement::SetParamValue( const std::string& param, double value )
89 {
90  // set parameter of the model to given value
91 
92  // Check if this parameter is already set to a value
93  // If so, issue a warning
94  // (Not sure if we want to throw an exception here, or
95  // issue a warning and move along. Thoughts?)
96  if( fParamValues.find(param) != fParamValues.end() ) {
97  std::cout << "Warning: Chainging parameter: " << param
98  << " value from: " << fParamValues[param]
99  << " to: " << value
100  << std::endl;
101  }
102 
103  // Store the parameter and its value
104  std::cout << "Setting parameter: " << param
105  << " value to " << value
106  << std::endl;
107 
108  fParamValues[param] = value;
109 
110 }
111 
112 void RooStats::HistFactory::Measurement::AddPreprocessFunction( std::string name, std::string expression, std::string dependencies )
113 {
114  // Add a preprocessed function by giving the function a name,
115  // a functional expression, and a string with a bracketed list of dependencies (eg "SigXsecOverSM[0,3]")
116 
117  PreprocessFunction func(name, expression, dependencies);
118  AddFunctionObject(func);
119 
120 }
121 
122 
124 {
125  // returns a list of defined proprocess function expressions
126 
127  std::vector<std::string> PreprocessFunctionExpressions;
128  for( unsigned int i = 0; i < fFunctionObjects.size(); ++i ) {
129  std::string expression = fFunctionObjects.at(i).GetCommand();
130  PreprocessFunctionExpressions.push_back( expression );
131  }
132  return PreprocessFunctionExpressions;
133 }
134 
135 void RooStats::HistFactory::Measurement::AddGammaSyst(std::string syst, double uncert)
136 {
137  // set constraint term for given systematic to Gamma distribution
138 
139  fGammaSyst[syst] = uncert;
140 }
141 
142 void RooStats::HistFactory::Measurement::AddLogNormSyst(std::string syst, double uncert)
143 {
144  // set constraint term for given systematic to LogNormal distribution
145 
146  fLogNormSyst[syst] = uncert;
147 }
148 
150 {
151  // set constraint term for given systematic to uniform distribution
152 
153  fUniformSyst[syst] = 1.0; // Is this parameter simply a dummy?
154 }
155 
157 {
158  // define given systematics to have no external constraint
159 
160  fNoSyst[syst] = 1.0; // dummy value
161 }
162 
163 
165 {
166  // is the given channel part of this measurement
167 
168  for( unsigned int i = 0; i < fChannels.size(); ++i ) {
169 
170  Channel& chan = fChannels.at(i);
171  if( chan.GetName() == ChanName ) {
172  return true;
173  }
174 
175  }
176 
177  return false;
178 
179 }
180 
182 {
183  // get channel with given name from this measurement
184  // throws an exception in case the channel is not found
185 
186  for( unsigned int i = 0; i < fChannels.size(); ++i ) {
187 
188  Channel& chan = fChannels.at(i);
189  if( chan.GetName() == ChanName ) {
190  return chan;
191  }
192 
193  }
194 
195  // If we get here, we didn't find the channel
196 
197  std::cout << "Error: Did not find channel: " << ChanName
198  << " in measurement: " << GetName() << std::endl;
199  throw hf_exc();
200 
201  // No Need to return after throwing exception
202  // return RooStats::HistFactory::BadChannel;
203 
204 
205 }
206 
207 /*
208  void RooStats::HistFactory::Measurement::Print( Option_t* option ) const {
209  RooStats::HistFactory::Measurement::Print( std::cout );
210  return;
211  }
212 */
213 
215 {
216  // print information about measurement object in tree-like structure to given stream
217 
218  stream << "Measurement Name: " << GetName()
219  << "\t OutputFilePrefix: " << fOutputFilePrefix
220  << "\t POI: ";
221  for(unsigned int i = 0; i < fPOI.size(); ++i) {
222  stream << fPOI.at(i);
223  }
224  stream << "\t Lumi: " << fLumi
225  << "\t LumiRelErr: " << fLumiRelErr
226  << "\t BinLow: " << fBinLow
227  << "\t BinHigh: " << fBinHigh
228  << "\t ExportOnly: " << fExportOnly
229  << std::endl;
230 
231 
232  if( fConstantParams.size() != 0 ) {
233  stream << "Constant Params: ";
234  for( unsigned int i = 0; i < fConstantParams.size(); ++i ) {
235  stream << " " << fConstantParams.at(i);
236  }
237  stream << std::endl;
238  }
239 
240  if( fFunctionObjects.size() != 0 ) {
241  stream << "Preprocess Functions: ";
242  for( unsigned int i = 0; i < fFunctionObjects.size(); ++i ) {
243  stream << " " << fFunctionObjects.at(i).GetCommand();
244  }
245  stream << std::endl;
246  }
247 
248  if( fChannels.size() != 0 ) {
249  stream << "Channels:" << std::endl;
250  for( unsigned int i = 0; i < fChannels.size(); ++i ) {
251  fChannels.at(i).Print( stream );
252  }
253  }
254 
255  std::cout << "End Measurement: " << GetName() << std::endl;
256 
257 }
258 
259 
260 
261 void RooStats::HistFactory::Measurement::PrintXML( std::string directory, std::string newOutputPrefix )
262 {
263  // create XML files for this measurement in the given directory
264  // XML files can be configured with a different output prefix
265 
266  // Create an XML file for this measurement
267  // First, create the XML driver
268  // Then, create xml files for each channel
269 
270  // First, check that the directory exists:
271  auto testExists = [](const std::string& theDirectory) {
272  void* dir = gSystem->OpenDirectory(theDirectory.c_str());
273  bool exists = dir != nullptr;
274  if (exists)
275  gSystem->FreeDirectory(dir);
276 
277  return exists;
278  };
279 
280  if ( !directory.empty() && !testExists(directory) ) {
281  int success = gSystem->MakeDirectory(directory.c_str() );
282  if( success != 0 ) {
283  std::cout << "Error: Failed to make directory: " << directory << std::endl;
284  throw hf_exc();
285  }
286  }
287 
288  // If supplied new Prefix, use that one:
289 
290  std::cout << "Printing XML Files for measurement: " << GetName() << std::endl;
291 
292  std::string XMLName = std::string(GetName()) + ".xml";
293  if( directory != "" ) XMLName = directory + "/" + XMLName;
294 
295  ofstream xml( XMLName.c_str() );
296 
297  if( ! xml.is_open() ) {
298  std::cout << "Error opening xml file: " << XMLName << std::endl;
299  throw hf_exc();
300  }
301 
302 
303  // Add the time
304  xml << "<!--" << std::endl;
305  xml << "This xml file created automatically on: " << std::endl;
306 /*
307  time_t t = time(0); // get time now
308  struct tm * now = localtime( &t );
309  xml << (now->tm_year + 1900) << '-'
310  << (now->tm_mon + 1) << '-'
311  << now->tm_mday
312  << std::endl;
313 */
314  // LM: use TTimeStamp
315  TTimeStamp t;
316  UInt_t year = 0;
317  UInt_t month = 0;
318  UInt_t day = 0;
319  t.GetDate(true, 0, &year, &month, &day);
320  xml << year << '-'
321  << month << '-'
322  << day
323  << std::endl;
324 
325  xml << "-->" << std::endl;
326 
327  // Add the doctype
328  xml << "<!DOCTYPE Combination SYSTEM 'HistFactorySchema.dtd'>" << std::endl << std::endl;
329 
330  // Add the combination name
331  if (newOutputPrefix.empty() ) newOutputPrefix = fOutputFilePrefix;
332  xml << "<Combination OutputFilePrefix=\"" << newOutputPrefix /*OutputFilePrefix*/ << "\" >" << std::endl << std::endl;
333 
334  // Add the Preprocessed Functions
335  for( unsigned int i = 0; i < fFunctionObjects.size(); ++i ) {
337  func.PrintXML(xml);
338  /*
339  xml << "<Function Name=\"" << func.GetName() << "\" "
340  << "Expression=\"" << func.GetExpression() << "\" "
341  << "Dependents=\"" << func.GetDependents() << "\" "
342  << "/>" << std::endl;
343  */
344  }
345 
346  xml << std::endl;
347 
348  // Add the list of channels
349  for( unsigned int i = 0; i < fChannels.size(); ++i ) {
350  xml << " <Input>" << "./";
351  if (!directory.empty() ) xml << directory << "/";
352  xml << GetName() << "_" << fChannels.at(i).GetName() << ".xml" << "</Input>" << std::endl;
353  }
354 
355  xml << std::endl;
356 
357  // Open the Measurement, Set Lumi
358  xml << " <Measurement Name=\"" << GetName() << "\" "
359  << "Lumi=\"" << fLumi << "\" "
360  << "LumiRelErr=\"" << fLumiRelErr << "\" "
361  //<< "BinLow=\"" << fBinLow << "\" "
362  // << "BinHigh=\"" << fBinHigh << "\" "
363  << "ExportOnly=\"" << (fExportOnly ? std::string("True") : std::string("False")) << "\" "
364  << " >" << std::endl;
365 
366 
367  // Set the POI
368  xml << " <POI>" ;
369  for(unsigned int i = 0; i < fPOI.size(); ++i) {
370  if(i==0) xml << fPOI.at(i);
371  else xml << " " << fPOI.at(i);
372  }
373  xml << "</POI> " << std::endl;
374 
375  // Set the Constant Parameters
376  if(fConstantParams.size()) {
377  xml << " <ParamSetting Const=\"True\">";
378  for( unsigned int i = 0; i < fConstantParams.size(); ++i ) {
379  if (i==0) xml << fConstantParams.at(i);
380  else xml << " " << fConstantParams.at(i);;
381  }
382  xml << "</ParamSetting>" << std::endl;
383  }
384 
385  // Set the Parameters with new Constraint Terms
386  std::map<std::string, double>::iterator ConstrItr;
387 
388  // Gamma
389  for( ConstrItr = fGammaSyst.begin(); ConstrItr != fGammaSyst.end(); ++ConstrItr ) {
390  xml << "<ConstraintTerm Type=\"Gamma\" RelativeUncertainty=\""
391  << ConstrItr->second << "\">" << ConstrItr->first
392  << "</ConstraintTerm>" << std::endl;
393  }
394  // Uniform
395  for( ConstrItr = fUniformSyst.begin(); ConstrItr != fUniformSyst.end(); ++ConstrItr ) {
396  xml << "<ConstraintTerm Type=\"Uniform\" RelativeUncertainty=\""
397  << ConstrItr->second << "\">" << ConstrItr->first
398  << "</ConstraintTerm>" << std::endl;
399  }
400  // LogNormal
401  for( ConstrItr = fLogNormSyst.begin(); ConstrItr != fLogNormSyst.end(); ++ConstrItr ) {
402  xml << "<ConstraintTerm Type=\"LogNormal\" RelativeUncertainty=\""
403  << ConstrItr->second << "\">" << ConstrItr->first
404  << "</ConstraintTerm>" << std::endl;
405  }
406  // NoSyst
407  for( ConstrItr = fNoSyst.begin(); ConstrItr != fNoSyst.end(); ++ConstrItr ) {
408  xml << "<ConstraintTerm Type=\"NoSyst\" RelativeUncertainty=\""
409  << ConstrItr->second << "\">" << ConstrItr->first
410  << "</ConstraintTerm>" << std::endl;
411  }
412 
413 
414  // Close the Measurement
415  xml << " </Measurement> " << std::endl << std::endl;
416 
417  // Close the combination
418  xml << "</Combination>" << std::endl;
419 
420  xml.close();
421 
422  // Now, make the xml files
423  // for the individual channels:
424 
425  std::string prefix = std::string(GetName()) + "_";
426 
427  for( unsigned int i = 0; i < fChannels.size(); ++i ) {
428  fChannels.at(i).PrintXML( directory, prefix );
429  }
430 
431 
432  std::cout << "Finished printing XML files" << std::endl;
433 
434 }
435 
436 
437 
439 {
440  // A measurement, once fully configured, can be saved into a ROOT
441  // file. This will persitify the Measurement object, along with any
442  // channels and samples that have been added to it. It can then be
443  // loaded, potentially modified, and used to create new models.
444 
445  // Write every histogram to the file.
446  // Edit the measurement to point to this file
447  // and to point to each histogram in this file
448  // Then write the measurement itself.
449 
450  // Create a tempory measurement
451  // (This is the one that is actually written)
452  RooStats::HistFactory::Measurement outMeas( *this );
453 
454  std::string OutputFileName = file->GetName();
455 
456  // Collect all histograms from file:
457  // HistCollector collector;
458 
459 
460  for( unsigned int chanItr = 0; chanItr < outMeas.fChannels.size(); ++chanItr ) {
461 
462  // Go to the main directory
463  // in the file
464  file->cd();
465  file->Flush();
466 
467  // Get the name of the channel:
468  RooStats::HistFactory::Channel& channel = outMeas.fChannels.at( chanItr );
469  std::string chanName = channel.GetName();
470 
471 
472  if( ! channel.CheckHistograms() ) {
473  std::cout << "Measurement.writeToFile(): Channel: " << chanName
474  << " has uninitialized histogram pointers" << std::endl;
475  throw hf_exc();
476  return;
477  }
478 
479  // Get and cache the histograms for this channel:
480  //collector.CollectHistograms( channel );
481  // Do I need this...?
482  // channel.CollectHistograms();
483 
484  // Make a directory to store the histograms
485  // for this channel
486 
487  TDirectory* chanDir = file->mkdir( (chanName + "_hists").c_str() );
488  if( chanDir == NULL ) {
489  std::cout << "Error: Cannot create channel " << (chanName + "_hists")
490  << std::endl;
491  throw hf_exc();
492  }
493  chanDir->cd();
494 
495  // Save the data:
496  TDirectory* dataDir = chanDir->mkdir( "data" );
497  if( dataDir == NULL ) {
498  std::cout << "Error: Cannot make directory " << chanDir << std::endl;
499  throw hf_exc();
500  }
501  dataDir->cd();
502 
503  channel.fData.writeToFile( OutputFileName, GetDirPath(dataDir) );
504 
505  /*
506  // Write the data file to this directory
507  TH1* hData = channel.data.GetHisto();
508  hData->Write();
509 
510  // Set the location of the data
511  // in the output measurement
512 
513  channel.data.InputFile = OutputFileName;
514  channel.data.HistoName = hData->GetName();
515  channel.data.HistoPath = GetDirPath( dataDir );
516  */
517 
518  // Loop over samples:
519 
520  for( unsigned int sampItr = 0; sampItr < channel.GetSamples().size(); ++sampItr ) {
521 
522  RooStats::HistFactory::Sample& sample = channel.GetSamples().at( sampItr );
523  std::string sampName = sample.GetName();
524 
525  std::cout << "Writing sample: " << sampName << std::endl;
526 
527  file->cd();
528  chanDir->cd();
529  TDirectory* sampleDir = chanDir->mkdir( sampName.c_str() );
530  if( sampleDir == NULL ) {
531  std::cout << "Error: Directory " << sampName << " not created properly" << std::endl;
532  throw hf_exc();
533  }
534  std::string sampleDirPath = GetDirPath( sampleDir );
535 
536  if( ! sampleDir ) {
537  std::cout << "Error making directory: " << sampName
538  << " in directory: " << chanName
539  << std::endl;
540  throw hf_exc();
541  }
542 
543  // Write the data file to this directory
544  sampleDir->cd();
545 
546  sample.writeToFile( OutputFileName, sampleDirPath );
547  /*
548  TH1* hSample = sample.GetHisto();
549  if( ! hSample ) {
550  std::cout << "Error getting histogram for sample: "
551  << sampName << std::endl;
552  throw -1;
553  }
554  sampleDir->cd();
555  hSample->Write();
556 
557  sample.InputFile = OutputFileName;
558  sample.HistoName = hSample->GetName();
559  sample.HistoPath = sampleDirPath;
560  */
561 
562  // Write the histograms associated with
563  // systematics
564 
565  /* THIS IS WHAT I"M COMMENTING
566  sample.GetStatError().writeToFile( OutputFileName, sampleDirPath );
567 
568  // Must write all systematics that contain internal histograms
569  // (This is not all systematics)
570 
571  for( unsigned int i = 0; i < sample.GetHistoSysList().size(); ++i ) {
572  sample.GetHistoSysList().at(i).writeToFile( OutputFileName, sampleDirPath );
573  }
574  for( unsigned int i = 0; i < sample.GetHistoFactorList().size(); ++i ) {
575  sample.GetHistoFactorList().at(i).writeToFile( OutputFileName, sampleDirPath );
576  }
577  for( unsigned int i = 0; i < sample.GetShapeSysList().size(); ++i ) {
578  sample.GetShapeSysList().at(i).writeToFile( OutputFileName, sampleDirPath );
579  }
580  END COMMENT */
581  /*
582  sample.statError.writeToFile( OutputFileName, sampleDirPath );
583 
584  // Now, get the Stat config histograms
585  if( sample.statError.HistoName != "" ) {
586  TH1* hStatError = sample.statError.GetErrorHist();
587  if( ! hStatError ) {
588  std::cout << "Error getting stat error histogram for sample: "
589  << sampName << std::endl;
590  throw -1;
591  }
592  hStatError->Write();
593 
594  sample.statError.InputFile = OutputFileName;
595  sample.statError.HistoName = hStatError->GetName();
596  sample.statError.HistoPath = sampleDirPath;
597 
598  }
599  */
600 
601  }
602 
603  }
604 
605 
606  // Finally, write the measurement itself:
607 
608  std::cout << "Saved all histograms" << std::endl;
609 
610  file->cd();
611  outMeas.Write();
612 
613  std::cout << "Saved Measurement" << std::endl;
614 
615 }
616 
617 
619 {
620  // Return the directory's path,
621  // stripped of unnecessary prefixes
622 
623  std::string path = dir->GetPath();
624 
625  if( path.find(":") != std::string::npos ) {
626  size_t index = path.find(":");
627  path.replace( 0, index+1, "" );
628  }
629 
630  path = path + "/";
631 
632  return path;
633 
634  /*
635  if( path.find(":") != std::string::npos ) {
636  size_t index = path.find(":");
637  SampleName.replace( 0, index, "" );
638  }
639 
640  // Remove the file:
641  */
642 
643 }
644 
645 
646 
648 {
649  // The most common way to add histograms to channels is to have them
650  // stored in ROOT files and to give HistFactory the location of these
651  // files. This means providing the path to the ROOT file and the path
652  // and name of the histogram within that file. When providing these
653  // in a script, HistFactory doesn't load the histogram from the file
654  // right away. Instead, once all such histograms have been supplied,
655  // one should run this method to open all ROOT files and to copy and
656  // save all necessary histograms.
657 
658  for( unsigned int chanItr = 0; chanItr < fChannels.size(); ++chanItr) {
659 
660  RooStats::HistFactory::Channel& chan = fChannels.at( chanItr );
661 
662  chan.CollectHistograms();
663 
664  }
665 
666 }
667 
668 
669 
void AddUniformSyst(std::string syst)
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:47
virtual Int_t Write(const char *name=0, Int_t option=0, Int_t bufsize=0)
Write this object to the current directory.
Definition: TObject.cxx:785
std::map< std::string, double > fGammaSyst
Definition: Measurement.h:155
void PrintXML(std::string Directory="", std::string NewOutputPrefix="")
const char * Title
Definition: TXMLSetup.cxx:67
virtual int MakeDirectory(const char *name)
Make a directory.
Definition: TSystem.cxx:825
void AddPreprocessFunction(std::string name, std::string expression, std::string dependencies)
virtual TDirectory * mkdir(const char *name, const char *title="")
Create a sub-directory "a" or a hierarchy of sub-directories "a/b/c/...".
STL namespace.
const char * Name
Definition: TXMLSetup.cxx:66
std::vector< std::string > GetPreprocessFunctions()
std::vector< RooStats::HistFactory::Channel > fChannels
Definition: Measurement.h:140
std::map< std::string, double > fParamValues
Definition: Measurement.h:146
void AddFunctionObject(const RooStats::HistFactory::PreprocessFunction function)
Definition: Measurement.h:72
The TNamed class is the base class for all named ROOT classes.
Definition: TNamed.h:29
std::string GetDirPath(TDirectory *dir)
std::string GetName()
Definition: Sample.h:82
std::vector< std::string > fConstantParams
Definition: Measurement.h:143
void writeToFile(std::string FileName, std::string DirName)
Definition: Data.cxx:57
void writeToFile(std::string FileName, std::string DirName)
Definition: Sample.cxx:80
void AddGammaSyst(std::string syst, double uncert)
R__EXTERN TSystem * gSystem
Definition: TSystem.h:540
void AddConstantParam(const std::string &param)
Definition: Measurement.cxx:65
unsigned int UInt_t
Definition: RtypesCore.h:42
std::vector< std::string > fPOI
Definition: Measurement.h:131
virtual const char * GetPath() const
Returns the full path of the directory.
Definition: TDirectory.cxx:987
virtual void FreeDirectory(void *dirp)
Free a directory.
Definition: TSystem.cxx:843
#define ClassImp(name)
Definition: Rtypes.h:359
Describe directory structure in memory.
Definition: TDirectory.h:34
The TTimeStamp encapsulates seconds and ns since EPOCH.
Definition: TTimeStamp.h:71
void AddNoSyst(std::string syst)
std::vector< RooStats::HistFactory::Sample > & GetSamples()
Definition: Channel.h:71
RooStats::HistFactory::Channel & GetChannel(std::string)
void SetParamValue(const std::string &param, double value)
Definition: Measurement.cxx:88
std::map< std::string, double > fLogNormSyst
Definition: Measurement.h:157
std::map< std::string, double > fUniformSyst
Definition: Measurement.h:156
std::map< std::string, double > fNoSyst
Definition: Measurement.h:158
virtual Bool_t cd(const char *path=0)
Change current directory to "this" directory.
Definition: TDirectory.cxx:497
Definition: file.py:1
void AddLogNormSyst(std::string syst, double uncert)
UInt_t GetDate(Bool_t inUTC=kTRUE, Int_t secOffset=0, UInt_t *year=0, UInt_t *month=0, UInt_t *day=0) const
Return date in form of 19971224 (i.e.
Definition: TTimeStamp.cxx:353
void PrintTree(std::ostream &=std::cout)
virtual void * OpenDirectory(const char *name)
Open a directory. Returns 0 if directory does not exist.
Definition: TSystem.cxx:834
HistFactory::Data fData
Definition: Channel.h:85
std::vector< RooStats::HistFactory::PreprocessFunction > fFunctionObjects
Definition: Measurement.h:149
char name[80]
Definition: TGX11.cxx:109