Logo ROOT   6.12/07
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 
272  if( directory != "" && gSystem->OpenDirectory( directory.c_str() ) == 0 ) {
273  int success = gSystem->MakeDirectory(directory.c_str() );
274  if( success != 0 ) {
275  std::cout << "Error: Failed to make directory: " << directory << std::endl;
276  throw hf_exc();
277  }
278  }
279 
280  // If supplied new Prefix, use that one:
281 
282  std::cout << "Printing XML Files for measurement: " << GetName() << std::endl;
283 
284  std::string XMLName = std::string(GetName()) + ".xml";
285  if( directory != "" ) XMLName = directory + "/" + XMLName;
286 
287  ofstream xml( XMLName.c_str() );
288 
289  if( ! xml.is_open() ) {
290  std::cout << "Error opening xml file: " << XMLName << std::endl;
291  throw hf_exc();
292  }
293 
294 
295  // Add the time
296  xml << "<!--" << std::endl;
297  xml << "This xml file created automatically on: " << std::endl;
298 /*
299  time_t t = time(0); // get time now
300  struct tm * now = localtime( &t );
301  xml << (now->tm_year + 1900) << '-'
302  << (now->tm_mon + 1) << '-'
303  << now->tm_mday
304  << std::endl;
305 */
306  // LM: use TTimeStamp
307  TTimeStamp t;
308  UInt_t year = 0;
309  UInt_t month = 0;
310  UInt_t day = 0;
311  t.GetDate(true, 0, &year, &month, &day);
312  xml << year << '-'
313  << month << '-'
314  << day
315  << std::endl;
316 
317  xml << "-->" << std::endl;
318 
319  // Add the doctype
320  xml << "<!DOCTYPE Combination SYSTEM 'HistFactorySchema.dtd'>" << std::endl << std::endl;
321 
322  // Add the combination name
323  if (newOutputPrefix.empty() ) newOutputPrefix = fOutputFilePrefix;
324  xml << "<Combination OutputFilePrefix=\"" << newOutputPrefix /*OutputFilePrefix*/ << "\" >" << std::endl << std::endl;
325 
326  // Add the Preprocessed Functions
327  for( unsigned int i = 0; i < fFunctionObjects.size(); ++i ) {
329  func.PrintXML(xml);
330  /*
331  xml << "<Function Name=\"" << func.GetName() << "\" "
332  << "Expression=\"" << func.GetExpression() << "\" "
333  << "Dependents=\"" << func.GetDependents() << "\" "
334  << "/>" << std::endl;
335  */
336  }
337 
338  xml << std::endl;
339 
340  // Add the list of channels
341  for( unsigned int i = 0; i < fChannels.size(); ++i ) {
342  xml << " <Input>" << "./";
343  if (!directory.empty() ) xml << directory << "/";
344  xml << GetName() << "_" << fChannels.at(i).GetName() << ".xml" << "</Input>" << std::endl;
345  }
346 
347  xml << std::endl;
348 
349  // Open the Measurement, Set Lumi
350  xml << " <Measurement Name=\"" << GetName() << "\" "
351  << "Lumi=\"" << fLumi << "\" "
352  << "LumiRelErr=\"" << fLumiRelErr << "\" "
353  //<< "BinLow=\"" << fBinLow << "\" "
354  // << "BinHigh=\"" << fBinHigh << "\" "
355  << "ExportOnly=\"" << (fExportOnly ? std::string("True") : std::string("False")) << "\" "
356  << " >" << std::endl;
357 
358 
359  // Set the POI
360  xml << " <POI>" ;
361  for(unsigned int i = 0; i < fPOI.size(); ++i) {
362  if(i==0) xml << fPOI.at(i);
363  else xml << " " << fPOI.at(i);
364  }
365  xml << "</POI> " << std::endl;
366 
367  // Set the Constant Parameters
368  if(fConstantParams.size()) {
369  xml << " <ParamSetting Const=\"True\">";
370  for( unsigned int i = 0; i < fConstantParams.size(); ++i ) {
371  if (i==0) xml << fConstantParams.at(i);
372  else xml << " " << fConstantParams.at(i);;
373  }
374  xml << "</ParamSetting>" << std::endl;
375  }
376 
377  // Set the Parameters with new Constraint Terms
378  std::map<std::string, double>::iterator ConstrItr;
379 
380  // Gamma
381  for( ConstrItr = fGammaSyst.begin(); ConstrItr != fGammaSyst.end(); ++ConstrItr ) {
382  xml << "<ConstraintTerm Type=\"Gamma\" RelativeUncertainty=\""
383  << ConstrItr->second << "\">" << ConstrItr->first
384  << "</ConstraintTerm>" << std::endl;
385  }
386  // Uniform
387  for( ConstrItr = fUniformSyst.begin(); ConstrItr != fUniformSyst.end(); ++ConstrItr ) {
388  xml << "<ConstraintTerm Type=\"Uniform\" RelativeUncertainty=\""
389  << ConstrItr->second << "\">" << ConstrItr->first
390  << "</ConstraintTerm>" << std::endl;
391  }
392  // LogNormal
393  for( ConstrItr = fLogNormSyst.begin(); ConstrItr != fLogNormSyst.end(); ++ConstrItr ) {
394  xml << "<ConstraintTerm Type=\"LogNormal\" RelativeUncertainty=\""
395  << ConstrItr->second << "\">" << ConstrItr->first
396  << "</ConstraintTerm>" << std::endl;
397  }
398  // NoSyst
399  for( ConstrItr = fNoSyst.begin(); ConstrItr != fNoSyst.end(); ++ConstrItr ) {
400  xml << "<ConstraintTerm Type=\"NoSyst\" RelativeUncertainty=\""
401  << ConstrItr->second << "\">" << ConstrItr->first
402  << "</ConstraintTerm>" << std::endl;
403  }
404 
405 
406  // Close the Measurement
407  xml << " </Measurement> " << std::endl << std::endl;
408 
409  // Close the combination
410  xml << "</Combination>" << std::endl;
411 
412  xml.close();
413 
414  // Now, make the xml files
415  // for the individual channels:
416 
417  std::string prefix = std::string(GetName()) + "_";
418 
419  for( unsigned int i = 0; i < fChannels.size(); ++i ) {
420  fChannels.at(i).PrintXML( directory, prefix );
421  }
422 
423 
424  std::cout << "Finished printing XML files" << std::endl;
425 
426 }
427 
428 
429 
431 {
432  // A measurement, once fully configured, can be saved into a ROOT
433  // file. This will persitify the Measurement object, along with any
434  // channels and samples that have been added to it. It can then be
435  // loaded, potentially modified, and used to create new models.
436 
437  // Write every histogram to the file.
438  // Edit the measurement to point to this file
439  // and to point to each histogram in this file
440  // Then write the measurement itself.
441 
442  // Create a tempory measurement
443  // (This is the one that is actually written)
444  RooStats::HistFactory::Measurement outMeas( *this );
445 
446  std::string OutputFileName = file->GetName();
447 
448  // Collect all histograms from file:
449  // HistCollector collector;
450 
451 
452  for( unsigned int chanItr = 0; chanItr < outMeas.fChannels.size(); ++chanItr ) {
453 
454  // Go to the main directory
455  // in the file
456  file->cd();
457  file->Flush();
458 
459  // Get the name of the channel:
460  RooStats::HistFactory::Channel& channel = outMeas.fChannels.at( chanItr );
461  std::string chanName = channel.GetName();
462 
463 
464  if( ! channel.CheckHistograms() ) {
465  std::cout << "Measurement.writeToFile(): Channel: " << chanName
466  << " has uninitialized histogram pointers" << std::endl;
467  throw hf_exc();
468  return;
469  }
470 
471  // Get and cache the histograms for this channel:
472  //collector.CollectHistograms( channel );
473  // Do I need this...?
474  // channel.CollectHistograms();
475 
476  // Make a directory to store the histograms
477  // for this channel
478 
479  TDirectory* chanDir = file->mkdir( (chanName + "_hists").c_str() );
480  if( chanDir == NULL ) {
481  std::cout << "Error: Cannot create channel " << (chanName + "_hists")
482  << std::endl;
483  throw hf_exc();
484  }
485  chanDir->cd();
486 
487  // Save the data:
488  TDirectory* dataDir = chanDir->mkdir( "data" );
489  if( dataDir == NULL ) {
490  std::cout << "Error: Cannot make directory " << chanDir << std::endl;
491  throw hf_exc();
492  }
493  dataDir->cd();
494 
495  channel.fData.writeToFile( OutputFileName, GetDirPath(dataDir) );
496 
497  /*
498  // Write the data file to this directory
499  TH1* hData = channel.data.GetHisto();
500  hData->Write();
501 
502  // Set the location of the data
503  // in the output measurement
504 
505  channel.data.InputFile = OutputFileName;
506  channel.data.HistoName = hData->GetName();
507  channel.data.HistoPath = GetDirPath( dataDir );
508  */
509 
510  // Loop over samples:
511 
512  for( unsigned int sampItr = 0; sampItr < channel.GetSamples().size(); ++sampItr ) {
513 
514  RooStats::HistFactory::Sample& sample = channel.GetSamples().at( sampItr );
515  std::string sampName = sample.GetName();
516 
517  std::cout << "Writing sample: " << sampName << std::endl;
518 
519  file->cd();
520  chanDir->cd();
521  TDirectory* sampleDir = chanDir->mkdir( sampName.c_str() );
522  if( sampleDir == NULL ) {
523  std::cout << "Error: Directory " << sampName << " not created properly" << std::endl;
524  throw hf_exc();
525  }
526  std::string sampleDirPath = GetDirPath( sampleDir );
527 
528  if( ! sampleDir ) {
529  std::cout << "Error making directory: " << sampName
530  << " in directory: " << chanName
531  << std::endl;
532  throw hf_exc();
533  }
534 
535  // Write the data file to this directory
536  sampleDir->cd();
537 
538  sample.writeToFile( OutputFileName, sampleDirPath );
539  /*
540  TH1* hSample = sample.GetHisto();
541  if( ! hSample ) {
542  std::cout << "Error getting histogram for sample: "
543  << sampName << std::endl;
544  throw -1;
545  }
546  sampleDir->cd();
547  hSample->Write();
548 
549  sample.InputFile = OutputFileName;
550  sample.HistoName = hSample->GetName();
551  sample.HistoPath = sampleDirPath;
552  */
553 
554  // Write the histograms associated with
555  // systematics
556 
557  /* THIS IS WHAT I"M COMMENTING
558  sample.GetStatError().writeToFile( OutputFileName, sampleDirPath );
559 
560  // Must write all systematics that contain internal histograms
561  // (This is not all systematics)
562 
563  for( unsigned int i = 0; i < sample.GetHistoSysList().size(); ++i ) {
564  sample.GetHistoSysList().at(i).writeToFile( OutputFileName, sampleDirPath );
565  }
566  for( unsigned int i = 0; i < sample.GetHistoFactorList().size(); ++i ) {
567  sample.GetHistoFactorList().at(i).writeToFile( OutputFileName, sampleDirPath );
568  }
569  for( unsigned int i = 0; i < sample.GetShapeSysList().size(); ++i ) {
570  sample.GetShapeSysList().at(i).writeToFile( OutputFileName, sampleDirPath );
571  }
572  END COMMENT */
573  /*
574  sample.statError.writeToFile( OutputFileName, sampleDirPath );
575 
576  // Now, get the Stat config histograms
577  if( sample.statError.HistoName != "" ) {
578  TH1* hStatError = sample.statError.GetErrorHist();
579  if( ! hStatError ) {
580  std::cout << "Error getting stat error histogram for sample: "
581  << sampName << std::endl;
582  throw -1;
583  }
584  hStatError->Write();
585 
586  sample.statError.InputFile = OutputFileName;
587  sample.statError.HistoName = hStatError->GetName();
588  sample.statError.HistoPath = sampleDirPath;
589 
590  }
591  */
592 
593  }
594 
595  }
596 
597 
598  // Finally, write the measurement itself:
599 
600  std::cout << "Saved all histograms" << std::endl;
601 
602  file->cd();
603  outMeas.Write();
604 
605  std::cout << "Saved Measurement" << std::endl;
606 
607 }
608 
609 
611 {
612  // Return the directory's path,
613  // stripped of unnecessary prefixes
614 
615  std::string path = dir->GetPath();
616 
617  if( path.find(":") != std::string::npos ) {
618  size_t index = path.find(":");
619  path.replace( 0, index+1, "" );
620  }
621 
622  path = path + "/";
623 
624  return path;
625 
626  /*
627  if( path.find(":") != std::string::npos ) {
628  size_t index = path.find(":");
629  SampleName.replace( 0, index, "" );
630  }
631 
632  // Remove the file:
633  */
634 
635 }
636 
637 
638 
640 {
641  // The most common way to add histograms to channels is to have them
642  // stored in ROOT files and to give HistFactory the location of these
643  // files. This means providing the path to the ROOT file and the path
644  // and name of the histogram within that file. When providing these
645  // in a script, HistFactory doesn't load the histogram from the file
646  // right away. Instead, once all such histograms have been supplied,
647  // one should run this method to open all ROOT files and to copy and
648  // save all necessary histograms.
649 
650  for( unsigned int chanItr = 0; chanItr < fChannels.size(); ++chanItr) {
651 
652  RooStats::HistFactory::Channel& chan = fChannels.at( chanItr );
653 
654  chan.CollectHistograms();
655 
656  }
657 
658 }
659 
660 
661 
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
#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