PandoraContentApiImpl.h

Go to the documentation of this file.

 
#ifndef PANDORA_CONTENT_API_IMPL_H
#define PANDORA_CONTENT_API_IMPL_H 1
 
#include "Api/PandoraContentApi.h"
 
#include "Pandora/ObjectCreation.h"
#include "Pandora/StatusCodes.h"
 
namespace pandora
{
 
class Pandora;
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
class PandoraContentApiImpl
{
private:
    template<class T>
    class ReturnType
    {
    public:
        typedef T Type;
    };
 
    template<typename T>
    typename ReturnType<T>::Type *GetManager() const;
 
 
    /* Object-metadata manipulation */
 
    template <typename OBJECT, typename METADATA>
    StatusCode AlterMetadata(const OBJECT *const pObject, const METADATA &metadata) const;
 
 
    /* Object-creation functions */
 
    template <typename PARAMETERS, typename OBJECT>
    StatusCode Create(const PARAMETERS &parameters, const OBJECT *&pObject, const ObjectFactory<PARAMETERS, OBJECT> &factory) const;
 
 
    /* Accessors for plugins and global settings */
 
    const PandoraSettings *GetSettings() const;
 
    const GeometryManager *GetGeometry() const;
 
    const PluginManager *GetPlugins() const;
 
 
    /* High-level steering functions */
 
    StatusCode RepeatEventPreparation() const;
 
    StatusCode CreateAlgorithmTool(TiXmlElement *const pXmlElement, AlgorithmTool *&pAlgorithmTool) const;
 
    StatusCode CreateDaughterAlgorithm(TiXmlElement *const pXmlElement, std::string &daughterAlgorithmName) const;
 
    StatusCode RunAlgorithm(const std::string &algorithmName) const;
 
     StatusCode RunClusteringAlgorithm(const Algorithm &algorithm, const std::string &clusteringAlgorithmName,
        const ClusterList *&pNewClusterList, std::string &newClusterListName) const;
 
 
    /* List-manipulation functions */
 
    template <typename T>
    StatusCode GetCurrentList(const T *&pT, std::string &listName) const;
 
    template <typename T>
    StatusCode GetCurrentListName(std::string &listName) const;
 
    template <typename T>
    StatusCode ReplaceCurrentList(const Algorithm &algorithm, const std::string &newListName) const;
 
    template <typename T>
    StatusCode DropCurrentList(const Algorithm &algorithm) const;
 
    template <typename T>
    StatusCode GetList(const std::string &listName, const T *&pT) const;
 
    template <typename T>
    StatusCode RenameList(const std::string &oldListName, const std::string &newListName) const;
 
 
    /* List-manipulation functions: input objects only (CaloHits, Tracks, MCParticles) */
 
    template <typename T>
    StatusCode SaveList(const T &t, const std::string &newListName) const;
 
 
    /* List-manipulation functions: algorithm objects only (Clusters, Pfos, Vertices) */
 
    template <typename T>
    StatusCode SaveList(const std::string &newListName) const;
 
    template <typename T>
    StatusCode SaveList(const std::string &oldListName, const std::string &newListName) const;
 
    template <typename T>
    StatusCode SaveList(const std::string &newListName, const T &t) const;
 
    template <typename T>
    StatusCode SaveList(const std::string &oldListName, const std::string &newListName, const T &t) const;
 
    template <typename T>
    StatusCode TemporarilyReplaceCurrentList(const std::string &newListName) const;
 
    template <typename T>
    StatusCode CreateTemporaryListAndSetCurrent(const Algorithm &algorithm, const T *&pT, std::string &temporaryListName) const;
 
 
    /* Object-related functions */
 
    template <typename T>
    bool IsAvailable(const T *const pT) const;
 
 
    /* Object-related functions: algorithm objects only (Clusters, Pfos, Vertices) */
 
    template <typename T>
    StatusCode Delete(const T *const pT) const;
 
    template <typename T>
    StatusCode Delete(const T *const pT, const std::string &listName) const;
 
 
    /* CaloHit-related functions */
 
    template <typename T>
    StatusCode AddToCluster(const Cluster *const pCluster, const T *const pT) const;
 
    StatusCode RemoveFromCluster(const Cluster *const pCluster, const CaloHit *const pCaloHit) const;
 
    template <typename T>
    StatusCode AddIsolatedToCluster(const Cluster *const pCluster, const T *const pT) const;
 
    StatusCode RemoveIsolatedFromCluster(const Cluster *const pCluster, const CaloHit *const pCaloHit) const;
 
    StatusCode Fragment(const CaloHit *const pOriginalCaloHit, const float fraction1, const CaloHit *&pDaughterCaloHit1,
        const CaloHit *&pDaughterCaloHit2, const ObjectFactory<object_creation::CaloHitFragment::Parameters, object_creation::CaloHitFragment::Object> &factory) const;
 
    StatusCode MergeFragments(const CaloHit *const pFragmentCaloHit1, const CaloHit *const pFragmentCaloHit2,
        const CaloHit *&pMergedCaloHit, const ObjectFactory<object_creation::CaloHitFragment::Parameters, object_creation::CaloHitFragment::Object> &factory) const;
 
 
    /* Track-related functions */
 
    StatusCode AddTrackClusterAssociation(const Track *const pTrack, const Cluster *const pCluster) const;
 
    StatusCode RemoveTrackClusterAssociation(const Track *const pTrack, const Cluster *const pCluster) const;
 
    StatusCode RemoveCurrentTrackClusterAssociations() const;
 
    StatusCode RemoveAllTrackClusterAssociations() const;
 
 
    /* MCParticle-related functions */
 
    StatusCode RepeatMCParticlePreparation() const;
 
    StatusCode RemoveAllMCParticleRelationships() const;
 
 
    /* Cluster-related functions */
 
    StatusCode MergeAndDeleteClusters(const Cluster *const pClusterToEnlarge, const Cluster *const pClusterToDelete) const;
 
    StatusCode MergeAndDeleteClusters(const Cluster *const pClusterToEnlarge, const Cluster *const pClusterToDelete, const std::string &enlargeListName,
        const std::string &deleteListName) const;
 
 
    /* Pfo-related functions */
 
    template <typename T>
    StatusCode AddToPfo(const ParticleFlowObject *const pPfo, const T *const pT) const;
 
    template <typename T>
    StatusCode RemoveFromPfo(const ParticleFlowObject *const pPfo, const T *const pT) const;
 
    StatusCode SetPfoParentDaughterRelationship(const ParticleFlowObject *const pParentPfo, const ParticleFlowObject *const pDaughterPfo) const;
 
    StatusCode RemovePfoParentDaughterRelationship(const ParticleFlowObject *const pParentPfo, const ParticleFlowObject *const pDaughterPfo) const;
 
 
    /* Reclustering functions */
 
    StatusCode InitializeFragmentation(const Algorithm &algorithm, const ClusterList &inputClusterList,
        std::string &originalClustersListName, std::string &fragmentClustersListName) const;
 
    StatusCode EndFragmentation(const Algorithm &algorithm, const std::string &clusterListToSaveName,
        const std::string &clusterListToDeleteName) const;
 
    StatusCode InitializeReclustering(const Algorithm &algorithm, const TrackList &inputTrackList,
        const ClusterList &inputClusterList, std::string &originalClustersListName) const;
 
    StatusCode EndReclustering(const Algorithm &algorithm, const std::string &selectedClusterListName) const;
 
private:
    PandoraContentApiImpl(Pandora *const pPandora);
 
    bool IsAddToClusterAllowed(const Cluster *const pCluster, const CaloHit *const pCaloHit) const;
 
    template <typename T>
    StatusCode PrepareForDeletion(const T *const pT) const;
 
    template <typename T>
    StatusCode PrepareForReclusteringDeletion(const T *const pT) const;
 
    StatusCode PreRunAlgorithm(Algorithm *const pAlgorithm) const;
 
    StatusCode PostRunAlgorithm(Algorithm *const pAlgorithm) const;
 
    Pandora    *m_pPandora;    
 
    friend class Pandora;
    friend class PandoraImpl;
    friend class ::PandoraContentApi;
    template<typename PARAMETERS, typename METADATA, typename OBJECT> friend class ::object_creation::ObjectCreationHelper;
};
 
} // namespace pandora
 
#endif // #ifndef PANDORA_CONTENT_API_IMPL_H