JPoint4D.cc File Reference

Test program for JFIT::JEstimator<JPoint4D> fit. More...

#include <string>
#include <iostream>
#include <iomanip>
#include <fstream>
#include <vector>
#include "TROOT.h"
#include "TFile.h"
#include "TH1D.h"
#include "TRandom3.h"
#include "JGeometry3D/JVertex3D.hh"
#include "JFit/JPoint4D.hh"
#include "JFit/JPoint4DEstimator.hh"
#include "JROOT/JRootToolkit.hh"
#include "JTools/JQuantile.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

Test program for JFIT::JEstimator<JPoint4D> fit.

Author

mdejong

Definition in file JPoint4D.cc.

Function Documentation

int main	(	int	argc,
		char **	argv
	)

Definition at line 29 of file JPoint4D.cc.

{
  using namespace std;

  string         inputFile;
  string         outputFile;
  int            numberOfEvents;
  double         precision;
  int            debug;

  try {

    JParser<> zap("Test program for vertex fit.");

    zap['f'] = make_field(inputFile)           = "";
    zap['o'] = make_field(outputFile)          = "";
    zap['n'] = make_field(numberOfEvents)      = 1000;
    zap['e'] = make_field(precision)           = 1.0e-5;
    zap['d'] = make_field(debug)               =  3;
 
    zap(argc, argv);
  }
  catch(const exception& error) {
    FATAL(error.what() << endl);
  }


  using namespace JPP;


  TH1D hx("hx", NULL, 101, -1.0, +1.0);
  TH1D hy("hy", NULL, 101, -1.0, +1.0);
  TH1D hz("hz", NULL, 101, -1.0, +1.0);
  TH1D ht("ht", NULL, 101, -1.0, +1.0);

  JQuantile Qx("x");
  JQuantile Qy("y");
  JQuantile Qz("z");
  JQuantile Qt("t");


  typedef vector<JVector3D> JDetector_t;

  JDetector_t detector;

  if (inputFile != "") {

    ifstream in(inputFile.c_str());
    
    for (double x, y, z; in >> x >> y >> z; ) {
      detector.push_back(JVector3D(x,y,z));
    }
    
    in.close();

  } else {

    for (double x = -50.0; x < 100.0; x += 100.0) {
      for (double y = -50.0; y < 100.0; y += 100.0) {
        for (double z = -50.0; z < 100.0; z += 100.0) {
          detector.push_back(JVector3D(x,y,z));
        }
      }
    }
  }


  typedef JVertex3D   JHit_t;

  const double xmin = -1.0;
  const double xmax = +1.0;

  const double tmin = -1.0;
  const double tmax = +1.0;


  for (int i = 0; i != numberOfEvents; ++i) {

    // generate vertex

    const double x = gRandom->Uniform(xmin, xmax);
    const double y = gRandom->Uniform(xmin, xmax);
    const double z = gRandom->Uniform(xmin, xmax);
    const double t = gRandom->Uniform(tmin, tmax);

    JVertex3D vertex(JVector3D(x,y,z), t);
    /*
    DEBUG("vertex" << endl);
    DEBUG(fixed << showpos << setprecision(1) 
          << setw(6) << vertex.getX() << ' ' 
          << setw(6) << vertex.getY() << ' ' 
          << setw(6) << vertex.getZ() << ' ' 
          << setw(6) << vertex.getT() << endl);
    */

    // generate hits
    
    vector<JHit_t> data;

    for (JDetector_t::const_iterator pos = detector.begin(); pos != detector.end(); ++pos) {
      data.push_back(JHit_t(*pos, vertex.getT(*pos)));
    }

    /*
    for (vector<JHit_t>::const_iterator hit = data.begin(); hit != data.end(); ++hit) {
      DEBUG(fixed << showpos << setprecision(1) 
            << setw(6) << hit->getX() << ' ' 
            << setw(6) << hit->getY() << ' ' 
            << setw(6) << hit->getZ() << ' ' 
            << setw(6) << hit->getT() << endl);
    }
    */

    // fit

    JEstimator<JPoint4D> result(data.begin(), data.end());

    hx.Fill(vertex.getX() - result.getX());
    hy.Fill(vertex.getY() - result.getY());
    hz.Fill(vertex.getZ() - result.getZ());
    ht.Fill(vertex.getT() - result.getT());

    Qx.put(vertex.getX() - result.getX());
    Qy.put(vertex.getY() - result.getY());
    Qz.put(vertex.getZ() - result.getZ());
    Qt.put(vertex.getT() - result.getT());
  }

  if (debug >= debug_t) {
    Qx.print(cout);
    Qy.print(cout);
    Qz.print(cout);
    Qt.print(cout);
  }

  if (outputFile != "") {

    TFile out(outputFile.c_str(), "recreate");
    
    out << hx << hy << hz << ht;

    out.Write();
    out.Close();
  }

  ASSERT(numberOfEvents > 0);

  ASSERT(Qx.getMean() <= precision);
  ASSERT(Qy.getMean() <= precision);
  ASSERT(Qz.getMean() <= precision);
  ASSERT(Qt.getMean() <= precision);

  ASSERT(Qx.getSTDev() <= precision);
  ASSERT(Qy.getSTDev() <= precision);
  ASSERT(Qz.getSTDev() <= precision);
  ASSERT(Qt.getSTDev() <= precision);

  return 0;
}