// BSurfXYPlane.cpp

#include "BSurfXYPlane.h"
#include <cassert>
#include <cmath>
#include "trfbase/CrossStat.h"
#include "trfbase/ETrack.h"
#include "trfutil/trfstream.h"
#include "objstream/ObjData.hpp"
#include "objstream/ObjTable.hpp"

#ifndef DEFECT_NO_STDLIB_NAMESPACES
using std::sqrt;
using std::fabs;
#endif

using namespace trf;

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

namespace {

// Creator.

ObjPtr create(const ObjData& data) {
  assert( data.get_object_type() == "BSurfXYPlane" );
  double dist = data.get_double("dist");
  double phi = data.get_double("phi");
  double zmin = data.get_double("zmin");
  double zmax = data.get_double("zmax");
  double vmin = data.get_double("vmin");
  double vmax = data.get_double("vmax");
  return ObjPtr( new BSurfXYPlane(dist,phi,vmin,vmax,zmin,zmax) );
}

}

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

// output stream
void BSurfXYPlane::ostr(ostream& stream) const {
  stream << begin_object ;
  SurfXYPlane::raw_ostr(stream);
  stream << ", vmin " << _vmin << " and vmax " << _vmax
         << ", zmin " << _zmin << " and zmax " << _zmax;
  stream << end_object;
}

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

// bounded equality
bool BSurfXYPlane::safe_bound_equal(const Surface& srf) const {
  const BSurfXYPlane& bxyp = (const BSurfXYPlane&) srf;
  return SurfXYPlane::safe_pure_equal(srf) &&
         abs(_vmin - bxyp._vmin)<1.0e-7  && abs(_vmax - bxyp._vmax)<1.0e-7 && 
         abs(_zmin - bxyp._zmin)<1.0e-7  && abs(_zmax - bxyp._zmax)<1.0e-7;
}

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

// constructor
BSurfXYPlane::BSurfXYPlane(double dist, double phi,
                           double vmin, double vmax, 
                           double zmin, double zmax)
: SurfXYPlane(dist,phi), _vmin(vmin), _vmax(vmax), _zmin(zmin), _zmax(zmax) {
  assert ( _zmax > _zmin );
  assert ( _vmax > _vmin );
}


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

// Clone.

Surface* BSurfXYPlane::new_surface() const {

  double phi = get_parameter(SurfXYPlane::NORMPHI);
  double dist = get_parameter(SurfXYPlane::DISTNORM);
  return new BSurfXYPlane( dist, phi, _vmin, _vmax, _zmin, _zmax );
}

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

// Calculate crossing status for VTrack.

CrossStat BSurfXYPlane::status(const VTrack& trv) const {
  double prec = CrossStat::get_static_precision();
  double dvtrk = prec;
  double dztrk = prec;
  return status(trv,dvtrk,dztrk);
}

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

// Calculate crossing status for ETrack.

CrossStat BSurfXYPlane::status(const ETrack& tre) const {
  double nsigma = CrossStat::get_static_nsigma();
  double prec = CrossStat::get_static_precision();
  double dvtrk = nsigma*
                 sqrt(tre.get_error()(SurfXYPlane::IV,SurfXYPlane::IV)) + prec; 
  double dztrk = nsigma*
                 sqrt(tre.get_error()(SurfXYPlane::IZ,SurfXYPlane::IZ)) + prec;
  return status(tre,dvtrk,dztrk);
}
//**********************************************************************

// calculate crossing status VTrack plus track (v,z)-reach.
CrossStat BSurfXYPlane::status(const VTrack& trv,
                               double dvtrk, double dztrk) const {
  CrossStat xstat = SurfXYPlane::pure_status(trv);
  // If track is not at surface exit with bounds flags undefined.
  if ( !xstat.at() ) return xstat;
  assert( ! xstat.bounds_checked() );
  // Calculate whether v track +/- nsigma is in and/or out of bounds.
  double vtrk = trv.get_vector()(SurfXYPlane::IV);
  double vtrk1 = vtrk - dvtrk;
  double vtrk2 = vtrk + dvtrk;
  
  // Calculate whether z track +/- nsigma is in and/or out of bounds.
  double ztrk = trv.get_vector()(SurfXYPlane::IZ);
  double ztrk1 = ztrk - dztrk;
  double ztrk2 = ztrk + dztrk;

  // fully out of bounds
  if( (vtrk2 < _vmin || vtrk1 > _vmax ) ||
      (ztrk2 < _zmin || ztrk1 > _zmax ) )
    return CrossStat(CrossStat::OUT_OF_BOUNDS);
  // fully in bounds
  if( (vtrk1 > _vmin  &&  vtrk2 < _vmax ) &&
      (ztrk1 > _zmin  &&  ztrk2 < _zmax ) )
    return CrossStat(CrossStat::IN_BOUNDS);
  // must be both
  return CrossStat(CrossStat::BOTH_BOUNDS);
}

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


// Return the creator.

ObjCreator BSurfXYPlane::get_creator() {
  return create;
}

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

// Write the object data.

ObjData BSurfXYPlane::write_data() const {
  ObjData data( get_type_name() );
  data.add_double( "dist", get_parameter(DISTNORM) );
  data.add_double( "phi", get_parameter(NORMPHI) );
  data.add_double( "vmin", get_vmin() );
  data.add_double( "vmax", get_vmax() );
  data.add_double( "zmin", get_zmin() );
  data.add_double( "zmax", get_zmax() );
  return data;
}

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