JMatrix_sol.cc File Reference

Auxiliary program to determine best inter-DU time offsets from hit time correlations. More...

#include <string>
#include <iostream>
#include <set>
#include <TVectorD.h>
#include <TMatrixD.h>
#include "TF2.h"
#include "TFile.h"
#include "TH1D.h"
#include "TH2D.h"
#include "TMath.h"
#include "TMatrixDSym.h"
#include "TROOT.h"
#include "TGraph.h"
#include "km3net-dataformat/online/JDAQ.hh"
#include "JDetector/JDetector.hh"
#include "JDetector/JDetectorToolkit.hh"
#include "Jeep/JParser.hh"
#include "JTools/JCombinatorics.hh"

Go to the source code of this file.

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

Detailed Description

Auxiliary program to determine best inter-DU time offsets from hit time correlations.

Author

dsamtleben

Definition in file JMatrix_sol.cc.

Function Documentation

main()

int main	(	int	argc,
		char **	argv )

Definition at line 33 of file JMatrix_sol.cc.

{
  using namespace std;
  using namespace JPP;
  using namespace JMATH;
 
  string inputFile;
  string detectorFile;
  string option;
  double min_cont;
  int    idu_ref;
  int    debug;
 
 
  try { 
 
    JParser<> zap("Program to calculate time offsets from FitL1dtSlices output");
    
    zap['f'] = make_field(inputFile,         "input file")                   = "nall.txt";
    zap['a'] = make_field(detectorFile,      "detector file");
    zap['r'] = make_field(idu_ref,          "reference DU set to t=0")       = 0;
    zap['m'] = make_field(min_cont,          "minimal content"       )       = 5;
    zap['d'] = make_field(debug) = 0;
 
 
    if (zap.read(argc, argv) != 0) {
      return 1;
    }
  }
  catch(const exception &error) {
    FATAL(error.what() << endl);
  }
 
  JDetector detector;
 
  try {
    load(detectorFile, detector);
  }
  catch(const JException& error) {
    FATAL(error);
  }
 
  const int number_of_strings = getNumberOfStrings(detector);
 
  TVectorD means(1);
  TMatrixD variance(1,1);
  TMatrixD combimatrix(1,number_of_strings);
 
  int du1,du2,du1_name,du2_name,nei;
  int duarr[number_of_strings];
  double off1,off2,offset,max1,max2;
 
  means[0]=0.;
  combimatrix(0,idu_ref)=1;
 
  int npairs = 1;
 
  std::ifstream file(inputFile);
 
  // --- read line with DU pair du1 & du2 and offset
  while (file >> du1 >> du2 >> off1 >> off2 >> offset >> max1 >> max2 >> du1_name >> du2_name >> nei)
        {
      if (max1 > min_cont and max2 > min_cont and max1 < 50. and max2 < 50.){
 
        combimatrix.ResizeTo(npairs+1,number_of_strings);
        combimatrix(npairs,du1) = +1;
        combimatrix(npairs,du2) = -1;
 
        means.ResizeTo(npairs+1);
        means[npairs]=offset; 
 
        duarr[du1]=du1_name;
        duarr[du2]=du2_name;
        npairs+=1;
      }
    }
 
 
  // Solve matrix equation:
  //
  //    combimatrix: A
  //    means: b
  //
  //    A * string_time_offsets = b 
  //    string_time_offset = (A^T * A)^(-1) * (A^T * b)
 
  TMatrixD combimatrix_T(number_of_strings,npairs);
 
  combimatrix_T.Transpose(combimatrix);  //     A^T
 
  TMatrixD pseudo = combimatrix_T * combimatrix;  //  A^T * A
  
  TMatrixD pseudoinverse = pseudo.Invert(); //       (A^T * A)^(-1)
  
  TVectorD offsets = pseudoinverse * combimatrix_T * means;  // (A^T * A)^(-1) * (A^T * b)
 
  TVectorD residues = (combimatrix * offsets) - means;
 
  std::cout.precision(3);
 
  for (int ii=0;ii<number_of_strings;ii++){
    cout << duarr[ii] << " " << offsets[ii] << endl;
  }
 
  double sumres=0.;
  for (int ii=0;ii<npairs;ii++){
    sumres+=fabs(residues[ii]);
  }
  cout << -1 << " " << sumres/double(npairs) << endl;
 
  return 1;
 
 
}