---

ConfigurerBase.cxx

Go to the documentation of this file.

#include "FastShowerUtils/ConfigurerBase.h"

// rest by alphabetical order:
#include "FastShowerUtils/CoreDepositor.h"
#include "FastShowerUtils/DepositorPtr.h"
#include "FastShowerUtils/FnOfParticleParametersPtr.h"
#include "FastShowerUtils/FnOfParticleParameters2Ptr.h"
#include "FastShowerUtils/IDepositor.h"
#include "FastShowerUtils/IFn.h"
#include "FastShowerUtils/IFnOfParticleParameters.h"
#include "FastShowerUtils/IFnOfParticleParameters2.h"
#include "FastShowerUtils/IFnPtr.h"
#include "FastShowerUtils/IInTailPtr.h"
#include "FastShowerUtils/NormaliserPtr.h"
#include "FastShowerUtils/ShowererPtr.h"
#include "FastShowerUtils/IShowerer.h"
#include "FastShowerUtils/Showerer.h"
#include "FastShowerUtils/PtrAdapter.h"
#include "FastShowerUtils/NullPtrAdapter.h"
#include "FastShowerUtils/IPtrAdapter.h"
#include "FastShowerUtils/IProcessedDistPtr.h"
#include "FastShowerUtils/ISampler.h"
#include "FastShowerUtils/InTail.h"
#include "FastShowerUtils/INormaliser.h"
#include "FastShowerUtils/ProcessedNormal.h"
#include "FastShowerUtils/ProcessedFlat.h"
#include "FastShowerUtils/PtrConverter.h"
#include "FastShowerUtils/SamplerPtr.h"
#include "FastShowerUtils/UpdatingGaussian.h"
#include "FastShowerUtils/UpdatingGaussian0LP.h"
#include "FastShowerUtils/UpdatingGaussian01P.h"
#include "FastShowerUtils/UpdatingGaussian02P.h"
#include "FastShowerUtils/UpGnPtr.h"
#include "FastShowerUtils/DummyFnOfParticleParameters.h"
//
#include <string>
#include <algorithm>

namespace FastShower{
  ConfigurerBase::ConfigurerBase(Moni ):
  
  m_fnPtrAdapter        (new PtrAdapter<IFn,               IFnPtr>),
  m_fnOfPPPtrAdapter    (new PtrAdapter<IFnOfParticleParameters, 
                                        FnOfParticleParametersPtr>),
  m_fnOfPP2PtrAdapter   (new PtrAdapter<IFnOfParticleParameters2, 
                                        FnOfParticleParameters2Ptr>),
  m_UpGnPtrAdapter      (new PtrAdapter<IUpdatingGaussian, UpGnPtr>),
  m_depositorPtrAdapter (new PtrAdapter<IDepositor,        DepositorPtr>),
  m_samplerPtrAdapter   (new PtrAdapter<ISampler,          SamplerPtr>),
  m_procDistPtrAdapter  (new PtrAdapter<IProcessedDist,    IProcessedDistPtr>),
  m_iinTailPtrAdapter   (new PtrAdapter<IInTail,           IInTailPtr>),
  m_normaliserPtrAdapter(new PtrAdapter<INormaliser,       NormaliserPtr>),
  m_showererPtrAdapter  (new PtrAdapter<IShowerer,         ShowererPtr>){
    cout<<"ConfigureBase constructer, Moni mode"<<endl;
  }
 
  //*******************************************************
  ConfigurerBase::ConfigurerBase(NoMoni ):
  
  m_fnPtrAdapter         (new NullPtrAdapter<IFn>),
  m_fnOfPPPtrAdapter     (new NullPtrAdapter<IFnOfParticleParameters>),
  m_fnOfPP2PtrAdapter    (new NullPtrAdapter<IFnOfParticleParameters2>),
  m_UpGnPtrAdapter       (new NullPtrAdapter<IUpdatingGaussian>),
  m_depositorPtrAdapter  (new NullPtrAdapter<IDepositor>),
  m_samplerPtrAdapter    (new NullPtrAdapter<ISampler>),
  m_procDistPtrAdapter   (new NullPtrAdapter<IProcessedDist>),
  m_iinTailPtrAdapter    (new NullPtrAdapter<IInTail>),
  m_normaliserPtrAdapter (new NullPtrAdapter<INormaliser>),
  m_showererPtrAdapter   (new NullPtrAdapter<IShowerer>){
    cout<<"ConfigureBase constructer, NoMoni mode"<<endl;
  }
  //*******************************************************
  IFn*  ConfigurerBase::findFn(const std::string& s ) const{
    if( m_ifn.find(s) != m_ifn.end() ){
      IDebug* idg= m_ifn.find(s)->second;
      idg->name();
      return m_ifn.find(s)->second;
    }else{
      cout<<"Function not found: "<<s<<endl;
      assert(true==false);
      return 0;
    }
  }
  //*******************************************************
  IFnOfParticleParameters* 
  ConfigurerBase::findFnPP(const std::string& s ) const{
    if( m_ifnPP.find(s) != m_ifnPP.end() ){
      IDebug* idg= m_ifnPP.find(s)->second;
      idg->name();
      return m_ifnPP.find(s)->second;
    }else{
      cout<<"Function not found: "<<s<<endl;
      assert(true==false);
      return 0;
    }
  }
  //*******************************************************
  IFnOfParticleParameters2* 
  ConfigurerBase::findFnPP2(const std::string& s ) const{
    if( m_ifnPP2.find(s) != m_ifnPP2.end() ){
      IDebug* idg= m_ifnPP2.find(s)->second;
      idg->name();
      return m_ifnPP2.find(s)->second;
    }else{
      cout<<"Function not found: "<<s<<endl;
      assert(true==false);
      return 0;
    }
  }
  //*******************************************************
  IUpdatingGaussian* 
  ConfigurerBase::findIUG(const std::string& s ) const{
    if( m_iug.find(s) != m_iug.end() ){
      IDebug* idg= m_iug.find(s)->second;
      idg->name();
      return m_iug.find(s)->second;
    }else{
      cout<<"IUpdatingGaussian not found: "<<s<<endl;
      assert(true==false);
      return 0;
    }
  }
  //*******************************************************
  ISampler* ConfigurerBase::findSampler(const std::string& s ) const{
    if( m_isamplers.find(s) != m_isamplers.end() ){
      IDebug* idg= m_isamplers.find(s)->second;
      idg->name();
      return m_isamplers.find(s)->second;
    }else{
      cout<<"ISampler not found: "<<s<<endl;
      assert(true==false);
      return 0;
    }
  }
  //*******************************************************
  INormaliser* ConfigurerBase::findNormaliser(const std::string& s ) const{
    if( m_inormalisers.find(s) != m_inormalisers.end() ){
      IDebug* idg= m_inormalisers.find(s)->second;
      idg->name();
      return m_inormalisers.find(s)->second;
    }else{
      cout<<"INormaliser not found: "<<s<<endl;
      assert(true==false);
      return 0;
    }
  }
  //*******************************************************
  void ConfigurerBase::eDepositors(std::vector<IDepositor*>& v) const {
    std::copy(m_eDepositors.begin(), m_eDepositors.end(), back_inserter(v));
  }  
  //*******************************************************
  void ConfigurerBase::hDepositors(std::vector<IDepositor*>& v) const {
    std::copy(m_hDepositors.begin(), m_hDepositors.end(), back_inserter(v));
  }  
  //*******************************************************
  EnergyLimiter* ConfigurerBase::energyLimiter() const {
    cout<<"ConfigureBase: constructing energy limiter"<<endl;
    return new EnergyLimiter(10., 100., "Default EnergyLimiter");
  }
  //*******************************************************
  void ConfigurerBase::addFn(const std::string& label, IFn* entry){
    m_ifn[label] = m_fnPtrAdapter->adapt(entry, label);
  }
  //*******************************************************
  void ConfigurerBase::addFnPP(const std::string& label, 
                               IFnOfParticleParameters* entry){
    m_ifnPP[label] = m_fnOfPPPtrAdapter->adapt(entry, label);
  }
  //*******************************************************
  void ConfigurerBase::addFnPP2(const std::string& label, 
                                IFnOfParticleParameters2* entry){
    m_ifnPP2[label] = m_fnOfPP2PtrAdapter->adapt(entry, label);
  }
  //*******************************************************
  void ConfigurerBase::addIUG(const std::string& label, 
                              IUpdatingGaussian* entry){
    m_iug[label] = m_UpGnPtrAdapter->adapt(entry, label);
  }
  //*******************************************************
  void ConfigurerBase::addSampler(const std::string& label, ISampler* entry){
    m_isamplers[label] = m_samplerPtrAdapter->adapt(entry, label);
  }
  //*******************************************************
  void ConfigurerBase::addEdepositor(const std::string& label, 
                                     IDepositor* entry){
    m_eDepositors.push_back(m_depositorPtrAdapter->adapt(entry, label));
  }
  //*******************************************************
  void ConfigurerBase::addHdepositor(const std::string& label, 
                                     IDepositor* entry){
    m_hDepositors.push_back(m_depositorPtrAdapter->adapt(entry, label));
  }
  //*******************************************************
  void ConfigurerBase::addNormaliser(const std::string& label, 
                                     INormaliser* entry){
    m_inormalisers[label] = m_normaliserPtrAdapter->adapt(entry, label);
  }
  //*******************************************************
  IUpdatingGaussian* 
  ConfigurerBase::makeGaussian(const std::string& label) const {
    IUpdatingGaussian* iug = 
      new  UpdatingGaussian(findFn(label+"PeakMean"), 
                            findFn(label+"PeakSigma"),
                            makeProcessedNormal(label)
                            );
    return m_UpGnPtrAdapter->adapt(iug, label+"UpdatingGaussian");
    
  }
  //*******************************************************
  IUpdatingGaussian* 
  ConfigurerBase::makeUpdatingGaussian0LP(const std::string& label) const {
    IUpdatingGaussian* iug = new  UpdatingGaussian0LP(label, *this); 
    //      new  UpdatingGaussian0LP(findFn(label+"PeakMean"), 
    //                         findFn(label+"PeakSigma"),
    //                         makeProcessedNormal(label)
    //                         );
    return m_UpGnPtrAdapter->adapt(iug, label+"UpdatingGaussian0LP");
  }
  //*******************************************************
  IUpdatingGaussian* 
  ConfigurerBase::makeUpdatingGaussian01P(const std::string& label) const {
    IUpdatingGaussian* iug = new  UpdatingGaussian01P(label, *this); 
    return m_UpGnPtrAdapter->adapt(iug, label+"UpdatingGaussian01P");
  }
  //*******************************************************
  IUpdatingGaussian* 
  ConfigurerBase::makeUpdatingGaussian02P(const std::string& label) const {
    IUpdatingGaussian* iug = new  UpdatingGaussian02P(label, *this); 
    return m_UpGnPtrAdapter->adapt(iug, label+"UpdatingGaussian02P");
  }
  //*******************************************************
  IProcessedDist*
  ConfigurerBase::makeProcessedNormal(const std::string& label) const {
    IProcessedDist* ipd = new  ProcessedNormal;
    return m_procDistPtrAdapter->adapt(ipd,  label+"ProcessedNormal");
  }
  //*******************************************************    
  IProcessedDist* 
  ConfigurerBase::makeProcessedFlat(const std::string& label) const {
    IProcessedDist* ipd = new  ProcessedFlat;
    return m_procDistPtrAdapter->adapt(ipd, label+"ProcessedFlat");
  }
  //*******************************************************    
  IInTail* 
  ConfigurerBase::makeIInTail(const std::string& label) const {
    
    IInTail* iit = new InTail(*this, label);
    return  m_iinTailPtrAdapter->adapt(iit, label+"IIntail");
  }
  //*******************************************************    
  //HaloDepositor::HaloArray* ConfigurerBase::makeHaloOrder() const {
  //  cout<<"ConfigurerBase: makeHaloOrder starts"<<endl;
  //  HaloDepositor::HaloArray* ha = new HaloDepositor::HaloArray();
  //
  //  for(std::size_t ind = 0; ind!=HaloDepositor::s_nHaloCells; ++ind){
  //    ha->push_back(ind);
  //  }
  //
  //  //    std::reverse( ha->begin(), ha->end() );// for testing only
  //  
  //  cout<<"ConfigurerBase: makeHaloOrder ends"<<endl;
  //  return ha;
  //}
  //*******************************************************    
  //HaloDepositor::HaloFns* ConfigurerBase::makeHaloFns() const {
  //  cout<<"ConfigurerBase: makeHaloFns starts"<<endl;
  // 
  //  HaloDepositor::HaloFns* hf = new HaloDepositor::HaloFns();
  //
  //  for(std::size_t ind = 0; ind!=HaloDepositor::s_nHaloCells; ++ind){
  //    hf->push_back(new ConstFnOfParticleParameters(0.01*ind ));
  //    //      hf->push_back(new ConstFnOfParticleParameters(0.95+0.001*ind ));
  //  }
  //  cout<<"ConfigurerBase: makeHaloFns ends"<<endl;
  //  return hf;
  //}
  IShowerer* ConfigurerBase::makeShowerer(const std::string& s) const {
    IShowerer* showerer = new Showerer(this, s);
    return m_showererPtrAdapter->adapt(showerer, s);
  }    
}//namespace

---