IParticleHelpers.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
 
// System include(s):
#include <iostream>
 
// EDM include(s):
#include "AthLinks/ElementLink.h"
 
// Local include(s):
#include "xAODBase/IParticleHelpers.h"
 
namespace xAOD {

   static const SG::AuxElement::Accessor< ElementLink< IParticleContainer > >
      acc( "originalObjectLink" );

   bool setOriginalObjectLink( const IParticle& original,
                               IParticle& copy ) {
 
      // We mustn't check for the availability of the decoration on the copied
      // object here. Since if the copy is already part of a container, the
      // decoration may well exist on it already. But it will not be set to
      // anything meaningful yet.
 
      // Check if the original is part of a container. If not, we can't set
      // up a link.
      const IParticleContainer* container =
         dynamic_cast< const IParticleContainer* >( original.container() );
      if( ! container ) {
         std::cerr << "xAOD::setOriginalObjectLink   ERROR Original object is "
                   << "not part of a container" << std::endl;
         return false;
      }
 
      // Construct the ElementLink that points back to the original.
      // We have to be tricky here. The original itself may already be a
      // copy. In which case the new object should point back to the same
      // original that "our original" is pointing to.
      const ElementLink< IParticleContainer > link =
         ( acc.isAvailable( original ) ?
           acc( original ) :
           ElementLink< IParticleContainer >( *container, original.index() ) );
 
      // Now set this link on the copy:
      acc( copy ) = link;
 
      // We were successful:
      return true;
   }

   bool setOriginalObjectLink( const IParticleContainer& original,
                               IParticleContainer& copy ) {
 
      // Check that the containers are of the same size:
      if( original.size() != copy.size() ) {
         std::cerr << "xAOD::setOriginalObjectLink   ERROR Size of original "
                   << "and copy containers differs" << std::endl;
         return false;
      }
 
      // Make sure that the original is not a view container. As the function
      // doesn't work correctly for those.
      if( original.ownPolicy() != SG::OWN_ELEMENTS ) {
         std::cerr << "xAOD::setOriginalObjectLink   ERROR Received a view "
                   << "container" << std::endl;
         return false;
      }
 
      // If the containers are empty, we're done:
      if( copy.empty() ) {
         return true;
      }
 
      // Create an ElementLink to the first element in the original container.
      // To be able to re-use the hashed key of this object in the loop.
      const ElementLink< IParticleContainer > refLink( original, 0 );
 
      // Loop over the copied container:
      IParticleContainer::const_iterator orig_itr = original.begin();
      IParticleContainer::const_iterator orig_end = original.end();
      IParticleContainer::iterator copy_itr = copy.begin();
      // To speed up the loop over large containers a bit, make the decision
      // about how to create the links, just once:
      if( acc.isAvailable( **orig_itr ) ) {
         for( ; orig_itr != orig_end; ++orig_itr, ++copy_itr ) {
            // Copy the variable from the original object:
            acc( **copy_itr ) = acc( **orig_itr );
         }
      } else {
         for( ; orig_itr != orig_end; ++orig_itr, ++copy_itr ) {
            // Construct the link from scratch:
            acc( **copy_itr ) =
               ElementLink< IParticleContainer >( refLink.key(),
                                                  ( *orig_itr )->index() );
         }
      }
 
      // We were successful:
      return true;
   }

   const IParticle* getOriginalObject( const IParticle& copy ) {
 
      // Check if the decoration is available on the object:
      if( ! acc.isAvailable( copy ) ) {
         return nullptr;
      }
 
      // Get the link:
      const ElementLink< IParticleContainer >& link = acc( copy );
 
      // Check if the link is valid:
      if( ! link.isValid() ) {
         return nullptr;
      }
 
      // Apparently all is fine:
      return *link;
   }

   const ElementLink< IParticleContainer >&
   getOriginalObjectLink( const IParticle& copy ) {
 
      // Blindly retrieve the link. Rely on the auxiliary store code throwing an
      // appropriate exception if this cannot be done. ;-)
      return acc( copy );
   }
 
} // namespace xAOD