DistSamplerOptions.cxx

Go to the documentation of this file.

// @(#)root/mathcore:$Id: DistSamplerOptions.cxx 37419 2010-12-08 21:19:45Z moneta $ 
// Author: L. Moneta Fri Aug 15 2008

/**********************************************************************
 *                                                                    *
 * Copyright (c) 2008  LCG ROOT Math Team, CERN/PH-SFT                *
 *                                                                    *
 *                                                                    *
 **********************************************************************/

#include "Math/DistSamplerOptions.h"

#include "Math/GenAlgoOptions.h"


#include <iomanip>

namespace ROOT { 
   

namespace Math { 

   namespace Sampler { 
      static std::string gDefaultSampler = "Unuran";
      static std::string gDefaultAlgorithm1D = "auto";
      static std::string gDefaultAlgorithmND = "vnrou";
      static int  gDefaultPrintLevel  = 0; 
   }


void DistSamplerOptions::SetDefaultSampler(const char * type ) {   
   // set the default minimizer type and algorithm
   if (type) Sampler::gDefaultSampler = std::string(type); 
}
void DistSamplerOptions::SetDefaultAlgorithm1D(const char * algo ) {   
   // set the default minimizer type and algorithm
   if (algo) Sampler::gDefaultAlgorithm1D = std::string(algo);
}
void DistSamplerOptions::SetDefaultAlgorithmND(const char * algo ) {   
   // set the default minimizer type and algorithm
   if (algo) Sampler::gDefaultAlgorithmND = std::string(algo);
}
void DistSamplerOptions::SetDefaultPrintLevel(int level) {
   // set the default printing level 
   Sampler::gDefaultPrintLevel = level; 
}

const std::string & DistSamplerOptions::DefaultAlgorithm1D() { return Sampler::gDefaultAlgorithm1D; }
const std::string & DistSamplerOptions::DefaultAlgorithmND() { return Sampler::gDefaultAlgorithmND; }
int    DistSamplerOptions::DefaultPrintLevel()       { return Sampler::gDefaultPrintLevel; }

const std::string & DistSamplerOptions::DefaultSampler() 
{ 
   // return default minimizer
   // if is "" (no default is set) read from etc/system.rootrc
   // use form /etc/ ??

   return Sampler::gDefaultSampler; 
}


DistSamplerOptions::DistSamplerOptions(int dim): 
   fLevel( Sampler::gDefaultPrintLevel),
   fExtraOptions(0)
{
   // constructor using  the default options

   fSamplerType = DistSamplerOptions::DefaultSampler();

   if (dim == 1) 
      fAlgoType =  DistSamplerOptions::DefaultAlgorithm1D();
   else if (dim >1) 
      fAlgoType =  DistSamplerOptions::DefaultAlgorithmND();
   else 
      // not specified - keep null string
      fAlgoType = std::string();

   // check if extra options exists (copy them if needed)
   if (!fExtraOptions) { 
      IOptions * gopts = FindDefault( fSamplerType.c_str() );
      if (gopts) fExtraOptions = gopts->Clone();
   }
}


DistSamplerOptions::DistSamplerOptions(const DistSamplerOptions & opt) : fExtraOptions(0) {  
   // copy constructor 
   (*this) = opt; 
}

DistSamplerOptions & DistSamplerOptions::operator=(const DistSamplerOptions & opt) {  
   // assignment operator 
   if (this == &opt) return *this; // self assignment
   fLevel = opt.fLevel;
   fSamplerType = opt.fSamplerType; 
   fAlgoType = opt.fAlgoType; 

   if (fExtraOptions) delete fExtraOptions; 
   fExtraOptions = 0; 
   if (opt.fExtraOptions)  fExtraOptions =  (opt.fExtraOptions)->Clone();
   return *this;
}

DistSamplerOptions::~DistSamplerOptions() { 
   if (fExtraOptions) delete fExtraOptions; 
}

void DistSamplerOptions::SetExtraOptions(const IOptions & opt) {  
   // set extra options (clone the passed one)
   if (fExtraOptions) delete fExtraOptions; 
   fExtraOptions = opt.Clone(); 
}

void DistSamplerOptions::Print(std::ostream & os) const {
   //print all the options
   os << std::setw(25) << "DistSampler Type"        << " : " << std::setw(15) << fSamplerType << std::endl;
   os << std::setw(25) << "DistSampler Algorithm"   << " : " << std::setw(15) << fAlgoType << std::endl;
   os << std::setw(25) << "Print Level"            << " : " << std::setw(15) << fLevel << std::endl;
   
   if (ExtraOptions()) { 
      os << fSamplerType << " specific options :"  << std::endl;
      ExtraOptions()->Print(os);
   }
}

IOptions & DistSamplerOptions::Default(const char * name) { 
   // create default extra options for the given algorithm type 
   return GenAlgoOptions::Default(name);
}

IOptions * DistSamplerOptions::FindDefault(const char * name) { 
   // find extra options for the given algorithm type 
   return GenAlgoOptions::FindDefault(name);
}

void DistSamplerOptions::PrintDefault(const char * name, std::ostream & os) {
   //print default options
   os << "Default DistSampler options " << std::endl;
   os << std::setw(25) << "Default  Type"        << " : " << std::setw(15) << DistSamplerOptions::DefaultSampler() << std::endl;
   os << std::setw(25) << "Default Algorithm 1D"   << " : " << std::setw(15) << DistSamplerOptions::DefaultAlgorithm1D() << std::endl;
   os << std::setw(25) << "Default Algorithm ND"   << " : " << std::setw(15) << DistSamplerOptions::DefaultAlgorithmND() << std::endl;
   os << std::setw(25) << "Default Print Level"    << " : " << std::setw(15) << DistSamplerOptions::DefaultPrintLevel() << std::endl;
   IOptions * opt = FindDefault(name);
   if (opt) { 
      os << "Specific default options for "  << name << std::endl;
      opt->Print(os);
   }
}




} // end namespace Math

} // end namespace ROOT

---