// BSurfZPlane.cpp

#include "BSurfZPlane.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;
#endif

using namespace trf;

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

namespace {

// Creator.

ObjPtr create(const ObjData& data) {
  assert( data.get_object_type() == "BSurfZPlane" );
  double z = data.get_double("z");
  double xmin = data.get_double("xmin");
  double xmax = data.get_double("xmax");
  double ymin = data.get_double("ymin");
  double ymax = data.get_double("ymax");
  return ObjPtr( new BSurfZPlane(z,xmin,xmax,ymin,ymax) );
}

}

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

// output stream
void BSurfZPlane::ostr(ostream& stream) const {
  stream << begin_object ;
  SurfZPlane::raw_ostr(stream);
  stream << ", xmin " << _xmin << " and xmax " << _xmax
         << ", ymin " << _ymin << " and ymax " << _ymax;
  stream << end_object;
}

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

// bounded equality
bool BSurfZPlane::safe_bound_equal(const Surface& srf) const {
  const BSurfZPlane& bxyp = (const BSurfZPlane&) srf;
  return SurfZPlane::safe_pure_equal(srf) &&
         _xmin == bxyp._xmin  && _xmax == bxyp._xmax && 
         _ymin == bxyp._ymin  && _ymax == bxyp._ymax;
}

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

// constructor
BSurfZPlane::BSurfZPlane(double zpos,
                           double xmin, double xmax, 
                           double ymin, double ymax)
: SurfZPlane(zpos), _xmin(xmin), _xmax(xmax), _ymin(ymin), _ymax(ymax) {
  assert ( _ymax > _ymin );
  assert ( _xmax > _xmin );
}

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

// Clone.

Surface* BSurfZPlane::new_surface() const {

  double zpos = get_parameter(SurfZPlane::ZPOS);
  return new BSurfZPlane( zpos, _xmin, _xmax, _ymin, _ymax );
}
//**********************************************************************

// Calculate crossing status for VTrack.

CrossStat BSurfZPlane::status(const VTrack& trv) const {
  double prec = CrossStat::get_static_precision();
  double dxtrk = prec;
  double dytrk = prec;
  return status(trv,dxtrk,dytrk);
}

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

// Calculate crossing status for ETrack.

CrossStat BSurfZPlane::status(const ETrack& tre) const {
  double nsigma = CrossStat::get_static_nsigma();
  double prec = CrossStat::get_static_precision();
  double dxtrk = nsigma*
                 sqrt(tre.get_error()(SurfZPlane::IX,SurfZPlane::IX)) + prec; 
  double dytrk = nsigma*
                 sqrt(tre.get_error()(SurfZPlane::IY,SurfZPlane::IY)) + prec;
  return status(tre,dxtrk,dytrk);
}
//**********************************************************************

// calculate crossing status VTrack plus track (x,y)-reach.
CrossStat BSurfZPlane::status(const VTrack& trv,
                               double dxtrk, double dytrk) const {
  CrossStat xstat = SurfZPlane::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 x track +/- nsigma is in and/or out of bounds.
  double xtrk = trv.get_vector()(SurfZPlane::IX);
  double xtrk1 = xtrk - dxtrk;
  double xtrk2 = xtrk + dxtrk;
  
  // Calculate whether y track +/- nsigma is in and/or out of bounds.
  double ytrk = trv.get_vector()(SurfZPlane::IY);
  double ytrk1 = ytrk - dytrk;
  double ytrk2 = ytrk + dytrk;

  // fully out of bounds
  if( (xtrk2 < _xmin || xtrk1 > _xmax ) ||
      (ytrk2 < _ymin || ytrk1 > _ymax ) )
    return CrossStat(CrossStat::OUT_OF_BOUNDS);
  // fully in bounds
  if( (xtrk1 > _xmin  &&  xtrk2 < _xmax ) &&
      (ytrk1 > _ymin  &&  ytrk2 < _ymax ) )
    return CrossStat(CrossStat::IN_BOUNDS);
  // must be both
  return CrossStat(CrossStat::BOTH_BOUNDS);
}

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

// Return the creator.

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

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

// Write the object data.

ObjData BSurfZPlane::write_data() const {
  ObjData data( get_type_name() );
  data.add_double( "z", get_z() );
  data.add_double( "xmin", get_xmin() );
  data.add_double( "xmax", get_xmax() );
  data.add_double( "ymin", get_ymin() );
  data.add_double( "ymax", get_ymax() );
  return data;
}

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