// HitCylPhi_t.cpp

// Test component HitCylPhi.

#include "HitCylPhi.h"
#include <string>
#include <sstream>
#include <cassert>
#include "objstream/ObjData.hpp"
#include "objstream/StdObjStream.hpp"
#include "trfutil/trfstream.h"
#include "trfbase/ETrack.h"
#include "trfutil/TRFMath.h"

using std::cout;
using std::cerr;
using std::endl;
using std::string;
using std::ostringstream;
using std::istringstream;
#ifndef DEFECT_CMATH_NOT_STD
using std::fabs;
#endif

using namespace trf;

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

int main( ) {
  string component = "HitCylPhi";
  string ok_prefix = component + " (I): ";
  string error_prefix = component + " test (E): ";

  cout << ok_prefix
       << "-------- Testing component " + component
          + ". --------" << endl;

  // Make sure assert is enabled.
  bool assert_flag = false;
  assert ( ( assert_flag = true, assert_flag ) );
  if ( ! assert_flag ) {
    cerr << "Assert is disabled" << endl;
    return 1;
  }

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

  ObjTable::register_type<ClusCylPhi>();

  cout << trf_format;
  cout << ok_prefix << "Test hit constructors." << endl;
  double r1 = 10.0;
  double phi1 = 1.0;
  double dphi1 = 0.1;
  SurfCylinder scy1(r1);
  ClusCylPhi* phcp1 = new ClusCylPhi(r1,phi1,dphi1);
  ClusCylPhi& hcp1 = *phcp1;
  cout << hcp1 << endl;
  ClusCylPhi hcp1c = hcp1;
  cout << hcp1c << endl;
  double r2 = 20.0;
  double phi2 = 2.0;
  double dphi2 = 0.2;
  ClusCylPhi* phcp2 = new ClusCylPhi(r2,phi2,dphi2);
  ClusCylPhi& hcp2 = *phcp2;

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

  cout << ok_prefix << "Test cluster type ID." << endl;
  cout << hcp1.get_type() << endl;
  cout << hcp2.get_type() << endl;
  assert( hcp1.get_type() != 0 );
  assert( hcp1.get_type() == hcp2.get_type() );

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

  cout << ok_prefix << "Test hit accessors." << endl;
  cout << hcp1 << endl;
  cout << hcp1.get_surface() << endl;
  cout << hcp1.get_phi() << endl;
  cout << hcp1.get_dphi() << endl;
  assert( hcp1.get_surface() == scy1 );
  assert( is_equal( hcp1.get_phi(), phi1 ) );
  assert( is_equal( hcp1.get_dphi(), dphi1 ) );

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

  cout << ok_prefix << "Generate a prediction." << endl;
  TrackVector vec;
  TrackError err;
  HitDerivative der_expect(1);
  der_expect(0,0) = 1.0;
  vec(0) = 1.1;
  err(0,0) = 0.02;
  ETrack tre1( SurfacePtr(scy1.new_pure_surface()), vec, err );
  const ClusterPtr hcp1ptr(&hcp1);
  HitList thits11 = hcp1.predict(tre1);
  assert( thits11.size() == 1 );
  Hit& pre11 = *thits11.front();
  double maxdiff = 1.e-12;
  cout << pre11.size() << endl;
  assert( pre11.size() == 1);
  cout << pre11.measured_vector() << endl;
  assert( is_equal( pre11.measured_vector()(0), phi1 ) );
  cout << pre11.measured_error() << endl;
  assert( is_equal( pre11.measured_error()(0,0), dphi1*dphi1 ) );
  cout << pre11.predicted_vector() << endl;
  assert( is_equal( pre11.predicted_vector()(0), vec(0) ) );
  cout << pre11.predicted_error() << endl;
  assert( is_equal( pre11.predicted_error()(0,0), err(0,0) ) );
  cout << der_expect << endl;
  cout << pre11.dhit_dtrack() << endl;
  cout << pre11.dhit_dtrack() - der_expect << endl;
  assert( is_equal( pre11.dhit_dtrack(), der_expect ) );
  cout << pre11.difference_vector() << endl;
  assert( fabs(pre11.difference_vector()(0) - vec(0) + phi1) < maxdiff );

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

  cout << ok_prefix << "Generate prediction for a different track."
       << endl;
  vec(0) = 1.2;
  ETrack tre2( SurfacePtr(scy1.new_pure_surface()), vec, err );
  HitList thits12 = hcp1.predict(tre2);
  assert( thits12.size() == 1 );
  const Hit& pre12 = *thits12.front();
  cout << pre12.size() << endl;
  assert( pre12.size() == 1);
  cout << pre12.measured_vector() << endl;
  assert( is_equal( pre12.measured_vector()(0), phi1 ) );
  cout << pre12.measured_error() << endl;
  assert( is_equal( pre12.measured_error()(0,0), dphi1*dphi1 ) );
  cout << pre12.predicted_vector() << endl;
  assert( is_equal( pre12.predicted_vector()(0), vec(0) ) );
  cout << pre12.predicted_error() << endl;
  assert( is_equal( pre12.predicted_error()(0,0), err(0,0) ) );
  cout << pre12.dhit_dtrack() << endl;
  assert( is_equal( pre12.dhit_dtrack(), der_expect ) );
  cout << pre12.difference_vector() << endl;
  assert( fabs(pre12.difference_vector()(0) - vec(0) + phi1) < maxdiff );
  // same hit ==> same prediction (even thogh track changes)
  assert( pre11 == pre11 );
  assert( ! ( pre11 != pre11 ) );
  assert( pre11 == pre12 );

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

  cout << ok_prefix << "Generate prediction for a different hit."
       << endl;
  const ClusterPtr hcp2ptr(&hcp2);
  HitList thits22 = hcp2.predict(tre2);
  assert( thits22.size() == 1 );
  const Hit& pre22 = *thits22.front();
  cout << pre22.size() << endl;
  assert( pre22.size() == 1);
  cout << pre22.measured_vector() << endl;
  assert( is_equal( pre22.measured_vector()(0), phi2 ) );
  cout << pre22.measured_error() << endl;
  assert( is_equal( pre22.measured_error()(0,0), dphi2*dphi2 ) );
  cout << pre22.predicted_vector() << endl;
  assert( is_equal( pre22.predicted_vector()(0), vec(0) ) );
  cout << pre22.predicted_error() << endl;
  assert( is_equal( pre22.predicted_error()(0,0), err(0,0) ) );

  cout << pre22.dhit_dtrack() << endl;
  assert( is_equal( pre22.dhit_dtrack(), der_expect ) );
  cout << pre22.difference_vector() << endl;

  assert( fabs(pre22.difference_vector()(0) - vec(0) + phi2) < maxdiff );
  // different hit ==> different prediction
  assert( pre22 != pre11 );
  assert( ! ( pre22 == pre11 ) );
  assert( pre22 != pre12 );

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

  cout << ok_prefix << "Update prediction." << endl;
  cout << pre11 << endl;
  pre11.update(tre2);
  cout << pre11 << endl;
  assert( pre11.size() == 1);
  cout << pre11.measured_vector() << endl;
  assert( pre11.measured_vector()(0) == phi1 );
  cout << pre11.measured_error() << endl;
  assert( is_equal(pre11.measured_error()(0,0), dphi1*dphi1) );
  cout << pre11.predicted_vector() << endl;
  assert( pre11.predicted_vector()(0) == vec(0) );
  cout << pre11.predicted_error() << endl;
  assert( pre11.predicted_error()(0,0) == err(0,0) );
  cout << pre11.dhit_dtrack() << endl;
  assert( pre11.dhit_dtrack() == der_expect );
  cout << pre11.difference_vector() << endl;
  assert( fabs(pre11.difference_vector()(0) - vec(0) + phi1) < maxdiff );

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

  cout << ok_prefix << "Check prediction type and equality." << endl;
  cout << HitCylPhi::get_static_type() << endl;
  cout << pre11.get_type() << endl;
  cout << pre12.get_type() << endl;
  assert( pre11.get_type() != 0 );
  assert( pre11.get_type() == HitCylPhi::get_static_type() );
  assert( pre11.get_type() == pre12.get_type() );
  assert( pre11.get_type() != hcp1.get_type() );

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

  cout << ok_prefix << "Check MC ID's." << endl;
  assert( phcp1->get_mc_ids().size() == 0 );
  McIdList ids;
  ids.push_back(1);
  ids.push_back(22);
  ids.push_back(333);
  ClusCylPhi* phcp3 = new ClusCylPhi(r2,phi2,dphi2,ids);
  cout << *phcp3 << endl;
  ClusterPtr pclu3(phcp3);
  {
    const McIdList& oids = phcp3->get_mc_ids();
    assert( oids.size() == 3 );
    assert( oids[0] == 1 );
    assert( oids[1] == 22 );
    assert( oids[2] == 333 );
  }
  {
    HitList thits31 = phcp3->predict(tre1);
    assert( thits31.size() == 1 );
    Hit& hit = *thits31.front();
    const McIdList& oids = hit.get_mc_ids();
    assert( oids.size() == 3 );
    assert( oids[0] == 1 );
    assert( oids[1] == 22 );
    assert( oids[2] == 333 );
  }
  {
    ClusCylPhi hcp4(*phcp3);
    const McIdList& oids = hcp4.get_mc_ids();
    assert( oids.size() == 3 );
    assert( oids[0] == 1 );
    assert( oids[1] == 22 );
    assert( oids[2] == 333 );
  }

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

  cout << ok_prefix << "Write object data." << endl;
  McIdList mcids;
  mcids.push_back(2);
  mcids.push_back(4);
  mcids.push_back(8);
  {
    ObjPtr pobj( new ClusCylPhi(12.3, 4.5, 1.2, mcids) );
    ostringstream mystream;
    StdObjStream objstream(mystream);
    objstream.write_object("obj1",pobj);
    cout << mystream.str() << endl;
    assert( ObjTable::has_object_name("obj1") );
    string::size_type pos = 0;
    assert( (pos=mystream.str().find( "obj1 ",pos)) != string::npos );
    assert( (pos=mystream.str().find( "ClusCylPhi ",pos)) != string::npos );
    assert( (pos=mystream.str().find( "radius",pos)) != string::npos );
    assert( (pos=mystream.str().find( "12.3 ",pos)) != string::npos );
    assert( (pos=mystream.str().find( "phi",pos)) != string::npos );
    assert( (pos=mystream.str().find( "4.5 ",pos)) != string::npos );
    assert( (pos=mystream.str().find( "dphi",pos)) != string::npos );
    assert( (pos=mystream.str().find( "1.2 ",pos)) != string::npos );
#ifdef ObjData_supports_lists
    assert( (pos=mystream.str().find( "mcids",pos)) != string::npos );
    assert( (pos=mystream.str().find( "2 ",pos)) != string::npos );
    assert( (pos=mystream.str().find( "4 ",pos)) != string::npos );
    assert( (pos=mystream.str().find( "8 ",pos)) != string::npos );
#endif
  }

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

  cout << ok_prefix << "Read object data." << endl;
  {
    string istring = "[ obj2 ClusCylPhi radius=24.4 phi=2.8 dphi=1.1";
#ifdef ObjData_supports_lists
    istring += " mcids=int( 2 4 8 )";
#endif
    istring += " ]";
    cout << istring << endl;
    istringstream isstrm(istring);
    {
      StdObjStream obstr(isstrm);
      string name = obstr.read_object();
      assert( name == "obj2" );
      const ClusCylPhi* pobj;
      ObjTable::get_object(name,pobj);
      assert( pobj != 0 );
      cout << *pobj << endl;
      assert( pobj->get_type() == ClusCylPhi::get_static_type() );
      assert( pobj->get_radius() == 24.4 );
      assert( pobj->get_phi() == 2.8 );
      assert( pobj->get_dphi() == 1.1 );
#ifdef ObjData_supports_lists
      assert( pobj->get_mc_ids() == mcids );
#endif
    }
  }

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

  cout << ok_prefix
       << "------------- All tests passed. -------------" << endl;
  return 0;

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

}