// LayerSimGeneric.cpp

#include "LayerSimGeneric.h"
#include "trfutil/trfstream.h"
#include "trfbase/Surface.h"
#include "trfbase/Propagator.h"
#include "trfbase/HitGenerator.h"
#include "trfbase/PropStat.h"
#include "trfbase/CrossStat.h"
#include "Layer.h"

using trf::Layer;
using trf::LayerSimGeneric;
using trf::LayerPtr;
using trf::Surface;
using trf::SurfacePtr;
using trf::ClusterPtr;
using trf::HitGenerator;
using trf::PropStat;
using trf::Propagator;
using trf::PropagatorPtr;

//**********************************************************************
// Helper functions.
//**********************************************************************

// Return true if the layer and generator surfaces match.
static bool
check_surfaces(const Layer& lyr,
               const LayerSimGeneric::HitGeneratorList& gens) {
  // Retrieve the active layer surfaces.
  const Layer::SurfaceList lsrfs = lyr.get_cluster_surfaces();
  if ( lsrfs.size() != gens.size() ) return false;
  Layer::SurfaceList::const_iterator ilsrf = lsrfs.begin();
  LayerSimGeneric::HitGeneratorList::const_iterator igen = gens.begin();
  // Require pure surfaces to match.
  while ( igen != gens.end() ) {
    const Surface& lsrf = **ilsrf++;
    LayerSimGeneric::HitGeneratorPtr pgen = *igen++;
    if ( ! pgen ) return false;
    const Surface& gsrf = pgen->get_surface();
    if ( ! lsrf.pure_equal(gsrf) ) return false;
  }
  return true;
}

//**********************************************************************
// Methods.
//**********************************************************************

// Output stream.

void LayerSimGeneric::ostr(ostream& stream) const {
  stream << begin_object;
  stream << "Generic layer simulator." << new_line;
  stream << "Layer: ";
  stream << get_layer() << new_line;
  stream << "Propagator: ";
  stream << *_pprop << new_line;
  int size = _gens.size();
  stream << "Hit generators (count is " << size << "):";
  for ( HitGeneratorList::const_iterator igen=_gens.begin();
        igen!=_gens.end(); ++igen ) {
    stream << new_line;
    stream << **igen;
  }
  stream << end_object;
}

//**********************************************************************

// Constructor for one surface.
// Requires that generator surface is same as layer surface.

LayerSimGeneric::LayerSimGeneric(LayerPtr plyr, HitGeneratorPtr pgen,
                                 PropagatorPtr pprop)
: LayerSimulator(plyr), _gens(1,pgen), _pprop(pprop) {
  assert ( plyr != 0 );
  assert ( pgen != 0 );
  assert ( pprop != 0 );
  assert ( check_surfaces(get_layer(),_gens) );
}

//**********************************************************************

// Constructor for many surfaces.
// Requires that generator surface is same as layer surface.

LayerSimGeneric::LayerSimGeneric(LayerPtr plyr, HitGeneratorList gens,
                                 PropagatorPtr pprop)
: LayerSimulator(plyr), _gens(gens), _pprop(pprop) {
  assert ( plyr != 0 );
  assert ( gens.size() > 0 );
  assert ( pprop != 0 );
  assert ( check_surfaces(get_layer(),_gens) );
}

//**********************************************************************

// Destructor.

LayerSimGeneric::~LayerSimGeneric() { }

//**********************************************************************

// Return the list of generators.

RandomSimulator::GeneratorList LayerSimGeneric::get_generators() {
  GeneratorList gens;
  LayerSimGeneric::HitGeneratorList::const_iterator igen;
  for ( igen=_gens.begin(); igen!=_gens.end(); ++igen )
    gens.push_back( *igen );
  return gens;
}

//**********************************************************************

// Generate clusters.

void LayerSimGeneric::add_clusters(const VTrack& trv0) {

  // Fetch the list of layer surfaces.
  Layer::SurfaceList lsrfs = get_layer().get_cluster_surfaces();

  // Loop over surfaces.
  Layer::SurfaceList::const_iterator ilsrf = lsrfs.begin();
  HitGeneratorList::iterator igen = _gens.begin();
  while ( ilsrf != lsrfs.end() ) {
    SurfacePtr plsrf = *ilsrf++;
    HitGenerator& gen = **igen++;
    const Surface& gsrf = gen.get_surface();

    // Propagate track to generator surface.
    VTrack trv = trv0;
    PropStat pstat = _pprop->vec_prop(trv,gsrf);
    if ( ! pstat.success() ) continue;

    // Generate a cluster and add to layer.
    ClusterPtr pclu = gen.new_cluster(trv);
    if ( pclu )
      get_layer().add_cluster(pclu,plsrf);

  }  // end loop over surfaces

}

//**********************************************************************