/*****************************************************************************
 * Project: RooFit                                                           *
 * Package: RooFitCore                                                       *
 *    File: $Id: RooIntegratorConfig.rdl,v 1.6 2003/05/09 20:48:23 wverkerke Exp $
 * Authors:                                                                  *
 *   WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu       *
 *   DK, David Kirkby,    UC Irvine,         dkirkby@uci.edu                 *
 *                                                                           *
 * Copyright (c) 2000-2004, 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)             *
 *****************************************************************************/
#ifndef ROO_INTEGRATOR_CONFIG
#define ROO_INTEGRATOR_CONFIG

#include "TObject.h"
#include "RooFitCore/RooIntegrator1D.hh"
#include "RooFitCore/RooMCIntegrator.hh"

class RooIntegratorConfig : public TObject {
public:

  RooIntegratorConfig();
  RooIntegratorConfig(const RooIntegratorConfig& other) ;
  virtual ~RooIntegratorConfig();

  // 1D accessors
  RooIntegrator1D::SummationRule summationRule1D() const { return _rule ; }
  Int_t maxSteps1D() const { return _maxSteps ; }
  Int_t minStepsZero1D() const { return _minSteps ; }
  Double_t epsilonRel1D() const { return _epsRel ; }
  Double_t epsilonAbs1D() const { return _epsAbs ; }
  Int_t numSegments1D() const { return _nseg1d ; }

  // 2D accessors
  Bool_t useMCFor2D() const { return _useMCFor2D ; }
  
  // MC accessors
  RooMCIntegrator::SamplingMode samplingModeMC() const { return _mode ; }
  RooMCIntegrator::GeneratorType generatorTypeMC() const { return _genType ; }
  Bool_t verboseMC() const { return _verboseMC ; }
  Double_t alphaMC() const { return _alpha ; }
  Int_t nRefineIterMC() const { return _nRefineIter ; }
  Int_t nRefinePerDimMC() const { return _nRefinePerDim ; }
  Int_t nIntegratePerDimMC() const { return _nIntegratePerDim ; }

  // 1D modifiers
  void setSummationRule1D(RooIntegrator1D::SummationRule rule) { _rule = rule ; }
  void setMaxSteps1D(Int_t maxSteps) { _maxSteps = maxSteps ; }
  void setMinStepsZero1D(Int_t minSteps) { _minSteps = minSteps ; }
  void setEpsilonAbs1D(Double_t eps) { _epsAbs = eps ; }
  void setEpsilonRel1D(Double_t eps) { _epsRel = eps ; }
  void setNumSegments1D(Int_t nseg) { _nseg1d = nseg ; }
  
  // 2D modifiers
  void setUseMCFor2D(Bool_t flag) { _useMCFor2D = flag ; }


  // MC modifiers
  void setSamplingModeMC(RooMCIntegrator::SamplingMode mode) { _mode = mode ; }
  void setGeneratorTypeMC(RooMCIntegrator::GeneratorType genType) { _genType = genType ; }
  void setVerboseMC(Bool_t flag) { _verboseMC = flag ; }
  void setAlphaMC(Double_t alpha) { _alpha = alpha ; }
  void setNRefineIterMC(Int_t n) { _nRefineIter = n ; }
  void setNRefinePerDimMC(Int_t n) { _nRefinePerDim = n ; }
  void setNIntegratePerDimMC(Int_t n) { _nIntegratePerDim = n ; }
  
protected:

  // 1D integrator
  RooIntegrator1D::SummationRule _rule ;
  Int_t _maxSteps ;
  Int_t _minSteps ;
  Double_t _epsAbs ;
  Double_t _epsRel ;
  Int_t _nseg1d ;

  // 2D integrator ;
  Bool_t _useMCFor2D ;

  // MC Integrator
  RooMCIntegrator::SamplingMode _mode ;
  RooMCIntegrator::GeneratorType _genType ;
  Bool_t _verboseMC ;
  Double_t _alpha ;
  Int_t _nRefineIter ;
  Int_t _nRefinePerDim ;
  Int_t _nIntegratePerDim ;
  
  ClassDef(RooIntegratorConfig,1) // Integrator configuration data
};

#endif