JHistory.cc File Reference

#include <iostream>
#include <iomanip>
#include <algorithm>
#include <iterator>
#include "JFit/JFitApplications.hh"
#include "JFit/JEvt.hh"
#include "JFit/JEvtToolkit.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

Example program to test application history.

Author

mdejong

Definition in file JHistory.cc.

Function Documentation

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 21 of file JHistory.cc.

{
  using namespace std;
  using namespace JPP;
 
  int debug;
 
  try {
 
    JParser<> zap("Example program to test application history.");
 
    zap['d'] = make_field(debug)     = 3;
 
    zap(argc, argv);
  }
  catch(const exception &error) {
    FATAL(error.what() << endl);
  }
 
 
  const int numberOfFits = 3;
 
  JEvt evt;
 
  // JPrefit
 
  for (int i = 0; i != numberOfFits; ++i) {
    evt.push_back(getFit(JHistory(JMUONPREFIT), JTrack3D(), 0, 0.0));
  }
 
  // subsequent fits
 
  const JFitApplication_t application[] = { JMUONSIMPLEX, 
                                            JMUONGANDALF, 
                                            //JMUONENERGY,
                                            JMUONSTART };
 
  for (int i = 0; i != sizeof(application)/sizeof(int); ++i) {
 
    JEvt out;
 
    // save previous results
 
    copy(evt.begin(), evt.end(), back_inserter(out));
 
    // sort quality
 
    partial_sort(evt.begin(), evt.end(), evt.end(), qualitySorter);
 
    // partition according history of best fit
 
    JEvt::const_iterator __end = partition(evt.begin(), evt.end(), JHistory::is_event(evt.begin()->getHistory()));
 
    for (JEvt::const_iterator fit = evt.begin(); fit != __end; ++fit) {
      out.push_back(getFit(JHistory(fit->getHistory()).add(application[i]), JTrack3D(), 0, 0.0));
    }
 
    // apply default sorter
 
    sort(out.begin(), out.end(), qualitySorter);
 
    // mimic process chain
 
    evt = out;
  }
 
  for (size_t i = 0; i != evt.size(); ++i) {
    DEBUG("fit[" << i << "]" << endl << static_cast<const JHistory&>(evt[i]) << endl);
  }
 
  ASSERT((int) evt.size() == numberOfFits * (sizeof(application)/sizeof(int) + 1));
 
  for (int i = 0; i != numberOfFits; ++i) {
    ASSERT(has_muon_prefit (evt[i]) && 
           has_muon_simplex(evt[i]) && 
           has_muon_gandalf(evt[i]) && 
           !has_muon_energy(evt[i]) &&  // disabled as test
           has_muon_start  (evt[i]));
  }
 
  ASSERT( has_reconstructed_track(evt, has_muon_prefit));
  ASSERT( has_reconstructed_track(evt, has_muon_simplex));
  ASSERT( has_reconstructed_track(evt, has_muon_gandalf));
  ASSERT(!has_reconstructed_track(evt, has_muon_energy));
  ASSERT( has_reconstructed_track(evt, has_muon_start));
  ASSERT( has_reconstructed_muon  (evt));
  ASSERT(!has_reconstructed_shower(evt));
 
  const JFit& fit = get_best_reconstructed_muon(evt);
 
  ASSERT(has_muon_prefit (fit) && 
         has_muon_simplex(fit) && 
         has_muon_gandalf(fit) && 
         !has_muon_energy(fit) &&  // disabled as test
         has_muon_start  (fit));  
 
  return 0;
}