// HitXYPlane1.cpp

#include "HitXYPlane1.h"
#include "trfbase/ETrack.h"
#include "trfutil/TRFMath.h"
#include "trfutil/trfstream.h"
#include "objstream/ObjData.hpp"
#include "objstream/ObjTable.hpp"

using namespace trf;

//**********************************************************************
// Free functions.
//**********************************************************************

namespace {

// Creator.

ObjPtr create_cluster(const ObjData& data) {
  assert( data.get_object_type() == "ClusXYPlane1" );
  double dist = data.get_double("dist");
  double phi = data.get_double("phi");
  double av = data.get_double("vweight");
  double az = data.get_double("zweight");
  double vz = data.get_double("vz");
  double dvz = data.get_double("dvz");
#ifdef ObjData_supports_lists
  McIdList mcids;
  data.get_int_list("mcids",mcids);
#endif
  return ObjPtr( new ClusXYPlane1(dist,phi,av,az,vz,dvz,mcids) );
}

ObjPtr create_hit(const ObjData& data) {
  assert(false);
  abort();
  return ObjPtr(0);
}

}


//**********************************************************************
// ClusXYPlane1
//**********************************************************************

// output stream

void ClusXYPlane1::ostr(ostream& stream) const {
  stream << begin_object ;
  stream << "avz " << _sxyp << " and v weight " << _wv 
                            << " and z weight " << _wz  
         << ": avz = " << _avz << " +/- " << _davz;
  stream << end_object;
}



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

// equality

bool ClusXYPlane1::equal(const Cluster& clus) const {
  assert( this->get_type() == clus.get_type() );
  const ClusXYPlane1& ccp = (const ClusXYPlane1&) clus;
  return    ( _wv == ccp._wv ) 
         && ( _wz == ccp._wz ) 
         && ( _avz == ccp._avz ) 
         && ( _davz == ccp._davz ) 
         && ( _sxyp == ccp._sxyp );
}

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

// constructor

ClusXYPlane1::ClusXYPlane1(double dist, double phi, 
                         double wv, double wz, 
                         double avz,double davz )
: _sxyp(dist,phi), _wv(wv), _wz(wz), _avz(avz), _davz(davz) {
  assert( _davz >= 0.0 );
}

ClusXYPlane1::ClusXYPlane1(double dist, double phi, 
                         double wv, double wz, 
                         double avz,double davz,const McIdList& mcids )
:_sxyp(dist,phi), _wv(wv), _wz(wz), _avz(avz), _davz(davz),McCluster(mcids) {
assert( _davz >= 0.0 );
}
 
//**********************************************************************

// copy constructor

ClusXYPlane1::ClusXYPlane1(const ClusXYPlane1& rhs)
:  _sxyp(rhs._sxyp), _wv(rhs._wv), _wz(rhs._wz), 
                  _avz(rhs._avz), _davz(rhs._davz),McCluster(rhs)
{ }

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

// destructor

ClusXYPlane1::~ClusXYPlane1( ) { }

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

// generate hits from a track 

HitList ClusXYPlane1::_predict(const ETrack& tre) const {
  HitList hits;
  double v_track = tre.get_vector()(SurfXYPlane::IV);
  double z_track = tre.get_vector()(SurfXYPlane::IZ);
  double evv_track = tre.get_error()(SurfXYPlane::IV,SurfXYPlane::IV);
  double evz_track = tre.get_error()(SurfXYPlane::IV,SurfXYPlane::IZ);
  double ezz_track = tre.get_error()(SurfXYPlane::IZ,SurfXYPlane::IZ);

  double avz  = _wv*v_track + _wz*z_track; 
  double eavz = evv_track*_wv*_wv + 2.*evz_track*_wv*_wz + ezz_track*_wz*_wz;  

  hits.push_back( HitPtr(new HitXYPlane1( avz, eavz ) ));
  return hits;
}
//**********************************************************************

// Return the creator.

ObjCreator ClusXYPlane1::get_creator() {
  return create_cluster;
}

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

// Write the object data.

ObjData ClusXYPlane1::write_data() const {
  ObjData data( get_type_name() );
  const SurfXYPlane& srf=(const SurfXYPlane&)(get_surface());
  data.add_double( "dist", srf.get_parameter( SurfXYPlane::DISTNORM) );
  data.add_double( "phi", srf.get_parameter( SurfXYPlane::NORMPHI) );
  data.add_double( "zweight", get_wz() );
  data.add_double( "vweight", get_wv() );
  data.add_double( "vz", get_avz() );
  data.add_double( "dvz", get_davz() );
#ifdef ObjData_supports_lists
  data.add_int_list( "mcids", get_mc_ids() );
#endif
  return data;
}

//**********************************************************************
// HitXYPlane1
//**********************************************************************

// output stream

void HitXYPlane1::ostr(ostream& stream) const {
  stream << begin_object ;
  if( _pclus )
    {
      stream << "hit from ";
      stream << *_pclus;
    }
  else
    {
      stream << "Hit with no parent clusters";
    }
  stream << end_object;
}

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

// equality
// Hits are equal if they have the same parent cluster.

bool HitXYPlane1::equal(const Hit& hit) const {
  assert( this->get_type() == hit.get_type() );
  return get_cluster() == hit.get_cluster();
}

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

// constructor

HitXYPlane1::HitXYPlane1(double avz, double eavz)
: _avz_pre(avz), _eavz_pre(eavz) { }

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

// copy constructor

HitXYPlane1::HitXYPlane1(const HitXYPlane1& lhs)
: Hit(lhs), _avz_pre(lhs._avz_pre), _eavz_pre(lhs._eavz_pre) { }

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

// destructor

HitXYPlane1::~HitXYPlane1() { }

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

// return the measured hit vector

HitVector HitXYPlane1::measured_vector() const {
  return HitVector( get_full_cluster().get_avz() );
}

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

// return the measured hit error

HitError HitXYPlane1::measured_error() const {
  double davz = get_full_cluster().get_davz();
  return HitError( davz*davz );
}

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

// return the predicted hit vector

HitVector HitXYPlane1::predicted_vector() const {
  return HitVector( _avz_pre );
}

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

// return the predicted hit error

HitError HitXYPlane1::predicted_error() const {
  return HitError( _eavz_pre );
}

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

// return the derivative

HitDerivative HitXYPlane1::dhit_dtrack() const {
  double values[] = { 0.0, 0.0, 0.0, 0.0, 0.0 };
  values[0] = get_full_cluster().get_wv();
  values[1] = get_full_cluster().get_wz();
  HitDerivative deriv(1,values);
  return deriv;
}

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

// return the difference between prediction and measurement.

HitVector HitXYPlane1::difference_vector() const {
  return HitVector( _avz_pre-get_full_cluster().get_avz() );
}

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

// update the hit prediction (measurement and derivative do not change)

void HitXYPlane1::update( const ETrack& tre) {

  double v_track = tre.get_vector()(SurfXYPlane::IV);
  double z_track = tre.get_vector()(SurfXYPlane::IZ);
  double evv_track = tre.get_error()(SurfXYPlane::IV,SurfXYPlane::IV);
  double evz_track = tre.get_error()(SurfXYPlane::IV,SurfXYPlane::IZ);
  double ezz_track = tre.get_error()(SurfXYPlane::IZ,SurfXYPlane::IZ);

  double cl_wv = get_full_cluster().get_wv();
  double cl_wz = get_full_cluster().get_wz();

   _avz_pre = cl_wv*v_track + cl_wz*z_track; 
  _eavz_pre =   evv_track*cl_wv*cl_wv + 
             2.*evz_track*cl_wv*cl_wz + 
                ezz_track*cl_wz*cl_wz;
}

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

// Return the creator.

ObjCreator HitXYPlane1::get_creator() {
  return create_hit;
}

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

// Write the object data.

ObjData HitXYPlane1::write_data() const {
  ObjData data( get_type_name() );
  return data;
}