include/Api/PandoraContentApi.h

0001 /**
0002  *  @file   PandoraSDK/include/Api/PandoraContentApi.h
0003  *
0004  *  @brief  Header file for the pandora content api class.
0005  *
0006  *  $Log: $
0007  */
0008 #ifndef PANDORA_CONTENT_API_H
0009 #define PANDORA_CONTENT_API_H 1
0010
0011 #include "Pandora/ObjectCreation.h"
0012 #include "Pandora/Pandora.h"
0013 #include "Pandora/PandoraObjectFactories.h"
0014
0015 namespace pandora { class TiXmlElement; }
0016
0017 //------------------------------------------------------------------------------------------------------------------------------------------
0018
0019 /**
0020  *  @brief  PandoraContentApi class
0021  */
0022 class PandoraContentApi
0023 {
0024 public:
0025     /* Map object creation and metadata functionality into PandoraContentApi */
0026     typedef object_creation::CaloHit CaloHit;
0027     typedef object_creation::Cluster Cluster;
0028     typedef object_creation::ParticleFlowObject ParticleFlowObject;
0029     typedef object_creation::Vertex Vertex;
0030     typedef object_creation::MCParticle MCParticle;
0031     typedef object_creation::Track Track;
0032     typedef object_creation::CaloHitFragment CaloHitFragment;
0033
0034     /* Accessors for plugins and global settings */
0035
0036     /**
0037      *  @brief  Get the pandora event context instance
0038      *
0039      *  @param  algorithm the algorithm calling this function
0040      *  @param  key the key associated with the desired event context object
0041      *
0042      *  @return the address of the pandora event context instance
0043      */
0044     static const pandora::EventContextObject *GetEventContextObject(const pandora::Algorithm &algorithm, const std::string &key);
0045
0046     /**
0047      *  @brief  Adds an EventContextObject object to this event context.
0048      *
0049      *  @param  algorithm the algorithm calling this function
0050      *  @param  key the key to associate with the event context object
0051      *  @param  eventObject the object to be stored
0052      */
0053     static void AddEventContextObject(const pandora::Algorithm &algorithm, const std::string &key, const pandora::EventContextObject *const eventObject);
0054
0055     /**
0056      *  @brief  Replaces an EventContextObject object within this event context.
0057      *
0058      *  @param  algorithm the algorithm calling this function
0059      *  @param  key the key of the event context object to replace
0060      *  @param  eventObject the new object to be stored
0061      */
0062     static void ReplaceEventContextObject(const pandora::Algorithm &algorithm, const std::string &key, const pandora::EventContextObject *const eventObject);
0063
0064     /**
0065      *  @brief  Remove an EventContextObject object from this event context.
0066      *
0067      *  @param  algorithm the algorithm calling this function
0068      *  @param  key the key of the event context object to be removed
0069      */
0070     static void RemoveEventContextObject(const pandora::Algorithm &algorithm, const std::string &key);
0071
0072     /**
0073      *  @brief  Get the pandora settings instance
0074      *
0075      *  @param  algorithm the algorithm calling this function
0076      *
0077      *  @return the address of the pandora settings instance
0078      */
0079     static const pandora::PandoraSettings *GetSettings(const pandora::Algorithm &algorithm);
0080
0081     /**
0082      *  @brief  Get the pandora geometry instance
0083      *
0084      *  @param  algorithm the algorithm calling this function
0085      *
0086      *  @return the address of the pandora geometry instance
0087      */
0088     static const pandora::GeometryManager *GetGeometry(const pandora::Algorithm &algorithm);
0089
0090     /**
0091      *  @brief  Get the pandora plugin instance, providing access to user registered functions and calculators
0092      *
0093      *  @param  algorithm the algorithm calling this function
0094      *
0095      *  @return the address of the pandora plugin instance
0096      */
0097     static const pandora::PluginManager *GetPlugins(const pandora::Algorithm &algorithm);
0098
0099
0100     /* High-level steering functions */
0101
0102     /**
0103      *  @brief  Repeat the event preparation stages, which are used to calculate properties of input objects for later use in algorithms
0104      *
0105      *  @param  algorithm the algorithm calling this function
0106      */
0107     static pandora::StatusCode RepeatEventPreparation(const pandora::Algorithm &algorithm);
0108
0109     /**
0110      *  @brief  Create an algorithm tool instance, via one of the algorithm tool factories registered with pandora.
0111      *          This function is expected to be called whilst reading the settings for a parent algorithm.
0112      *
0113      *  @param  algorithm the parent algorithm, which will later run this algorithm tool
0114      *  @param  pXmlElement address of the xml element describing the algorithm tool type and settings
0115      *  @param  pAlgorithmTool to receive the address of the algorithm tool instance
0116      */
0117     static pandora::StatusCode CreateAlgorithmTool(const pandora::Algorithm &algorithm, pandora::TiXmlElement *const pXmlElement,
0118         pandora::AlgorithmTool *&pAlgorithmTool);
0119
0120     /**
0121      *  @brief  Create an algorithm instance, via one of the algorithm factories registered with pandora.
0122      *          This function is expected to be called whilst reading the settings for a parent algorithm.
0123      *
0124      *  @param  algorithm address of the parent algorithm, which will later run this daughter algorithm
0125      *  @param  pXmlElement address of the xml element describing the daughter algorithm type and settings
0126      *  @param  daughterAlgorithmName to receive the name of the daughter algorithm instance
0127      */
0128     static pandora::StatusCode CreateDaughterAlgorithm(const pandora::Algorithm &algorithm, pandora::TiXmlElement *const pXmlElement,
0129         std::string &daughterAlgorithmName);
0130
0131     /**
0132      *  @brief  Run an algorithm registered with pandora, from within a parent algorithm
0133      *
0134      *  @param  algorithm the parent algorithm, now attempting to run a daughter algorithm
0135      *  @param  daughterAlgorithmName the name of the daughter algorithm instance to run
0136      */
0137     static pandora::StatusCode RunDaughterAlgorithm(const pandora::Algorithm &algorithm, const std::string &daughterAlgorithmName);
0138
0139     /**
0140      *  @brief  Run a clustering algorithm (an algorithm that will create new cluster objects)
0141      *
0142      *  @param  algorithm the parent algorithm, now attempting to run a daughter clustering algorithm
0143      *  @param  clusteringAlgorithmName the name of the clustering algorithm to run
0144      *  @param  pNewClusterList to receive the address of the new cluster list populated
0145      *  @param  newClusterListName to receive the name of the new cluster list populated
0146      */
0147     static pandora::StatusCode RunClusteringAlgorithm(const pandora::Algorithm &algorithm, const std::string &clusteringAlgorithmName,
0148         const pandora::ClusterList *&pNewClusterList, std::string &newClusterListName);
0149
0150
0151     /* List-manipulation functions */
0152
0153     /**
0154      *  @brief  Get the current list
0155      *
0156      *  @param  algorithm the algorithm calling this function
0157      *  @param  pT to receive the address of the current list
0158      */
0159     template <typename T>
0160     static pandora::StatusCode GetCurrentList(const pandora::Algorithm &algorithm, const T *&pT);
0161
0162     /**
0163      *  @brief  Get the current list
0164      *
0165      *  @param  algorithm the algorithm calling this function
0166      *  @param  pT to receive the address of the current list
0167      *  @param  listName to receive the current list name
0168      */
0169     template <typename T>
0170     static pandora::StatusCode GetCurrentList(const pandora::Algorithm &algorithm, const T *&pT, std::string &listName);
0171
0172     /**
0173      *  @brief  Get the current list name
0174      *
0175      *  @param  algorithm the algorithm calling this function
0176      *  @param  listName to receive the current list name
0177      */
0178     template <typename T>
0179     static pandora::StatusCode GetCurrentListName(const pandora::Algorithm &algorithm, std::string &listName);
0180
0181     /**
0182      *  @brief  Replace the current list with a pre-saved list; use this new list as a permanent replacement
0183      *          for the current list (will persist outside the current algorithm)
0184      *
0185      *  @param  algorithm the algorithm calling this function
0186      *  @param  newListName the name of the replacement list
0187      */
0188     template <typename T>
0189     static pandora::StatusCode ReplaceCurrentList(const pandora::Algorithm &algorithm, const std::string &newListName);
0190
0191     /**
0192      *  @brief  Drop the current list, returning the current list to its default empty/null state
0193      *
0194      *  @param  algorithm the algorithm calling this function
0195      */
0196     template <typename T>
0197     static pandora::StatusCode DropCurrentList(const pandora::Algorithm &algorithm);
0198
0199     /**
0200      *  @brief  Get a named list
0201      *
0202      *  @param  algorithm the algorithm calling this function
0203      *  @param  listName the name of the list
0204      *  @param  pT to receive the address of the list
0205      */
0206     template <typename T>
0207     static pandora::StatusCode GetList(const pandora::Algorithm &algorithm, const std::string &listName, const T *&pT);
0208
0209     /**
0210      *  @brief  Rename a saved list, altering its saved name from a specified old list name to a specified new list name
0211      *
0212      *  @param  algorithm the algorithm calling this function
0213      *  @param  oldListName the old list name
0214      *  @param  newListName the new list name
0215      */
0216     template <typename T>
0217     static pandora::StatusCode RenameList(const pandora::Algorithm &algorithm, const std::string &oldListName, const std::string &newListName);
0218
0219
0220     /* List-manipulation functions: input objects only (CaloHits, Tracks, MCParticles) */
0221
0222     /**
0223      *  @brief  Save a provided input object list under a new name
0224      *
0225      *  @param  algorithm the algorithm calling this function
0226      *  @param  t the provided input object list
0227      *  @param  newListName the new list name
0228      */
0229     template <typename T>
0230     static pandora::StatusCode SaveList(const pandora::Algorithm &algorithm, const T &t, const std::string &newListName);
0231
0232
0233     /* List-manipulation functions: algorithm objects only (Clusters, Pfos, Vertices) */
0234
0235     /**
0236      *  @brief  Save the current list in a list with the specified new name. Note that this will empty the list; the objects
0237      *          will all be moved to the new named list.
0238      *
0239      *  @param  algorithm the algorithm calling this function
0240      *  @param  newListName the new list name
0241      */
0242     template <typename T>
0243     static pandora::StatusCode SaveList(const pandora::Algorithm &algorithm, const std::string &newListName);
0244
0245     /**
0246      *  @brief  Save a named list in a list with the specified new name. Note that this will empty the old list; the objects
0247      *          will all be moved to the new named list.
0248      *
0249      *  @param  algorithm the algorithm calling this function
0250      *  @param  oldListName the old list name
0251      *  @param  newListName the new list name
0252      */
0253     template <typename T>
0254     static pandora::StatusCode SaveList(const pandora::Algorithm &algorithm, const std::string &oldListName, const std::string &newListName);
0255
0256     /**
0257      *  @brief  Save elements of the current list in a list with the specified new name. If all the objects in the current
0258      *          list are saved, this will empty the current list; the objects will all be moved to the new named list.
0259      *
0260      *  @param  algorithm the algorithm calling this function
0261      *  @param  newListName the new list name
0262      *  @param  t a subset of the current object list - only objects in both this and the current list will be saved
0263      */
0264     template <typename T>
0265     static pandora::StatusCode SaveList(const pandora::Algorithm &algorithm, const std::string &newListName, const T &t);
0266
0267     /**
0268      *  @brief  Save elements of a named list in a list with the specified new name. If all the objects in the old
0269      *          list are saved, this will empty the old list; the objects will all be moved to the new named list.
0270      *
0271      *  @param  algorithm the algorithm calling this function
0272      *  @param  oldClusterListName the old cluster list name
0273      *  @param  newClusterListName the new cluster list name
0274      *  @param  t a subset of the old object list - only objects in both this and the old list will be saved
0275      */
0276     template <typename T>
0277     static pandora::StatusCode SaveList(const pandora::Algorithm &algorithm, const std::string &oldListName, const std::string &newListName,
0278         const T &t);
0279
0280     /**
0281      *  @brief  Temporarily replace the current list with another list, which may only be a temporary list. This switch
0282      *          will persist only for the duration of the algorithm and its daughters; unless otherwise specified, the current list
0283      *          will revert to the algorithm input list upon algorithm completion.
0284      *
0285      *  @param  algorithm the algorithm calling this function
0286      *  @param  newListName the name of the replacement list
0287      */
0288     template <typename T>
0289     static pandora::StatusCode TemporarilyReplaceCurrentList(const pandora::Algorithm &algorithm, const std::string &newListName);
0290
0291     /**
0292      *  @brief  Create a temporary list and set it to be the current list, enabling object creation
0293      *
0294      *  @param  algorithm the algorithm calling this function
0295      *  @param  pT to receive the address of the temporary list
0296      *  @param  temporaryListName to receive the temporary list name
0297      */
0298     template <typename T>
0299     static pandora::StatusCode CreateTemporaryListAndSetCurrent(const pandora::Algorithm &algorithm, const T *&pT, std::string &temporaryListName);
0300
0301
0302     /* Object-related functions */
0303
0304     /**
0305      *  @brief  Is object, or a list of objects, available as a building block
0306      *
0307      *  @param  algorithm the algorithm calling this function
0308      *  @param  pT address of the object
0309      *
0310      *  @return boolean
0311      */
0312     template <typename T>
0313     static bool IsAvailable(const pandora::Algorithm &algorithm, const T *const pT);
0314
0315
0316     /* Object-related functions: algorithm objects only (Clusters, Pfos, Vertices) */
0317
0318     /**
0319      *  @brief  Delete an object from the current list
0320      *
0321      *  @param  algorithm the algorithm calling this function
0322      *  @param  pT address of the object, or a list of objects, to delete
0323      */
0324     template <typename T>
0325     static pandora::StatusCode Delete(const pandora::Algorithm &algorithm, const T *const pT);
0326
0327     /**
0328      *  @brief  Delete an object from a specified list
0329      *
0330      *  @param  algorithm the algorithm calling this function
0331      *  @param  pT address of the object, or a list of objects, to delete
0332      *  @param  listName name of the list containing the object
0333      */
0334     template <typename T>
0335     static pandora::StatusCode Delete(const pandora::Algorithm &algorithm, const T *const pT, const std::string &listName);
0336
0337
0338     /* CaloHit-related functions */
0339
0340     /**
0341      *  @brief  Add a calo hit, or a list of calo hits, to a cluster
0342      *
0343      *  @param  algorithm the algorithm calling this function
0344      *  @param  pCluster address of the cluster to modify
0345      *  @param  pT address of the calo hit, or list of calo hits, to add
0346      */
0347     template <typename T>
0348     static pandora::StatusCode AddToCluster(const pandora::Algorithm &algorithm, const pandora::Cluster *const pCluster, const T *const pT);
0349
0350     /**
0351      *  @brief  Remove a calo hit from a cluster. Note this function will not remove the final calo hit from a cluster, and
0352      *          will instead return status code "not allowed" as a prompt to delete the cluster
0353      *
0354      *  @param  algorithm the algorithm calling this function
0355      *  @param  pCluster address of the cluster to modify
0356      *  @param  pCaloHit address of the hit to remove
0357      */
0358     static pandora::StatusCode RemoveFromCluster(const pandora::Algorithm &algorithm, const pandora::Cluster *const pCluster,
0359         const pandora::CaloHit *const pCaloHit);
0360
0361     /**
0362      *  @brief  Add an isolated calo hit, or a list of isolated calo hits, to a cluster. An isolated calo hit is not counted as a
0363      *          regular calo hit: it contributes only towards the cluster energy and does not affect any other cluster properties.
0364      *
0365      *  @param  algorithm the algorithm calling this function
0366      *  @param  pCluster address of the cluster to modify
0367      *  @param  pT address of the isolated calo hit, or list of isolated calo hits, to add
0368      */
0369     template <typename T>
0370     static pandora::StatusCode AddIsolatedToCluster(const pandora::Algorithm &algorithm, const pandora::Cluster *const pCluster, const T *const pT);
0371
0372     /**
0373      *  @brief  Remove an isolated calo hit from a cluster. Note this function will not remove the final calo hit from a cluster, and
0374      *          will instead return status code "not allowed" as a prompt to delete the cluster
0375      *
0376      *  @param  algorithm the algorithm calling this function
0377      *  @param  pCluster address of the cluster to modify
0378      *  @param  pCaloHit address of the isolated hit to remove
0379      */
0380     static pandora::StatusCode RemoveIsolatedFromCluster(const pandora::Algorithm &algorithm, const pandora::Cluster *const pCluster,
0381         const pandora::CaloHit *const pCaloHit);
0382
0383     /**
0384      *  @brief  Fragment a calo hit into two daughter calo hits, with a specified energy division
0385      *
0386      *  @param  algorithm the algorithm calling this function
0387      *  @param  pOriginalCaloHit address of the original calo hit, which will be deleted
0388      *  @param  fraction1 the fraction of energy to be assigned to daughter fragment 1
0389      *  @param  pDaughterCaloHit1 to receive the address of daughter fragment 1
0390      *  @param  pDaughterCaloHit2 to receive the address of daughter fragment 2
0391      *  @param  factory to create the fragmented calo hits
0392      */
0393     static pandora::StatusCode Fragment(const pandora::Algorithm &algorithm, const pandora::CaloHit *const pOriginalCaloHit,
0394         const float fraction1, const pandora::CaloHit *&pDaughterCaloHit1, const pandora::CaloHit *&pDaughterCaloHit2,
0395         const pandora::ObjectFactory<object_creation::CaloHitFragment::Parameters, object_creation::CaloHitFragment::Object> &factory = pandora::PandoraObjectFactory<object_creation::CaloHitFragment::Parameters, object_creation::CaloHitFragment::Object>());
0396
0397     /**
0398      *  @brief  Merge two calo hit fragments, originally from the same parent hit, to form a new calo hit
0399      *
0400      *  @param  algorithm the algorithm calling this function
0401      *  @param  pFragmentCaloHit1 address of calo hit fragment 1, which will be deleted
0402      *  @param  pFragmentCaloHit2 address of calo hit fragment 2, which will be deleted
0403      *  @param  pMergedCaloHit to receive the address of the merged calo hit
0404      *  @param  factory to create the fragmented calo hits
0405      */
0406     static pandora::StatusCode MergeFragments(const pandora::Algorithm &algorithm, const pandora::CaloHit *const pFragmentCaloHit1,
0407         const pandora::CaloHit *const pFragmentCaloHit2, const pandora::CaloHit *&pMergedCaloHit,
0408         const pandora::ObjectFactory<object_creation::CaloHitFragment::Parameters, object_creation::CaloHitFragment::Object> &factory = pandora::PandoraObjectFactory<object_creation::CaloHitFragment::Parameters, object_creation::CaloHitFragment::Object>());
0409
0410
0411     /* Track-related functions */
0412
0413     /**
0414      *  @brief  Add an association between a track and a cluster
0415      *
0416      *  @param  algorithm the algorithm calling this function
0417      *  @param  pTrack address of the track
0418      *  @param  pCluster address of the cluster
0419      */
0420     static pandora::StatusCode AddTrackClusterAssociation(const pandora::Algorithm &algorithm, const pandora::Track *const pTrack,
0421         const pandora::Cluster *const pCluster);
0422
0423     /**
0424      *  @brief  Remove an association between a track and a cluster
0425      *
0426      *  @param  algorithm the algorithm calling this function
0427      *  @param  pTrack address of the track
0428      *  @param  pCluster address of the cluster
0429      */
0430     static pandora::StatusCode RemoveTrackClusterAssociation(const pandora::Algorithm &algorithm, const pandora::Track *const pTrack,
0431         const pandora::Cluster *const pCluster);
0432
0433     /**
0434      *  @brief  Remove all track-cluster associations from objects in the current track and cluster lists
0435      *
0436      *  @param  algorithm the algorithm calling this function
0437      */
0438     static pandora::StatusCode RemoveCurrentTrackClusterAssociations(const pandora::Algorithm &algorithm);
0439
0440     /**
0441      *  @brief  Remove all associations between tracks and clusters
0442      *
0443      *  @param  algorithm the algorithm calling this function
0444      */
0445     static pandora::StatusCode RemoveAllTrackClusterAssociations(const pandora::Algorithm &algorithm);
0446
0447
0448     /* MCParticle-related functions */
0449
0450     /**
0451      *  @brief  Remove all mc particle relationships previously registered with the mc manager and linked to tracks/calo hits
0452      *
0453      *  @param  algorithm the algorithm calling this function
0454      */
0455     static pandora::StatusCode RemoveAllMCParticleRelationships(const pandora::Algorithm &algorithm);
0456
0457
0458     /* Cluster-related functions */
0459
0460     /**
0461      *  @brief  Merge two clusters in the current list, enlarging one cluster and deleting the second
0462      *
0463      *  @param  algorithm the algorithm calling this function
0464      *  @param  pClusterToEnlarge address of the cluster to enlarge
0465      *  @param  pClusterToDelete address of the cluster to delete
0466      */
0467     static pandora::StatusCode MergeAndDeleteClusters(const pandora::Algorithm &algorithm, const pandora::Cluster *const pClusterToEnlarge,
0468         const pandora::Cluster *const pClusterToDelete);
0469
0470     /**
0471      *  @brief  Merge two clusters from two specified lists, enlarging one cluster and deleting the second
0472      *
0473      *  @param  algorithm the algorithm calling this function
0474      *  @param  pClusterToEnlarge address of the cluster to enlarge
0475      *  @param  pClusterToDelete address of the cluster to delete
0476      *  @param  enlargeListName name of the list containing the cluster to enlarge
0477      *  @param  deleteListName name of the list containing the cluster to delete
0478      */
0479     static pandora::StatusCode MergeAndDeleteClusters(const pandora::Algorithm &algorithm, const pandora::Cluster *const pClusterToEnlarge,
0480         const pandora::Cluster *const pClusterToDelete, const std::string &enlargeListName, const std::string &deleteListName);
0481
0482
0483     /* Pfo-related functions */
0484
0485     /**
0486      *  @brief  Add a cluster to a particle flow object
0487      *
0488      *  @param  algorithm the algorithm calling this function
0489      *  @param  pPfo address of the particle flow object to modify
0490      *  @param  pCluster address of the cluster to add
0491      */
0492     template <typename T>
0493     static pandora::StatusCode AddToPfo(const pandora::Algorithm &algorithm, const pandora::ParticleFlowObject *const pPfo, const T *const pT);
0494
0495     /**
0496      *  @brief  Remove a cluster from a particle flow object. Note this function will not remove the final object (track or cluster)
0497      *          from a particle flow object, and will instead return status code "not allowed" as a prompt to delete the cluster
0498      *
0499      *  @param  algorithm the algorithm calling this function
0500      *  @param  pPfo address of the particle flow object to modify
0501      *  @param  pCluster address of the cluster to remove
0502      */
0503     template <typename T>
0504     static pandora::StatusCode RemoveFromPfo(const pandora::Algorithm &algorithm, const pandora::ParticleFlowObject *const pPfo, const T *const pT);
0505
0506     /**
0507      *  @brief  Set parent-daughter particle flow object relationship
0508      *
0509      *  @param  algorithm the algorithm calling this function
0510      *  @param  pParentPfo address of parent particle flow object
0511      *  @param  pDaughterPfo address of daughter particle flow object
0512      */
0513     static pandora::StatusCode SetPfoParentDaughterRelationship(const pandora::Algorithm &algorithm, const pandora::ParticleFlowObject *const pParentPfo,
0514         const pandora::ParticleFlowObject *const pDaughterPfo);
0515
0516     /**
0517      *  @brief  Remove parent-daughter particle flow object relationship
0518      *
0519      *  @param  algorithm the algorithm calling this function
0520      *  @param  pParentPfo address of parent particle flow object
0521      *  @param  pDaughterPfo address of daughter particle flow object
0522      */
0523     static pandora::StatusCode RemovePfoParentDaughterRelationship(const pandora::Algorithm &algorithm, const pandora::ParticleFlowObject *const pParentPfo,
0524         const pandora::ParticleFlowObject *const pDaughterPfo);
0525
0526
0527     /* Reclustering functions */
0528
0529     /**
0530      *  @brief  Initialize cluster fragmentation operations on clusters in the algorithm input list. This allows hits in a list
0531      *          of clusters (a subset of the algorithm input list) to be redistributed.
0532      *
0533      *  @param  algorithm the algorithm calling this function
0534      *  @param  inputClusterList the input cluster list
0535      *  @param  originalClustersListName to receive the name of the list in which the original clusters are stored
0536      *  @param  fragmentClustersListName to receive the name of the list in which the fragment clusters are stored
0537      */
0538     static pandora::StatusCode InitializeFragmentation(const pandora::Algorithm &algorithm, const pandora::ClusterList &inputClusterList,
0539         std::string &originalClustersListName, std::string &fragmentClustersListName);
0540
0541     /**
0542      *  @brief  End cluster fragmentation operations on clusters in the algorithm input list
0543      *
0544      *  @param  algorithm the algorithm calling this function
0545      *  @param  clusterListToSaveName the name of the list containing the clusters chosen to be saved (original or fragments)
0546      *  @param  clusterListToDeleteName the name of the list containing the clusters chosen to be deleted (original or fragments)
0547      */
0548     static pandora::StatusCode EndFragmentation(const pandora::Algorithm &algorithm, const std::string &clusterListToSaveName,
0549         const std::string &clusterListToDeleteName);
0550
0551     /**
0552      *  @brief  Initialize reclustering operations on clusters in the algorithm input list. This allows hits in a list
0553      *          of clusters (a subset of the algorithm input list) to be redistributed.
0554      *
0555      *  @param  algorithm the algorithm calling this function
0556      *  @param  inputTrackList the input track list
0557      *  @param  inputClusterList the input cluster list
0558      *  @param  originalClustersListName to receive the name of the list in which the original clusters are stored
0559      */
0560     static pandora::StatusCode InitializeReclustering(const pandora::Algorithm &algorithm, const pandora::TrackList &inputTrackList,
0561         const pandora::ClusterList &inputClusterList, std::string &originalClustersListName);
0562
0563     /**
0564      *  @brief  End reclustering operations on clusters in the algorithm input list
0565      *
0566      *  @param  algorithm the algorithm calling this function
0567      *  @param  selectedClusterListName the name of the list containing the chosen recluster candidates (or the original candidates)
0568      */
0569     static pandora::StatusCode EndReclustering(const pandora::Algorithm &algorithm, const std::string &selectedClusterListName);
0570 };
0571
0572 #endif // #ifndef PANDORA_CONTENT_API_H