DDSpacePointBuilder.h

#ifndef DDSpacePointBuilder_h
#define DDSpacePointBuilder_h 1

#include "marlin/Processor.h"
#include "lcio.h"
#include <string>
#include <map>
#include <EVENT/TrackerHit.h>
#include <EVENT/TrackerHitPlane.h>
#include <IMPL/TrackerHitImpl.h>

#include "CLHEP/Vector/ThreeVector.h"
#include "CLHEP/Vector/Rotation.h"

// DD4HEP classes
#include "DDSurfaces/Vector2D.h"
#include "DDSurfaces/Vector3D.h"
#include "DDSurfaces/ISurface.h"
#include "DD4hep/LCDD.h"
#include "DDRec/SurfaceManager.h"
#include "DDRec/SurfaceHelper.h"
#include "DD4hep/DD4hepUnits.h"

using namespace lcio ;
using namespace marlin ;





class DDSpacePointBuilder : public Processor {
  
 public:
  
  virtual Processor*  newProcessor() { return new DDSpacePointBuilder ; }
  
  
  DDSpacePointBuilder() ;
  
  virtual void init() ;
  
  virtual void processRunHeader( LCRunHeader* run ) ;
  
  virtual void processEvent( LCEvent * evt ) ; 
  
  
  virtual void check( LCEvent * evt ) ; 
  
  
  virtual void end() ;
  

  
  
 protected:



  std::string _TrackerHitCollection;

  std::string _TrackerHitSimHitRelCollection;
  
  std::string _SpacePointsCollection;
  
  std::string _relColName;

  static int calculateXingPoint( double x1, double y1, float ex1, float ey1, double x2, double y2, float ex2, float ey2, double& x, double& y );
 
  static int calculatePointBetweenTwoLines( 
                                           const CLHEP::Hep3Vector& P1, 
                                           const CLHEP::Hep3Vector& V1, 
                                           const CLHEP::Hep3Vector& P2, 
                                           const CLHEP::Hep3Vector& V2, 
                                           CLHEP::Hep3Vector& point );

  
  
  static int calculatePointBetweenTwoLines_UsingVertex( 
                                                  const CLHEP::Hep3Vector& PA, 
                                                  const CLHEP::Hep3Vector& PB, 
                                                  const CLHEP::Hep3Vector& PC, 
                                                  const CLHEP::Hep3Vector& PD,
                                                  const CLHEP::Hep3Vector& Vertex,
                                                  CLHEP::Hep3Vector& point);
  
  
  //TrackerHitImpl* createSpacePoint( TrackerHitPlane* a , TrackerHitPlane* b, double stripLength, const DD4hep::DDRec::SurfaceMap* surfMap );
  TrackerHitImpl* createSpacePoint( TrackerHitPlane* a , TrackerHitPlane* b, double stripLength );
//   TrackerHitImpl* createSpacePointOld( TrackerHitPlane* a , TrackerHitPlane* b );
  
  std::vector< int > getCellID0sAtBack( int cellID0 );
  
  std::vector< int > getCellID0sAtBackOfFTD( int cellID0 );
  
  std::vector< int > getCellID0sAtBackOfSET( int cellID0 );
  
  std::vector< int > getCellID0sAtBackOfSIT( int cellID0 );

  
  std::string getCellID0Info( int cellID0 );
 

  int _nRun ;
  int _nEvt ;

  unsigned _nOutOfBoundary;
  unsigned _nStripsTooParallel;
  unsigned _nPlanesNotParallel;

  float _nominal_vertex_x;
  float _nominal_vertex_y;
  float _nominal_vertex_z;

  CLHEP::Hep3Vector _nominal_vertex;

  float _striplength_tolerance;

  double _striplength ;
  std::string _subDetName ;

  //DD4hep::Geometry::LCDD& lcdd;
  const DD4hep::DDRec::SurfaceMap* surfMap ;
  
} ;

#endif