JMakeHDF.cc File Reference

Program to convert multi-dimensional histograms of muon light to multi-dimensional PDFs. More...

#include <string>
#include <iostream>
#include <fstream>
#include <iomanip>
#include "JPhysics/JPDFTransformer.hh"
#include "JPhysics/JPDFTable.hh"
#include "JPhysics/JPDFTypes.hh"
#include "JIO/JFileStreamIO.hh"
#include "JTools/JHistogram1D_t.hh"
#include "JTools/JHistogramMap_t.hh"
#include "JTools/JTransformableMultiHistogram.hh"
#include "JTools/JFunction1D_t.hh"
#include "JTools/JFunctionalMap_t.hh"
#include "JGeometry3D/JAngle3D.hh"
#include "JGeometry3D/JDirection3D.hh"
#include "JPhysics/JConstants.hh"
#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"

Go to the source code of this file.

Functions
int	main (int argc, char **argv)

Detailed Description

Program to convert multi-dimensional histograms of muon light to multi-dimensional PDFs.

Author

mdejong

Definition in file JMakeHDF.cc.

Function Documentation

int main	(	int	argc,
		char **	argv
	)

Definition at line 32 of file JMakeHDF.cc.

{
  using namespace std;
  using namespace JPP;

  string      inputFile;
  string      fileDescriptor;
  int         debug;

  try {

    JParser<> zap("Program to convert multi-dimensional histograms of muon light to multi-dimensional PDFs.");

    zap['f'] = make_field(inputFile);
    zap['o'] = make_field(fileDescriptor)      = "J%p.dat";
    zap['d'] = make_field(debug)               = 1;

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


  if (!hasWildCard(fileDescriptor)) {
    FATAL("error file descriptor " << fileDescriptor << endl);
  }

  typedef JHistogram1D_t::abscissa_type                             abscissa_type;

  typedef JTransformableMultiHistogram<JHistogram1D_t, 
                                       JMAPLIST<JHistogramMap_t,
                                                JHistogramGridMap_t,
                                                JHistogramGridMap_t>::maplist> JMultiHistogram_t;

  typedef JPDFTransformer<3, abscissa_type>                         JFunction3DTransformer_t;

  JMultiHistogram_t h0;   // occurrence rate of PMT (used for normalisation)
  JMultiHistogram_t h1;   // light from muon
  JMultiHistogram_t h2;   // light from EM showers

  h1.transformer.reset(new JFunction3DTransformer_t());
  h2.transformer.reset(new JFunction3DTransformer_t());


  // input

  JFileStreamReader in(inputFile.c_str());

  for (JMultiHistogram_t* p : { &h0, &h1, &h2 }) {
    in.load(*p);
  }

  in.close();


  // rebin histograms according angle of incidence on PMT and normalise contents to PMT occurrence rate

  for (JMultiHistogram_t::super_iterator
         i0 = h0.super_begin(),
         i1 = h1.super_begin(),
         i2 = h2.super_begin(); i0 != h0.super_end(); ++i0, ++i1, ++i2) {

    const double W = i0.getValue().getIntegral();

    if (W != 0.0) {

      const JDirection3D u(JAngle3D(i0->second->first, i0->second->second->first));
      const JDirection3D v(getSinThetaC(), 0.0, getCosThetaC());

      int number_of_bins = (int) (2 + u.getDot(v));

      for (JHistogram1D_t* p : { &i1.getValue(), &i2.getValue() }) {
        p->rebin(JHistogram1D_t::JRebin(number_of_bins));
        p->div(W);
      }
    }
  }


  // output

  struct tuple {
    const JPDFType_t         type;
    const JMultiHistogram_t& value;
  };

  tuple ntuple[] = {                       // map histogram to PDF type
    { SCATTERED_LIGHT_FROM_MUON,      h1 },
    { SCATTERED_LIGHT_FROM_EMSHOWERS, h2 }
  };


  typedef JPDFTable<JPolint1Function1D_t, 
                    JMAPLIST<JPolint1FunctionalMap,
                             JPolint1FunctionalGridMap,
                             JPolint1FunctionalGridMap>::maplist> JPDF_t;
  
  for (int i = 0; i != sizeof(ntuple)/sizeof(ntuple[0]); ++i) {

    const string file_name = getFilename(fileDescriptor, ntuple[i].type);

    try {

      NOTICE("storing output to file " << file_name << "... " << flush);

      const JPDF_t pdf(ntuple[i].value);

      pdf.store(file_name.c_str());

      NOTICE("OK" << endl);
    }
    catch(const JException& error) {
      FATAL(error.what() << endl);
    }
  }
}