// CFTPathBuilder.h

#ifndef CFTPathBuilder_H
#define CFTPathBuilder_H

// Build paths used for D0 scifi reconstruction.  Paths are built
// upon construction and the head path can be accessed via the
// method get_head_path.  Paths are destroyed when the destructor is
// called.

#include <string>
#include <map>
#include "ptr/Ptr.h"
#include "trfbase/PropagatorPtr.h"
#include "trffit/AddFitterPtr.h"
#include "trffind/CheckerPtr.h"
#include "trffind/FilterPtr.h"
#include "trffind/PathStopPtr.h"
#include "trffind/Path.h"

namespace trf {

class Detector;
class ETrack;

class CFTPathBuilder {

private:  // typedefs

  // comparator for strings
  typedef std::less<std::string> StringCmp;

public:  // typedefs

  // map of stop pointers indexed by name
  typedef std::map<std::string,PathStopPtr,StringCmp> StopMap;

  // map of checkers indexed by name
  typedef std::map<std::string,CheckerPtr,StringCmp> CheckerMap;

  // map of filters indexed by name
  typedef std::map<std::string,FilterPtr,StringCmp> FilterMap;

private:  // attributes

  // Detector--must include the CFT layers.
  const Detector& _cftdet;

  // propagators
  std::map<std::string,PropagatorPtr,StringCmp> _props;

  // fitters
  std::map<std::string,AddFitterPtr,StringCmp> _fits;

  // stops
  StopMap _stops;

  // checkers
  CheckerMap _checkers;

  // filters
  FilterMap _filters;

private:  // methods

  // hide copy constructor
  CFTPathBuilder(const CFTPathBuilder& rhs);

  // hide assignment operator
  CFTPathBuilder& operator=(const CFTPathBuilder& rhs);

public:  // methods

  // constructor
  // from layer manager and starting track
  // layer_manager = layer manager
  // tre = starting track
  // bfield = assumed B-field in Tesla
  // ptmin = pT threshold for 2-phi fitter in GeV/c
  // nsigma_3phi = nsigma limit for 3-phi fitter
  CFTPathBuilder(const Detector& det,
                const ETrack& tre, double bfield, double ptmin,
                double nsigma_3phi);

  // destructor
  ~CFTPathBuilder();

  // Add a tree to the specified path node.
  void add_path_tree(MutablePathPtr ppath) const;

  // Return the map of stops
  const StopMap& get_stops() const { return _stops; };

};

}  // end namespace trf

#endif