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

RooAbsHiddenReal is a 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 "RooFit.h"

#include "Riostream.h"

#include "RooArgSet.h"
#include "RooArgSet.h"
#include "RooAbsHiddenReal.h"
#include "RooCategory.h"
#include "RooMsgService.h"

using namespace std;

ClassImp(RooAbsHiddenReal)
;

RooCategory* RooAbsHiddenReal::_dummyBlindState = 0;


////////////////////////////////////////////////////////////////////////////////
/// 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_t RooAbsHiddenReal::readFromStream(istream& is, Bool_t compact, Bool_t verbose)
{
  if (isHidden()) {
    // No-op version of readFromStream 
    coutE(InputArguments) << "RooAbsHiddenReal::readFromStream(" << GetName() << "): not allowed" << endl ;
    return kTRUE ;
  } else {
    return readFromStream(is,compact,verbose) ;
  }
}



////////////////////////////////////////////////////////////////////////////////
/// Special version of writeToStream that disallows reading from stream

void RooAbsHiddenReal::writeToStream(ostream& os, Bool_t 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 ;
}