// Miss.h

#ifndef Miss_H
#define Miss_H

// A miss represents the crossing of a track with a layer surface.
// It returns the likelihood that the track would cross the layer
// without producing a cluster.
//
// This likelihood should reflect overlap with inactive parts of the
// detector (beyond boundaries, gaps, dead channels, ...) as well
// as the intrinsic inefficiency of active regions.
//
// This is an abstract base class.  Concrete subclasses must provide
// methods to return the surface and likelihood, update the likelihood,
// clone and fill the output stream.
//
// These subclasses will typically be defined along with concrete
// layer classes.

#include <iosfwd>
#include "ref_count/RefCounter.hpp"

namespace trf {

class Surface;
class ETrack;
class Miss;

// output stream
std::ostream& operator<<(std::ostream& stream, const Miss& miss);

class Miss : public RefCounter {

private:  // methods

  // output stream
  virtual void ostr(std::ostream& stream) const =0;

public:  // methods

  // constructor
  Miss();

  // destructor
  virtual ~Miss();

  // return a unique address specifying the type
  // Default retuns zero--override for subclasses which are able to
  // identify themselves.
  virtual void* get_type() const;

  // Clone the miss.
  virtual Miss* new_copy() const =0;

  // update the likelihood with a new track
  virtual void update(const ETrack& tre) =0;

  // return the surface
  virtual const Surface& get_surface() const =0;

  // return the likelihood
  virtual double get_likelihood() const =0;

// friends.

  // output stream
  friend std::ostream&
  operator<<(std::ostream& stream, const Miss& miss);

};

}  // end namepsace trf

#endif