TauJetCnv_p5.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
 
 
#include "tauEvent/TauJet.h"
#include "DataModelAthenaPool/ElementLinkCnv_p3.h"
#include "DataModelAthenaPool/ElementLinkVectorCnv_p1.h"
 
#include "EventCommonTPCnv/P4ImplEEtaPhiMCnv_p2.h"
#include "ParticleEventTPCnv/ParticleBaseCnv_p2.h"
#include "tauEventTPCnv/TauJetCnv_p5.h"
 
#include "EventCommonTPCnv/HepLorentzVectorCnv_p1.h"
 
//Pre-allocate converters
static const HepLorentzVectorCnv_p1 hepLorentzVectorCnv;
static const P4ImplEEtaPhiMCnv_p2 momCnv;
static const ParticleBaseCnv_p2 partBaseCnv;
static const ElementLinkCnv_p3<ElementLink<CaloClusterContainer> > clusterCnv;
static const ElementLinkCnv_p3<ElementLink<JetCollection> > jetCnv;
static const ElementLinkVectorCnv_p1<ElementLinkVector<Analysis::TauDetailsContainer> > detailsCnv;
static const ElementLinkVectorCnv_p1<ElementLinkVector<Rec::TrackParticleContainer> > tracksCnv;
static const ElementLinkVectorCnv_p1<ElementLinkVector<Rec::TrackParticleContainer> > conversionTracksCnv;
static const ElementLinkVectorCnv_p1<ElementLinkVector<Rec::TrackParticleContainer> > seedCalo_tracksCnv;
static const ElementLinkVectorCnv_p1<ElementLinkVector<Rec::TrackParticleContainer> > seedTrk_tracksCnv;
 
static void setBit( unsigned char &field, unsigned num, bool val )
{
    if ( val )
        field |= (1 << num);
    else
        field &= ~(1 << num);
}
 
static bool getBit( unsigned char field, unsigned num )
{
    return (field & (1 << num)) ? true : false;
}
 
void TauJetCnv_p5::persToTrans( const TauJet_p5 *pers,
        Analysis::TauJet *trans,
        MsgStream &msg ) const
{
    momCnv.persToTrans( &pers->m_momentum, &trans->momentumBase(), msg );
    partBaseCnv.persToTrans( &pers->m_particleBase, &trans->particleBase(), msg );
    clusterCnv.persToTrans( &pers->m_cluster, &trans->clusterLink(), msg );
    clusterCnv.persToTrans( &pers->m_cellCluster, &trans->cellClusterLink(), msg );
    jetCnv.persToTrans( &pers->m_jet, &trans->jetLink(), msg );
    tracksCnv.persToTrans( &pers->m_tracks, &trans->trackLinkVector(), msg );
    detailsCnv.persToTrans( &pers->m_tauDetails, &trans->tauDetailLinkVector(), msg );
    trans->setNumberOfTracks (pers->m_numberOfTracks);
    trans->setROIWord (pers->m_roiWord);
 
    if( getBit( pers->m_flags, 0 ) ) {
        std::vector<std::pair<TauJetParameters::TauID, double> > params; 
        params.reserve(pers->m_params.size());
        for (const auto& p : pers->m_params) {
          params.emplace_back( static_cast<TauJetParameters::TauID>( p.first),
                               p.second);
                                                                       
        }
 
        Analysis::TauPID* tauID = new Analysis::TauPID (std::move(params),
                                                        pers->m_isTauFlags,
                                                        pers->m_vetoFlags);
        trans->setTauID (tauID);
    } else {
        trans->setTauID( 0 );
    }
 
    if( getBit( pers->m_flags, 2 ) )
        trans->setAuthor( TauJetParameters::tauRec );
    if( getBit( pers->m_flags, 3 ) )
        trans->setAuthor( TauJetParameters::tau1P3P );
    conversionTracksCnv.persToTrans( 
            &pers->m_conversionTracks, 
            &trans->conversionTrackLinkVector(), msg );
    seedCalo_tracksCnv.persToTrans( 
            &pers->m_seedCalo_tracks, 
            &trans->seedCalo_trackLinkVector(), msg );
    seedTrk_tracksCnv.persToTrans( 
            &pers->m_seedTrk_tracks, 
            &trans->seedTrk_trackLinkVector(), msg );
 
//     STILL NEED CONDITIONALS
    /*
     std::vector<std::pair<int, HepLorentzVector_p1> >::const_iterator it;
     trans->m_tauHLVStorage.clear();
     trans->m_tauHLVStorage.reserve(pers->m_tauHLVStorage.size());
     for( it = pers->m_tauHLVStorage.begin(); 
             it != pers->m_tauHLVStorage.end(); ++it )
         {
           CLHEP::HepLorentzVector dummy;
           hepLorentzVectorCnv.persToTrans(&((*it).second), &dummy,msg);
           std::pair<TauJetParameters::TauCalibType, CLHEP::HepLorentzVector> store;
           store.first = static_cast<TauJetParameters::TauCalibType>( (*it).first );
           store.second = dummy;
           trans->m_tauHLVStorage.push_back( store );
     }
     */
    trans->clearHLV();
    CLHEP::HepLorentzVector hlv;
    hepLorentzVectorCnv.persToTrans( &pers->m_tauHLV_jetseed, &hlv,msg);
    trans->storeHLV ( TauJetParameters::JetSeed,hlv);
    hepLorentzVectorCnv.persToTrans( &pers->m_tauHLV_detaxis, &hlv,msg);
    trans->storeHLV ( TauJetParameters::DetectorAxis,hlv);
    hepLorentzVectorCnv.persToTrans( &pers->m_tauHLV_intaxis, &hlv,msg);
    trans->storeHLV ( TauJetParameters::IntermediateAxis,hlv);
    hepLorentzVectorCnv.persToTrans( &pers->m_tauHLV_tesaxis, &hlv,msg);
    trans->storeHLV ( TauJetParameters::TauEnergyScale,hlv);
    hepLorentzVectorCnv.persToTrans( &pers->m_tauHLV_etaaxis, &hlv,msg);
    trans->storeHLV ( TauJetParameters::TauEtaCalib,hlv);
}
 
void TauJetCnv_p5::transToPers( const Analysis::TauJet *trans,
        TauJet_p5 *pers,
        MsgStream &msg ) const
{
    momCnv.transToPers( &trans->momentumBase(), &pers->m_momentum, msg );
    partBaseCnv.transToPers( &trans->particleBase(), &pers->m_particleBase, msg );
    const ElementLink<CaloClusterContainer> clusterLink = trans->clusterLink();
    clusterCnv.transToPers( &clusterLink, &pers->m_cluster, msg );
    const ElementLink<CaloClusterContainer> cellClusterLink = trans->cellClusterLink();
    clusterCnv.transToPers( &cellClusterLink, &pers->m_cellCluster, msg );
    const ElementLink<JetCollection> jetLink = trans->jetLink();
    jetCnv.transToPers( &jetLink, &pers->m_jet, msg );
    tracksCnv.transToPers( &trans->trackLinkVector(), &pers->m_tracks, msg );
    detailsCnv.transToPers( &trans->tauDetailLinkVector(), &pers->m_tauDetails, msg );
    pers->m_numberOfTracks = trans->numberOfTracks();
    pers->m_roiWord = trans->ROIWord();
    pers->m_params.clear();
 
    if( trans->tauID() ) {
        setBit( pers->m_flags, 0, true );
 
        pers->m_vetoFlags = trans->tauID()->vetoFlags().to_ulong();
        pers->m_isTauFlags = trans->tauID()->isTauFlags().to_ulong();
 
        pers->m_params.reserve (trans->tauID()->params().size());
        for (const auto& p : trans->tauID()->params()) {
            pers->m_params.emplace_back (static_cast<int>( p.first ), p.second);
        }
    } else {
        setBit( pers->m_flags, 0, false );
    }
    if( trans->hasAuthor( TauJetParameters::tauRec ) )
        setBit( pers->m_flags, 2, true );
    if( trans->hasAuthor( TauJetParameters::tau1P3P ) )
        setBit( pers->m_flags, 3, true );
    conversionTracksCnv.transToPers(
            &trans->conversionTrackLinkVector(), 
            &pers->m_conversionTracks, msg );
    seedCalo_tracksCnv.transToPers(
            &trans->seedCalo_trackLinkVector(), 
            &pers->m_seedCalo_tracks, msg );
    seedTrk_tracksCnv.transToPers(
            &trans->seedTrk_trackLinkVector(), 
            &pers->m_seedTrk_tracks, msg );
 
 
//       STILL NEED CONDITIONALS
    /*
        pers->m_tauHLVStorage.clear();
        pers->m_tauHLVStorage.reserve (trans->m_tauHLVStorage.size());
        std::vector<std::pair<TauJetParameters::TauCalibType, CLHEP::HepLorentzVector> >::const_iterator it;
        for( it = trans->m_tauHLVStorage.begin(); it != trans->m_tauHLVStorage.end(); ++it ) {
          HepLorentzVector_p1 dummy;
          hepLorentzVectorCnv.transToPers( &((*it).second), &dummy, msg);
 
          std::pair<int, HepLorentzVector_p1 > store;
          store.first = static_cast<int>( (*it).first );
          store.second = dummy;
          pers->m_tauHLVStorage.push_back( store );
        }
        */
 
    CLHEP::HepLorentzVector hlv = trans->getHLV(TauJetParameters::JetSeed);
    hepLorentzVectorCnv.transToPers( &hlv, &pers->m_tauHLV_jetseed, msg);
    hlv = trans->getHLV(TauJetParameters::DetectorAxis);
    hepLorentzVectorCnv.transToPers( &hlv,  &pers->m_tauHLV_detaxis, msg);
    hlv = trans->getHLV(TauJetParameters::IntermediateAxis);
    hepLorentzVectorCnv.transToPers( &hlv, &pers->m_tauHLV_intaxis, msg);
    hlv = trans->getHLV(TauJetParameters::TauEnergyScale);
    hepLorentzVectorCnv.transToPers( &hlv, &pers->m_tauHLV_tesaxis, msg);
    hlv = trans->getHLV(TauJetParameters::TauEtaCalib);
    hepLorentzVectorCnv.transToPers( &hlv, &pers->m_tauHLV_etaaxis, msg);
}