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;
}