JCompass.cc File Reference

Program to calibrate in situ AHRS. More...

#include <iostream>
#include <iomanip>
#include <vector>
#include <map>
#include "TROOT.h"
#include "TFile.h"
#include "TH1D.h"
#include "TH2D.h"
#include "km3net-dataformat/definitions/module_status.hh"
#include "JDB/JSupport.hh"
#include "JDB/JAHRS.hh"
#include "JDB/JAHRSCalibration_t.hh"
#include "JDB/JAHRSToolkit.hh"
#include "JSupport/JMultipleFileScanner.hh"
#include "JSupport/JFileRecorder.hh"
#include "JSupport/JMeta.hh"
#include "JROOT/JManager.hh"
#include "JFit/JSimplex.hh"
#include "JLang/JComparator.hh"
#include "JSystem/JStat.hh"
#include "JDetector/JDetector.hh"
#include "JDetector/JDetectorToolkit.hh"
#include "JDetector/JModuleRouter.hh"
#include "JDetector/JStringRouter.hh"
#include "JDetector/JCompass.hh"
#include "JCompass/JHit.hh"
#include "JCompass/JModel.hh"
#include "JCompass/JEvt.hh"
#include "JCompass/JEvtToolkit.hh"
#include "JCompass/JSupport.hh"
#include "Jeep/JProperties.hh"
#include "Jeep/JContainer.hh"
#include "Jeep/JPrint.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 calibrate in situ AHRS.

Author

mdejong

Definition in file software/JCompass/JCompass.cc.

Function Documentation

main()

int main	(	int	argc,
		char **	argv )

Definition at line 52 of file software/JCompass/JCompass.cc.

{
  using namespace std;
  using namespace JPP;
 
  JMultipleFileScanner_t inputFile;
  counter_type    numberOfEvents;
  JFileRecorder<JTYPELIST<JEvt, JMeta, TH1D, TH2D>::typelist>  outputFile;
  string          detectorFile;
  long long int   Tmax_s           = 600;                                // time window data collection [s]
  int             mestimator       = EM_LORENTZIAN;                      // M-estimator fit
  double          sigma_deg        = 1.0;                                // resolution [deg]
  double          stdev            = numeric_limits<double>::max();      // number of standard deviations
  int             numberOfOutliers = 0;
  string          ahrsFile;
  bool            overwriteDetector;
  int             debug;
 
  try {
 
    JProperties properties;
 
    properties.insert(gmake_property(Tmax_s));
    properties.insert(gmake_property(mestimator));
    properties.insert(gmake_property(sigma_deg));
    properties.insert(gmake_property(stdev));
    properties.insert(gmake_property(numberOfOutliers));
 
    JParser<> zap("Program to calibrate in situ AHRS.");
    
    zap['f'] = make_field(inputFile,    "output of JConvertDB -q ahrs");
    zap['n'] = make_field(numberOfEvents)                                    = JLimit::max();
    zap['a'] = make_field(detectorFile);
    zap['@'] = make_field(properties)                                        = JPARSER::initialised();
    zap['c'] = make_field(ahrsFile,     "output of JAHRSCalibration");
    zap['A'] = make_field(overwriteDetector);
    zap['o'] = make_field(outputFile)    = "compass.root";
    zap['d'] = make_field(debug)         = 2;
 
    zap(argc, argv);
  }
  catch(const exception &error) {
    FATAL(error.what() << endl);
  }
 
 
  JDetector detector;
 
  try {
    load(detectorFile, detector);
  }
  catch(const JException& error) {
    FATAL(error);
  }
 
  const floor_range   range = getRangeOfFloors(detector);
 
  const JModuleRouter router(detector);
  const JStringRouter string(detector);
  
 
  map<int, JAverage<JQuaternion3D> > compass;                     // output compass calibration
 
 
  const JAHRSCalibration_t calibration(ahrsFile.c_str());
  const JAHRSValidity      is_valid;
 
 
  JSimplex<JModel> simplex;
 
  JSimplex<JModel>::MAXIMUM_ITERATIONS = 10000;
 
  simplex.debug = debug;
 
  const JChi2 getChi2(mestimator);
 
 
  typedef JManager<int, TH1D>  JManager_t;
 
  JManager_t H0(new TH1D("%.twist", NULL, 100,  0.0,   5.0));
  JManager_t H1(new TH1D("%.swing", NULL, 250,  0.0,   2.5));
  JManager_t HN(new TH1D("%.count", NULL, 100, -0.5,  99.5));
 
  TH2D  h2("h2", NULL,
           string.size(), -0.5, string.size() - 0.5,
           range.getLength() + 1, range.getLowerLimit() - 0.5, range.getUpperLimit() + 0.5);
 
  for (Int_t i = 1; i <= h2.GetXaxis()->GetNbins(); ++i) {
    h2.GetXaxis()->SetBinLabel(i, MAKE_CSTRING(string.at(i-1)));
  }
  for (Int_t i = 1; i <= h2.GetYaxis()->GetNbins(); ++i) {
    h2.GetYaxis()->SetBinLabel(i, MAKE_CSTRING(i-1));
  }
 
  TH2D* h1 = (TH2D*) h2.Clone("h1");
 
 
  outputFile.open();
 
  outputFile.put(JMeta(argc, argv));
 
  counter_type counter = 0;
  
  for (JMultipleFileScanner_t::const_iterator file_name = inputFile.begin(); file_name != inputFile.end(); ++file_name) {
 
    STATUS("processing file " << *file_name << endl);
      
    map<int, vector<JAHRS> > data;                                // AHRS data per string
    
    for (JMultipleFileScanner<JAHRS> in(*file_name); in.hasNext() && counter != numberOfEvents; ++counter) {
 
      const JAHRS* parameters = in.next();
 
      if (is_valid(*parameters) && router.hasModule(parameters->DOMID)) {
        data[router.getModule(parameters->DOMID).getString()].push_back(*parameters);
      }
    }
    
    for (map<int, vector<JAHRS> >::iterator i = data.begin(); i != data.end(); ++i) {
 
      sort(i->second.begin(), i->second.end(), make_comparator(&JAHRS::UNIXTIME));
    
      for (vector<JAHRS>::const_iterator p = i->second.begin(); p != i->second.end(); ) {
 
        long long int t1 = p->UNIXTIME;
        long long int t2 = t1;
 
        vector<JHit> buffer;                                      // calibrated quaternion data
 
        for ( ; p != i->second.end() && p->UNIXTIME < t1 + Tmax_s * 1000; t2 = (p++)->UNIXTIME) {
 
          if (calibration.has(p->DOMID)) {
 
            const JModule& module = router.getModule(p->DOMID);
 
            if (module.getFloor() != 0 && !module.has(COMPASS_DISABLE)) {
 
              const JCompass compass(*p, calibration.get(p->DOMID));
 
              const JQuaternion3D Q = module.getQuaternion() * compass.getQuaternion();
 
              buffer.push_back(JHit(p->DOMID, module.getZ(), Q, sigma_deg));
            }
          }
        }
 
        if (buffer.size() > JModel::NUMBER_OF_PARAMETERS) {
 
          for (vector<JHit>::const_iterator hit = buffer.begin(); hit != buffer.end(); ++hit) {
 
            const JLocation& location = router.getModule(hit->getID());
 
            h1->Fill((double) string.getIndex(location.getString()), (double) location.getFloor());
          }
          
          JModel result(buffer.begin(), buffer.end());            // prefit
 
          vector<JHit>::iterator __end = buffer.end();
 
          for (int ns = 0; ns != numberOfOutliers; ++ns) {        // outlier removal
 
            double                 xmax = 0.0;
            vector<JHit>::iterator out  = __end;
          
            for (vector<JHit>::iterator hit = buffer.begin(); hit != __end; ++hit) {
 
              const JQuaternion3D Q1 = result(hit->getZ());       // fitted
              const JQuaternion3D Q2 = hit->getQuaternion();      // measured
 
              const double x = getAngle(Q1, Q2);
 
              if (x > xmax) {
                xmax = x;
                out  = hit;
              }
            }
 
            if (xmax > stdev * sigma_deg) {
 
              const JLocation& location = router.getModule(out->getID());
 
              h2.Fill((double) string.getIndex(location.getString()), (double) location.getFloor());
 
              if (debug >= debug_t) {
              
                const JQuaternion3D Q1 = result(out->getZ());     // fitted
                const JQuaternion3D Q2 = out->getQuaternion();    // measured
 
                const JQuaternion3D::decomposition q1(Q1, JVector3Z_t);
                const JQuaternion3D::decomposition q2(Q2, JVector3Z_t);
 
                cout << "remove "  << location                     << ' '
                     << FIXED(5,2) << getAngle(Q1,Q2)              << ' '
                     << FIXED(5,2) << getAngle(q1.twist, q2.twist) << ' '
                     << FIXED(5,2) << getAngle(q1.swing, q2.swing) << endl;
              }
            
              swap(*out, *--__end);
 
              result = JModel(buffer.begin(), __end);             // refit
 
            } else {
 
              break;
            }
          }
 
          simplex.value = result;                                 // start value
 
          simplex.step.resize(4);
 
          simplex.step[0] = JModel(JQuaternion3X(5.0e-1 * PI / 180.0), JQuaternion3D::getIdentity());
          simplex.step[1] = JModel(JQuaternion3Y(5.0e-1 * PI / 180.0), JQuaternion3D::getIdentity());
          simplex.step[2] = JModel(JQuaternion3Z(5.0e-1 * PI / 180.0), JQuaternion3D::getIdentity());
          simplex.step[3] = JModel(JQuaternion3D::getIdentity(), JQuaternion3Z(5.0e-2 * PI / 180.0));
 
          const double chi2 = simplex(getChi2, buffer.begin(), __end);
          const int    ndf  = distance(buffer.begin(), __end) * 4 - simplex.step.size();
 
          result = simplex.value;                                 // final value
 
 
          outputFile.put(getEvt(JHead(t1, t2, i->first, ndf, chi2), result));
 
 
          for (vector<JHit>::const_iterator hit = buffer.begin(); hit != buffer.end(); ++hit) {
 
            const JQuaternion3D Q1 = result(hit->getZ());         // fitted
            const JQuaternion3D Q2 = hit->getQuaternion();        // measured
 
            const JQuaternion3D::decomposition q1(Q1, JVector3Z_t);
            const JQuaternion3D::decomposition q2(Q2, JVector3Z_t);
 
            compass[hit->getID()].put(Q1 * Q2.getConjugate());
          
            H0[hit->getID()]->Fill(getAngle(q1.twist, q2.twist));
            H1[hit->getID()]->Fill(getAngle(q1.swing, q2.swing));
          }
 
          map<int, int> count;
 
          for (vector<JHit>::const_iterator hit = buffer.begin(); hit != __end; ++hit) {
            count[hit->getID()] += 1;
          }
 
          for (map<int, int>::const_iterator i = count.begin(); i != count.end(); ++i) {
            HN[i->first]->Fill(i->second);
          }
        }
      }
    }
  }
 
  
  h2.Divide(h1);
 
  outputFile.put(h2);
 
  for (JManager_t* p : { &H0, &H1, &HN }) {
    for (JManager_t::iterator i = p->begin(); i != p->end(); ++i) {
      outputFile.put(*(i->second));
    }
  }
 
  outputFile.close();
 
 
  if (overwriteDetector) {
 
    NOTICE("Store calibration data on file " << detectorFile << endl);
 
    if (detector.setToLatestVersion()) {
      NOTICE("Set detector version to " << detector.getVersion() << endl);
    }
 
    detector.comment.add(JMeta(argc, argv));
 
    for (map<int, JAverage<JQuaternion3D> >::const_iterator i = compass.begin(); i != compass.end(); ++i) {
 
      JModule& module = detector[router.getIndex(i->first)];
 
      JQuaternion3D Q(i->second * module.getQuaternion());
 
      module.setQuaternion(Q.normalise());
    }
 
    store(detectorFile, detector);
  }
}