JWriteOscParametersGrid.cc

Go to the documentation of this file.

#include <set>
#include <string>
#include <iostream>

#include "JIO/JFileStreamIO.hh"

#include "Jeep/JPrint.hh"
#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"

#include "JOscProb/JOscParameters.hh"


namespace {

  /**
   * Auxiliary function to terminate recursive calculation of flattened multi-dimensional container index.
   * 
   * \param  index     index
   * \return           index
   */
  int getIndex(const int index)
  {
    return index;
  }

  
  /**
   * Auxiliary function to retrieve the index of a flattened multi-dimensional container.
   *
   * Note: The containers and container indices corresponding to higher dimensions\n
   *       should be specified before those of lower dimensions.
   *
   * \param  grid       constituent grid
   * \param  index      constituent grid index
   * \param  args       remaining arguments
   * \return            index for flattened multi-dimensional container
   */
  template<class ...Args, class JContainer_t>
  int getIndex(const int  index,
               const JContainer_t& container,
               const Args&      ...args)
  {
    return getIndex(args...) * container.getSize() + index;
  }
}


/**
 * Auxiliary program to write all elements in an oscillation parameters grid to separate output files.
 */
int main(const int argc, const char **argv)
{
  using namespace std;
  using namespace JPP;

  typedef JGrid<double>                   JGrid_t;
  typedef JOscParameters<JGrid_t>         JOscParameters_t;
  

  JOscParameters_t parameterGrids;  
  string           outputFile;

  char             wildcard;
  
  int              debug;

  try {

    JParser<> zap;

    zap['o'] = make_field(outputFile,        "output file")
      = "oscillation_parameters.%.txt";
    zap['w'] = make_field(wildcard,          "wildcard character")
      = '%';
    zap['@'] = make_field(parameterGrids,    "oscillation parameter grids")
      = JOscParameters_t(true);
    zap['d'] = make_field(debug,             "debug")
      = 0;

    zap(argc, argv);
  }
  catch(const exception& error) {
    FATAL(error.what() << endl);
  }

  
  const size_t pos = outputFile.find(wildcard);

  if (pos == std::string::npos) {
    FATAL("Given output file name must contain the given wildcard character " << wildcard);
  }
  
  const JGrid_t& theta12 = parameterGrids.theta12;
  const JGrid_t& theta13 = parameterGrids.theta13;
  const JGrid_t& theta23 = parameterGrids.theta23;
  const JGrid_t& deltaCP = parameterGrids.deltaCP;
  const JGrid_t& dM21sq  = parameterGrids.dM21sq;
  const JGrid_t& dM31sq  = parameterGrids.dM31sq;

  const int N = (theta12.getSize() *
                 theta13.getSize() *
                 theta23.getSize() *
                 deltaCP.getSize() *
                 dM21sq.getSize()  *
                 dM31sq.getSize());

  const int maxDigits = to_string(N).length();

  NOTICE("Writing " << N << " oscillation parameters files" << endl);

  JOscParameters<double> parameters;

  for (int i1 = 0; i1 != dM21sq.getSize(); ++i1) {

    parameters.dM21sq = dM21sq.getX(i1);

    for (int i2 = 0; i2 != dM31sq.getSize(); ++i2) {

      parameters.dM31sq = dM31sq.getX(i2);      

      for (int i3 = 0; i3 != deltaCP.getSize(); ++i3) {

        parameters.deltaCP = deltaCP.getX(i3);  

        for (int i4 = 0; i4 != theta12.getSize(); ++i4) {

          parameters.theta12 = theta12.getX(i4);

          for (int i5 = 0; i5 != theta13.getSize(); ++i5) {

            parameters.theta13 = theta13.getX(i5);          

            for (int i6 = 0; i6 != theta23.getSize(); ++i6) {

              parameters.theta23 = theta23.getX(i6);

              const int index = (getIndex(i6, theta23,
                                          i5, theta13,
                                          i4, theta12,
                                          i3, deltaCP,
                                          i2, dM31sq,
                                          i1) + 1);

              const string filename = string(outputFile).replace(pos, 1, MAKE_STRING(FILL(maxDigits,'0') << index));

              ofstream out(filename.c_str());

              out << parameters;

              out.close();
            }
          }
        }
      }
    }
  }

  return 0;
}