MdtCalibOutputDbSvc Class Reference

#include <MdtCalibOutputDbSvc.h>

Inheritance diagram for MdtCalibOutputDbSvc:

Collaboration diagram for MdtCalibOutputDbSvc:

Public Member Functions
	MdtCalibOutputDbSvc (const std::string &name, ISvcLocator *svc_locator)
	Constructor. More...
virtual	~MdtCalibOutputDbSvc ()=default
	Virtual destructor. More...
virtual StatusCode	queryInterface (const InterfaceID &riid, void **ppvUnknown)
	method required by the base class which is need to obtain a pointer to the service in the standard way More...
virtual StatusCode	initialize ()
	initialize method as required by the base class More...
virtual StatusCode	finalize ()
	finalize method as required by the base class; the finalize method calls the method "save_calibration_results" More...
void	AddRunNumber (int run_number)
	add a run number to the iov interval. More...
bool	memorize (std::shared_ptr< const MuonCalib::IMdtCalibrationOutput > result)
	memorize the result of a particular calibration (given in result) for the calibration region "regionKey"; previous calibration result of the same type (e.g. More...
bool	memorize (std::shared_ptr< const MuonCalib::IMdtCalibrationOutput > result, std::shared_ptr< const MuonCalib::IRtResolution > resol)
	memorize the result of a particular calibration (given in result) for the calibration region "regionKey"; a previous calibration result of the same type (e.g. More...
void	reset ()
	reset, clear memory of results More...
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()
	Methods required as defined in the base class "Service". More...

Private Member Functions
StatusCode	saveCalibrationResults ()
	write out all memorized results to text files (location specified in the job options) which can be uploaded to the calibration database; method returns true in case of success, false otherwise More...
void	create_default_resolution (const std::shared_ptr< const MuonCalib::IRtRelation > &rt)

Static Private Member Functions
static const MuonCalib::MdtTubeFitContainer *	postprocess_t0s (const MuonCalib::MdtTubeFitContainer *new_t0, const MuonCalib::NtupleStationId &id)

Private Attributes
std::shared_ptr< const MuonCalib::IMdtCalibrationOutput >	m_results
std::shared_ptr< const MuonCalib::IRtResolution >	m_resolution
bool	m_postprocess_calibration
double	m_flat_default_resolution
bool	m_force_default_resolution
ToolHandle< MuonCalib::ICalibrationIOTool >	m_calib_output_tool {this, "OutputTool", "MuonCalib::CalibrationFileIOTool"}
int	m_iov_start
int	m_iov_end
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager >	m_DetectorManagerKey
ServiceHandle< RegionSelectionSvc >	m_reg_sel_svc
ServiceHandle< MdtCalibInputSvc >	m_input_service
std::vector< MuonCalib::NtupleStationId >	m_region_ids

Detailed Description

Service which holds the results of the calibration algorithms. In its initial version the class can only write out the calibration to text files as it is currently performed in the calibration algorithms. The location of the output file is given in the job options file.

The name of the service is MdtCalibOutputDbSvc. MdtCalibOutputDbSvc is a singleton.

Author

Olive.nosp@m.r.Ko.nosp@m.rtner.nosp@m.@CER.nosp@m.N.CH

Date

07.10.2006

Definition at line 46 of file MdtCalibOutputDbSvc.h.

Constructor & Destructor Documentation

MdtCalibOutputDbSvc()

MdtCalibOutputDbSvc::MdtCalibOutputDbSvc	(	const std::string &	name,
		ISvcLocator *	svc_locator
	)

Constructor.

Definition at line 24 of file MdtCalibOutputDbSvc.cxx.

                                                                                        :
    AthService(name, svc_locator),
    m_results(nullptr),
    m_postprocess_calibration(false),
    m_iov_start(-1),
    m_iov_end(-1),
    m_reg_sel_svc("RegionSelectionSvc", name),
    m_input_service("MdtCalibInputSvc", name) {
    declareProperty("PostprocessCalibration", m_postprocess_calibration);
    m_flat_default_resolution = -1;
    declareProperty("FlatDefaultResolution", m_flat_default_resolution);
    m_force_default_resolution = false;
    declareProperty("ForceDefaultResolution", m_force_default_resolution);
 
    declareProperty("MdtCalibInputSvc", m_input_service);
    declareProperty("RegionSelectionSvc", m_reg_sel_svc);
 
    // for the sake of coverity
    m_resolution = nullptr;
}

~MdtCalibOutputDbSvc()

virtual MdtCalibOutputDbSvc::~MdtCalibOutputDbSvc ( )

virtualdefault

Virtual destructor.

Member Function Documentation

AddRunNumber()

void MdtCalibOutputDbSvc::AddRunNumber

(

int

run_number

)

add a run number to the iov interval.

The interval will begin with the smallest run number, and end with the largest run number

Definition at line 108 of file MdtCalibOutputDbSvc.cxx.

                                                     {
    if (run_number < m_iov_start || m_iov_start < 0) { m_iov_start = run_number; }
    if (run_number > m_iov_end || m_iov_end < 0) { m_iov_end = run_number; }
}

create_default_resolution()

void MdtCalibOutputDbSvc::create_default_resolution ( const std::shared_ptr< const MuonCalib::IRtRelation > &  rt )

inlineprivate

Definition at line 282 of file MdtCalibOutputDbSvc.cxx.

                                                                                                              {
    // check if resolution is saved in input service
    const IRtResolution *old_res = m_input_service->GetResolution();
    const IRtRelation *old_rel = m_input_service->GetRtRelation();
    if (old_res != nullptr && old_rel != nullptr && !m_force_default_resolution) {
        // scale the old resolution to the new rt relation
        ATH_MSG_INFO("Taken old resolution");
        std::vector<SamplePoint> res_points(100);
        for (unsigned int i = 0; i < 100; i++) {
            double di = static_cast<double>(i);
            double t_new = rt->tLower() + (di / 100.0) * (rt->tUpper() - rt->tLower());
            double t_old = old_rel->tLower() + (di / 100.0) * (old_rel->tUpper() - old_rel->tLower());
            res_points[i].set_x1(t_new);
            res_points[i].set_x2(old_res->resolution(t_old));
            if (res_points[i].x2() > 100 && i > 0) res_points[i].set_x2(res_points[i - 1].x2());
            res_points[i].set_error(1);
        }
        RtResolutionFromPoints respoints;
        m_resolution = std::make_shared<RtResolutionLookUp>(MuonCalib::RtResolutionFromPoints::getRtResolutionLookUp(res_points));
        return;
    }
    ATH_MSG_INFO("Creating default resolution");
    // parameters for default resolution curve
    double alpha[9] = {0.31476, -0.217661, 0.118337, -0.0374466, 0.00692553, -0.000764969, 4.97305E-05, -1.75457E-06, 2.59E-08};
    MuonCalib::CalibFunc::ParVec par_vec;
 
    if (m_flat_default_resolution < 0.0) {
        double bin_width = (rt->tUpper() - rt->tLower()) / 100.0;
        par_vec.resize(102);
        par_vec[0] = rt->tLower();
        par_vec[1] = bin_width;
        for (unsigned int i = 0; i < 100; i++) {
            double t = rt->tLower() + i * bin_width;
            double r = rt->radius(t);
            double resol(0.0);
            for (int l = 0; l < 9; l++) { resol = resol + alpha[l] * std::pow(r, l); }
            par_vec[i + 2] = resol;
        }
    } else {
        par_vec.resize(4);
        par_vec[0] = rt->tLower();
        par_vec[1] = (rt->tUpper() - rt->tLower()) / 2.0;
        par_vec[2] = m_flat_default_resolution;
        par_vec[3] = m_flat_default_resolution;
    }
    m_resolution = std::make_shared<MuonCalib::RtResolutionLookUp>(par_vec);
}  // end MdtCalibOutputDbSvc::create_default_resolution

finalize()

StatusCode MdtCalibOutputDbSvc::finalize ( )

virtual

finalize method as required by the base class; the finalize method calls the method "save_calibration_results"

Definition at line 97 of file MdtCalibOutputDbSvc.cxx.

                                         {
    ATH_CHECK(saveCalibrationResults());
    ATH_MSG_INFO("Results saved!");
    return StatusCode::SUCCESS;
}

initialize()

StatusCode MdtCalibOutputDbSvc::initialize ( )

virtual

initialize method as required by the base class

Definition at line 65 of file MdtCalibOutputDbSvc.cxx.

                                           {
    // to get service via static function
    //  m_MdtCalibOutputDbSvc_pointer = this;
    ATH_MSG_INFO("initialize MdtCalibOutputDbSvc");
 
    // get id helper and detector manager if postprocessing of calibration is selected
    if (m_postprocess_calibration) {
        // retrieve detector store
        StoreGateSvc *detStore;
        ATH_CHECK(serviceLocator()->service("DetectorStore", detStore));
        // retrieve mdt id helper
        ATH_CHECK(m_idHelperSvc.retrieve());
        // retrieve detector manager from the conditions store
        ATH_CHECK(m_DetectorManagerKey.initialize());
    }
 
    // get region selection service
    ATH_CHECK(m_reg_sel_svc.retrieve());
    m_region_ids = m_reg_sel_svc->GetStationsInRegions();
    ATH_MSG_INFO("Regions selected: " << m_region_ids.size());
    // retrieve tool
    ATH_CHECK(m_calib_output_tool.retrieve());
    ATH_CHECK(m_input_service.retrieve());
 
    return StatusCode::SUCCESS;
}

interfaceID()

static const InterfaceID& MdtCalibOutputDbSvc::interfaceID ( )

inlinestatic

Methods required as defined in the base class "Service".

interface

Definition at line 58 of file MdtCalibOutputDbSvc.h.

                                            {
        static const InterfaceID IID_IMdtCalibOutputDbSvc("MdtCalibOutputDbSvc", 1, 0);
        return IID_IMdtCalibOutputDbSvc;
    }

memorize() [1/2]

bool MdtCalibOutputDbSvc::memorize

(

std::shared_ptr< const MuonCalib::IMdtCalibrationOutput >

result

)

memorize the result of a particular calibration (given in result) for the calibration region "regionKey"; previous calibration result of the same type (e.g.

r-t relation calibration) will be overwritten internally if overwrite is true; the calibration which is memorized will only be saved for ever after a call to the method "saved_calibration_results"; method return true in case of success, false otherwise

Definition at line 118 of file MdtCalibOutputDbSvc.cxx.

                                                                                             {
    // no overwriting is allowed //
    m_results = std::move(result);
    m_resolution.reset();
    return true;
}

memorize() [2/2]

bool MdtCalibOutputDbSvc::memorize	(	std::shared_ptr< const MuonCalib::IMdtCalibrationOutput >	result,
		std::shared_ptr< const MuonCalib::IRtResolution >	resol
	)

memorize the result of a particular calibration (given in result) for the calibration region "regionKey"; a previous calibration result of the same type (e.g.

r-t relation calibration) will be overwritten internally if overwrite is true; the calibration which is memorized will only be saved for ever after a call to the method "saved_calibration_results"; method return true in case of success, false otherwise; the user can pass a pointer to a resolution function which should be associated with the calibration output

Definition at line 130 of file MdtCalibOutputDbSvc.cxx.

                                                                                      {
    m_results = std::move(result);
    m_resolution = std::move(resol);
    return true;
}

msg() [1/2]

MsgStream& AthCommonMsg< Service >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

MsgStream& AthCommonMsg< Service >::msg ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

msgLvl()

bool AthCommonMsg< Service >::msgLvl ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

postprocess_t0s()

const MuonCalib::MdtTubeFitContainer * MdtCalibOutputDbSvc::postprocess_t0s ( const MuonCalib::MdtTubeFitContainer *  new_t0, const MuonCalib::NtupleStationId &  id  )

staticprivate

Definition at line 228 of file MdtCalibOutputDbSvc.cxx.

                                                                                                               {
    int n_layers(-1), n_tubes(-1);
    if (id.NMultilayers() < 0) return t0;
    // get the maximum number of layers and tubes per layer for this station
    for (int i = 0; i < id.NMultilayers(); i++) {
        if (n_layers < id.NLayers(i)) n_layers = id.NLayers(i);
        if (n_tubes < id.NTubes(i)) n_tubes = id.NTubes(i);
    }
    MdtTubeFitContainer *new_t0 = new MdtTubeFitContainer(id.regionId(), id.NMultilayers(), n_layers, n_tubes);
    new_t0->setImplementation(t0->implementation());
    new_t0->setGroupBy(t0->GroupBy());
 
    // loop over tubes
    double n_goods(0.0);
    double mean_t0(0.0);
    bool has_bad_fits(false);
    for (unsigned int ml = 0; ml < t0->numMultilayers(); ml++) {
        if (static_cast<int>(ml) == id.NMultilayers()) break;
        for (unsigned int ly = 0; ly < t0->numLayers(); ly++) {
            if (static_cast<int>(ly) == n_layers) break;
            for (unsigned int tb = 0; tb < t0->numTubes(); tb++) {
                if (static_cast<int>(tb) == n_tubes) break;
                new_t0->setFit(ml, ly, tb, *(t0->getFit(ml, ly, tb)));
                new_t0->setCalib(ml, ly, tb, *(t0->getCalib(ml, ly, tb)));
                // if tube was ok use for mean t0
                if (t0->getCalib(ml, ly, tb)->statusCode == 0) {
                    n_goods++;
                    mean_t0 += t0->getCalib(ml, ly, tb)->t0;
                } else {
                    has_bad_fits = true;
                }
            }
        }
    }
 
    // check for bad fits and insert mean t0;
    if (has_bad_fits) {
        mean_t0 /= n_goods;
        for (unsigned int ml = 0; ml < new_t0->numMultilayers(); ml++) {
            for (unsigned int ly = 0; ly < new_t0->numLayers(); ly++) {
                for (unsigned int tb = 0; tb < new_t0->numTubes(); tb++) {
                    if (t0->getCalib(ml, ly, tb)->statusCode != 0) {
                        MdtTubeCalibContainer::SingleTubeCalib calib(*(new_t0->getCalib(ml, ly, tb)));
                        calib.t0 = mean_t0;
                        new_t0->setCalib(ml, ly, tb, calib);
                    }
                }
            }
        }
    }
    return new_t0;
}  // end MdtCalibOutputDbSvc::postprocess_t0s

queryInterface()

StatusCode MdtCalibOutputDbSvc::queryInterface ( const InterfaceID &  riid, void **  ppvUnknown  )

virtual

method required by the base class which is need to obtain a pointer to the service in the standard way

Definition at line 50 of file MdtCalibOutputDbSvc.cxx.

                                                                                         {
    if (interfaceID().versionMatch(riid)) {
        *ppvUnknown = (MdtCalibOutputDbSvc *)this;
    } else {
        return AthService::queryInterface(riid, ppvUnknown);
    }
 
    return StatusCode::SUCCESS;
}

reset()

void MdtCalibOutputDbSvc::reset

(

)

reset, clear memory of results

Definition at line 224 of file MdtCalibOutputDbSvc.cxx.

                                {
    m_results.reset();
}

saveCalibrationResults()

StatusCode MdtCalibOutputDbSvc::saveCalibrationResults ( )

private

write out all memorized results to text files (location specified in the job options) which can be uploaded to the calibration database; method returns true in case of success, false otherwise

Definition at line 142 of file MdtCalibOutputDbSvc.cxx.

                                                       {
    if (!m_results) return StatusCode::SUCCESS;
 
    SG::ReadCondHandle<MuonGM::MuonDetectorManager> DetectorManagerHandle{m_DetectorManagerKey};
    const MuonGM::MuonDetectorManager *MuonDetMgr = DetectorManagerHandle.cptr();
    if (!MuonDetMgr) {
        ATH_MSG_ERROR("Null pointer to the read MuonDetectorManager conditions object");
        return StatusCode::FAILURE;
    }
 
    StatusCode sc;
 
    // VARIABLES //
 
    // LOOP OVER THE STORED RESULTS AND WRITE THEM OUT ACCORDING TO THEIR TYPE //
 
    //-----------------------------------------------------------------------------
    for (const auto & region_id : m_region_ids) {
        //-----------------------------------------------------------------------------
        MuonCalib::NtupleStationId the_id(region_id);
        // get region geometry if required
        if (m_postprocess_calibration) {
            if (!the_id.InitializeGeometry(m_idHelperSvc->mdtIdHelper(), MuonDetMgr)) {
                ATH_MSG_ERROR("Faild to get geometry for " << the_id.regionId());
            }
        }
        // t0 calibration //
        std::shared_ptr<const T0CalibrationOutput> t0_output = std::dynamic_pointer_cast<const T0CalibrationOutput>(m_results);
        if (t0_output != nullptr) {
            ATH_MSG_INFO("Writing out t0s.");
            const MdtTubeFitContainer *new_t0s = t0_output->t0s();
            if (!t0_output->GetMap().empty()) {
                std::map<NtupleStationId, MdtTubeFitContainer *>::const_iterator mit(t0_output->GetMap().find(region_id));
                if (mit != t0_output->GetMap().end()) { new_t0s = mit->second; }
            }
            if (!new_t0s) continue;
            if (m_postprocess_calibration) new_t0s = postprocess_t0s(new_t0s, the_id);
 
            sc = m_calib_output_tool->WriteT0(new_t0s, the_id, m_iov_start, m_iov_end);
            if (sc.isFailure()) return sc;
        }
 
        // r-t calibration //
        bool real_resolution(true), real_rt(true);
        std::shared_ptr<const RtCalibrationOutput> rt_output = std::dynamic_pointer_cast<const RtCalibrationOutput>(m_results);
        if (rt_output) {
            if (rt_output->rt()) {
                if (!rt_output->rt()->HasTmaxDiff()) {
                    const IRtRelation *old_rel = m_input_service->GetRtRelation();
                    if (old_rel && old_rel->HasTmaxDiff()) {
                        std::const_pointer_cast<IRtRelation>(rt_output->rt())->SetTmaxDiff(old_rel->GetTmaxDiff());
                    }
                }
            }
 
            ATH_MSG_INFO("Writing out r-t relationships.");
            if (!m_resolution) {
                real_resolution = false;
                create_default_resolution(rt_output->rt());
            } else {
                real_rt = false;
            }
            sc = m_calib_output_tool->WriteRt(rt_output.get(), m_resolution, the_id, m_iov_start, m_iov_end, real_rt, real_resolution);
            if (sc.isFailure()) return sc;
        }
 
        //-----------------------------------------------------------------------------
    }
    //-----------------------------------------------------------------------------
    ATH_MSG_INFO("Finished writing");
    return StatusCode::SUCCESS;
}  // end MdtCalibOutputDbSvc::saveCalibrationResults

Member Data Documentation

m_calib_output_tool

ToolHandle<MuonCalib::ICalibrationIOTool> MdtCalibOutputDbSvc::m_calib_output_tool {this, "OutputTool", "MuonCalib::CalibrationFileIOTool"}

private

Definition at line 108 of file MdtCalibOutputDbSvc.h.

m_DetectorManagerKey

SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> MdtCalibOutputDbSvc::m_DetectorManagerKey

private

Initial value:

{this, "DetectorManagerKey", "MuonDetectorManager",
                                                                            "Key of input MuonDetectorManager condition data"}

Definition at line 115 of file MdtCalibOutputDbSvc.h.

m_flat_default_resolution

double MdtCalibOutputDbSvc::m_flat_default_resolution

private

Definition at line 104 of file MdtCalibOutputDbSvc.h.

m_force_default_resolution

bool MdtCalibOutputDbSvc::m_force_default_resolution

private

Definition at line 106 of file MdtCalibOutputDbSvc.h.

m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> MdtCalibOutputDbSvc::m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

private

Definition at line 112 of file MdtCalibOutputDbSvc.h.

m_input_service

ServiceHandle<MdtCalibInputSvc> MdtCalibOutputDbSvc::m_input_service

private

Definition at line 121 of file MdtCalibOutputDbSvc.h.

m_iov_end

int MdtCalibOutputDbSvc::m_iov_end

private

Definition at line 110 of file MdtCalibOutputDbSvc.h.

m_iov_start

int MdtCalibOutputDbSvc::m_iov_start

private

Definition at line 110 of file MdtCalibOutputDbSvc.h.

m_postprocess_calibration

bool MdtCalibOutputDbSvc::m_postprocess_calibration

private

Definition at line 102 of file MdtCalibOutputDbSvc.h.

m_reg_sel_svc

ServiceHandle<RegionSelectionSvc> MdtCalibOutputDbSvc::m_reg_sel_svc

private

Definition at line 119 of file MdtCalibOutputDbSvc.h.

m_region_ids

std::vector<MuonCalib::NtupleStationId> MdtCalibOutputDbSvc::m_region_ids

private

Definition at line 122 of file MdtCalibOutputDbSvc.h.

m_resolution

std::shared_ptr<const MuonCalib::IRtResolution> MdtCalibOutputDbSvc::m_resolution

private

Definition at line 97 of file MdtCalibOutputDbSvc.h.

m_results

std::shared_ptr<const MuonCalib::IMdtCalibrationOutput> MdtCalibOutputDbSvc::m_results

private

Definition at line 94 of file MdtCalibOutputDbSvc.h.

---

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

• MdtCalibOutputDbSvc.h
• MdtCalibOutputDbSvc.cxx