JOscProbTable.hh

Go to the documentation of this file.

#ifndef __JOSCPROB__JOSCPROBTABLE__
#define __JOSCPROB__JOSCPROBTABLE__

#include "Jeep/JMessage.hh"

#include "JIO/JFileStreamIO.hh"
#include "JIO/JObjectBinaryIO.hh"

#include "JTools/JRange.hh"
#include "JTools/JArray.hh"
#include "JTools/JDistance.hh"
#include "JTools/JToolsToolkit.hh"
#include "JTools/JMultiFunction.hh"

#include "JOscProb/JOscProbTable_t.hh"


/**
 * \author bjung, mdejong
 */

namespace JOSCPROB {}
namespace JPP { using namespace JOSCPROB; }

namespace JOSCPROB {

  using JEEP::JMessage;
  
  using JIO::JReader;
  using JIO::JWriter;
  using JIO::JSerialisable;
  using JIO::JObjectBinaryIO;

  using JTOOLS::JArray;
  using JTOOLS::JRange;
  using JTOOLS::JMultiFunction;

  
  /** 
   * Template definition of a multi-dimensional interpolation table for oscillation probabilities.
   */
  template<class JFunction1D_t,
           class JMaplist_t,
           class JDistance_t = JTOOLS::JDistance<typename JFunction1D_t::argument_type> >
  struct JOscProbTable :
    public JSerialisable,
    public JMultiFunction<JFunction1D_t, JMaplist_t, JDistance_t>,
    public JMessage< JOscProbTable <JFunction1D_t, JMaplist_t, JDistance_t> >,
    public JObjectBinaryIO< JOscProbTable <JFunction1D_t, JMaplist_t, JDistance_t> >
  {
    typedef JMultiFunction<JFunction1D_t, JMaplist_t, JDistance_t>   multifunction_type;
    typedef JOscProbTable <JFunction1D_t, JMaplist_t, JDistance_t>           table_type;
    
    typedef typename multifunction_type::argument_type                    argument_type;
    typedef typename multifunction_type::result_type                        result_type;
    typedef typename multifunction_type::value_type                          value_type;

    typedef typename multifunction_type::multimap_type                    multimap_type;

    enum { NUMBER_OF_DIMENSIONS = multifunction_type::NUMBER_OF_DIMENSIONS };

    typedef typename multifunction_type::super_const_iterator      super_const_iterator;
    typedef typename multifunction_type::super_iterator                  super_iterator;
    typedef typename multifunction_type::function_type                    function_type;

    using JMessage<table_type>::debug;

    
    /**
     * Constructor.
     */
    JOscProbTable() :
      multifunction_type()
    {}


    /**
     * Constructor.
     *
     * \param  fileName             oscillation probability table filename
     */
    JOscProbTable(const char* fileName) :
      multifunction_type()
    {
      this->load(fileName);
    }      
    

    /**
     * Constructor.
     *
     * \param  input                multi-dimensional function
     */
    template<class JOscProb_t, class JOscProbMaplist_t, class JOscProbDistance_t>    
    JOscProbTable(const JMultiFunction<JOscProb_t, JOscProbMaplist_t, JOscProbDistance_t>& input) :
      multifunction_type(input)
    {}


    /**
     * Load oscillation probability table from file.
     *
     * \param  fileName             oscillation probability table fileName
     */
    void load(const char* fileName)
    {
      using namespace std;
      using namespace JPP;
      
      try {
        NOTICE("loading "                                   << NUMBER_OF_DIMENSIONS  <<
               "D oscillation probability table from file " << fileName << "... " << flush);
        
        JObjectBinaryIO< JOscProbTable<JFunction1D_t, JMaplist_t, JDistance_t> >::load(fileName);

        NOTICE("OK" << endl);
      }
      catch(const JException& error) {
        FATAL(error.what() << endl);
      }
    }
    
    
    /**
     * Compresses OscProb table to given abscissa range.
     *
     * \param   range               abscissa range
     */
    void compress(const JRange<typename function_type::argument_type>& range)
    {        
      for (super_iterator i = this->super_begin(); i != this->super_end(); ++i) {

        function_type& f1 = i.getValue();
        
        typename function_type::iterator p = f1.lower_bound(range.getLowerLimit());

        f1.function_type::container_type::erase(f1.begin(), p);

        typename function_type::iterator q = f1.lower_bound(range.getUpperLimit());

        f1.function_type::container_type::erase(++q, f1.end());
      }

      this->compile();
    }
    

    /**
     * Read from input.
     *
     * \param  in                   reader
     * \return                      reader
     */
    virtual JReader& read(JReader& in) override 
    {
      in >> static_cast<multifunction_type&>(*this);
      
      this->compile();
      
      return in;
    }
    
    
    /**
     * Write from input.
     *
     * \param  out                  writer
     * \return                      writer
     */
    virtual JWriter& write(JWriter& out) const override 
    {
      out << static_cast<const multifunction_type&>(*this);

      return out;
    }
  };


  /**
   * Explicit template specialization for 6D interpolation table in:\n
   * 1. \f$sin^2(\theta_{12})\f$
   * 2. \f$\Delta m_{21}^2\f$
   * 3. \f$sin^2(\theta_{13})\f$
   * 4. \f$\Delta m_{31}^2\f$
   * 5. \f$sin^2(\theta_{23})\f$
   * 6. \f$\delta_{\text{CP}}\f$
   */
  template< class JDistance_t = JTOOLS::JDistance<typename JOscProbTable6D_t::argument_type> >
  struct JOscProbTable6D :
    public JOscProbTable< typename JOscProbTable6D_t::JConstantFunction1D_t,
                          typename JOscProbTable6D_t::JMaplist6D_t,
                          JDistance_t >
  {
    typedef typename JOscProbTable6D_t::JConstantFunction1D_t                   function_type;
    typedef typename JOscProbTable6D_t::JMaplist6D_t                             maplist_type;
    
    typedef JMultiFunction<function_type, maplist_type, JDistance_t>       multifunction_type;
    typedef JOscProbTable< function_type, maplist_type, JDistance_t>               table_type;    

    typedef typename multifunction_type::argument_type                          argument_type;
    typedef typename multifunction_type::result_type                              result_type;
    typedef typename multifunction_type::value_type                                value_type;
    
    typedef typename multifunction_type::multimap_type                          multimap_type;

    enum { NUMBER_OF_DIMENSIONS = multifunction_type::NUMBER_OF_DIMENSIONS };

    typedef typename multifunction_type::super_const_iterator            super_const_iterator;
    typedef typename multifunction_type::super_iterator                        super_iterator;

    
    /**
     * Default constructor.
     */
    JOscProbTable6D() :
      JOscProbTable<function_type, maplist_type>()
    {}
    
    
    /**
     * Constructor.
     *
     * \param  input                multi-dimensional function
     */
    template<class JOscProb_t, class JOscProbMaplist_t, class JOscProbDistance_t>    
    JOscProbTable6D(const JMultiFunction<JOscProb_t, JOscProbMaplist_t, JOscProbDistance_t>& input) :
      JOscProbTable<function_type, maplist_type>(multifunction_type(input))
    {}


    /**
     * Constructor.
     *
     * \param  fileName             2D oscillation probability table filename
     */
    JOscProbTable6D(const char* fileName) :
      JOscProbTable<function_type, maplist_type>(fileName)
    {}      
  };
  

  /**
   * Explicit template specialization for 2D interpolation table in:\n
   * 1. \f$log_{10}(E)\f$
   * 2. \f$cos(\theta)\f$
   */
  template< class JDistance_t = JTOOLS::JDistance<typename JOscProbTable2D_t::JFunction2D_t::argument_type> >
  struct JOscProbTable2D :
    public JOscProbTable< typename JOscProbTable2D_t::JFunction1D_t,
                          typename JOscProbTable2D_t::JMaplist1D_t,
                          JDistance_t>
  {
    typedef typename JOscProbTable2D_t::JFunction1D_t                           function_type;
    typedef typename JOscProbTable2D_t::JMaplist1D_t                             maplist_type;

    typedef JMultiFunction<function_type, maplist_type, JDistance_t>       multifunction_type;
    typedef JOscProbTable< function_type, maplist_type, JDistance_t>               table_type;

    typedef typename multifunction_type::argument_type                          argument_type;
    typedef typename multifunction_type::result_type                              result_type;
    typedef typename multifunction_type::value_type                                value_type;
    
    typedef typename multifunction_type::multimap_type                          multimap_type;

    enum { NUMBER_OF_DIMENSIONS = multifunction_type::NUMBER_OF_DIMENSIONS };

    typedef typename multifunction_type::super_const_iterator            super_const_iterator;
    typedef typename multifunction_type::super_iterator                        super_iterator;

    using JMessage<table_type>::debug;
    
    
    /**
     * Default constructor.
     */
    JOscProbTable2D() :
      JOscProbTable<function_type, maplist_type>()      
    {}


    /**
     * Constructor.
     *
     * \param  input                multi-dimensional function
     */
    template<class JOscProb_t, class JOscProbMaplist_t, class JOscProbDistance_t>    
    JOscProbTable2D(const JMultiFunction<JOscProb_t, JOscProbMaplist_t, JOscProbDistance_t>& input) :
      JOscProbTable<function_type, maplist_type>(multifunction_type(input))

    {}
    

    /**
     * Constructor.
     *
     * \param  fileName             2D oscillation probability table filename
     */
    JOscProbTable2D(const char* fileName) :
      JOscProbTable<function_type, maplist_type>(fileName)      
    {}      


    /**
     * Constructor.
     *
     * \param  table                6D oscillation probability table
     * \param  parameters           oscillation parameters
     */
    JOscProbTable2D(const JOscProbTable6D<JDistance_t>& table,
                    const JOscParameters&               parameters) :
      JOscProbTable<function_type, maplist_type>()      
    {
      using namespace std;
      using namespace JPP;
      
      NOTICE("Extracting 2D interpolation table for:\n" << parameters.getProperties() << flush);

      typename JOscProbTable6D<JDistance_t>::result_type result = table(parameters.sinsqTh12,
                                                                        parameters.dM21sq,
                                                                        parameters.sinsqTh13,
                                                                        parameters.dM31sq,
                                                                        parameters.sinsqTh23,
                                                                        parameters.deltaCP);
      
      copy(result, static_cast<multimap_type&>(*this));
      
      this->compile();

      NOTICE("OK" << endl);
    }
  };
  

  /**
   * Explicit template specialization for 8D interpolation table in:\n
   * 1. \f$sin^2(\theta_{12})\f$
   * 2. \f$\Delta m_{21}^2\f$
   * 3. \f$sin^2(\theta_{13})\f$
   * 4. \f$\Delta m_{31}^2\f$
   * 5. \f$sin^2(\theta_{23})\f$
   * 6. \f$\delta_{\text{CP}}\f$
   * 7. \f$log_{10}(E)\f$
   * 8. \f$cos(\theta)\f$
   */
  template< class JDistance_t = JTOOLS::JDistance<typename JOscProbTable8D_t::JFunction2D_t::argument_type> >
  struct JOscProbTable8D :
    public JOscProbTable< typename JOscProbTable8D_t::JFunction2D_t,
                          typename JOscProbTable8D_t::JMaplist6D_t,
                          JDistance_t>
  {
    typedef typename JOscProbTable8D_t::JFunction2D_t                           function_type;
    typedef typename JOscProbTable8D_t::JMaplist6D_t                             maplist_type;
    
    typedef JMultiFunction<function_type, maplist_type, JDistance_t>       multifunction_type;
    typedef JOscProbTable< function_type, maplist_type, JDistance_t>               table_type;    

    typedef typename multifunction_type::argument_type                          argument_type;
    typedef typename multifunction_type::result_type                              result_type;
    typedef typename multifunction_type::value_type                                value_type;
    
    typedef typename multifunction_type::multimap_type                          multimap_type;

    enum { NUMBER_OF_DIMENSIONS = multifunction_type::NUMBER_OF_DIMENSIONS };

    typedef typename multifunction_type::super_const_iterator            super_const_iterator;
    typedef typename multifunction_type::super_iterator                        super_iterator;

    
    /**
     * Default constructor.
     */
    JOscProbTable8D() :
      JOscProbTable<function_type, maplist_type>()      
    {}
    
    
    /**
     * Constructor.
     *
     * \param  input                multi-dimensional function
     */
    template<class JOscProb_t, class JOscProbMaplist_t, class JOscProbDistance_t>    
    JOscProbTable8D(const JMultiFunction<JOscProb_t, JOscProbMaplist_t, JOscProbDistance_t>& input) :
      JOscProbTable<function_type, maplist_type>(multifunction_type(input))      
    {}


    /**
     * Constructor.
     *
     * \param  fileName             2D oscillation probability table filename
     */
    JOscProbTable8D(const char* fileName) :
      JOscProbTable<function_type, maplist_type>(fileName)      
    {}
  };
  
  
  /**
   * Default debug-levels for oscillation probability tables.
   */
  template<>
  int JMessage<typename JOscProbTable2D<>::table_type>::debug = (int) JEEP::notice_t;

  template<>
  int JMessage<typename JOscProbTable6D<>::table_type>::debug = (int) JEEP::notice_t;

  template<>
  int JMessage<typename JOscProbTable8D<>::table_type>::debug = (int) JEEP::notice_t;
}

#endif