ElementLinkVectorCnv_p1.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
/** @file ElementLinkVectorCnv_p1.icc
 *  @brief This file contains the implementation for the ElementLinkVectorCnv_p1 template methods.
 *  @author Marcin.Nowak@cern.ch
 **/
 
#include <stdexcept>
 
#include "AthLinks/ElementLinkVector.h"
#include "AthenaKernel/ThinningCache.h"
#include "AthenaKernel/ThinningDecisionBase.h"
#include "AthenaKernel/getThinningCache.h"
 
//#include <iostream>
//using namespace std;
 
//#define ELVEC_DEBUG
 
 
template <typename LINK_TYPE>
void
ElementLinkVectorCnv_p1<LINK_TYPE>::transToPers(const LinkVect_t& trans,
                                                PersLinkVect_t& pers,
                                                const SG::ThinningCache* cache,
                                                MsgStream& msg) const
{
  pers.m_elementRefs.clear();
  pers.m_links.clear();
 
  LinkVect_t tmpTrans = trans;
  tmpTrans.doRemap();
 
  // easy case first
  if ( !cache ) {
    std::vector<typename LinkVect_t::DataLinkVector::size_type> shortrefs;
    tmpTrans.toPersistent(shortrefs);
    // copy the container keys
    m_DLinkVectorCnv.transToPers(&tmpTrans.hostDObjs(), &pers.m_links, msg);
    
    // copy the element links in the compact form
    size_t link_n = tmpTrans.size();
    pers.m_elementRefs.reserve(link_n);
    for ( std::size_t i=0; i!=link_n; ++i ) {
      using Index_t = typename PersLinkVect_t::Index_t;
      size_t idx = SG::ThinningDecisionBase::RemovedIdx;
      if (shortrefs[i] != SG::ThinningDecisionBase::RemovedIdx)
        idx = tmpTrans.elementIndex(i);
      pers.m_elementRefs.emplace_back( static_cast<Index_t>(idx), shortrefs[i] );
    }
    return;
  }
 
  // the not so easy case: thinning occured...
 
  // Note: we can't use ElementLinkVector::toPersistent.
  // we have to first handle the DataLinks and then the elementlink refs
  // otherwise we:
  //  - corrupt the ElementLinks
  //  - generate many-many ERRORs (when the EL points at a thinned away elmt)
 
  // set all DataLinks to persistent state
  tmpTrans.toPersistentDL();
 
  // copy the container keys
  m_DLinkVectorCnv.transToPers(&tmpTrans.hostDObjs(), &pers.m_links, msg);
  //std::cout << "*** -- ElementLinkVectorCnv: KEY=" << *iter << std::endl;
 
  // copy the element links in the compact form
  size_t link_n = tmpTrans.size();
  pers.m_elementRefs.reserve(link_n);
  typedef typename LinkVect_t::ElemLink    EL;
  for ( std::size_t ilink = 0; ilink != link_n; ++ilink ) {
    // note the _copy_ of the original
    // (needed for multi-stream thinning)
    EL el = tmpTrans[ilink];
    // here is the problem: in case the ElementLink was directly created w/
    // only a pointer to the element, _and_ if the the pointed-at element 
    // has been thinned away, EL::index() will throw b/c
    // IndexingPolicy::setIndex will fail.
    std::size_t orig_idx = SG::ThinningDecisionBase::RemovedIdx;
    try {
      orig_idx = el.index();
    } catch ( const SG::maybe_thinning_error& err ) {
      // ok. that's the corner case we talked about above.
      msg << MSG::DEBUG
      << "caught a maybe_thinning_error: [" << err.what() << "]"
      << endmsg
      << "(this is an expected case of the EL-state-phase-space "
      << "when thinning is active)"
      << endmsg;
    }
    std::size_t idx = orig_idx;
    if (cache) {
      const SG::ThinningDecisionBase* dec = cache->thinning (el.key());
      if (dec) {
        idx = dec->index (idx);
      }
    }
 
    typename LinkVect_t::size_type shortref = 0;
    if ( idx == SG::ThinningDecisionBase::RemovedIdx ) {
      // that element has been thinned away.
      shortref = idx; //< 'special' well-known value
    } else {
      // element not thinned away
      typename LinkVect_t::DataLinkVector::iterator ihost =
        tmpTrans.findHostDObj (el);
      if (ihost != tmpTrans.endHostDObjs())
        shortref = std::distance (tmpTrans.beginHostDObjs(), ihost);
      else {
        msg << MSG::WARNING
            << "link not found in ElemLinkVector" << endmsg;
      }
    }
    typedef typename PersLinkVect_t::ElementRef PersELRef;
    pers.m_elementRefs.push_back( PersELRef (idx, shortref) );
  }
}
 
 
template <typename LINK_TYPE>
void ElementLinkVectorCnv_p1<LINK_TYPE>::transToPers(const LinkVect_t& trans,
                                                     PersLinkVect_t& pers,
                                                     MsgStream& msg) const
{
  transToPers (trans, pers,
               SG::getThinningCache(),
               msg);
}
 
 
template <typename LINK_TYPE >
void ElementLinkVectorCnv_p1< LINK_TYPE >::persToTrans(const PersLinkVect_t& pers, LinkVect_t& trans, MsgStream& msg) const
{
   // copy the container keys
   typename LinkVect_t::DataLinkVector dl;
   m_DLinkVectorCnv.persToTrans(&pers.m_links, &dl, msg);
   trans.clear();
   trans.moveHostDObjs (dl);
   trans.toTransient();
   // cout << "*** -- ElementLinkVectorCnv: KEY=" << *iter << endl;
   // copy the element links in the compact form
   size_t link_n = pers.m_elementRefs.size();
   trans.reserve(link_n);
   typename  PersLinkVect_t::ElementRefVector::const_iterator link_iter = pers.m_elementRefs.begin();
   while(link_n--) {
      // This test needed for 32/64 bit compatibility.
      if ( link_iter->m_nameIndex == static_cast<uint32_t>(SG::ThinningDecisionBase::RemovedIdx) &&
       link_iter->m_elementIndex == static_cast<Index_t>(SG::ThinningDecisionBase::RemovedIdx) )
      {
    // thinned-away element...
        trans.push_back (SG::ThinningDecisionBase::RemovedIdx,
                         SG::ThinningDecisionBase::RemovedIdx);
      }
      else
        trans.push_back (link_iter->m_nameIndex, link_iter->m_elementIndex);
 
      #ifdef ELVEC_DEBUG
      msg << MSG::DEBUG 
      << "ElementLinkVectorCnv_p1::PersToTrans(): KEY="
      <<  pers->m_links[link_iter->m_nameIndex].m_link
      << ", IDX=" << link_iter->m_elementIndex 
      << endmsg;
      #endif
      ++link_iter;
   }
}
 
 
 
 
template <typename LINK_TYPE>
inline
void
ElementLinkVectorCnv_p1<LINK_TYPE>
::transToPers(const LinkVect_t* trans, PersLinkVect_t* pers, MsgStream& msg) const
{
   this->transToPers(*trans, *pers, msg);
}
 
 
template <typename LINK_TYPE >
inline
void
ElementLinkVectorCnv_p1< LINK_TYPE >
::persToTrans(const PersLinkVect_t* pers, LinkVect_t* trans, MsgStream& msg) const
{
   this->persToTrans(*pers, *trans, msg);
}