ModuleAlignment.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <top/reconstruction_cpp/TOPTrack.h>
#include <top/reconstruction_cpp/PDFConstructor.h>
#include <framework/gearbox/Const.h>
#include <framework/logging/Logger.h>
#include <vector>
#include <string>
#include <algorithm>
#include <TMatrixDSym.h>
 
namespace Belle2 {
  namespace TOP {
 
    class ModuleAlignment {
 
    public:
      ModuleAlignment(PDFConstructor::EPDFOption opt = PDFConstructor::c_Rough);
 
      void setModuleID(int moduleID) {m_moduleID = moduleID;}
 
      void setSteps(double position, double angle, double time);
 
      void setParameters(const std::vector<double>& parInit)
      {
        for (size_t i = 0; i < std::min(parInit.size(), m_parInit.size()); i++) {
          m_parInit[i] = parInit[i];
        }
        m_par = m_parInit;
      }
 
      void fixParameter(const std::string& name)
      {
        for (unsigned i = 0; i < m_parNames.size(); i++) {
          if (name == m_parNames[i]) {
            m_fixed[i] = true;
            return;
          }
        }
        B2ERROR("TOP::ModuleAlignment::fixParameter: invalid parameter name '" << name << "'");
      }
 
      void releaseParameter(const std::string& name)
      {
        for (unsigned i = 0; i < m_parNames.size(); i++) {
          if (name == m_parNames[i]) {
            m_fixed[i] = false;
            return;
          }
        }
        B2ERROR("TOP::ModuleAlignment::releaseParameter: invalid parameter name '" << name << "'");
      }
 
      void releaseAllParameters()
      {
        for (unsigned i = 0; i < m_fixed.size(); i++) m_fixed[i] = false;
      }
 
      int iterate(TOPTrack& track, const Const::ChargedStable& hypothesis);
 
      void reset();
 
      int getModuleID() const {return m_moduleID;}
 
      const std::vector<std::string>& getParameterNames() const {return m_parNames;}
 
      const std::vector<double>& getParams() const {return m_par;}
 
      std::vector<float> getParameters() const;
 
      std::vector<float> getErrors() const;
 
      const TMatrixDSym& getErrorMatrix() const {return m_COV;}
 
      int getNumTracks() const {return m_numTracks;}
 
      int getNumUsedTracks() const {return m_numUsedTracks;}
 
      bool isValid() const {return m_valid;}
 
      int getNumOfPhotons() const {return m_numPhotons;}
 
    private:
 
      double getLogL(const std::vector<double>& par, bool& ok);
 
      bool derivatives(std::vector<double>& first, TMatrixDSym& second);
 
      int invertMatrixU();
 
      int m_moduleID = 0; 
      PDFConstructor::EPDFOption m_opt = PDFConstructor::c_Rough; 
      std::vector<std::string> m_parNames; 
      std::vector<double> m_parInit;  
      std::vector<double> m_par;  
      std::vector<double> m_steps; 
      std::vector<double> m_maxDpar; 
      std::vector<bool> m_fixed; 
      TMatrixDSym m_COV;  
      int m_numTracks = 0;  
      int m_numUsedTracks = 0;  
      int m_numPhotons = 0; 
      bool m_valid = false; 
      TMatrixDSym m_U;   
      TOPTrack* m_track = 0; 
      Const::ChargedStable m_hypothesis = Const::muon; 
    };
 
  } // namespace TOP
} // namespace Belle2