RooAbsHiddenReal.cxx

Go to the documentation of this file.

/*****************************************************************************
 * Project: RooFit                                                           *
 * Package: RooFitCore                                                       *
 * @(#)root/roofitcore:$Id$
 * Authors:                                                                  *
 *   WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu       *
 *   DK, David Kirkby,    UC Irvine,         dkirkby@uci.edu                 *
 *                                                                           *
 * Copyright (c) 2000-2005, Regents of the University of California          *
 *                          and Stanford University. All rights reserved.    *
 *                                                                           *
 * Redistribution and use in source and binary forms,                        *
 * with or without modification, are permitted according to the terms        *
 * listed in LICENSE (http://roofit.sourceforge.net/license.txt)             *
 *****************************************************************************/
 
/**
\file RooAbsHiddenReal.cxx
\class RooAbsHiddenReal
\ingroup Roofitcore
 
Base class for objects that want to hide
their return value from interactive use, e.g. for implementations
of parameter unblinding functions. This class overrides all
printing methods with versions that do not reveal the objects value
and it has a protected version of getVal()
**/
 
#include "Riostream.h"
 
#include "RooArgSet.h"
#include "RooAbsHiddenReal.h"
#include "RooCategory.h"
#include "RooMsgService.h"
 
using namespace std;
 
ClassImp(RooAbsHiddenReal);
;
 
RooCategory* RooAbsHiddenReal::_dummyBlindState = nullptr;
 
 
////////////////////////////////////////////////////////////////////////////////
/// Constructor
 
RooAbsHiddenReal::RooAbsHiddenReal(const char *name, const char *title, const char* unit)
  : RooAbsReal(name,title,unit),
    _state("state","Blinding state",this,dummyBlindState())
{
}
 
 
 
////////////////////////////////////////////////////////////////////////////////
/// Constructor
 
RooAbsHiddenReal::RooAbsHiddenReal(const char *name, const char *title, RooAbsCategory& blindState, const char* unit)
  : RooAbsReal(name,title,unit),
  _state("state","Blinding state",this,blindState)
{
}
 
 
 
////////////////////////////////////////////////////////////////////////////////
/// Copy constructor
 
RooAbsHiddenReal::RooAbsHiddenReal(const RooAbsHiddenReal& other, const char* name) :
  RooAbsReal(other, name),
  _state("state",this,other._state)
{
}
 
 
 
////////////////////////////////////////////////////////////////////////////////
/// Destructor
 
RooAbsHiddenReal::~RooAbsHiddenReal()
{
}
 
 
 
////////////////////////////////////////////////////////////////////////////////
/// Special version of printValue that doesn't reveal the objects value
 
void RooAbsHiddenReal::printValue(ostream& os) const
{
  os << "(hidden)" ;
}
 
 
 
////////////////////////////////////////////////////////////////////////////////
/// Special version of readFromStream that disallows reading from stream
 
bool RooAbsHiddenReal::readFromStream(istream& is, bool compact, bool verbose)
{
  if (isHidden()) {
    // No-op version of readFromStream
    coutE(InputArguments) << "RooAbsHiddenReal::readFromStream(" << GetName() << "): not allowed" << endl ;
    return true ;
  } else {
    return readFromStream(is,compact,verbose) ;
  }
}
 
 
 
////////////////////////////////////////////////////////////////////////////////
/// Special version of writeToStream that disallows reading from stream
 
void RooAbsHiddenReal::writeToStream(ostream& os, bool compact) const
{
  if (isHidden()) {
    // No-op version of writeToStream
    coutE(InputArguments) << "RooAbsHiddenReal::writeToStream(" << GetName() << "): not allowed" << endl ;
  } else {
    RooAbsReal::writeToStream(os,compact) ;
  }
}
 
 
 
////////////////////////////////////////////////////////////////////////////////
/// Return reference to internal dummy RooCategory implementation
/// blinding state switch
 
RooAbsCategory& RooAbsHiddenReal::dummyBlindState() const
{
  if (!_dummyBlindState) {
    _dummyBlindState = new RooCategory("dummyBlindState","dummy blinding state") ;
    _dummyBlindState->defineType("Normal",0) ;
    _dummyBlindState->defineType("Blind",1) ;
    _dummyBlindState->setIndex(1) ;
  }
  return *_dummyBlindState ;
}