MuonCalib::RtCalibrationIntegration Class Reference

#include <RtCalibrationIntegration.h>

Inheritance diagram for MuonCalib::RtCalibrationIntegration:

Collaboration diagram for MuonCalib::RtCalibrationIntegration:

Public Types
using	MuonSegVec = std::vector< std::shared_ptr< MuonCalibSegment > >
using	MuonSegIt = MuonSegVec::iterator
using	MuonSegCit = MuonSegVec::const_iterator
using	MdtCalibOutputPtr = std::shared_ptr< IMdtCalibrationOutput >

Public Member Functions
	RtCalibrationIntegration (const std::string &name)
	Default constructor. More...
	RtCalibrationIntegration (const std::string &name, bool close_hits, double r_max, double lower_extrapolation_radius, double upper_extrapolation_radius, bool add_tmax_difference)
	Constructor. More...
unsigned int	number_of_hits_used () const
	get the number of hits used in the r-t determination More...
MdtCalibOutputPtr	analyseSegments (const MuonSegVec &seg) override
	determine r(t) More...
bool	handleSegment (MuonCalibSegment &seg)
	analyse the segment "seg" More...
void	setInput (const IMdtCalibrationOutput *rt_input) override
	the method is empty as no initial r-t relationship is required by the algorithm More...
bool	analyse ()
	perform the integration method More...
bool	converged () const
	returns true, if the integration method has been performed More...
MdtCalibOutputPtr	getResults () const override
	returns the final r-t relationship More...
virtual std::string	name () const
	returns name (region) of instance More...

Private Member Functions
void	init (bool close_hits, double r_max, double lower_extrapolation_radius, double higher_extrapolation_radius, bool add_tmax_difference)

Private Attributes
bool	m_close_hits
double	m_lower_extrapolation_radius
	sets the lower radius to perform the More...
double	m_upper_extrapolation_radius
	parabolic extrapolation. More...
bool	m_add_tmax_difference
std::vector< std::pair< double, bool > >	m_t_drift
std::shared_ptr< IRtRelation >	m_rt
unsigned int	m_nb_hits_used
unsigned int	m_nb_segments_used
double	m_r_max
std::shared_ptr< RtCalibrationOutput >	m_output
std::string	m_name

Detailed Description

This class allows the user to obtain an r-t relationship from the drift time spectrum in a given calibration region. The user can ask the class to restrict the r-t determination on hit on the segments or to use close hits too. The algorithms performs a t0 and tmax fit in order to get t(r=0) and t(r=rmax) right.

Definition at line 33 of file RtCalibrationIntegration.h.

Member Typedef Documentation

MdtCalibOutputPtr

using MuonCalib::IMdtCalibration::MdtCalibOutputPtr = std::shared_ptr<IMdtCalibrationOutput>

inherited

Definition at line 30 of file IMdtCalibration.h.

MuonSegCit

using MuonCalib::IMdtCalibration::MuonSegCit = MuonSegVec::const_iterator

inherited

Definition at line 29 of file IMdtCalibration.h.

MuonSegIt

using MuonCalib::IMdtCalibration::MuonSegIt = MuonSegVec::iterator

inherited

Definition at line 28 of file IMdtCalibration.h.

MuonSegVec

using MuonCalib::IMdtCalibration::MuonSegVec = std::vector<std::shared_ptr<MuonCalibSegment> >

inherited

Definition at line 27 of file IMdtCalibration.h.

Constructor & Destructor Documentation

RtCalibrationIntegration() [1/2]

MuonCalib::RtCalibrationIntegration::RtCalibrationIntegration ( const std::string &  name )

inline

Default constructor.

Only hits on the segment are used by the algorithm by default. The maximum drift radius is set to 14.6 mm.

Definition at line 36 of file RtCalibrationIntegration.h.

RtCalibrationIntegration() [2/2]

MuonCalib::RtCalibrationIntegration::RtCalibrationIntegration ( const std::string &  name, bool  close_hits, double  r_max, double  lower_extrapolation_radius, double  upper_extrapolation_radius, bool  add_tmax_difference  )

inline

Constructor.

If close_hits is set to true, also close hits are used. The maximum drift radius is set to r_max [mm].

Definition at line 40 of file RtCalibrationIntegration.h.

Member Function Documentation

analyse()

bool RtCalibrationIntegration::analyse

(

)

perform the integration method

Definition at line 87 of file RtCalibrationIntegration.cxx.

                                       {
    // VARIABLES //
 
    T0MTSettings t0_setting;  // settings of the MT t0 fitter
    t0_setting.AddFitfun() = true;
    //  t0_setting.DrawDebugGraphs()=true;
    t0_setting.T0Settings()->ScrambleThreshold() = 2;
    t0_setting.T0Settings()->SlicingThreshold() = 3;
    t0_setting.TMaxSettings()->DistAB() += 50;
    T0MTHistos drift_time_spec;  // drift time spectrum used in the t0 and
    // the tmax fit
    std::array<T0MTHistos, 2> drift_time_spec_ml;
 
    double t0, tmax;  // t0 and tmax
    int k_min(-1);    //, k_max(-1); // first and last drift-time entry to be
    // used in the integration procedure
    unsigned int nb_bins(100);                    // number of integration bins
    double bin_content;                           // number of entries per bin
    std::vector<SamplePoint> point(nb_bins + 1);  // (t, r) points
    double radius(0.0);                           // r(t)
    double scf = 0.;                              // scale factor (r_max/number of used hits)
    RtFromPoints rt_from_points;                  // r-t converter
 
    // STOP HERE, IF THERE ARE NOT ENOUGH ENTRIES IN THE DRIFT-TIME SPECTRUM //
 
    if (m_t_drift.size() < 2000) {
        MsgStream log(Athena::getMessageSvc(), "RtCalibrationIntegration");
        log << MSG::WARNING << "analyse() - Less than 2000 drift-time entries! No r-t relationship will be determined!" << endmsg;
        return false;
    }
 
    // INTEGRATION METHOD //
 
    // sort the hits in ascending order of their drift times //
    sort(m_t_drift.begin(), m_t_drift.end());
 
    // perform a t0 and tmax fit //
    // fill the histogram with the drift-time spectrum //
    int n_bins = static_cast<int>(32 * (200.0 + m_t_drift[m_t_drift.size() - 1].first - m_t_drift[0].first) / 25.0);
    float min_t = m_t_drift[0].first - 100.0;
    float max_t = m_t_drift[m_t_drift.size() - 1].first + 100.0;
    std::unique_ptr<TH1F> tspec = std::make_unique<TH1F>("tspec", "DRIFT-TIME SPECTRUM", n_bins, min_t, max_t);
    std::array<std::unique_ptr<TH1F>, 2> tspec_ml;
    tspec_ml[0] = std::make_unique<TH1F>("tspec_ml0", "DRIFT-TIME SPECTRUM ML 0", n_bins, min_t, max_t);
    tspec_ml[1] = std::make_unique<TH1F>("tspec_ml1", "DRIFT-TIME SPECTRUM ML 1", n_bins, min_t, max_t);
 
    for (auto & k : m_t_drift) {
        tspec->Fill(k.first, 1.0);
        tspec_ml[static_cast<unsigned int>(k.second)]->Fill(k.first, 1.0);
    }
    drift_time_spec.SetTSpec(1, tspec.get(), &t0_setting, false);
    drift_time_spec_ml[0].SetTSpec(2, tspec_ml[0].get(), &t0_setting, false);
    drift_time_spec_ml[1].SetTSpec(3, tspec_ml[1].get(), &t0_setting, false);
 
    // t0 and tmax fits //
 
    if (!drift_time_spec.FitT0() || !drift_time_spec.T0Ok()) {
        MsgStream log(Athena::getMessageSvc(), "RtCalibrationIntegration");
        log << MSG::WARNING << "analyse() - t0 fit not successful, no r-t relationship will be calculated!" << endmsg;
        return false;
    }
    t0 = drift_time_spec.GetT0Function()->GetParameter(T0MTHistos::T0_PAR_NR_T0);
 
    if (!drift_time_spec.FitTmax() || !drift_time_spec.TmaxOk()) {
        MsgStream log(Athena::getMessageSvc(), "RtCalibrationIntegration");
        log << MSG::WARNING << "analyse() - tmax fit not successful, no r-t relationship will be calculated!" << endmsg;
        return false;
    }
    tmax = drift_time_spec.GetTMaxFunction()->GetParameter(T0MTHistos::TMAX_PAR_NR_TMAX) +
           2.0 * drift_time_spec.GetTMaxFunction()->GetParameter(T0MTHistos::TMAX_PAR_NR_T);
 
    // determine (t,r) points by integration //
    m_nb_hits_used = 0;
    for (unsigned int k = 0; k < m_t_drift.size(); k++) {
        if (m_t_drift[k].first >= t0 && m_t_drift[k].first <= tmax) { m_nb_hits_used++; }
        if (k_min < 0 && m_t_drift[k].first >= t0) { k_min = k; }
    }
    // k_max = k_min+m_nb_hits_used-1;
 
    bin_content = static_cast<double>(m_nb_hits_used) / static_cast<double>(nb_bins);
 
    if (m_nb_hits_used > 0) { scf = m_r_max / static_cast<double>(m_nb_hits_used); }
 
    point[0].set_x1(t0);
    point[0].set_x2(0.0);
    point[0].set_error(0.1);  // give a higher weight to the end point in
 
    // the final fit
    for (unsigned int k = 1; k < nb_bins; k++) {
        radius = radius + scf * bin_content;
        point[k].set_x1(m_t_drift[k_min + static_cast<int>(bin_content) * (k)].first);
        point[k].set_x2(radius);
        point[k].set_error(1.0);
    }
 
    point[nb_bins].set_x1(tmax);
    point[nb_bins].set_x2(m_r_max);
    point[nb_bins].set_error(1.);
 
    // get the r-t relationship //
    m_rt = rt_from_points.getRtChebyshev(point, 15);
 
    // PARABOLIC EXTRAPOLATION FOR LARGE DRIFT RADII //
    std::vector<SamplePoint> add_fit_point;  // additional r-t points for r(t_max)
    add_fit_point.push_back(SamplePoint(tmax, m_r_max, 1.0));
    RtParabolicExtrapolation rt_extrapolated;
    RtRelationLookUp tmp_rt(rt_extrapolated.getRtWithParabolicExtrapolation(*m_rt, m_lower_extrapolation_radius,
                                                                            m_upper_extrapolation_radius, m_r_max, add_fit_point));
    std::shared_ptr<IRtRelation> rt_new = std::make_shared<RtRelationLookUp>(tmp_rt);
 
    // Get length difference between multilayers    //
 
    if (tspec_ml[0]->GetEntries() >= 10000 && tspec_ml[0]->GetEntries() > 10000) {
        bool fit_ok(true);
        std::array<float, 2> b{}, tmax{}, T{};
        for (unsigned int i = 0; i < 2; i++) {
            if (!drift_time_spec_ml[i].FitT0()) {
                fit_ok = false;
                break;
            }
            if (!drift_time_spec_ml[i].FitTmax()) {
                fit_ok = false;
                break;
            }
            b[i] = drift_time_spec_ml[i].GetTMaxFunction()->GetParameter(T0MTHistos::TMAX_PAR_NR_B);
            tmax[i] = drift_time_spec_ml[i].GetTMaxFunction()->GetParameter(T0MTHistos::TMAX_PAR_NR_TMAX) -
                      drift_time_spec_ml[i].GetT0Function()->GetParameter(T0MTHistos::T0_PAR_NR_T0);
            T[i] = drift_time_spec_ml[i].GetTMaxFunction()->GetParameter(T0MTHistos::TMAX_PAR_NR_T);
        }
        if (fit_ok) {
            int refit = static_cast<int>((b[1] + 1.33717e-03) > (b[0] + 1.33717e-03));
            int norefit = static_cast<bool>(refit) ? 0 : 1;
            TF1 *fixfun = drift_time_spec_ml[refit].GetTMaxFunctionNC();
            fixfun->FixParameter(T0MTHistos::TMAX_PAR_NR_B, b[norefit]);
            update_parameter_on_mttmax(drift_time_spec_ml[refit].GetTSpec(), fixfun, b[norefit], T[norefit], *t0_setting.TMaxSettings());
            TList *l = drift_time_spec_ml[refit].GetTSpec()->GetListOfFunctions();
            l->Remove(l->FindObject("mt_tmax_fermi"));
            fit_ok = drift_time_spec_ml[refit].FitTmax();
            tmax[refit] = drift_time_spec_ml[refit].GetTMaxFunction()->GetParameter(T0MTHistos::TMAX_PAR_NR_TMAX) -
                          drift_time_spec_ml[refit].GetT0Function()->GetParameter(T0MTHistos::T0_PAR_NR_T0);
        }
 
        if (fit_ok && m_add_tmax_difference) rt_new->SetTmaxDiff(tmax[0] - tmax[1]);
    }
 
    // STORE THE RESULTS IN THE RtCalibrationOutput //
 
    m_output = std::make_unique<RtCalibrationOutput>(
        rt_new, std::make_shared<RtFullInfo>("RtCalibrationIntegration", 1, m_nb_segments_used, 0.0, 0.0, 0.0, 0.0));
 
    return true;
}

analyseSegments()

RtCalibrationIntegration::MdtCalibOutputPtr RtCalibrationIntegration::analyseSegments ( const MuonSegVec &  seg )

overridevirtual

determine r(t)

Implements MuonCalib::IMdtCalibration.

Definition at line 58 of file RtCalibrationIntegration.cxx.

                                                                                                         {
    for (const auto & k : seg) { handleSegment(*k); }
    m_nb_segments_used = seg.size();
    analyse();
 
    return getResults();
}

converged()

bool RtCalibrationIntegration::converged

(

)

const

returns true, if the integration method has been performed

Definition at line 258 of file RtCalibrationIntegration.cxx.

{ return (m_output != nullptr); }

getResults()

RtCalibrationIntegration::MdtCalibOutputPtr RtCalibrationIntegration::getResults ( ) const

overridevirtual

returns the final r-t relationship

Implements MuonCalib::IMdtCalibration.

Definition at line 265 of file RtCalibrationIntegration.cxx.

{ return m_output; }

handleSegment()

bool RtCalibrationIntegration::handleSegment

(

MuonCalibSegment &

seg

)

analyse the segment "seg"

Definition at line 65 of file RtCalibrationIntegration.cxx.

                                                                  {
    // LOOP OVER THE HITS OF THE SEGMENTS AND STORE THEM //
 
    // start with hits on the segment //
    for (unsigned int k = 0; k < seg.mdtHitsOnTrack(); k++) {
        if (seg.mdtHOT()[k]->driftTime() < -8e8) continue;
        m_t_drift.push_back(std::pair<double, bool>(seg.mdtHOT()[k]->driftTime(), seg.mdtHOT()[k]->identify().mdtMultilayer() == 2));
    }
 
    // continue with close hits if requested //
    if (m_close_hits == true) {
        for (unsigned int k = 0; k < seg.mdtCloseHits(); k++) {
            m_t_drift.push_back(std::pair<double, bool>(seg.mdtHOT()[k]->driftTime(), seg.mdtHOT()[k]->identify().mdtMultilayer() == 2));
        }
    }
 
    return true;
}

init()

void RtCalibrationIntegration::init ( bool  close_hits, double  r_max, double  lower_extrapolation_radius, double  higher_extrapolation_radius, bool  add_tmax_difference  )

private

Definition at line 43 of file RtCalibrationIntegration.cxx.

                                                              {
    m_close_hits = close_hits;
    m_rt = nullptr;
    m_r_max = r_max;
    m_lower_extrapolation_radius = lower_extrapolation_radius;
    m_upper_extrapolation_radius = upper_extrapolation_radius;
    m_output = nullptr;
    m_nb_hits_used = 0;
    m_nb_segments_used = 0;
    m_add_tmax_difference = add_tmax_difference;
    return;
}

name()

virtual std::string MuonCalib::IMdtCalibration::name ( ) const

inlinevirtualinherited

returns name (region) of instance

Definition at line 49 of file IMdtCalibration.h.

{ return m_name; }

number_of_hits_used()

unsigned int RtCalibrationIntegration::number_of_hits_used

(

)

const

get the number of hits used in the r-t determination

Definition at line 56 of file RtCalibrationIntegration.cxx.

{ return m_nb_hits_used; }

setInput()

void RtCalibrationIntegration::setInput ( const IMdtCalibrationOutput *  rt_input )

overridevirtual

the method is empty as no initial r-t relationship is required by the algorithm

Implements MuonCalib::IMdtCalibration.

Definition at line 86 of file RtCalibrationIntegration.cxx.

{ return; }

Member Data Documentation

m_add_tmax_difference

bool MuonCalib::RtCalibrationIntegration::m_add_tmax_difference

private

Definition at line 80 of file RtCalibrationIntegration.h.

m_close_hits

bool MuonCalib::RtCalibrationIntegration::m_close_hits

private

Definition at line 73 of file RtCalibrationIntegration.h.

m_lower_extrapolation_radius

double MuonCalib::RtCalibrationIntegration::m_lower_extrapolation_radius

private

sets the lower radius to perform the

Definition at line 75 of file RtCalibrationIntegration.h.

m_name

std::string MuonCalib::IMdtCalibration::m_name

privateinherited

Definition at line 52 of file IMdtCalibration.h.

m_nb_hits_used

unsigned int MuonCalib::RtCalibrationIntegration::m_nb_hits_used

private

Definition at line 86 of file RtCalibrationIntegration.h.

m_nb_segments_used

unsigned int MuonCalib::RtCalibrationIntegration::m_nb_segments_used

private

Definition at line 87 of file RtCalibrationIntegration.h.

m_output

std::shared_ptr<RtCalibrationOutput> MuonCalib::RtCalibrationIntegration::m_output

private

Definition at line 89 of file RtCalibrationIntegration.h.

m_r_max

double MuonCalib::RtCalibrationIntegration::m_r_max

private

Definition at line 88 of file RtCalibrationIntegration.h.

m_rt

std::shared_ptr<IRtRelation> MuonCalib::RtCalibrationIntegration::m_rt

private

Definition at line 85 of file RtCalibrationIntegration.h.

m_t_drift

std::vector<std::pair<double, bool> > MuonCalib::RtCalibrationIntegration::m_t_drift

private

Definition at line 83 of file RtCalibrationIntegration.h.

m_upper_extrapolation_radius

double MuonCalib::RtCalibrationIntegration::m_upper_extrapolation_radius

private

parabolic extrapolation.

the parabolic fit will be performet between the lower extrapolation radius and the upper extrapolation value and be extrapolated till r_max

Definition at line 76 of file RtCalibrationIntegration.h.

---

The documentation for this class was generated from the following files:

• RtCalibrationIntegration.h
• RtCalibrationIntegration.cxx