diff --git a/Utilities/KalDet/CMakeLists.txt b/Utilities/KalDet/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..52b96cf23b79b6c6458ec56803353977aecb70ec
--- /dev/null
+++ b/Utilities/KalDet/CMakeLists.txt
@@ -0,0 +1,58 @@
+##############################################################################
+# Package: KalDet
+# Desc: import from ILCSoft
+##############################################################################
+
+gaudi_subdir(KalDet v0r0)
+
+find_package(CLHEP REQUIRED)
+find_package(LCIO)
+find_package(GEAR)
+find_package(ROOT COMPONENTS MathCore)
+find_package(EDM4HEP REQUIRED)
+
+gaudi_depends_on_subdirs(
+ Detector/DetInterface
+ Utilities/KalTest
+)
+
+list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/cmake)
+
+INCLUDE( MyFindROOT )
+INCLUDE( MacroRootDict )
+
+SET( ROOT_DICT_CINT_DEFINITIONS "-DHANDLE_DICT_EXCEPTIONS=IGNORED_FOR_CINT" )
+
+INCLUDE( ${ROOT_DICT_MACROS_FILE} )
+
+SET( lib_input_dirs src/gen src/kern src/lctpc/gearTPC )
+
+FOREACH( lib_input_dir ${lib_input_dirs} )
+ LIST( APPEND ROOT_DICT_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/${lib_input_dir} )
+ENDFOREACH()
+
+LIST( APPEND ROOT_DICT_INCLUDE_DIRS /workfs/bes/fucd/Key4hep/CEPCSW/Utilities/KalTest )
+
+#MESSAGE( STATUS "ROOT_DICT_INCLUDE_DIRS: ${ROOT_DICT_INCLUDE_DIRS}" )
+
+FOREACH( lib_input_dir ${lib_input_dirs} )
+ AUX_SOURCE_DIRECTORY( ${lib_input_dir} lib_sources )
+ PREPARE_ROOT_DICT_HEADERS( ${lib_input_dir} )
+ INSTALL(DIRECTORY ${lib_input_dir}/ DESTINATION "include/kaldet"
+ FILES_MATCHING PATTERN "*.h" PATTERN "LinkDef.h" EXCLUDE
+ )
+ GEN_ROOT_DICT_SOURCES( ${lib_input_dir}Dict.cxx )
+ LIST( APPEND lib_sources ${ROOT_DICT_OUTPUT_SOURCES} )
+ENDFOREACH()
+
+FILE( GLOB_RECURSE ild_sources "src/ild/*.cc" )
+FILE( GLOB_RECURSE lib_headers "src/ild/*.h" )
+
+include_directories(src/ild/common)
+
+set(KalDetLib_srcs ${lib_sources} src/ild/*/*.cc )
+
+gaudi_add_library(KalDetLib ${KalDetLib_srcs}
+ PUBLIC_HEADERS kaldet
+ LINK_LIBRARIES GaudiKernel ROOT CLHEP LCIO $ENV{GEAR}/lib/libgearsurf.so KalTestLib EDM4HEP::edm4hep EDM4HEP::edm4hepDict
+)
diff --git a/Utilities/KalDet/cmake/MacroCheckPackageLibs.cmake b/Utilities/KalDet/cmake/MacroCheckPackageLibs.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..c4451b3e40839e00dcefe08680a34ef98a3dd2b6
--- /dev/null
+++ b/Utilities/KalDet/cmake/MacroCheckPackageLibs.cmake
@@ -0,0 +1,164 @@
+##############################################################################
+# macro for checkin package libraries in ${PKG_ROOT}/lib
+#
+#
+# macro usage:
+# CHECK_PACKAGE_LIBS( PACKAGE_NAME stdlib1 stdlib2 ... stdlibn )
+# only standard libraries should be passed as arguments to the macro
+# component libraries are set by cmake in PKG_FIND_COMPONENTS (when
+# calling FIND_PACKAGE with COMPONENTS argument) or through the
+# variable PKG_USE_COMPONENTS
+#
+#
+# required variables:
+# PKG_ROOT : path to PKG root directory
+#
+#
+# returns following variables:
+# PKG_LIBRARY_DIRS : list of paths to be used with LINK_DIRECTORIES
+# PGK_LIBRARIES : list of STANDARD libraries (NOT including COMPONENTS)
+# PKG_COMPONENT_LIBRARIES : list of COMPONENT libraries
+# PKG_${COMPONENT}_FOUND : set to TRUE or FALSE for each library
+# PKG_${COMPONENT}_LIBRARY : path to each individual library
+#
+#
+# PKG_LIBRARIES and PKG_LIBRARY_DIRS will be empty if any of the standard
+# libraries is missing
+#
+# @author Jan Engels, Desy
+##############################################################################
+
+
+SET( CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS TRUE )
+
+MACRO( CHECK_PACKAGE_LIBS _pkgname )
+
+ SET( _std_lib_missing FALSE )
+ SET( _ext_lib_missing FALSE )
+
+ SET( _std_libnames ${ARGN} )
+ SET( _ext_libnames ${${_pkgname}_FIND_COMPONENTS} ${${_pkgname}_USE_COMPONENTS} )
+
+ IF( _ext_libnames )
+ SEPARATE_ARGUMENTS( _ext_libnames )
+ LIST( REMOVE_DUPLICATES _ext_libnames )
+ ENDIF()
+
+ IF( NOT ${_pkgname}_FIND_QUIETLY )
+ MESSAGE( STATUS "Check for ${_pkgname}_LIBRARIES: ${_std_libnames}" )
+ IF( _ext_libnames )
+ MESSAGE( STATUS "Check for ${_pkgname}_COMPONENT_LIBRARIES: ${_ext_libnames}" )
+ ENDIF()
+ ENDIF()
+
+ SET( ${_pkgname}_LIBRARY_DIRS )
+ MARK_AS_ADVANCED( ${_pkgname}_LIBRARY_DIRS )
+
+ SET( ${_pkgname}_LIBRARIES )
+ MARK_AS_ADVANCED( ${_pkgname}_LIBRARIES )
+
+ SET( ${_pkgname}_COMPONENT_LIBRARIES )
+ MARK_AS_ADVANCED( ${_pkgname}_COMPONENT_LIBRARIES )
+
+ SET( ${_pkgname}_COMPONENT_VARIABLES )
+ MARK_AS_ADVANCED( ${_pkgname}_COMPONENT_VARIABLES )
+
+ FOREACH( _libname ${_std_libnames} ${_ext_libnames} )
+
+ # flag to check if it is a standard or a component library
+ LIST( FIND _std_libnames "${_libname}" _aux )
+ IF( ${_aux} LESS 0 )
+ SET( _is_std_lib FALSE )
+ ELSE()
+ SET( _is_std_lib TRUE )
+ ENDIF()
+
+ # libname in upper case
+ STRING( TOUPPER ${_libname} _ulibname )
+
+ SET( ${_pkgname}_${_ulibname}_LIBRARY ${_pkgname}_${_ulibname}_LIBRARY-NOTFOUND )
+ MARK_AS_ADVANCED( ${_pkgname}_${_ulibname}_LIBRARY )
+
+ # WARNING: using PATH_SUFFIXES may cause problems when using variable CMAKE_FIND_ROOT_PATH
+ # this problem does not occur if expanding PATHS
+ # look in FindMySQL.cmake for more info
+ #FIND_LIBRARY( ${_pkgname}_${_ulibname}_LIBRARY NAMES ${_libname} PATHS
+ # ${${_pkgname}_ROOT} ${${_pkgname}_DIR} ${${_pkgname}_LIB_SEARCH_PATH}
+ # PATH_SUFFIXES lib64 lib
+ # NO_DEFAULT_PATH
+ #)
+
+ FIND_LIBRARY( ${_pkgname}_${_ulibname}_LIBRARY NAMES ${_libname} PATHS
+ ${${_pkgname}_ROOT}/lib64 ${${_pkgname}_ROOT}/lib
+ ${${_pkgname}_DIR}/lib64 ${${_pkgname}_DIR}/lib
+ ${${_pkgname}_LIB_SEARCH_PATH} ${${_pkgname}_LIB_SEARCH_PATH}/lib64 ${${_pkgname}_LIB_SEARCH_PATH}/lib
+ NO_DEFAULT_PATH
+ )
+
+ IF( NOT ${_pkgname}_DIR )
+ FIND_LIBRARY( ${_pkgname}_${_ulibname}_LIBRARY NAMES ${_libname} )
+ ENDIF()
+
+ IF( ${_pkgname}_FIND_REQUIRED )
+ LIST( APPEND ${_pkgname}_COMPONENT_VARIABLES ${_pkgname}_${_ulibname}_LIBRARY )
+ ENDIF()
+
+ IF( ${_pkgname}_${_ulibname}_LIBRARY ) # if library found
+
+ SET( ${_pkgname}_${_ulibname}_FOUND TRUE )
+
+ # split libraries in PKG_LIBRARIES and PKG_COMPONENT_LIBRARIES
+ IF( _is_std_lib )
+ LIST( APPEND ${_pkgname}_LIBRARIES ${${_pkgname}_${_ulibname}_LIBRARY} )
+ ELSE()
+ LIST( APPEND ${_pkgname}_COMPONENT_LIBRARIES ${${_pkgname}_${_ulibname}_LIBRARY} )
+ ENDIF()
+
+ GET_FILENAME_COMPONENT( _aux ${${_pkgname}_${_ulibname}_LIBRARY} PATH )
+ LIST( APPEND ${_pkgname}_LIBRARY_DIRS ${_aux} )
+
+ IF( NOT ${_pkgname}_FIND_QUIETLY )
+ MESSAGE( STATUS "Check for ${_pkgname}_${_ulibname}_LIBRARY: ${${_pkgname}_${_ulibname}_LIBRARY} -- ok" )
+ ENDIF()
+
+ ELSE() # library not found
+
+ SET( ${_pkgname}_${_ulibname}_FOUND FALSE )
+
+ IF( _is_std_lib )
+ SET( _std_lib_missing TRUE )
+ ELSE()
+ SET( _ext_lib_missing TRUE )
+ ENDIF()
+
+ IF( NOT ${_pkgname}_FIND_QUIETLY )
+ MESSAGE( STATUS "Check for ${_pkgname}_${_ulibname}_LIBRARY: ${_libname} -- failed" )
+ ENDIF()
+
+ ENDIF()
+
+ ENDFOREACH()
+
+ # clear PKG_LIBRARIES if standard library is missing
+ IF( _std_lib_missing )
+ SET( ${_pkgname}_LIBRARIES )
+ ENDIF()
+
+ # clear PKG_COMPONENT_LIBRARIES if a component library is missing and
+ # FIND_PACKAGE called with REQUIRED argument
+ IF( _ext_lib_missing AND ${_pkgname}_FIND_REQUIRED )
+ SET( ${_pkgname}_COMPONENT_LIBRARIES )
+ ENDIF()
+
+ # remove duplicate paths in PKG_LIBRARY_DIRS
+ IF( ${_pkgname}_LIBRARY_DIRS )
+ LIST( REMOVE_DUPLICATES ${_pkgname}_LIBRARY_DIRS )
+ ENDIF()
+
+ # debug
+ #MESSAGE( STATUS "${_pkgname}_LIBRARIES: ${${_pkgname}_LIBRARIES}" )
+ #MESSAGE( STATUS "${_pkgname}_COMPONENT_LIBRARIES: ${${_pkgname}_COMPONENT_LIBRARIES}" )
+ #MESSAGE( STATUS "${_pkgname}_LIBRARY_DIRS: ${${_pkgname}_LIBRARY_DIRS}" )
+
+ENDMACRO( CHECK_PACKAGE_LIBS _pkgname )
+
diff --git a/Utilities/KalDet/cmake/MacroCheckPackageVersion.cmake b/Utilities/KalDet/cmake/MacroCheckPackageVersion.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..e3ec75d9faa2ee03919d01179636fb1ba843e41e
--- /dev/null
+++ b/Utilities/KalDet/cmake/MacroCheckPackageVersion.cmake
@@ -0,0 +1,108 @@
+##############################################################################
+# macro for checking a package version
+#
+# this macro should be called from your PKGVersion.cmake or from a
+# FindPKG.cmake module with the following arguments:
+# _pkgname : The package name
+# _iversion : The installed version of the package
+#
+#
+# the following conventions are used:
+#
+# if FIND_PACKAGE is called with EXACT argument than the version has to
+# match EXACTLY, i.e.:
+# 1.5 == 1.5
+# 1.5 == 1.5.0
+# 1.5 == 1.5.0.0
+# 1.5.2 == 1.5.2.0
+# 1.5.2.1 == 1.5.2.1
+# 1.5.2 != 1.5.2.1
+# 1.5 != 1.5.0.1
+#
+#
+# otherwise a MINIMUM_REQUIRED version is checked for, i.e. the same
+# behavior as with the cmake variable CMAKE_MINIMUM_REQUIRED, e.g.:
+# searching: 1.2 --> installed: 1.5.2.2 --> compatible
+# searching: 1.5 --> installed: 1.5.2.2 --> compatible
+# searching: 1.5.2.1 --> installed: 1.5.2.2 --> compatible
+# searching: 1.5.2.3 --> installed: 1.5.2.2 --> unsuitable
+# searching: 1.7 --> installed: 1.5.2.2 --> unsuitable
+#
+#
+# following variables are returned (internally to cmake):
+# PACKAGE_VERSION_EXACT : set to TRUE if exact version was found
+# PACKAGE_VERSION_COMPATIBLE : set to TRUE if version is compatible
+# PACKAGE_VERSION_UNSUITABLE : set to TRUE if version found is unsuitable
+#
+#
+# @author Jan Engels, Desy IT
+##############################################################################
+
+# these variables are evaluated internally by the cmake command FIND_PACKAGE to mark this
+# package as suitable or not depending on the required version
+SET( PACKAGE_VERSION_EXACT FALSE )
+SET( PACKAGE_VERSION_COMPATIBLE TRUE )
+SET( PACKAGE_VERSION_UNSUITABLE FALSE )
+
+
+# cmake internal variable PACKAGE_FIND_NAME is not defined on FindPKG.cmake
+# modules, therefore it is passed as an argument to the macro
+# _iversion is the installed version of the package
+# _sversion is the version searched by the user with FIND_PACKAGE
+#MACRO( CHECK_PACKAGE_VERSION _pkgname _iversion )
+MACRO( CHECK_PACKAGE_VERSION _pkgname ) # left with one argument only for backwards compatibility
+
+ IF( NOT "${ARGV1}" STREQUAL "" )
+ SET( _iversion ${ARGV1} )
+ ELSE()
+ SET( _iversion ${${_pkgname}_VERSION_MAJOR}.${${_pkgname}_VERSION_MINOR}.${${_pkgname}_VERSION_PATCH}.${${_pkgname}_VERSION_TWEAK} )
+ ENDIF()
+
+ #SET( _sversion_major ${${_pkgname}_FIND_VERSION_MAJOR} )
+ #SET( _sversion_minor ${${_pkgname}_FIND_VERSION_MINOR} )
+
+ SET( _sversion ${${_pkgname}_FIND_VERSION} )
+
+ IF( NOT ${_pkgname}_FIND_QUIETLY )
+ MESSAGE( STATUS "Check for ${_pkgname} (${_iversion})" )
+ ENDIF()
+
+ # only do work if FIND_PACKAGE called with a version argument
+ IF( _sversion )
+
+ #IF( NOT ${_pkgname}_FIND_QUIETLY )
+ # MESSAGE( STATUS "Check for ${_pkgname}: looking for version ${_sversion}" )
+ #ENDIF()
+
+ IF( ${_iversion} VERSION_EQUAL ${_sversion} ) # if version matches EXACTLY
+ #IF( NOT ${_pkgname}_FIND_QUIETLY )
+ # MESSAGE( STATUS "Check for ${_pkgname}: exact version found: ${_iversion}" )
+ #ENDIF()
+ SET( PACKAGE_VERSION_EXACT TRUE )
+ ELSE() # if version does not match EXACTLY, check if it is compatible/suitable
+
+ # installed version must be greater or equal than version searched by the user, i.e.
+ # like with the CMAKE_MINIMUM_REQUIRED commando
+ # if user asks for version 1.2.5 then any version >= 1.2.5 is suitable/compatible
+ IF( NOT ${_sversion} VERSION_LESS ${_iversion} )
+ SET( PACKAGE_VERSION_UNSUITABLE TRUE )
+ ENDIF()
+ # -------------------------------------------------------------------------------------
+
+ IF( ${_pkgname}_FIND_VERSION_EXACT ) # if exact version was required search must fail!!
+ #IF( NOT ${_pkgname}_FIND_QUIETLY )
+ # MESSAGE( "Check for ${_pkgname}: could not find exact version" )
+ #ENDIF()
+ SET( PACKAGE_VERSION_UNSUITABLE TRUE )
+ ENDIF()
+
+ ENDIF()
+
+ IF( PACKAGE_VERSION_UNSUITABLE )
+ SET( PACKAGE_VERSION_COMPATIBLE FALSE )
+ ENDIF()
+
+ ENDIF( _sversion )
+
+ENDMACRO( CHECK_PACKAGE_VERSION )
+
diff --git a/Utilities/KalDet/cmake/MacroRootDict.cmake b/Utilities/KalDet/cmake/MacroRootDict.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..eb1059ed05176adc07b3252b599872328c98b272
--- /dev/null
+++ b/Utilities/KalDet/cmake/MacroRootDict.cmake
@@ -0,0 +1,145 @@
+IF(APPLE)
+ SET( LD_LIBRARY_PATH_VAR DYLD_LIBRARY_PATH )
+ELSE()
+ SET( LD_LIBRARY_PATH_VAR LD_LIBRARY_PATH )
+ENDIF()
+SET( LD_LIBRARY_PATH_CONTENTS $ENV{${LD_LIBRARY_PATH_VAR}} )
+#MESSAGE( STATUS "LD_LIBRARY_PATH_CONTENTS: ${LD_LIBRARY_PATH_CONTENTS}" )
+#MESSAGE( STATUS "ROOT_CINT_EXECUTABLE: ${ROOT_CINT_EXECUTABLE}" )
+
+SET( ROOT_CINT_WRAPPER ${LD_LIBRARY_PATH_VAR}=${ROOT_LIBRARY_DIR}:${LD_LIBRARY_PATH_CONTENTS} ${ROOT_CINT_EXECUTABLE} )
+
+IF( NOT DEFINED ROOT_DICT_OUTPUT_DIR )
+ SET( ROOT_DICT_OUTPUT_DIR "${PROJECT_BINARY_DIR}/rootdict" )
+ENDIF()
+
+# clean generated header files with 'make clean'
+SET_DIRECTORY_PROPERTIES( PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES "${ROOT_DICT_OUTPUT_DIR}" )
+
+IF( NOT ROOT_FIND_QUIETLY )
+ MESSAGE( STATUS "Check for ROOT_DICT_OUTPUT_DIR: ${PROJECT_BINARY_DIR}/rootdict" )
+ MESSAGE( STATUS "Check for ROOT_DICT_CINT_DEFINITIONS: ${ROOT_DICT_CINT_DEFINITIONS}" )
+ENDIF()
+
+
+# ============================================================================
+# helper macro to prepare input headers for GEN_ROOT_DICT_SOURCES
+# sorts LinkDef.h to be the last header (required by rootcint)
+#
+# arguments:
+# input_dir - directory to search for headers matching *.h
+#
+# returns:
+# ROOT_DICT_INPUT_HEADERS - all header files found in input_dir with
+# LinkDef.h as the last header (if found)
+#
+# ----------------------------------------------------------------------------
+MACRO( PREPARE_ROOT_DICT_HEADERS _input_dir )
+
+ FILE( GLOB ROOT_DICT_INPUT_HEADERS "${_input_dir}/*.h" )
+ FILE( GLOB _linkdef_hdr "${_input_dir}/LinkDef.h" )
+
+ #LIST( FIND ROOT_DICT_INPUT_HEADERS ${_linkdef_hdr} _aux )
+ #IF( ${_aux} EQUAL 0 OR ${_aux} GREATER 0 )
+ # LIST( REMOVE_ITEM ROOT_DICT_INPUT_HEADERS "${_linkdef_hdr}" )
+ # LIST( APPEND ROOT_DICT_INPUT_HEADERS "${_linkdef_hdr}" )
+ #ENDIF()
+
+ IF( _linkdef_hdr )
+ LIST( REMOVE_ITEM ROOT_DICT_INPUT_HEADERS "${_linkdef_hdr}" )
+ LIST( APPEND ROOT_DICT_INPUT_HEADERS "${_linkdef_hdr}")
+ ENDIF()
+
+ #MESSAGE( STATUS "ROOT_DICT_INPUT_HEADERS: ${ROOT_DICT_INPUT_HEADERS}" )
+
+ENDMACRO( PREPARE_ROOT_DICT_HEADERS )
+
+
+
+# ============================================================================
+# helper macro to generate Linkdef.h files for rootcint
+#
+# arguments:
+# namespace - prefix used for creating header <namespace>_Linkdef.h
+# ARGN - list of sources to be used for generating Linkdef.h
+#
+# returns:
+# ROOT_DICT_INPUT_HEADERS - all header files + <namespace>_LinkDef.h in the
+# correct order to be used by macro GEN_ROOT_DICT_SOURCES
+#
+# ----------------------------------------------------------------------------
+MACRO( GEN_ROOT_DICT_LINKDEF_HEADER _namespace )
+
+ SET( _input_headers ${ARGN} )
+ SET( _linkdef_header "${ROOT_DICT_OUTPUT_DIR}/${_namespace}_Linkdef.h" )
+
+ FOREACH( _header ${_input_headers} )
+ SET( ${_namespace}_file_contents "${${_namespace}_file_contents}\\#pragma link C++ defined_in \\\"${_header}\\\"\\;\\\\n" )
+ ENDFOREACH()
+
+ ADD_CUSTOM_COMMAND(
+ OUTPUT ${_linkdef_header}
+ COMMAND mkdir -p ${ROOT_DICT_OUTPUT_DIR}
+ COMMAND printf "${${_namespace}_file_contents}" > ${_linkdef_header}
+ DEPENDS ${_input_headers}
+ COMMENT "generating: ${_linkdef_header}"
+ )
+
+ SET( ROOT_DICT_INPUT_HEADERS ${_input_headers} ${_linkdef_header} )
+
+ENDMACRO()
+
+
+# ============================================================================
+# macro for generating root dict sources with rootcint
+#
+# arguments:
+# dict_src_filename - filename of the dictionary source (to be generated)
+#
+# requires following variables:
+# ROOT_DICT_INPUT_HEADERS - list of headers needed to generate dict source
+# * if LinkDef.h is in the list it must be at the end !!
+# ROOT_DICT_INCLUDE_DIRS - list of include dirs to pass to rootcint -I..
+# ROOT_DICT_CINT_DEFINITIONS - extra definitions to pass to rootcint
+# ROOT_DICT_OUTPUT_DIR - where dictionary source should be generated
+#
+# returns:
+# ROOT_DICT_OUTPUT_SOURCES - list containing generated source and other
+# previously generated sources
+
+# ----------------------------------------------------------------------------
+MACRO( GEN_ROOT_DICT_SOURCE _dict_src_filename )
+
+ # TODO check for ROOT_CINT_EXECUTABLE
+
+ # need to prefix all include dirs with -I
+ set( _dict_includes )
+ FOREACH( _inc ${ROOT_DICT_INCLUDE_DIRS} )
+ SET( _dict_includes "${_dict_includes}\t-I${_inc}") #fg: the \t fixes a wired string expansion
+ #SET( _dict_includes ${_dict_includes} -I${_inc} )
+ ENDFOREACH()
+
+ STRING( REPLACE "/" "_" _dict_src_filename_nosc ${_dict_src_filename} )
+ SET( _dict_src_file ${ROOT_DICT_OUTPUT_DIR}/${_dict_src_filename_nosc} )
+ STRING( REGEX REPLACE "^(.*)\\.(.*)$" "\\1.h" _dict_hdr_file "${_dict_src_file}" )
+ #message("fucd debug: ${_dict_src_file} ${ROOT_DICT_CINT_DEFINITIONS} ${_dict_includes} ${ROOT_DICT_INPUT_HEADERS}")
+ ADD_CUSTOM_COMMAND(
+ OUTPUT ${_dict_src_file} ${_dict_hdr_file}
+ COMMAND mkdir -p ${ROOT_DICT_OUTPUT_DIR}
+ COMMAND ${ROOT_CINT_WRAPPER} -f "${_dict_src_file}" -c ${ROOT_DICT_CINT_DEFINITIONS} ${_dict_includes} ${ROOT_DICT_INPUT_HEADERS}
+ WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+ DEPENDS ${ROOT_DICT_INPUT_HEADERS}
+ COMMENT "generating: ${_dict_src_file} ${_dict_hdr_file}"
+ )
+ LIST( APPEND ROOT_DICT_OUTPUT_SOURCES ${_dict_src_file} )
+
+ENDMACRO()
+
+# for backwards compatibility
+MACRO( GEN_ROOT_DICT_SOURCES _dict_src_filename )
+ #MESSAGE( "USING DEPRECATED GEN_ROOT_DICT_SOURCES. PLEASE USE GEN_ROOT_DICT_SOURCE instead." )
+ SET( ROOT_DICT_OUTPUT_SOURCES )
+ GEN_ROOT_DICT_SOURCE( ${_dict_src_filename} )
+ENDMACRO()
+# ============================================================================
+
diff --git a/Utilities/KalDet/cmake/MyFindROOT.cmake b/Utilities/KalDet/cmake/MyFindROOT.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..567ce159fc7b846f509fd6c968be7e292a0e98f9
--- /dev/null
+++ b/Utilities/KalDet/cmake/MyFindROOT.cmake
@@ -0,0 +1,316 @@
+###############################################################################
+# cmake module for finding ROOT
+#
+# requires:
+# MacroCheckPackageLibs.cmake for checking package libraries
+#
+# Following cmake variables are returned by this module:
+#
+# ROOT_FOUND : set to TRUE if ROOT found
+# If FIND_PACKAGE is called with REQUIRED and COMPONENTS arguments
+# ROOT_FOUND is only set to TRUE if ALL components are found.
+# If REQUIRED is NOT set components may or may not be available
+#
+# ROOT_LIBRARIES : list of ROOT libraries (NOT including COMPONENTS)
+# ROOT_INCLUDE_DIRS : list of paths to be used with INCLUDE_DIRECTORIES
+# ROOT_LIBRARY_DIRS : list of paths to be used with LINK_DIRECTORIES
+# ROOT_COMPONENT_LIBRARIES : list of ROOT component libraries
+# ROOT_${COMPONENT}_FOUND : set to TRUE or FALSE for each library
+# ROOT_${COMPONENT}_LIBRARY : path to individual libraries
+#
+#
+# Please note that by convention components should be entered exactly as
+# the library names, i.e. the component name equivalent to the library
+# $ROOTSYS/lib/libMathMore.so should be called MathMore and NOT:
+# mathmore or Mathmore or MATHMORE
+#
+# However to follow the usual cmake convention it is agreed that the
+# ROOT_${COMPONENT}_FOUND and ROOT_${COMPONENT}_LIBRARY variables are ALL
+# uppercase, i.e. the MathMore component returns: ROOT_MATHMORE_FOUND and
+# ROOT_MATHMORE_LIBRARY NOT ROOT_MathMore_FOUND or ROOT_MathMore_LIBRARY
+#
+#
+# The additional ROOT components should be defined as follows:
+# FIND_PACKAGE( ROOT COMPONENTS MathMore Gdml Geom ...)
+#
+# If components are required use:
+# FIND_PACKAGE( ROOT REQUIRED COMPONENTS MathMore Gdml Geom ...)
+#
+# If only root is required and components are NOT required use:
+# FIND_PACKAGE( ROOT REQUIRED )
+# FIND_PACKAGE( ROOT COMPONENTS MathMore Gdml Geom ... QUIET )
+# then you need to check for ROOT_MATHMORE_FOUND, ROOT_GDML_FOUND, etc.
+#
+# The variable ROOT_USE_COMPONENTS can also be used before calling
+# FIND_PACKAGE, i.e.:
+# SET( ROOT_USE_COMPONENTS MathMore Gdml Geom )
+# FIND_PACKAGE( ROOT REQUIRED ) # all ROOT_USE_COMPONENTS must also be found
+# FIND_PACKAGE( ROOT ) # check for ROOT_FOUND, ROOT_MATHMORE_FOUND, etc.
+#
+# @author Jan Engels, DESY
+###############################################################################
+
+# ==============================================
+# === ROOT_CONFIG_EXECUTABLE ===
+# ==============================================
+
+SET( ROOT_CONFIG_EXECUTABLE ROOT_CONFIG_EXECUTABLE-NOTFOUND )
+MARK_AS_ADVANCED( ROOT_CONFIG_EXECUTABLE )
+# FIND_PROGRAM: Once one of the calls succeeds the result variable will be set and stored in the cache so that no call will search again.
+FIND_PROGRAM( ROOT_CONFIG_EXECUTABLE root-config PATHS ${ROOT_DIR}/bin NO_DEFAULT_PATH )
+FIND_PROGRAM( ROOT_CONFIG_EXECUTABLE root-config PATHS $ENV{ROOTSYS}/bin NO_DEFAULT_PATH)
+FIND_PROGRAM( ROOT_CONFIG_EXECUTABLE root-config PATHS ENV PATH )
+FIND_PROGRAM( ROOT_CONFIG_EXECUTABLE root-config )
+
+IF( NOT ROOT_FIND_QUIETLY )
+ MESSAGE( STATUS "Check for ROOT_CONFIG_EXECUTABLE: ${ROOT_CONFIG_EXECUTABLE}" )
+ENDIF()
+
+IF( ROOT_CONFIG_EXECUTABLE )
+
+
+ # ==============================================
+ # === ROOT_VERSION ===
+ # ==============================================
+
+ INCLUDE( MacroCheckPackageVersion )
+
+ EXECUTE_PROCESS( COMMAND "${ROOT_CONFIG_EXECUTABLE}" --version
+ OUTPUT_VARIABLE _version
+ RESULT_VARIABLE _exit_code
+ OUTPUT_STRIP_TRAILING_WHITESPACE
+ )
+ IF( _exit_code EQUAL 0 )
+
+ # set required variables for MacroCheckPackageVersion
+ STRING(REGEX REPLACE "^([0-9]+).*" "\\1" ROOT_VERSION_MAJOR "${_version}")
+ STRING(REGEX REPLACE "^[0-9]+.([0-9]+).*" "\\1" ROOT_VERSION_MINOR "${_version}")
+ STRING(REGEX REPLACE "^[0-9]+.[0-9]+.([0-9]+).*" "\\1" ROOT_VERSION_PATCH "${_version}")
+
+ SET( ROOT_VERSION "${ROOT_VERSION_MAJOR}.${ROOT_VERSION_MINOR}.${ROOT_VERSION_PATCH}" )
+ ENDIF()
+
+ CHECK_PACKAGE_VERSION( ROOT ${ROOT_VERSION} )
+
+
+
+ # ==============================================
+ # === ROOT_PREFIX ===
+ # ==============================================
+
+ # get root prefix from root-config output
+ EXECUTE_PROCESS( COMMAND "${ROOT_CONFIG_EXECUTABLE}" --prefix
+ OUTPUT_VARIABLE ROOT_PREFIX
+ RESULT_VARIABLE _exit_code
+ OUTPUT_STRIP_TRAILING_WHITESPACE
+ )
+ IF( NOT _exit_code EQUAL 0 )
+ # clear variable if root-config exits with error
+ # it might contain garbage
+ SET( ROOT_PREFIX )
+ ENDIF()
+
+ # PKG_ROOT variables are a cmake standard
+ # since this package is also called ROOT the variable name
+ # becomes ROOT_ROOT ...
+ SET( ROOT_ROOT ${ROOT_PREFIX} )
+
+
+
+ # ==============================================
+ # === ROOT_BIN_DIR ===
+ # ==============================================
+
+ # get bindir from root-config output
+ EXECUTE_PROCESS( COMMAND "${ROOT_CONFIG_EXECUTABLE}" --bindir
+ OUTPUT_VARIABLE ROOT_BIN_DIR
+ RESULT_VARIABLE _exit_code
+ OUTPUT_STRIP_TRAILING_WHITESPACE
+ )
+ IF( NOT _exit_code EQUAL 0 )
+ # clear variable if root-config exits with error
+ # it might contain garbage
+ SET( ROOT_BIN_DIR )
+ ENDIF()
+
+
+
+ # ==============================================
+ # === ROOT_EXECUTABLE ===
+ # ==============================================
+
+
+ SET( ROOT_EXECUTABLE ROOT_EXECUTABLE-NOTFOUND )
+ MARK_AS_ADVANCED( ROOT_EXECUTABLE )
+ FIND_PROGRAM( ROOT_EXECUTABLE root PATHS ${ROOT_BIN_DIR} NO_DEFAULT_PATH )
+
+ IF( NOT ROOT_FIND_QUIETLY )
+ MESSAGE( STATUS "Check for ROOT_EXECUTABLE: ${ROOT_EXECUTABLE}" )
+ ENDIF()
+
+
+
+
+ # ==============================================
+ # === ROOT_CINT_EXECUTABLE ===
+ # ==============================================
+
+
+ # find rootcint
+ SET( ROOT_CINT_EXECUTABLE ROOT_CINT_EXECUTABLE-NOTFOUND )
+ MARK_AS_ADVANCED( ROOT_CINT_EXECUTABLE )
+ FIND_PROGRAM( ROOT_CINT_EXECUTABLE rootcint PATHS ${ROOT_BIN_DIR} NO_DEFAULT_PATH )
+
+ IF( NOT ROOT_FIND_QUIETLY )
+ MESSAGE( STATUS "Check for ROOT_CINT_EXECUTABLE: ${ROOT_CINT_EXECUTABLE}" )
+ ENDIF()
+
+
+
+ # ==============================================
+ # === ROOT_INCLUDE_DIR ===
+ # ==============================================
+
+ # get include dir from root-config output
+ EXECUTE_PROCESS( COMMAND "${ROOT_CONFIG_EXECUTABLE}" --incdir
+ OUTPUT_VARIABLE _inc_dir
+ RESULT_VARIABLE _exit_code
+ OUTPUT_STRIP_TRAILING_WHITESPACE
+ )
+ IF( NOT _exit_code EQUAL 0 )
+ # clear variable if root-config exits with error
+ # it might contain garbage
+ SET( _inc_dir )
+ ENDIF()
+
+
+ SET( ROOT_INCLUDE_DIRS ROOT_INCLUDE_DIRS-NOTFOUND )
+ MARK_AS_ADVANCED( ROOT_INCLUDE_DIRS )
+
+ FIND_PATH( ROOT_INCLUDE_DIRS
+ NAMES TH1.h
+ PATHS ${ROOT_DIR}/include ${_inc_dir}
+ NO_DEFAULT_PATH
+ )
+
+
+
+ # ==============================================
+ # === ROOT_LIBRARIES ===
+ # ==============================================
+
+ # get library dir from root-config output
+ EXECUTE_PROCESS( COMMAND "${ROOT_CONFIG_EXECUTABLE}" --libdir
+ OUTPUT_VARIABLE ROOT_LIBRARY_DIR
+ RESULT_VARIABLE _exit_code
+ OUTPUT_STRIP_TRAILING_WHITESPACE
+ )
+ IF( NOT _exit_code EQUAL 0 )
+ # clear variable if root-config exits with error
+ # it might contain garbage
+ SET( ROOT_LIBRARY_DIR )
+ ENDIF()
+
+
+
+ # ========== standard root libraries =================
+
+ # standard root libraries (without components)
+ SET( _root_libnames )
+
+ # get standard root libraries from 'root-config --libs' output
+ EXECUTE_PROCESS( COMMAND "${ROOT_CONFIG_EXECUTABLE}" --noauxlibs --libs
+ OUTPUT_VARIABLE _aux
+ RESULT_VARIABLE _exit_code
+ OUTPUT_STRIP_TRAILING_WHITESPACE
+ )
+ IF( _exit_code EQUAL 0 )
+
+ # create a list out of the output
+ SEPARATE_ARGUMENTS( _aux )
+
+ # remove first item -L compiler flag
+ LIST( REMOVE_AT _aux 0 )
+
+ FOREACH( _lib ${_aux} )
+
+ # extract libnames from -l compiler flags
+ STRING( REGEX REPLACE "^-.(.*)$" "\\1" _libname "${_lib}")
+
+ # fix for some root-config versions which export -lz even if using --noauxlibs
+ IF( NOT _libname STREQUAL "z" )
+
+ # append all library names into a list
+ LIST( APPEND _root_libnames ${_libname} )
+
+ ENDIF()
+
+ ENDFOREACH()
+
+ ENDIF()
+
+
+
+ # ========== additional root components =================
+
+ #LIST( APPEND ROOT_FIND_COMPONENTS Minuit2 ) # DEPRECATED !!!
+
+
+ # ---------- libraries --------------------------------------------------------
+ INCLUDE( MacroCheckPackageLibs )
+
+ SET( ROOT_LIB_SEARCH_PATH ${ROOT_LIBRARY_DIR} )
+
+ # only standard libraries should be passed as arguments to CHECK_PACKAGE_LIBS
+ # additional components are set by cmake in variable PKG_FIND_COMPONENTS
+ # first argument should be the package name
+ CHECK_PACKAGE_LIBS( ROOT ${_root_libnames} )
+
+
+
+
+ # ====== DL LIBRARY ==================================================
+ # workaround for cmake bug in 64 bit:
+ # see: http://public.kitware.com/mantis/view.php?id=10813
+ IF( CMAKE_SIZEOF_VOID_P EQUAL 8 )
+ FIND_LIBRARY( DL_LIB NAMES ${CMAKE_DL_LIBS} dl PATHS /usr/lib64 /lib64 NO_DEFAULT_PATH )
+ ENDIF( CMAKE_SIZEOF_VOID_P EQUAL 8 )
+
+ FIND_LIBRARY( DL_LIB NAMES ${CMAKE_DL_LIBS} dl )
+ MARK_AS_ADVANCED( DL_LIB )
+
+ IF( NOT ROOT_FIND_QUIETLY )
+ MESSAGE( STATUS "Check for libdl.so: ${DL_LIB}" )
+ ENDIF()
+
+ENDIF( ROOT_CONFIG_EXECUTABLE )
+
+# Threads library
+#FIND_PACKAGE( Threads REQUIRED)
+
+
+# ---------- final checking ---------------------------------------------------
+INCLUDE( FindPackageHandleStandardArgs )
+# set ROOT_FOUND to TRUE if all listed variables are TRUE and not empty
+# ROOT_COMPONENT_VARIABLES will be set if FIND_PACKAGE is called with REQUIRED argument
+FIND_PACKAGE_HANDLE_STANDARD_ARGS( ROOT DEFAULT_MSG ROOT_INCLUDE_DIRS ROOT_LIBRARIES ${ROOT_COMPONENT_VARIABLES} PACKAGE_VERSION_COMPATIBLE DL_LIB )
+
+IF( ROOT_FOUND )
+ LIST( APPEND ROOT_LIBRARIES ${DL_LIB} )
+ # FIXME DEPRECATED
+ SET( ROOT_DEFINITIONS "-DUSEROOT -DUSE_ROOT -DMARLIN_USE_ROOT" )
+ MARK_AS_ADVANCED( ROOT_DEFINITIONS )
+
+ # file including MACROS for generating root dictionary sources
+ GET_FILENAME_COMPONENT( _aux ${CMAKE_CURRENT_LIST_FILE} PATH )
+ SET( ROOT_DICT_MACROS_FILE ${_aux}/MacroRootDict.cmake )
+
+ENDIF( ROOT_FOUND )
+
+# ---------- cmake bug --------------------------------------------------------
+# ROOT_FIND_REQUIRED is not reset between FIND_PACKAGE calls, i.e. the following
+# code fails when geartgeo component not available: (fixed in cmake 2.8)
+# FIND_PACKAGE( ROOT REQUIRED )
+# FIND_PACKAGE( ROOT COMPONENTS geartgeo QUIET )
+SET( ROOT_FIND_REQUIRED )
+
diff --git a/Utilities/KalDet/kaldet/EXEventGen.h b/Utilities/KalDet/kaldet/EXEventGen.h
new file mode 100644
index 0000000000000000000000000000000000000000..bea7bee87b844e42a2a1d2ef97e6f1c4d0d1cb64
--- /dev/null
+++ b/Utilities/KalDet/kaldet/EXEventGen.h
@@ -0,0 +1,33 @@
+#ifndef __EXEVENTGEN__
+#define __EXEVENTGEN__
+
+#include "TKalDetCradle.h"
+#include "THelicalTrack.h"
+#include "TMath.h"
+
+class EXEventGen {
+public:
+ EXEventGen(TKalDetCradle const &cradle, TObjArray &kalhits)
+ : fCradlePtr(&cradle), fHitBufPtr(&kalhits) {}
+ virtual ~EXEventGen() {}
+
+ THelicalTrack GenerateHelix(Double_t pt,
+ Double_t cosmin,
+ Double_t cosmax,
+ Double_t phimin=0.,
+ Double_t phimax=2*TMath::Pi(),
+ TVector3 xv0=TVector3(0.,0.,0.));
+ void Swim(THelicalTrack &heltrk);
+
+ static void SetT0(Double_t t0) { fgT0 = t0; }
+ static Double_t GetT0() { return fgT0; }
+
+private:
+ TKalDetCradle const *fCradlePtr; // pointer to detector system
+ TObjArray *fHitBufPtr; // pointer to hit array
+
+ static Double_t fgT0; // t0
+
+};
+
+#endif
diff --git a/Utilities/KalDet/kaldet/EXTPCHit.h b/Utilities/KalDet/kaldet/EXTPCHit.h
new file mode 100644
index 0000000000000000000000000000000000000000..8d604c36f5b3120156e030626f293e312aa3dac6
--- /dev/null
+++ b/Utilities/KalDet/kaldet/EXTPCHit.h
@@ -0,0 +1,54 @@
+#ifndef LCTPC_EXTPCHIT_H
+#define LCTPC_EXTPCHIT_H
+
+#include "GearTPCCylinderHit.h"
+#include <kaltest/TVMeasLayer.h>
+
+/**
+ * A backward compatibility class for GearTPCCylinderHit.
+ * Do not use this in new code, but use GearTPCCylinderHit directly.
+ * This class extends the GearTPCCylinderHit by a side, which is never used anywhere.
+ *
+ * \deprecated EXTPCHit
+ */
+
+class EXTPCHit : public kaldet::GearTPCCylinderHit
+{
+ public:
+ /// The default constructor.
+ EXTPCHit(Int_t m = kMdim);
+
+ /// Constructor initialising the original hit as 3D coordinates.
+ EXTPCHit(const TVMeasLayer &ms,
+ Double_t *x,
+ Double_t *dx,
+ Int_t side,
+ Double_t v,
+ const TVector3 &xx,
+ Double_t b,
+ Int_t m = kMdim);
+
+ /// Constructor initialising the original hit with a reference pointer.
+ EXTPCHit(const TVMeasLayer &ms,
+ Double_t *x,
+ Double_t *dx,
+ Int_t side,
+ Double_t v,
+ const void *hitp,
+ Double_t b,
+ Int_t m = kMdim);
+
+ /// The destructor.
+ virtual ~EXTPCHit();
+
+ /// Get the side value which has been set in the constructor.
+ inline Int_t GetSide () const { return fSide; }
+
+ private:
+ Int_t fSide; /// (-1, +1) = (-z side, +z side)
+
+ // ClassDef(EXTPCHit, 1) // EXTPC hit class
+
+};
+
+#endif // LCTPC_EXTPCHIT_H
diff --git a/Utilities/KalDet/kaldet/EXTPCKalDetector.h b/Utilities/KalDet/kaldet/EXTPCKalDetector.h
new file mode 100644
index 0000000000000000000000000000000000000000..96025f38d7ac92b6ac795935ca71b793a2b25799
--- /dev/null
+++ b/Utilities/KalDet/kaldet/EXTPCKalDetector.h
@@ -0,0 +1,45 @@
+#ifndef LCTPC_EXTPCKALDETECTOR_H
+#define LCTPC_EXTPCKALDETECTOR_H
+
+#include "GearTPCKalDetector.h"
+
+/**
+ * A backward compatibility class for GearTPCKalDetector.
+ * It basically provides a static instance of the detector which can be
+ * accessed via the GetInstance() method.
+ * In addition it provides the static GetVDrift() and GetBField(), which are used
+ * in the old code. The use of this class is highly depreciated.
+ *
+ * \deprecated EXTPCKalDetector
+ */
+
+class EXTPCKalDetector: public kaldet::GearTPCKalDetector
+{
+ private:
+ /// As this this a singleton class the constructor is private.
+ EXTPCKalDetector(const gear::GearMgr& gearMgr);
+
+public:
+ /// The destructor.
+ virtual ~EXTPCKalDetector();
+
+ /// Static access function to the singleton instance.
+ static EXTPCKalDetector * GetInstance();
+
+ /// Returns the hard coded drift velocity of 76.e-3 mm/ns.
+ static Double_t GetVdrift() { return fgVdrift; }
+
+ /// Static function to access the magnetic field.
+ static Double_t GetBfield();
+
+ private:
+ static Double_t fgVdrift; //< The drift velocity.
+ static EXTPCKalDetector * fgInstance; //< The singleton pointer.
+
+ Double_t fBField; //< The magnetic field
+
+ // ClassDef(EXTPCKalDetector, 1) // User defined detector class
+
+};
+
+#endif // LCTPC_EXTPCKALDETECTOR_H
diff --git a/Utilities/KalDet/kaldet/EXTPCMeasLayer.h b/Utilities/KalDet/kaldet/EXTPCMeasLayer.h
new file mode 100644
index 0000000000000000000000000000000000000000..3557ae56f0f3b46757fc53446cb2707d918b327d
--- /dev/null
+++ b/Utilities/KalDet/kaldet/EXTPCMeasLayer.h
@@ -0,0 +1,83 @@
+#ifndef LCTPC_EXTPCMEASLAYER_H
+#define LCTPC_EXTPCMEASLAYER_H
+
+#include "GearTPCMeasLayer.h"
+#include <kaltest/TCylinder.h>
+
+/**
+ * A backward compatibility class for GearTPCCylinderMeasLayer.
+ * It introduces one module and one row, which are associated to the layer.
+ * This is deprecated, the GearTPCCylinderMeasLayer provides an assiciation of several
+ * module-row pairs to the layer.
+
+ * This class is an intermediate inheritance class so a GearTPCCylinderMeasLayer can be
+ * instantiated (as should be in the current code) and the old code can cast the
+ * TObject pointer, which is delivered by the detector cradle, to an EXTPCMeasLayer.
+ *
+ * \attention Do not use any of these function in new code. All new code should still run
+ * after this class has been removed from the ineritance chain.
+ *
+ * \deprecated EXTPCMeasLayer
+ */
+class EXTPCMeasLayer : public kaldet::GearTPCMeasLayer, public TCylinder
+{
+
+public:
+ /// Minimal constructor for this (partially) virtual class.
+ EXTPCMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ Int_t module,
+ Int_t row,
+ Double_t r0,
+ Double_t lhalf,
+ TVector3 xc,
+ Bool_t isPerfect,
+ Bool_t isActive,
+ Double_t sigmaX0 = 0., //< the constant part of sigmaX
+ Double_t sigmaX1 = 0., //< the z-dependent part of sigmaX
+ Double_t sigmaZ0 = 0., //< the constant part of sigmaZ
+ Double_t sigmaZ1 = 0.); //< the z-dependent part of sigmaZ
+
+ /// The destructor.
+ virtual ~EXTPCMeasLayer();
+
+ /**
+ * Get the module associated with this layer (deprecated).
+ * \attention Do not programme against this when using the GearTPC interface.
+ * This is for backward compatibility only!!!
+ */
+ Int_t GetModuleID() const;
+
+ /**
+ * Get the layer ID (i.\ e.\ row in the module) associated with this Kalman layer (deprecated).
+ *
+ * \attention Do not programme against this when using the GearTPC interface.
+ * This is for backward compatibility only!!!
+ */
+ Int_t GetLayerID () const;
+
+ /** Deprecated XvToMv which in addition to the position takes a side.
+ * Side is ignored and XvToMv without the side is called.
+ * \attention Do not programme against this when using the GearTPC interface.
+ * This is for backward compatibility only!!!
+ */
+ TKalMatrix XvToMv(const TVector3 &xv, Int_t side) const;
+
+ /** The fully virtual declaration of XvToMv. It is called within the version which also takes
+ * the side argument, but is implemented in GearTPCCylinderMeasLayer.
+ */
+ virtual TKalMatrix XvToMv(const TVector3 &xv) const = 0;
+
+ /** Smear the incoming hit in the layes measurement surface and place the result into the TObjArray
+ * which is given as argument.
+ * From a design point of view this function should not be in the detector class but in a
+ * simulation extension. It is only put in for compatibility reasons.
+ * \attention Do not programme against this when using the GearTPC interface.
+ * This is for backward compatibility only!!!
+ */
+ virtual void ProcessHit(const TVector3 &xx, TObjArray &hits) const;
+
+ //ClassDef(EXTPCMeasLayer, 1) // User defined measurement layer class
+};
+
+#endif // LCTPC_EXTPCMEASLAYER_H
diff --git a/Utilities/KalDet/kaldet/EXVKalDetector.h b/Utilities/KalDet/kaldet/EXVKalDetector.h
new file mode 100644
index 0000000000000000000000000000000000000000..bb1e09cb113920577879dfa220d8017b8f5941ce
--- /dev/null
+++ b/Utilities/KalDet/kaldet/EXVKalDetector.h
@@ -0,0 +1,67 @@
+#ifndef EXVKALDETECTOR_H
+#define EXVKALDETECTOR_H
+//*************************************************************************
+//* ======================
+//* EXVKalDetector Class
+//* ======================
+//*
+//* (Description)
+//* Abstract detector class for Kalman filter
+//* (Requires)
+//* TVKalDetector
+//* (Provides)
+//* class EXVKalDetector
+//* (Update Recored)
+//* 2009/11/23 K.Ikematsu Derived from KalTest/examples/kaltest/
+//* hybrid/kern/EXVKalDetector.h
+//*
+//* $Id: EXVKalDetector.h,v 1.1.1.1 2009-11-24 00:13:59 ikematsu Exp $
+//*************************************************************************
+//
+#include <TVector3.h>
+#include <kaltest/TVKalDetector.h>
+#include <kaltest/TAttDrawable.h>
+
+class TNode;
+
+/**
+ * Base class to make a detector drawable, add a magnetic field,
+ * a power switch (whatever the use may be).
+ *
+ * Killenb: I removed the TAttDrawable for the moment. The TNode pointer
+ * stuff and the implementation of Draw belong to the TAttDrawable anyway. So if
+ * the drawability is needed move it to TAttDrawable and just inherit from it.
+ *
+ * \deprecated EXVKalDetector
+ */
+class EXVKalDetector : public TVKalDetector, public TAttDrawable {
+ //class EXVKalDetector : public TVKalDetector {
+public:
+ EXVKalDetector(Double_t bField, Int_t m = 100);
+ virtual ~EXVKalDetector();
+
+ /// Return whether the power is on. Currently hard coded to true.
+ inline virtual Bool_t IsPowerOn() const { return true; }
+
+ /// Turn the power on. Currently ignored.
+ inline virtual void PowerOn () { fIsPowerOn = kTRUE; }
+
+ /// Turn the power off. Currently ignored.
+ inline virtual void PowerOff () { fIsPowerOn = kFALSE; }
+
+ /// Returns a single double value with a 3D point as an input.
+ /// Completely unphysical interface. Either the magnetic field varies with the position,
+ /// in which case you need a three-dimensional return value, or B can be desrcibed as single
+ /// value, which means it is homogeneous and thus indepenent from the position.
+ /// Currently it does the only reasonable thing: It ignores the argument and returns the
+ /// constant value given in the constructor.
+ virtual Double_t GetBfield (const TVector3 &xx = TVector3(0.,0.,0.)) const
+ { return fBfield; }
+
+protected:
+ Bool_t fIsPowerOn; // power status
+ Double_t fBfield; // magnetic field [T]
+
+ ClassDef(EXVKalDetector, 1) // Abstract measurement layer class
+};
+#endif
diff --git a/Utilities/KalDet/kaldet/EXVMeasLayer.h b/Utilities/KalDet/kaldet/EXVMeasLayer.h
new file mode 100644
index 0000000000000000000000000000000000000000..db456868c0886921699599834ace276b7d54d426
--- /dev/null
+++ b/Utilities/KalDet/kaldet/EXVMeasLayer.h
@@ -0,0 +1,60 @@
+#ifndef EXVMEASLAYER_H
+#define EXVMEASLAYER_H
+//*************************************************************************
+//* ====================
+//* EXVMeasLayer Class
+//* ====================
+//*
+//* (Description)
+//* Abstract measurement layer class used by TVTrackHit
+//* (Requires)
+//* TVMeasLayer
+//* (Provides)
+//* class EXVMeasLayer
+//* (Update Recored)
+//* 2009/11/23 K.Ikematsu Derived from KalTest/examples/kaltest/
+//* hybrid/kern/EXVMeasLayer.h
+//*
+//* $Id: EXVMeasLayer.h,v 1.1.1.1 2009-11-24 00:13:59 ikematsu Exp $
+//*************************************************************************
+//
+#include <TVector3.h>
+#include <kaltest/TKalMatrix.h>
+#include <kaltest/TCylinder.h>
+#include <kaltest/TVMeasLayer.h>
+#include <kaltest/TAttDrawable.h>
+#include <kaltest/KalTrackDim.h>
+#include <TString.h>
+
+class TVTrackHit;
+#include <TNode.h>
+
+class EXVMeasLayer : public TVMeasLayer, public TAttDrawable {
+
+public:
+ static Bool_t kActive;
+ static Bool_t kDummy;
+
+ // Ctors and Dtor
+
+ EXVMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ Bool_t type = EXVMeasLayer::kActive,
+ const Char_t *name = "MeasL");
+ virtual ~EXVMeasLayer();
+
+ virtual void ProcessHit(const TVector3 &xx,
+ TObjArray &hits) const = 0;
+
+ inline TString GetMLName () const { return fName; }
+ inline TNode *GetNodePtr() const { return fNodePtr; }
+
+ inline void SetNodePtr(TNode *nodep) { fNodePtr = nodep; }
+
+private:
+ TString fName; // layer name
+ TNode *fNodePtr; // node pointer
+
+ ClassDef(EXVMeasLayer, 1) // Abstract measurement layer class
+};
+#endif
diff --git a/Utilities/KalDet/kaldet/GearTPCCylinderHit.h b/Utilities/KalDet/kaldet/GearTPCCylinderHit.h
new file mode 100644
index 0000000000000000000000000000000000000000..109a122019392d6a863696d97f761a2c5e1b1c7b
--- /dev/null
+++ b/Utilities/KalDet/kaldet/GearTPCCylinderHit.h
@@ -0,0 +1,55 @@
+#ifndef GEARTPCCYLINDERHIT_H
+#define GEARTPCCYLINDERHIT_H
+
+#include <KalTrackDim.h>
+#include "GearTPCHit.h"
+#include <TVMeasLayer.h>
+
+namespace kaldet{
+
+/** The cylindrical implementation of the GearTPCHit.
+ */
+class GearTPCCylinderHit : public GearTPCHit {
+
+public:
+ /// KILLENB What does this constructor do? Best throw it out, it does not
+ /// properly initialise the class at all, does it?
+ GearTPCCylinderHit(Int_t m = kMdim);
+
+ /** Constructor to initialise the GearTPCHit using space point coordinates (TVector3) as original hit.
+ */
+ GearTPCCylinderHit(const TVMeasLayer &ms,
+ Double_t *x,
+ Double_t *dx,
+ const TVector3 &xx,
+ Double_t b,
+ Double_t v,
+ Int_t m = kMdim);
+
+ /** Constructor using a pointer to the original hit as reference.
+ */
+ GearTPCCylinderHit(const TVMeasLayer &ms,
+ Double_t *x,
+ Double_t *dx,
+ const void *hitp,
+ Double_t b,
+ Double_t v,
+ Int_t m = kMdim);
+
+ /** The dectructor.
+ */
+ virtual ~GearTPCCylinderHit();
+
+ /** Implementation of the space vector (xv) to measurement vector (mv) calculation
+ * for a cylindrical hit.
+ */
+ virtual TKalMatrix XvToMv(const TVector3 &xv, Double_t t0) const;
+
+ /** Print some debug output to std err.
+ */
+ virtual void DebugPrint(Option_t *opt = "") const;
+};
+
+}//namespace kaldet
+
+#endif //GEARTPCCYLINDERHIT_H
diff --git a/Utilities/KalDet/kaldet/GearTPCCylinderMeasLayer.h b/Utilities/KalDet/kaldet/GearTPCCylinderMeasLayer.h
new file mode 100644
index 0000000000000000000000000000000000000000..90f7386bbf2bc9e4d9fc5a713f64edc58d9b8a4e
--- /dev/null
+++ b/Utilities/KalDet/kaldet/GearTPCCylinderMeasLayer.h
@@ -0,0 +1,131 @@
+#ifndef GEARTPCCYLINDERMEASLAYER_H
+#define GEARTPCCYLINDERMEASLAYER_H
+#include <TVector3.h>
+#include <TKalMatrix.h>
+#include <TCylinder.h>
+#include <EXTPCMeasLayer.h>
+//#include <KalTrackDim.h>
+
+#include <TMath.h>
+
+#include <set>
+
+class TVTrackHit;
+
+namespace kaldet
+{
+
+ /**
+ * A cylindrical measurement layer.
+ */
+ class GearTPCCylinderMeasLayer
+ : public EXTPCMeasLayer
+ /* this is the original code which should be reactivated once the EXTPCMeasLayer is phased out:
+ : public GearTPCMeasLayer, public TCylinder
+ */
+ {
+
+ public:
+ /** The constructor.
+ * If the layer is perfect it is always a full circle. The constructor forces
+ * phiMin and phiMax to +-TMath::Pi(). Differing values will be ignored and a warning is
+ * printed.
+ *
+ * Note: The current implementation forces the layer to be perfect. Segmented layers are
+ * not supported yet.
+ *
+ * Note: for backward compatibility this is derrived from EXTPCMeasLayer.
+ * After the change to the GearTPC interface this should be changed to GearTPCMeasLayer and
+ * TCylinder, as EXTPCMeasLayer is inherrited now.
+ * The current version ensures compatibility for the transition phase.
+ */
+ GearTPCCylinderMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ Int_t module,
+ Int_t row,
+ Double_t r0,
+ Double_t lhalf,
+ TVector3 xc = TVector3(),
+ Bool_t isPerfect = true,
+ Bool_t isActive = true,
+ Double_t sigmaX0 = 0.,
+ Double_t sigmaX1 = 0.,
+ Double_t sigmaZ0 = 0.,
+ Double_t sigmaZ1 = 0.,
+ Double_t phiMin = -TMath::Pi(),
+ Double_t phiMax = TMath::Pi());
+
+ /**
+ * The desctructor.
+ */
+ virtual ~GearTPCCylinderMeasLayer();
+
+ // Parent's pure virtuals that must be implemented
+
+ /** Implements kaltest::TVMeasLayer's XvToMv. I have no idea why there are two arguments.
+ * It ignores ht and just calls XvToMv(xv).
+ */
+ virtual TKalMatrix XvToMv (const TVTrackHit &ht,
+ const TVector3 &xv) const;
+
+ /** Implements the coordinate transformation from the space vector xv to the
+ * measurement vector (Kalman matrix).
+ */
+ virtual TKalMatrix XvToMv (const TVector3 &xv) const;
+
+ /** Implements the conversion from a Kalman hit (measurement vector) to
+ * a 3D space point.
+ */
+ virtual TVector3 HitToXv (const TVTrackHit &ht) const;
+
+ /**
+ * Implements CalcDhDa, whatever that is.
+ */
+ virtual void CalcDhDa (const TVTrackHit &ht,
+ const TVector3 &xv,
+ const TKalMatrix &dxphiada,
+ TKalMatrix &H) const;
+ /** Implements the sorting policy.
+ * The layers are first sorted by radius + offset. This offset is only
+ * useful for segments of a cylinder, like the LP1.
+ * As offsets in this case can be positive or negative, but only make sense in one
+ * direction (you need a continuous number), we only allow offsets in x.
+ * This should not be too much of a problem, you should be able to rotate your coordinates
+ * so the offset is in x. If not you have to extend the sorting policy. (Please thake
+ * care not to reduce versatility when doing so. You might want to implement your own class?)
+ *
+ * For equal radii + offset the layers are sorted by moduleID. As we have to squeeze this
+ * information into only one number, we multiply the radius + offset by 1e9 and add the moduleID.
+ * A double has a precision of 53 bits, which is 15.9 digits. So the radius can be up to 1e6.9 mm
+ * without causing the last digit of the the ModuleID to be cut, and for up to 1000 modules the
+ * layers can be distinguished down to 1 nm without the two numbers mixing, or down to 1 micron
+ * with up to 1.000.000 modules.
+ *
+ * The additional sorting by module is intended for cylinder segments. Here only one module/row
+ * per layer is allowed, so we just take the first entry in the set. In case of a perfect layer
+ * it does not matter because there should only be one layer at this radius, so the sort order
+ * should not be affected by adding an arbitrary module ID (as long as the module ID is < 1e6, as
+ * described above).
+ */
+ virtual Double_t GetSortingPolicy() const;
+
+ /**
+ * Creates a GearTPCCylinderHit and hands over the ownership.
+ */
+ virtual GearTPCHit * createHit(Double_t * meas,
+ Double_t * dmeas,
+ void * hitPointer,
+ Double_t bField,
+ Double_t vDrift,
+ Int_t m = kMdim) const;
+
+
+
+protected:
+ Double_t fPhiMin; //< Minimum phi.
+ Double_t fPhiMax; //< Maximum phi.
+
+};
+
+}//namespace kaldet
+#endif
diff --git a/Utilities/KalDet/kaldet/GearTPCHit.h b/Utilities/KalDet/kaldet/GearTPCHit.h
new file mode 100644
index 0000000000000000000000000000000000000000..aafbb71e7dfd77b43f0f2af28f4d713503512a4c
--- /dev/null
+++ b/Utilities/KalDet/kaldet/GearTPCHit.h
@@ -0,0 +1,94 @@
+#ifndef GEARTPCHIT_H
+#define GEARTPCHIT_H
+
+#include <KalTrackDim.h>
+#include <TVTrackHit.h>
+#include <TVMeasLayer.h>
+
+namespace kaldet{
+
+/** Base class of a hit for GearTPCKalDetector. It extends the TVTrackHit with the functionality to
+ * store a space point or a pointer to the original hit for reference. In addition it stores
+ * the local drift velocity and allows sorting of the hits (according to the distance to the
+ * origin).
+ *
+ * It does not implement the purely virtual functions of the TVTrackHit, which happens in the
+ * specialisations for cylindrical and planar measurement layers.
+ */
+class GearTPCHit : public TVTrackHit {
+
+public:
+ /// KILLENB What does this constructor do? Best throw it out, it does not
+ /// properly initialise the class at all, does it?
+ GearTPCHit(Int_t m = kMdim);
+
+ /** Constructor to initialise the GearTPCHit using space point coordinates (TVector3) as original hit.
+ */
+ GearTPCHit(const TVMeasLayer &ms,
+ Double_t *x,
+ Double_t *dx,
+ const TVector3 &xx,
+ Double_t b,
+ Double_t v,
+ Int_t m = kMdim);
+
+ /** Constructor using a pointer to the original hit as reference.
+ */
+ GearTPCHit(const TVMeasLayer &ms,
+ Double_t *x,
+ Double_t *dx,
+ const void *hitp,
+ Double_t b,
+ Double_t v,
+ Int_t m = kMdim);
+
+ /** The dectructor.
+ */
+ virtual ~GearTPCHit();
+
+ /**
+ * The sorting policy of hits is implemented as the distance to the origin.
+ *
+ * Note: The sorting of hits does not necessarily correspond to the sort order of
+ * the corresponding Kalman layer!
+ */
+ virtual Double_t GetSortingPolicy() const;
+
+ /**
+ * Compare two hits according to their sorting policy.
+ * Returns
+ * \li -1 if this hits sorting policy is smaller
+ * \li 0 if both soting policies are equal
+ * \li 1 if this hits hits sortin policy is larger
+ *
+ * Killenb: n.b. Who comes up with this wierd stuff? Ever head of anything like a
+ * `less than operator` or `comparison operator`?
+ */
+ virtual Int_t Compare(const TObject *obj) const;
+
+ /**
+ * Returns true.
+ */
+ virtual Bool_t IsSortable() const;
+
+ /// Get the pointer to the reference hit. 0 if the TVector3 has been used for initialisation.
+ inline const void *GetHitPtr() const { return fHitPtr; }
+
+ /// Get the referece position. (0, 0, 0) if the reference pointer has been used for initialisation.
+ inline TVector3 GetExactX() const { return *fXXPtr; }
+
+ /// Get the local drift velocity set in the constructor.
+ inline Double_t GetVdrift() const { return fVDrift; }
+
+protected:
+ const TVector3 *fXXPtr; //< pointer to exact hit
+ const void *fHitPtr; //< pointer to raw Hit object
+
+ Double_t fVDrift; //< the local drift veclocity at this point
+
+
+};
+
+}//namespace kaldet
+
+#endif
diff --git a/Utilities/KalDet/kaldet/GearTPCKalDetector.h b/Utilities/KalDet/kaldet/GearTPCKalDetector.h
new file mode 100644
index 0000000000000000000000000000000000000000..800934a5dce925b27ac6460cec8ad011494a662c
--- /dev/null
+++ b/Utilities/KalDet/kaldet/GearTPCKalDetector.h
@@ -0,0 +1,77 @@
+#ifndef GEARTPCKALDETECTOR_H
+#define GEARTPCKALDETECTOR_H
+
+#include "kaltest/TVKalDetector.h"
+
+#include "GearTPCMeasLayer.h"
+
+#include <map>
+
+namespace gear{
+ class GearMgr ;
+}
+
+namespace kaldet{
+
+ /**
+ * The LCTPC implementation for a TPC which is completely instantiated from GEAR.
+ *
+ */
+class GearTPCKalDetector : public TVKalDetector {
+
+public:
+ /**
+ * The constructor. All information to initialise the TPC is taken from GEAR.
+ *
+ * As a pragmatic approach to avoid dealing with conditions data and material databases,
+ * the information about the material budget and the resolution of the layers
+ * is taken from the GEAR file as user parameters. If the parameters are not found in the
+ * file the previously hard coded parameters are used as default, which ensures backward
+ * compatibility.
+ *
+ * The gas properties for the matrial budget can be given as user parameters
+ * for the TPCParameters:
+ * \param TPCGas_A The mean atomic mass (default 36.2740552)
+ * \param TPCGas_Z The mean number of protons (default 16.4)
+ * \param TPCGas_density The density (default 0.749e-3 in which units?)
+ * \param TPCGas_radlen The radiation length (default 2.392e4 in which units?)
+ *
+ * The default gas parameters (are supposed to) correspond to Ar/CH4 90/10.
+ * N.B.: KILLENB: I think there is a bug in the calculation, the mean A should be
+ * 37.6 instead of 36.3 (see source code).
+ * In addition the description as a single TMaterial is not good.
+ * Using TMixture would be better.
+ *
+ * The reslution is calculated as \f$\sigma_x = \sqrt{x_0^2 + x_1^2 \cdot z}\f$.
+ * This requires z to be proportional to the drift distance, i.\ e. z=0 is at the readout.
+
+ * The resolution of the layers can be given as user parameters in each TPCModule
+ * section of the GEAR xml file.
+ * \param sigmax0 The constant part of the x resolution (default 38.3e-3 mm)
+ * \param sigmax1 The drift distance dependent part of the x resolution
+ * (default 6.74e-3 mm/sqrt(mm) )
+ * \param sigmaz0 The constant part of the z resolution (default 0.5 mm)
+ * \param sigmaz1 The drift distance dependent part the z resolution
+ * (default 10.2e-3 mm/sqrt(mm) )
+ */
+ GearTPCKalDetector(const gear::GearMgr& gearMgr);
+
+ /// The destructor.
+ virtual ~GearTPCKalDetector();
+
+ /**
+ * Get access to the measurement layers using moduleID and row.
+ * Do not directly access the measurement layers using At()
+ * because the order depends on the order in the gear file.
+ * Throws a gear::Exception if the row on the module is not defined.
+ */
+ virtual GearTPCMeasLayer const * GetMeasLayer(int moduleID, int row) const;
+
+protected:
+ /// Map which contains the information which measurement layer is stored
+ /// at which position in the array.
+ std::map< std::pair<int, int >, Int_t > moduleRowToMeasurementLayerMap;
+};
+
+}// namespace kaldet
+#endif //GEARTPCKALDETECTOR_H
diff --git a/Utilities/KalDet/kaldet/GearTPCMeasLayer.h b/Utilities/KalDet/kaldet/GearTPCMeasLayer.h
new file mode 100644
index 0000000000000000000000000000000000000000..3e2d0193d14a9e1fdf442a924b1b533d7f3f7eb5
--- /dev/null
+++ b/Utilities/KalDet/kaldet/GearTPCMeasLayer.h
@@ -0,0 +1,123 @@
+#ifndef GEARTPC_MEASLAYER_H
+#define GEARTPC_MEASLAYER_H
+
+#include "kaltest/TVMeasLayer.h"
+#include <set>
+
+namespace kaldet
+{
+
+ class GearTPCHit;
+
+ /**
+ * The GearTPCMeasLayer class introduces the z-dependent resolutions sigmaX and sigmaZ
+ * as well as Gear modules and rows which correspond to this layer.
+ *
+ * If the layer is defined as a perfect layer this means all modules are perfectly alligned
+ * and more than one module/row can be assigned to this layer. You can add them using AddModuleRow.
+ * The perfect layer should contain all the moduleRows on it, so it is guaranteed that the
+ * user can access all neighbouring modules this way.
+ *
+ * If the layer is not defined as perfect (default) there can only be one module on this layer.
+ * Calling AddModuleRow will throw an exception. This is the default behaviour because Gear does
+ * not guarantee that the modules are alligned. Displaced modules do not make up a perfect
+ * cylinder / plane and have to be treated as separate segments. Finding a neighbouring module/row
+ * is not trivial and has to be left to the user or a future Gear version.
+ */
+
+ class GearTPCMeasLayer
+ : public TVMeasLayer
+ {
+
+ public:
+ /** The constructor.
+ * The materials and the type (active or passive) are passed on to the
+ * TVMeasLayer. sigmaX0 [mm] is the constant part of sigmaX, sigmaX1 [mm/sqrt(mm)]
+ * the z-dependent part, accordingly for sigmaZ.
+ *
+ * Module and row have to be specified. They will be added as the first
+ * module/row pair of this measurement layer.
+ * For a perfect layer modules can be added with AddModuleRow.
+ *
+ * Note: This class cannot be instantiated because the parent's geometry dependent
+ * purely virtual
+ * functions like XvToMv are not implemented. This will happen in the cylindrical or planar
+ * implementations.
+ *
+ * For inactive layers you will usually leave the sigmas at 0, they have no useful meaning in
+ * this case.
+ */
+ GearTPCMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ Int_t module,
+ Int_t row,
+ Bool_t isPerfect,
+ Bool_t isActive,
+ Double_t sigmaX0 = 0., //< the constant part of sigmaX
+ Double_t sigmaX1 = 0., //< the z-dependent part of sigmaX
+ Double_t sigmaZ0 = 0. , //< the constant part of sigmaZ
+ Double_t sigmaZ1 = 0.); //< the z-dependent part of sigmaZ
+
+ /// The destructor
+ virtual ~GearTPCMeasLayer();
+
+ /**
+ * A perfect measurement layer contains all the modules with rows (row segments)
+ * that make up the layer.
+ */
+ virtual std::set< std::pair <int, int> > const & GetModuleRows() const;
+
+ /**
+ * Add another row on another module which lies on the same cylinder.
+ */
+ virtual void AddModuleRow(int module, int row);
+
+ /**
+ * Get the measurement vector (mv) for this layer from a space point (xv)
+ */
+ virtual TKalMatrix XvToMv (const TVector3 &xv) const = 0;
+
+ /**
+ * Get the z-depenent resolution in the readout plane
+ * (usually x or r\f$\phi\f$).
+ */
+ virtual Double_t GetSigmaX(Double_t z) const;
+
+ /**
+ * Get the z-depenent resolution in z (drift direction).
+ */
+ virtual Double_t GetSigmaZ(Double_t z) const;
+
+
+ /**
+ * Get the flag whether the layer is declared as perfect.
+ */
+ virtual Bool_t IsPerfect() const;
+
+ /**
+ * A virtual function to create the appropriate hit. Depending on the implementation
+ * (cylindrical or straight measurement layer) you get the appropriate implementation
+ * of GearTPCHit.
+ * It creates a new hit on the heap and hands over the ownership.
+ */
+ virtual GearTPCHit * createHit(Double_t * meas,
+ Double_t * dmeas,
+ void * hitPointer,
+ Double_t bField,
+ Double_t vDrift,
+ Int_t m = kMdim) const = 0;
+
+ protected:
+ Double_t fSigmaX0; // xy resolution
+ Double_t fSigmaX1; // xy resolution
+ Double_t fSigmaZ0; // z resolution
+ Double_t fSigmaZ1; // z resolution
+
+ /// A set to hold all the module/row combinations associated to this layer
+ std::set< std::pair<int, int> > fModuleRows;
+
+ Bool_t fIsPerfect;
+ };
+
+}// namespace kaldet
+#endif // GEARTPC_MEASLAYER_H
diff --git a/Utilities/KalDet/kaldet/ILDConeMeasLayer.h b/Utilities/KalDet/kaldet/ILDConeMeasLayer.h
new file mode 100644
index 0000000000000000000000000000000000000000..00e9fb0611e760c211a854bbf55cf93b8f1ef25c
--- /dev/null
+++ b/Utilities/KalDet/kaldet/ILDConeMeasLayer.h
@@ -0,0 +1,99 @@
+#ifndef ILDCONEMEASLAYER_H
+#define ILDCONEMEASLAYER_H
+//*************************************************************************
+//* ===================
+//* ILDConeMeasLayer Class
+//* ===================
+//*
+//* (Update Recored)
+//* 2012/01/19 K.Fujii Original version. (EXBPConeMeasLayer)
+//* 2012/01/24 R.Glattauer Adapted to ILD common in KalDet
+//*
+//*************************************************************************
+//
+#include "TVector3.h"
+
+#include "kaltest/TKalMatrix.h"
+#include "kaltest/TCutCone.h"
+#include "kaltest/KalTrackDim.h"
+
+#include "ILDVMeasLayer.h"
+#include "iostream"
+/* #include "streamlog/streamlog.h" */
+#include "UTIL/ILDConf.h"
+#include "edm4hep/TrackerHit.h"
+
+class ILDConeMeasLayer : public ILDVMeasLayer, public TCutCone {
+public:
+ // Ctors and Dtor
+ /** Constructor Taking inner and outer materials, z and radius at start and end, B-Field, whether the layer is sensitive, Cell ID, and an optional name */
+ ILDConeMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ Double_t z1,
+ Double_t r1,
+ Double_t z2,
+ Double_t r2,
+ Double_t Bz,
+ Double_t SortingPolicy,
+ Bool_t is_active,
+ Int_t CellID = -1,
+ const Char_t *name = "BPCONEML");
+ virtual ~ILDConeMeasLayer();
+
+ // Parrent's pure virtuals that must be implemented
+ /** Global to Local coordinates */
+ virtual TKalMatrix XvToMv (const TVTrackHit &ht,
+ const TVector3 &xv) const;
+
+ /** Global to Local coordinates */
+ virtual TKalMatrix XvToMv (const TVector3 &xv) const;
+
+ /** Local to Global coordinates */
+ virtual TVector3 HitToXv (const TVTrackHit &ht) const;
+
+ /** Calculate Projector Matrix */
+ virtual void CalcDhDa (const TVTrackHit &ht,
+ const TVector3 &xv,
+ const TKalMatrix &dxphiada,
+ TKalMatrix &H) const;
+
+ Bool_t IsOnSurface(const TVector3 &xx) const;
+
+ /** Convert LCIO Tracker Hit to an ILDCylinderHit */
+ virtual ILDVTrackHit* ConvertLCIOTrkHit(edm4hep::TrackerHit* trkhit) const {
+
+ /* streamlog_out( ERROR ) << "Don't use this, it's not implemented!"; */
+ return NULL;
+ }
+
+ /** Get the intersection and the CellID, needed for multilayers */
+ virtual int getIntersectionAndCellID(const TVTrack &hel,
+ TVector3 &xx,
+ Double_t &phi,
+ Int_t &CellID,
+ Int_t mode,
+ Double_t eps = 1.e-8) const {
+
+ CellID = this->getCellIDs()[0]; // not multilayer
+ return this->CalcXingPointWith(hel,xx,phi,0,eps);
+
+
+ }
+
+ /** Get sorting policy for this plane */
+ virtual double GetSortingPolicy() const { return fsortingPolicy; }
+
+
+
+
+private:
+ Double_t fZ1; // z of front face
+ Double_t fR1; // r of front face
+ Double_t fZ2; // z of back end
+ Double_t fR2; // r of back end
+ Double_t fsortingPolicy; // used for sorting the layers in to out
+
+
+};
+
+#endif
diff --git a/Utilities/KalDet/kaldet/ILDCylinderHit.h b/Utilities/KalDet/kaldet/ILDCylinderHit.h
new file mode 100644
index 0000000000000000000000000000000000000000..9dbe5b73ef225aa41f7b06cf54d5775166073da3
--- /dev/null
+++ b/Utilities/KalDet/kaldet/ILDCylinderHit.h
@@ -0,0 +1,38 @@
+#ifndef ILDCYLINDERHIT_H
+#define ILDCYLINDERHIT_H
+
+/** ILDCylinderHit: User defined KalTest hit class using R and Rphi coordinates, which provides coordinate vector as defined by the MeasLayer
+ *
+ * @author S.Aplin DESY
+ */
+
+#include "kaltest/KalTrackDim.h"
+#include "ILDVTrackHit.h"
+
+
+class ILDCylinderHit : public ILDVTrackHit {
+
+public:
+
+
+ /** Constructor Taking R and Rphi coordinates and associated measurement layer, with bfield */
+ ILDCylinderHit(const TVMeasLayer &ms, Double_t *x, Double_t *dx,
+ Double_t bfield, edm4hep::TrackerHit* trkhit )
+ : ILDVTrackHit(ms, x, dx, bfield, 2, trkhit)
+ { /* no op */ }
+
+
+ // TVTrackHit's pure virtuals that must be implemented
+
+ /** Global to Local coordinates */
+ virtual TKalMatrix XvToMv(const TVector3 &xv, Double_t t0) const;
+
+ /** Print Debug information */
+ virtual void DebugPrint(Option_t *opt = "") const;
+
+
+private:
+
+
+};
+#endif
diff --git a/Utilities/KalDet/kaldet/ILDCylinderMeasLayer.h b/Utilities/KalDet/kaldet/ILDCylinderMeasLayer.h
new file mode 100644
index 0000000000000000000000000000000000000000..04740cc81edde2029bc347dc50a481001a2f2740
--- /dev/null
+++ b/Utilities/KalDet/kaldet/ILDCylinderMeasLayer.h
@@ -0,0 +1,93 @@
+#ifndef ILDCYLINDERMEASLAYER_H
+#define ILDCYLINDERMEASLAYER_H
+
+/** ILDCylinderMeasLayer: User defined KalTest measurement layer class
+ *
+ * @author S.Aplin DESY
+ */
+
+
+#include "ILDVMeasLayer.h"
+#include <iostream>
+#include <cmath>
+/* #include "streamlog/streamlog.h" */
+
+
+class ILDCylinderMeasLayer : public ILDVMeasLayer, public TCylinder {
+
+public:
+
+ /** Constructor Taking inner and outer materials, radius and half length, B-Field, whether the layer is sensitive, Cell ID, and an optional name */
+ ILDCylinderMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ Double_t r0,
+ Double_t lhalf,
+ Double_t x0,
+ Double_t y0,
+ Double_t z0,
+ Double_t Bz,
+ Bool_t is_active,
+ Int_t CellID = -1,
+ const Char_t *name = "ILDCylinderMeasL")
+ : ILDVMeasLayer(min, mout, Bz, is_active, CellID, name),
+ TCylinder(r0, lhalf,x0,y0,z0)
+ { /* no op */ }
+
+
+ Bool_t IsOnSurface(const TVector3 &xx) const {
+
+ bool z = (xx.Z() >= GetZmin() && xx.Z() <= GetZmax());
+ bool r = std::fabs( (xx-this->GetXc()).Perp() - this->GetR() ) < 1.e-3; // for very short, very stiff tracks this can be poorly defined, so we relax this here a bit to 1 micron
+
+// streamlog_out(DEBUG0) << "ILDCylinderMeasLayer IsOnSurface for " << this->TVMeasLayer::GetName() << " R = " << this->GetR() << " GetZmin() = " << GetZmin() << " GetZmax() = " << GetZmax()
+// << " dr = " << std::fabs( (xx-this->GetXc()).Perp() - this->GetR() ) << " r = " << r << " z = " << z
+// << std::endl;
+
+ return r && z;
+ }
+
+
+
+ // Parent's pure virtuals that must be implemented
+
+ /** Global to Local coordinates */
+ virtual TKalMatrix XvToMv (const TVector3 &xv) const;
+
+ /** Global to Local coordinates */
+ virtual TKalMatrix XvToMv (const TVTrackHit &ht,
+ const TVector3 &xv) const
+
+ { return this->XvToMv(xv); }
+
+
+ /** Local to Global coordinates */
+ virtual TVector3 HitToXv (const TVTrackHit &ht) const;
+
+
+ /** Calculate Projector Matrix */
+ virtual void CalcDhDa (const TVTrackHit &ht,
+ const TVector3 &xv,
+ const TKalMatrix &dxphiada,
+ TKalMatrix &H) const;
+
+ /** Convert LCIO Tracker Hit to an ILDCylinderHit */
+ virtual ILDVTrackHit* ConvertLCIOTrkHit(edm4hep::TrackerHit* trkhit) const ;
+
+ /** Get the intersection and the CellID, needed for multilayers */
+ virtual int getIntersectionAndCellID(const TVTrack &hel,
+ TVector3 &xx,
+ Double_t &phi,
+ Int_t &CellID,
+ Int_t mode,
+ Double_t eps = 1.e-8) const {
+
+ CellID = this->getCellIDs()[0]; // not multilayer
+ return this->CalcXingPointWith(hel,xx,phi,0,eps);
+
+ }
+
+
+private:
+
+};
+#endif
diff --git a/Utilities/KalDet/kaldet/ILDDiscMeasLayer.h b/Utilities/KalDet/kaldet/ILDDiscMeasLayer.h
new file mode 100644
index 0000000000000000000000000000000000000000..fe3ff82672144da1330120ebe3a8a26d56ae21d4
--- /dev/null
+++ b/Utilities/KalDet/kaldet/ILDDiscMeasLayer.h
@@ -0,0 +1,101 @@
+#ifndef __ILDDISCMEASLAYER__
+#define __ILDDISCMEASLAYER__
+
+/** ILDDiscMeasLayer: User defined KalTest Disc measurement layer class used with ILDPLanarTrackHit.
+ *
+ * @author S.Aplin DESY
+ */
+
+#include "TVector3.h"
+
+#include "kaltest/TKalMatrix.h"
+#include "kaltest/TPlane.h"
+#include "kaltest/KalTrackDim.h"
+#include "ILDVMeasLayer.h"
+
+#include "TMath.h"
+#include <sstream>
+
+class TVTrackHit;
+
+
+class ILDDiscMeasLayer : public ILDVMeasLayer, public TPlane {
+
+public:
+
+ /** Constructor Taking inner and outer materials, center and normal to the plane, B-Field, sorting policy, min and max r, whether the layer is sensitive, Cell ID, and an optional name */
+
+ ILDDiscMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ const TVector3 ¢er,
+ const TVector3 &normal,
+ double Bz,
+ double SortingPolicy,
+ double rMin,
+ double rMax,
+ Bool_t is_active,
+ Int_t CellID = -1,
+ const Char_t *name = "ILDDiscMeasL")
+ : ILDVMeasLayer(min, mout, Bz, is_active, CellID, name),
+ TPlane(center, normal),
+ _sortingPolicy(SortingPolicy), _rMin(rMin), _rMax(rMax)
+ { /* no op */ }
+
+
+
+ // Parrent's pure virtuals that must be implemented
+
+ /** Global to Local coordinates */
+ virtual TKalMatrix XvToMv (const TVTrackHit &ht,
+ const TVector3 &xv) const
+ { return this->XvToMv(xv); }
+
+ /** Global to Local coordinates */
+ virtual TKalMatrix XvToMv (const TVector3 &xv) const;
+
+ /** Local to Global coordinates */
+ virtual TVector3 HitToXv (const TVTrackHit &ht) const;
+
+ /** Calculate Projector Matrix */
+ virtual void CalcDhDa (const TVTrackHit &ht,
+ const TVector3 &xv,
+ const TKalMatrix &dxphiada,
+ TKalMatrix &H) const;
+
+ virtual Int_t CalcXingPointWith(const TVTrack &hel,
+ TVector3 &xx,
+ Double_t &phi,
+ Int_t mode,
+ Double_t eps) const;
+
+
+ /** Convert LCIO Tracker Hit to an ILDPLanarTrackHit */
+ virtual ILDVTrackHit* ConvertLCIOTrkHit(edm4hep::TrackerHit* trkhit) const ;
+
+ /** Check if global point is on surface */
+ inline virtual Bool_t IsOnSurface (const TVector3 &xx) const;
+
+ /** Get sorting policy for this plane */
+ double GetSortingPolicy() const { return _sortingPolicy; }
+
+ /** Get the intersection and the CellID, needed for multilayers */
+ virtual int getIntersectionAndCellID(const TVTrack &hel,
+ TVector3 &xx,
+ Double_t &phi,
+ Int_t &CellID,
+ Int_t mode,
+ Double_t eps = 1.e-8) const {
+
+ CellID = this->getCellIDs()[0]; // not multilayer
+ return this->CalcXingPointWith(hel,xx,phi,0,eps);
+
+ }
+
+private:
+ double _sortingPolicy;
+ double _rMin;
+ double _rMax;
+
+};
+
+#endif
diff --git a/Utilities/KalDet/kaldet/ILDFTDDiscBasedKalDetector.h b/Utilities/KalDet/kaldet/ILDFTDDiscBasedKalDetector.h
new file mode 100644
index 0000000000000000000000000000000000000000..c8536c6403b54d650ac0418ab2e845ec5f21053b
--- /dev/null
+++ b/Utilities/KalDet/kaldet/ILDFTDDiscBasedKalDetector.h
@@ -0,0 +1,44 @@
+#ifndef __ILDFTDDISCBASEDDETECTOR__
+#define __ILDFTDDISCBASEDDETECTOR__
+
+/** Disk based version of the FTD alla LOI
+*
+* @author S.Aplin DESY
+*/
+
+#include "kaltest/TVKalDetector.h"
+
+class TNode;
+
+namespace gear{
+ class GearMgr ;
+}
+
+
+class ILDFTDDiscBasedKalDetector : public TVKalDetector {
+public:
+
+ /** Initialize the FTD from GEAR */
+ ILDFTDDiscBasedKalDetector( const gear::GearMgr& gearMgr );
+
+
+private:
+
+ void setupGearGeom( const gear::GearMgr& gearMgr ) ;
+
+ int _nDisks ;
+ double _bZ ;
+
+ struct FTD_Disk {
+ double rInner;
+ double rOuter;
+ double senThickness;
+ double supThickness;
+ double zPos;
+
+ };
+ std::vector<FTD_Disk> _FTDgeo;
+
+};
+
+#endif
diff --git a/Utilities/KalDet/kaldet/ILDFTDKalDetector.h b/Utilities/KalDet/kaldet/ILDFTDKalDetector.h
new file mode 100644
index 0000000000000000000000000000000000000000..36cf54b8e5a889a09431635740c3e2c3035d6d6a
--- /dev/null
+++ b/Utilities/KalDet/kaldet/ILDFTDKalDetector.h
@@ -0,0 +1,92 @@
+#ifndef __ILDFTDDETECTOR__
+#define __ILDFTDDETECTOR__
+
+/** Petal based FTD to be used for ILD DBD studies
+ * WARNING: Still very experimental
+ *
+ * @author S.Aplin DESY, Robin Glattauer HEPHY
+ */
+
+#include "kaltest/TVKalDetector.h"
+
+class TNode;
+class TVector3;
+
+namespace gear{
+ class GearMgr ;
+}
+
+
+class ILDFTDKalDetector : public TVKalDetector {
+public:
+
+ /** Initialize the FTD from GEAR */
+ ILDFTDKalDetector( const gear::GearMgr& gearMgr );
+
+
+private:
+
+ struct FTD_Petal {
+
+ int ipetal;
+ double phi;
+ double alpha;
+ double rInner;
+ double height;
+ double innerBaseLength;
+ double outerBaseLength;
+ double senThickness;
+ double supThickness;
+ double senZPos;
+ bool faces_ip;
+
+ };
+
+
+ struct FTD_Disk {
+ int nPetals;
+ double phi0;
+ double dphi;
+
+ double alpha;
+ double rInner;
+ double height;
+ double innerBaseLength;
+ double outerBaseLength;
+ double senThickness;
+ double supThickness;
+
+ double stripAngle;
+
+ double senZPos_even_front;
+ double senZPos_odd_front;
+
+ bool isDoubleSided;
+ bool isStripReadout;
+
+ int nSensors;
+
+
+ };
+
+
+ void build_staggered_design();
+
+ //void create_petal(TVector3 measurement_plane_centre, FTD_Petal petal, int CellID);
+ /**
+ * @param zpos the z position of the front measurement surface (middle of front sensitive)
+ */
+ void create_segmented_disk_layers(int idisk, int nsegments, bool even_petals, double phi0, double zpos );
+
+
+ void setupGearGeom( const gear::GearMgr& gearMgr ) ;
+
+ int _nDisks ;
+ double _bZ ;
+
+
+ std::vector<FTD_Disk> _FTDgeo;
+
+};
+
+#endif
diff --git a/Utilities/KalDet/kaldet/ILDMeasurementSurfaceStoreFiller.h b/Utilities/KalDet/kaldet/ILDMeasurementSurfaceStoreFiller.h
new file mode 100644
index 0000000000000000000000000000000000000000..79ff8e1ea0aafc6123eed869b85573f5f8580aee
--- /dev/null
+++ b/Utilities/KalDet/kaldet/ILDMeasurementSurfaceStoreFiller.h
@@ -0,0 +1,81 @@
+#ifndef ILDMEASUREMENTSURFACESTOREFILLER_H
+#define ILDMEASUREMENTSURFACESTOREFILLER_H
+
+#include "gearsurf/MeasurementSurfaceStore.h"
+
+#include <vector>
+
+namespace gear{
+ class GearMgr;
+ class ZPlanarParameters;
+ class FTDParameters;
+}
+
+using namespace gear;
+
+class ILDMeasurementSurfaceStoreFiller : public MeasurementSurfaceStoreFiller{
+
+ public:
+
+
+ ILDMeasurementSurfaceStoreFiller(const gear::GearMgr& gear_mgr) :
+ _nVTXLayers(0),
+ _nSITLayers(0),
+ _nFTDLayers(0),
+ _nSETLayers(0) {
+
+ this->get_gear_parameters(gear_mgr);
+
+ }
+
+ ~ILDMeasurementSurfaceStoreFiller() { /* no op */ }
+
+ void getMeasurementSurfaces( std::vector<MeasurementSurface*>& surface_list ) const;
+
+ std::string getName() const { return "ILDMeasurementSurfaceStoreFiller" ; } ;
+
+ private:
+
+ /** adds MeasurementSufaces to the store
+ * @param param: the ZPlanarParameters pointer of the detector, of which the measurement surfaces shall be added
+ *
+ * @param det_id: the detector id (as in ILDConf)
+ */
+ void storeZPlanar( const gear::ZPlanarParameters* param , int det_id, std::vector<MeasurementSurface*>& surface_list ) const;
+
+ void storeFTD( const gear::FTDParameters* param, std::vector<MeasurementSurface*>& surface_list ) const;
+
+
+ void get_gear_parameters(const gear::GearMgr& gear_mgr);
+
+ /** the strip angles for every layer */
+ std::vector< double > _VTXStripAngles;
+ std::vector< double > _SITStripAngles;
+ std::vector< double > _SETStripAngles;
+
+ /** the number of sensors for every layer */
+ std::vector< int > _VTXNSensors;
+ std::vector< int > _SITNSensors;
+ std::vector< int > _SETNSensors;
+
+
+ /** the strip angles for every layer and sensor */
+ std::vector< std::vector< double > > _FTDStripAngles;
+
+ unsigned _nVTXLayers;
+ unsigned _nSITLayers;
+ unsigned _nFTDLayers;
+ unsigned _nSETLayers;
+
+
+ const gear::ZPlanarParameters* _paramVXD;
+ const gear::ZPlanarParameters* _paramSIT;
+ const gear::ZPlanarParameters* _paramSET;
+ const gear::FTDParameters* _paramFTD;
+
+
+
+};
+
+#endif
+
diff --git a/Utilities/KalDet/kaldet/ILDParallelPlanarMeasLayer.h b/Utilities/KalDet/kaldet/ILDParallelPlanarMeasLayer.h
new file mode 100644
index 0000000000000000000000000000000000000000..7262a3e84e248b8eb03ad0d6afbea283b06750cc
--- /dev/null
+++ b/Utilities/KalDet/kaldet/ILDParallelPlanarMeasLayer.h
@@ -0,0 +1,80 @@
+#ifndef __ILDParallelPlanarMeasLayer__
+#define __ILDParallelPlanarMeasLayer__
+
+/** ILDParallelPlanarMeasLayer: User defined KalTest measurement layer class
+ *
+ * @author S.Aplin DESY
+ */
+
+
+#include "ILDPlanarMeasLayer.h"
+
+class ILDParallelPlanarMeasLayer : public ILDPlanarMeasLayer {
+
+public:
+
+ /** Constructor Taking inner and outer materials, distance and phi of plane pca to origin, B-Field, Sorting policy, plane transverse witdth and offset of centre, longitudinal width, whether the layer is sensitive, Cell ID, and an optional name */
+ ILDParallelPlanarMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ Double_t r,
+ Double_t phi,
+ Double_t Bz,
+ Double_t SortingPolicy,
+ Double_t xiwidth,
+ Double_t zetawidth,
+ Double_t xioffset,
+ Double_t zoffset,
+ Double_t UOrigin,
+ Bool_t is_active,
+ Int_t CellID = -1,
+ const Char_t *name = "ILDParallelPlanarMeasLayer")
+ :
+ ILDPlanarMeasLayer(min,mout,TVector3(r*cos(phi),r*sin(phi),zoffset),TVector3(cos(phi),sin(phi),0.0),Bz,SortingPolicy,xiwidth,zetawidth,xioffset,UOrigin,is_active,CellID,name), _r(r),_phi(phi),_cos_phi(cos(_phi)),_sin_phi(sin(_phi))
+ { /* no op */ }
+
+
+ // Parent's pure virtuals that must be implemented
+
+ /** overloaded version of CalcXingPointWith using closed solution */
+ virtual Int_t CalcXingPointWith(const TVTrack &hel,
+ TVector3 &xx,
+ Double_t &phi,
+ Int_t mode,
+ Double_t eps = 1.e-8) const;
+
+ /** overloaded version of CalcXingPointWith using closed solution */
+ virtual Int_t CalcXingPointWith(const TVTrack &hel,
+ TVector3 &xx,
+ Double_t &phi,
+ Double_t eps = 1.e-8) const{
+
+ return CalcXingPointWith(hel,xx,phi,0,eps);
+
+ }
+
+ /** Get the intersection and the CellID, needed for multilayers */
+ virtual int getIntersectionAndCellID(const TVTrack &hel,
+ TVector3 &xx,
+ Double_t &phi,
+ Int_t &CellID,
+ Int_t mode,
+ Double_t eps = 1.e-8) const {
+
+ CellID = this->getCellIDs()[0]; // not multilayer
+ return CalcXingPointWith(hel,xx,phi,0,eps);
+
+ }
+
+
+protected:
+
+ Double_t _r;
+ Double_t _phi;
+ Double_t _cos_phi;
+ Double_t _sin_phi;
+
+
+};
+
+#endif
+
diff --git a/Utilities/KalDet/kaldet/ILDParallelPlanarStripMeasLayer.h b/Utilities/KalDet/kaldet/ILDParallelPlanarStripMeasLayer.h
new file mode 100644
index 0000000000000000000000000000000000000000..c717f4c13a37397762a9aaf6d63980d8e0dfe61c
--- /dev/null
+++ b/Utilities/KalDet/kaldet/ILDParallelPlanarStripMeasLayer.h
@@ -0,0 +1,62 @@
+#ifndef __ILDParallelPlanarStripMeasLayer__
+#define __ILDParallelPlanarStripMeasLayer__
+
+/** ILDParallelPlanarStripMeasLayer: User defined KalTest measurement layer class
+ *
+ * @author S.Aplin DESY
+ */
+
+//#include "TKalMatrix.h"
+//#include "TVector3.h"
+//#include "TVTrackHit.h"
+
+
+#include "ILDParallelPlanarMeasLayer.h"
+
+class ILDParallelPlanarStripMeasLayer : public ILDParallelPlanarMeasLayer {
+
+public:
+
+ /** Constructor Taking inner and outer materials, distance and phi of plane pca to origin, B-Field, Sorting policy, plane transverse witdth and offset of centre, longitudinal width, whether the layer is sensitive, Cell ID, and an optional name */
+ ILDParallelPlanarStripMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ Double_t r,
+ Double_t phi,
+ Double_t Bz,
+ Double_t SortingPolicy,
+ Double_t xiwidth,
+ Double_t zetawidth,
+ Double_t xioffset,
+ Double_t zoffset,
+ Double_t UOrigin,
+ Double_t stripAngle,
+ Int_t CellID = -1,
+ const Char_t *name = "ILDParallelPlanarStripMeasLayer")
+ :
+ ILDParallelPlanarMeasLayer(min,mout,r,phi,Bz,SortingPolicy,xiwidth,zetawidth,xioffset,zoffset,UOrigin,true,CellID,name), _stripAngle(stripAngle)
+
+ { /* no op */ }
+
+
+ // Parent's pure virtuals that must be implemented
+
+ TKalMatrix XvToMv(const TVector3 &xv) const;
+
+ TKalMatrix XvToMv(const TVTrackHit &, const TVector3 &xv) const {
+ return XvToMv(xv);
+ }
+
+ TVector3 HitToXv(const TVTrackHit &vht) const ;
+
+ void CalcDhDa(const TVTrackHit &vht, const TVector3 &xxv, const TKalMatrix &dxphiada, TKalMatrix &H) const;
+
+ ILDVTrackHit* ConvertLCIOTrkHit(edm4hep::TrackerHit* trkhit) const;
+
+private:
+
+ double _stripAngle;
+
+};
+
+#endif
+
diff --git a/Utilities/KalDet/kaldet/ILDPlanarHit.h b/Utilities/KalDet/kaldet/ILDPlanarHit.h
new file mode 100644
index 0000000000000000000000000000000000000000..e54f0cf7e053dda87041fd4d9e80fc010b5787fa
--- /dev/null
+++ b/Utilities/KalDet/kaldet/ILDPlanarHit.h
@@ -0,0 +1,41 @@
+#ifndef ILDPLANARHIT_H
+#define ILDPLANARHIT_H
+
+/** ILDPlanarHit: User defined KalTest hit class using u and v coordinates, which provides coordinate vector as defined by the MeasLayer
+ *
+ * @author S.Aplin DESY
+ */
+
+#include "kaltest/KalTrackDim.h"
+
+#include "ILDVTrackHit.h"
+
+#define ILDPlanarHit_DIM 2
+
+class ILDPlanarHit : public ILDVTrackHit {
+
+public:
+
+ /** Constructor Taking u and v coordinates and associated measurement layer, with bfield */
+ ILDPlanarHit(const TVMeasLayer &ms,
+ Double_t *x,
+ Double_t *dx,
+ Double_t bfield,
+ edm4hep::TrackerHit* trkhit)
+ : ILDVTrackHit(ms, x, dx, bfield, ILDPlanarHit_DIM,trkhit)
+ { /* no op */ }
+
+ // TVTrackHit's pure virtuals that must be implemented
+
+ /** Global to Local coordinates */
+ virtual TKalMatrix XvToMv (const TVector3 &xv, Double_t t0) const;
+
+ /** Print Debug information */
+ virtual void DebugPrint(Option_t *opt = "") const;
+
+
+private:
+
+
+};
+#endif
diff --git a/Utilities/KalDet/kaldet/ILDPlanarMeasLayer.h b/Utilities/KalDet/kaldet/ILDPlanarMeasLayer.h
new file mode 100644
index 0000000000000000000000000000000000000000..500f2a233093f6409eb3428fa1f23b82bb45c95b
--- /dev/null
+++ b/Utilities/KalDet/kaldet/ILDPlanarMeasLayer.h
@@ -0,0 +1,84 @@
+#ifndef __ILDPLANARMEASLAYER__
+#define __ILDPLANARMEASLAYER__
+//*************************************************************************
+//* ===================
+//* ILDPlanarMeasLayer Class
+//* ===================
+//*
+//* (Description)
+//* Planar measurement layer class used with ILDPLanarTrackHit.
+//* (Requires)
+//* ILDVMeasLayer
+//* (Provides)
+//* class ILDPlanarMeasLayer
+//* (Update Recored)
+//* 2003/09/30 Y.Nakashima Original version.
+//*
+//* 2011/06/17 D.Kamai Modified to handle ladder structure.
+//*************************************************************************
+//
+#include "TVector3.h"
+
+#include "kaltest/TKalMatrix.h"
+#include "kaltest/TPlane.h"
+#include "kaltest/KalTrackDim.h"
+#include "ILDVMeasLayer.h"
+
+#include "TMath.h"
+#include <sstream>
+
+class TVTrackHit;
+
+class ILDPlanarMeasLayer : public ILDVMeasLayer, public TPlane {
+public:
+ // Ctors and Dtor
+
+ ILDPlanarMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ const TVector3 ¢er,
+ const TVector3 &normal,
+ Double_t Bz,
+ Double_t SortingPolicy,
+ Double_t xiwidth,
+ Double_t zetawidth,
+ Double_t xioffset,
+ Double_t fUOrigin,
+ Bool_t is_active,
+ Int_t CellID = -1,
+ const Char_t *name = "ILDPlanarMeasL");
+
+ virtual ~ILDPlanarMeasLayer();
+
+ // Parrent's pure virtuals that must be implemented
+
+ virtual TKalMatrix XvToMv (const TVTrackHit &ht,
+ const TVector3 &xv) const;
+
+ virtual TKalMatrix XvToMv (const TVector3 &xv) const;
+
+ virtual TVector3 HitToXv (const TVTrackHit &ht) const;
+
+ virtual void CalcDhDa (const TVTrackHit &ht,
+ const TVector3 &xv,
+ const TKalMatrix &dxphiada,
+ TKalMatrix &H) const;
+
+ virtual ILDVTrackHit* ConvertLCIOTrkHit(edm4hep::TrackerHit* trkhit) const ;
+
+ virtual Bool_t IsOnSurface (const TVector3 &xx) const;
+
+ Double_t GetSortingPolicy() const { return fSortingPolicy; }
+ Double_t GetXiwidth() const { return fXiwidth; }
+ Double_t GetZetawidth() const { return fZetawidth; }
+ Double_t GetXioffset() const { return fXioffset; }
+
+protected:
+ Double_t fSortingPolicy;
+ Double_t fXiwidth;
+ Double_t fZetawidth;
+ Double_t fXioffset; //determines how far the centre of the plane is translated in the direction positive rotation
+ Double_t fUOrigin; //determines origin of the transverse coordinate
+
+};
+
+#endif
diff --git a/Utilities/KalDet/kaldet/ILDPlanarStripHit.h b/Utilities/KalDet/kaldet/ILDPlanarStripHit.h
new file mode 100644
index 0000000000000000000000000000000000000000..1103eeda84a5e6729d204ac6385a11b5de909ac3
--- /dev/null
+++ b/Utilities/KalDet/kaldet/ILDPlanarStripHit.h
@@ -0,0 +1,42 @@
+#ifndef ILDPLANARSTRIPHIT_H
+#define ILDPLANARSTRIPHIT_H
+
+/** ILDPlanarStripHit: User defined KalTest hit class using u coordinate, which provides coordinate vector as defined by the MeasLayer
+ *
+ * @author S.Aplin DESY
+ */
+
+#include "kaltest/KalTrackDim.h"
+
+#include "ILDVTrackHit.h"
+
+
+#define ILDPlanarStripHit_DIM 1 // set to 2 if one want to debug strip hits by using the 2nd dimention
+
+class ILDPlanarStripHit : public ILDVTrackHit {
+
+public:
+
+ /** Constructor Taking a single coordinate and associated measurement layer, with bfield */
+ ILDPlanarStripHit(const TVMeasLayer &ms,
+ Double_t *x,
+ Double_t *dx,
+ Double_t bfield,
+ edm4hep::TrackerHit* trkhit)
+ : ILDVTrackHit(ms, x, dx, bfield, ILDPlanarStripHit_DIM,trkhit)
+ { /* no op */ }
+
+ // TVTrackHit's pure virtuals that must be implemented
+
+ /** Global to Local coordinates */
+ virtual TKalMatrix XvToMv (const TVector3 &xv, Double_t t0) const;
+
+ /** Print Debug information */
+ virtual void DebugPrint(Option_t *opt = "") const;
+
+
+private:
+
+
+};
+#endif
diff --git a/Utilities/KalDet/kaldet/ILDPolygonBarrelMeasLayer.h b/Utilities/KalDet/kaldet/ILDPolygonBarrelMeasLayer.h
new file mode 100644
index 0000000000000000000000000000000000000000..684bb876e7e0be4e48381ca59528c9871b6ffb1d
--- /dev/null
+++ b/Utilities/KalDet/kaldet/ILDPolygonBarrelMeasLayer.h
@@ -0,0 +1,138 @@
+#ifndef __ILDSEGMENTEDDISCMEASLAYER_H__
+#define __ILDSEGMENTEDDISCMEASLAYER_H__
+
+/** ILDPolygonBarrelMeasLayer: User defined Polygonal Barrel KalTest measurement layer class to be used only for dead material. Segments are planes parallel to the z axis
+ *
+ * NOTE: ALL METHODS INVOLVING HITS ARE DISABLED AND CALL EXIT(1)
+ * THIS CLASS IS ONLY MEANT FOR DEAD MATERIAL
+ *
+ * @author S.Aplin DESY
+ */
+
+#include "TVector3.h"
+
+#include "kaltest/TKalMatrix.h"
+#include "kaltest/TVSurface.h"
+#include "kaltest/KalTrackDim.h"
+#include "ILDVMeasLayer.h"
+
+#include "TMath.h"
+#include <sstream>
+
+#include "ILDParallelPlanarMeasLayer.h"
+
+#include <vector>
+
+class TVTrackHit;
+
+
+class ILDPolygonBarrelMeasLayer : public ILDVMeasLayer, public TVSurface {
+public:
+ // Ctors and Dtor
+
+
+
+ ILDPolygonBarrelMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ double Bz,
+ double SortingPolicy,
+ double r0, // min distance to the z-axis
+ double lhalf, // half length
+ int nsides,
+ double zpos, // z of the centre
+ double phi0, // phi of the first normal following the xaxis positive rotation
+ std::vector<int> CellIDs,
+ bool is_active,
+ const Char_t *name = "ILDPolygonBarrelMeasL");
+
+
+ ~ILDPolygonBarrelMeasLayer(){ delete _enclosing_cylinder;}
+
+
+ // Parrent's pure virtuals that must be implemented
+
+ /** Global to Local coordinates */
+ virtual TKalMatrix XvToMv (const TVTrackHit &ht,
+ const TVector3 &xv) const
+ { return this->XvToMv(xv); }
+
+
+ /** Global to Local coordinates */
+ virtual TKalMatrix XvToMv (const TVector3 &xv) const;
+
+ /** Local to Global coordinates */
+ virtual TVector3 HitToXv (const TVTrackHit &ht) const;
+
+ /** Calculate Projector Matrix */
+ virtual void CalcDhDa (const TVTrackHit &ht,
+ const TVector3 &xv,
+ const TKalMatrix &dxphiada,
+ TKalMatrix &H) const;
+
+ /** Convert LCIO Tracker Hit to an ILDPLanarTrackHit */
+ virtual ILDVTrackHit* ConvertLCIOTrkHit(edm4hep::TrackerHit* trkhit) const ;
+
+ /** overloaded version of CalcXingPointWith using closed solution*/
+ virtual Int_t CalcXingPointWith(const TVTrack &hel,
+ TVector3 &xx,
+ Double_t &phi,
+ Int_t mode,
+ Double_t eps = 1.e-8) const;
+
+ /** overloaded version of CalcXingPointWith using closed solution*/
+ virtual Int_t CalcXingPointWith(const TVTrack &hel,
+ TVector3 &xx,
+ Double_t &phi,
+ Double_t eps = 1.e-8) const{
+
+ return CalcXingPointWith(hel,xx,phi,0,eps);
+
+ }
+
+
+ /** Get the intersection and the CellID, needed for multilayers */
+ virtual int getIntersectionAndCellID(const TVTrack &hel,
+ TVector3 &xx,
+ Double_t &phi,
+ Int_t &CellID,
+ Int_t mode,
+ Double_t eps = 1.e-8) const ;
+
+
+ bool IsOutside(const TVector3 &xx) const;
+
+ double CalcS(const TVector3 &xx) const;
+
+ TMatrixD CalcDSDx(const TVector3 &xx) const;
+
+ /** Check if global point is on surface */
+ inline virtual Bool_t IsOnSurface (const TVector3 &xx) const;
+
+ /** Get sorting policy for this plane */
+ double GetSortingPolicy() const { return _sortingPolicy; }
+
+private:
+
+ double angular_range_2PI( double phi ) const;
+
+ unsigned int get_plane_index(double phi) const;
+
+ double _sortingPolicy;
+
+ double _r0; // min distance to the z-axis
+ double _lhalf; // half length
+ int _nsides;
+ double _zpos; // z of the centre
+ double _phi0; // phi of the first normal following the xaxis positive rotation
+
+ double _segment_dphi;
+ double _start_phi;
+ double _rmax;
+
+ std::vector<ILDParallelPlanarMeasLayer> _planes;
+ TCylinder* _enclosing_cylinder;
+};
+
+
+
+#endif
diff --git a/Utilities/KalDet/kaldet/ILDRotatedTrapMeaslayer.h b/Utilities/KalDet/kaldet/ILDRotatedTrapMeaslayer.h
new file mode 100644
index 0000000000000000000000000000000000000000..8cb7e4e07bd142df53533ca42b88333a818327d1
--- /dev/null
+++ b/Utilities/KalDet/kaldet/ILDRotatedTrapMeaslayer.h
@@ -0,0 +1,106 @@
+#ifndef __ILDPLANARMEASLAYER__
+#define __ILDPLANARMEASLAYER__
+/** ILDRotatedTrapMeaslayer: User defined Rotated Trapezoid Planar KalTest measurement layer class used with ILDPLanarTrackHit.
+ *
+ * @author S.Aplin DESY
+ */
+
+#include "TVector3.h"
+
+#include "kaltest/TKalMatrix.h"
+#include "kaltest/TPlane.h"
+#include "kaltest/KalTrackDim.h"
+#include "ILDVMeasLayer.h"
+
+#include "TMath.h"
+#include <sstream>
+class TVTrackHit;
+
+class ILDRotatedTrapMeaslayer : public ILDVMeasLayer, public TPlane {
+
+public:
+
+ /** Constructor Taking inner and outer materials, centre and normal of the plane, B-Field, sorting policy, height, inner base length, outer base length, tilt angle around axis of symmetry, represents full or half petal, whether the layer is sensitive, Cell ID, and an optional name */
+ ILDRotatedTrapMeaslayer(TMaterial &min,
+ TMaterial &mout,
+ const TVector3 ¢er,
+ const TVector3 &normal,
+ Double_t Bz,
+ Double_t SortingPolicy,
+ Double_t height,
+ Double_t innerBaseLength,
+ Double_t outerBaseLength,
+ Double_t alpha,
+ Int_t half_petal,
+ Bool_t is_active,
+ Int_t CellID = -1,
+ const Char_t *name = "ILDRotatedTrapMeasL");
+
+
+ // Parrent's pure virtuals that must be implemented
+
+ /** Global to Local coordinates */
+ virtual TKalMatrix XvToMv (const TVTrackHit &ht,
+ const TVector3 &xv) const
+ { return this->XvToMv(xv); }
+
+ /** Global to Local coordinates */
+ virtual TKalMatrix XvToMv (const TVector3 &xv) const;
+
+ /** Local to Global coordinates */
+ virtual TVector3 HitToXv (const TVTrackHit &ht) const;
+
+ /** Calculate Projector Matrix */
+ virtual void CalcDhDa (const TVTrackHit &ht,
+ const TVector3 &xv,
+ const TKalMatrix &dxphiada,
+ TKalMatrix &H) const;
+
+ /** Convert LCIO Tracker Hit to an ILDPLanarTrackHit */
+ virtual ILDVTrackHit* ConvertLCIOTrkHit(edm4hep::TrackerHit* trkhit) const ;
+
+ /** Check if global point is on surface */
+ inline virtual Bool_t IsOnSurface (const TVector3 &xx) const;
+
+ /** Get sorting policy for this plane */
+ Double_t GetSortingPolicy() const { return _sortingPolicy; }
+
+ /** Get the intersection and the CellID, needed for multilayers */
+ virtual int getIntersectionAndCellID(const TVTrack &hel,
+ TVector3 &xx,
+ Double_t &phi,
+ Int_t &CellID,
+ Int_t mode,
+ Double_t eps = 1.e-8) const {
+
+ CellID = this->getCellIDs()[0]; // not multilayer
+ return this->CalcXingPointWith(hel,xx,phi,0,eps);
+
+ }
+
+
+
+private:
+ Double_t _sortingPolicy ;
+ Double_t _signZ ;
+ Double_t _innerR ;
+ Double_t _outerR ;
+ Double_t _innerBaseLength ;
+ Double_t _outerBaseLength ;
+ Double_t _cosPhi ; //** cos of the azimuthal angle of the petal
+ Double_t _sinPhi ; //** sin of the azimuthal angle of the petal
+ Double_t _cosAlpha ; //** cos of the tilt angle of the petal
+ Double_t _sinAlpha ; //** sin of the tilt angle of the petal
+ Double_t _tanBeta ; //** tan of the openning angle of the petal
+
+ // meaning of _halfPetal:
+ // 0 complete trapezoid
+ // +1 positive half only, i.e. the side of the petal in which the transverse coordinate, mv(0,0), is positive
+ // -1 negative half only, i.e. the side of the petal in which the transverse coordinate, mv(0,0), is negative
+ Int_t _halfPetal ;
+
+
+
+};
+
+#endif
diff --git a/Utilities/KalDet/kaldet/ILDSETKalDetector.h b/Utilities/KalDet/kaldet/ILDSETKalDetector.h
new file mode 100644
index 0000000000000000000000000000000000000000..9327aa8a065e8ff6243df53193df544e37389381
--- /dev/null
+++ b/Utilities/KalDet/kaldet/ILDSETKalDetector.h
@@ -0,0 +1,58 @@
+#ifndef __ILDSETKALDETECTOR__
+#define __ILDSETKALDETECTOR__
+
+/** Ladder based SET to be used for ILD DBD studies
+ *
+ * @author S.Aplin DESY
+ */
+
+#include "kaltest/TVKalDetector.h"
+
+#include "TMath.h"
+
+class TNode;
+
+namespace gear{
+ class GearMgr ;
+}
+
+
+class ILDSETKalDetector : public TVKalDetector {
+
+public:
+
+ /** Initialize the SET from GEAR */
+ ILDSETKalDetector( const gear::GearMgr& gearMgr );
+
+
+private:
+
+ void setupGearGeom( const gear::GearMgr& gearMgr ) ;
+
+ int _nLayers ;
+ double _bZ ;
+
+ bool _isStripDetector;
+
+ struct SET_Layer {
+ int nLadders;
+ int nSensorsPerLadder;
+ double phi0;
+ double dphi;
+ double senRMin;
+ double supRMin;
+ double length;
+ double width;
+ double offset;
+ double senThickness;
+ double supThickness;
+ double sensorLength;
+ double stripAngle;
+ };
+ std::vector<SET_Layer> _SETgeo;
+
+};
+
+
+
+#endif
diff --git a/Utilities/KalDet/kaldet/ILDSITCylinderKalDetector.h b/Utilities/KalDet/kaldet/ILDSITCylinderKalDetector.h
new file mode 100644
index 0000000000000000000000000000000000000000..29f13f6f7cf5eaf3fba067693d475a9c6fa47449
--- /dev/null
+++ b/Utilities/KalDet/kaldet/ILDSITCylinderKalDetector.h
@@ -0,0 +1,44 @@
+#ifndef __ILDSITCYLINDERKALDETECTOR__
+#define __ILDSITCYLINDERKALDETECTOR__
+
+/** SIT Cylinder based detector to be used for ILD DBD studies when using the old LOI base SIT
+ *
+ * @author S.Aplin DESY
+ */
+
+#include "kaltest/TVKalDetector.h"
+
+class TNode;
+
+namespace gear{
+ class GearMgr ;
+}
+
+
+class ILDSITCylinderKalDetector : public TVKalDetector {
+public:
+
+ /** Initialize the TPC from GEAR */
+ ILDSITCylinderKalDetector( const gear::GearMgr& gearMgr );
+
+
+private:
+
+ void setupGearGeom( const gear::GearMgr& gearMgr ) ;
+
+ unsigned int _nLayers ;
+ double _bZ ;
+
+ struct SIT_Layer {
+ double radius;
+ double half_length;
+ double senThickness;
+ double supThickness;
+
+ };
+ std::vector<SIT_Layer> _SITgeo;
+
+
+};
+
+#endif
diff --git a/Utilities/KalDet/kaldet/ILDSITKalDetector.h b/Utilities/KalDet/kaldet/ILDSITKalDetector.h
new file mode 100644
index 0000000000000000000000000000000000000000..639e1b27bb76512ad05c8570814b218a9480cb5b
--- /dev/null
+++ b/Utilities/KalDet/kaldet/ILDSITKalDetector.h
@@ -0,0 +1,58 @@
+#ifndef __ILDSITKALDETECTOR__
+#define __ILDSITKALDETECTOR__
+
+/** Ladder based SIT to be used for ILD DBD studies
+ *
+ * @author S.Aplin DESY
+ */
+
+#include "kaltest/TVKalDetector.h"
+
+#include "TMath.h"
+
+class TNode;
+
+namespace gear{
+ class GearMgr ;
+}
+
+
+class ILDSITKalDetector : public TVKalDetector {
+
+public:
+
+ /** Initialize the SIT from GEAR */
+ ILDSITKalDetector( const gear::GearMgr& gearMgr );
+
+
+private:
+
+ void setupGearGeom( const gear::GearMgr& gearMgr ) ;
+
+ int _nLayers ;
+ double _bZ ;
+
+ bool _isStripDetector;
+
+ struct SIT_Layer {
+ int nLadders;
+ int nSensorsPerLadder;
+ double phi0;
+ double dphi;
+ double senRMin;
+ double supRMin;
+ double length;
+ double width;
+ double offset;
+ double senThickness;
+ double supThickness;
+ double sensorLength;
+ double stripAngle;
+ };
+ std::vector<SIT_Layer> _SITgeo;
+
+};
+
+
+
+#endif
diff --git a/Utilities/KalDet/kaldet/ILDSegmentedDiscMeasLayer.h b/Utilities/KalDet/kaldet/ILDSegmentedDiscMeasLayer.h
new file mode 100644
index 0000000000000000000000000000000000000000..6133570279f935d889f3e5ed76f3f51ed2f1205b
--- /dev/null
+++ b/Utilities/KalDet/kaldet/ILDSegmentedDiscMeasLayer.h
@@ -0,0 +1,144 @@
+#ifndef __ILDSEGMENTEDDISCMEASLAYER_H__
+#define __ILDSEGMENTEDDISCMEASLAYER_H__
+
+/** ILDSegmentedDiscMeasLayer: User defined Segemented Disk Planar KalTest measurement layer class used with ILDPLanarTrackHit. Segments are isosolese trapezoids whose axis of symmetry points to the origin
+ * WARNING: ONLY IMPLEMENTED FOR X AND Y COORDINATES AT FIXED Z
+ *
+ * @author S.Aplin DESY
+ */
+
+#include "TVector3.h"
+
+#include "kaltest/TKalMatrix.h"
+#include "kaltest/TPlane.h"
+#include "kaltest/KalTrackDim.h"
+#include "ILDVMeasLayer.h"
+
+#include "TMath.h"
+#include <sstream>
+#include <iostream>
+
+#include <vector>
+
+class TVTrackHit;
+
+class ILDSegmentedDiscMeasLayer : public ILDVMeasLayer, public TPlane {
+public:
+ // Ctors and Dtor
+
+ ILDSegmentedDiscMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ double Bz,
+ double SortingPolicy,
+ int nsegments,
+ double zpos,
+ double phi0, // defined by the axis of symmerty of the first petal
+ double trap_rmin,
+ double trap_height,
+ double trap_innerBaseLength,
+ double trap_outerBaseLength,
+ bool is_active,
+ std::vector<int> CellIDs,
+ const Char_t *name = "ILDDiscMeasL");
+
+ ILDSegmentedDiscMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ double Bz,
+ double SortingPolicy,
+ int nsegments,
+ double zpos,
+ double phi0, // defined by the axis of symmerty of the first petal
+ double trap_rmin,
+ double trap_height,
+ double trap_innerBaseLength,
+ double trap_outerBaseLength,
+ bool is_active,
+ const Char_t *name = "ILDDiscMeasL");
+
+
+ // Parrent's pure virtuals that must be implemented
+
+ /** Global to Local coordinates */
+ virtual TKalMatrix XvToMv (const TVTrackHit &ht,
+ const TVector3 &xv) const
+ { return this->XvToMv(xv); }
+
+
+ /** Global to Local coordinates */
+ virtual TKalMatrix XvToMv (const TVector3 &xv) const;
+
+ /** Local to Global coordinates */
+ virtual TVector3 HitToXv (const TVTrackHit &ht) const;
+
+ /** Calculate Projector Matrix */
+ virtual void CalcDhDa (const TVTrackHit &ht,
+ const TVector3 &xv,
+ const TKalMatrix &dxphiada,
+ TKalMatrix &H) const;
+
+ /** Convert LCIO Tracker Hit to an ILDPLanarTrackHit */
+ virtual ILDVTrackHit* ConvertLCIOTrkHit(edm4hep::TrackerHit* trkhit) const ;
+
+ /** overloaded version of CalcXingPointWith using closed solution*/
+ virtual Int_t CalcXingPointWith(const TVTrack &hel,
+ TVector3 &xx,
+ Double_t &phi,
+ Int_t mode,
+ Double_t eps = 1.e-8) const;
+
+ /** overloaded version of CalcXingPointWith using closed solution*/
+ virtual Int_t CalcXingPointWith(const TVTrack &hel,
+ TVector3 &xx,
+ Double_t &phi,
+ Double_t eps = 1.e-8) const{
+
+ return CalcXingPointWith(hel,xx,phi,0,eps);
+
+ }
+
+
+
+ /** Get the intersection and the CellID, needed for multilayers */
+ virtual int getIntersectionAndCellID(const TVTrack &hel,
+ TVector3 &xx,
+ Double_t &phi,
+ Int_t &CellID,
+ Int_t mode,
+ Double_t eps = 1.e-8) const ;
+
+
+
+ /** Check if global point is on surface */
+ virtual Bool_t IsOnSurface (const TVector3 &xx) const;
+
+ /** Get sorting policy for this plane */
+ double GetSortingPolicy() const { return _sortingPolicy; }
+
+protected:
+
+ double angular_range_2PI( double phi ) const;
+ unsigned int get_segment_index(double phi) const;
+ double get_segment_phi(unsigned int index) const;
+ TVector3 get_segment_centre(unsigned int index) const;
+
+private:
+
+ double _sortingPolicy;
+ int _nsegments;
+ double _trap_rmin;
+ double _trap_height;
+ double _trap_inner_base_length;
+ double _trap_outer_base_length;
+ double _trap_tan_beta; // tan of the openning angle of the petal
+
+ double _rmax;
+ double _start_phi; // trailing edge of the first sector
+ double _segment_dphi;
+
+
+
+};
+
+
+
+#endif
diff --git a/Utilities/KalDet/kaldet/ILDSegmentedDiscStripMeasLayer.h b/Utilities/KalDet/kaldet/ILDSegmentedDiscStripMeasLayer.h
new file mode 100644
index 0000000000000000000000000000000000000000..8bdab6686dcc7ba6d2ac04bcc3e7a7eae1dc84b8
--- /dev/null
+++ b/Utilities/KalDet/kaldet/ILDSegmentedDiscStripMeasLayer.h
@@ -0,0 +1,80 @@
+#ifndef __ILDSEGMENTEDDISCSTRIPMEASLAYER_H__
+#define __ILDSEGMENTEDDISCSTRIPMEASLAYER_H__
+
+/** ILDSegmentedDiscStripMeasLayer: User defined Segemented Disk Planar KalTest measurement layer class used with ILDPLanarTrackHit. Segments are isosolese trapezoids whose axis of symmetry points to the origin
+ * WARNING: ONLY IMPLEMENTED FOR X AND Y COORDINATES AT FIXED Z
+ *
+ * @author S.Aplin DESY
+ */
+#include "TVector3.h"
+
+#include "kaltest/TKalMatrix.h"
+#include "kaltest/TPlane.h"
+#include "kaltest/KalTrackDim.h"
+#include "ILDSegmentedDiscMeasLayer.h"
+
+#include "TMath.h"
+#include <sstream>
+#include <iostream>
+
+#include <vector>
+
+class TVTrackHit;
+
+class ILDSegmentedDiscStripMeasLayer : public ILDSegmentedDiscMeasLayer {
+
+public:
+ // Ctors and Dtor
+
+ ILDSegmentedDiscStripMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ double Bz,
+ double SortingPolicy,
+ int nsegments,
+ double zpos,
+ double phi0, // defined by the axis of symmerty of the first petal
+ double trap_rmin,
+ double trap_height,
+ double trap_innerBaseLength,
+ double trap_outerBaseLength,
+ double stripAngle,
+ bool is_active,
+ std::vector<int> CellIDs,
+ const Char_t *name = "ILDDiscMeasL")
+ : ILDSegmentedDiscMeasLayer(min,mout,Bz,SortingPolicy,nsegments,zpos,phi0,trap_rmin,trap_height,trap_innerBaseLength,trap_outerBaseLength,is_active,CellIDs,name),
+ _stripAngle(stripAngle)
+ { /* no op */ }
+
+
+ // Parrent's pure virtuals that must be implemented
+
+ /** Global to Local coordinates */
+ virtual TKalMatrix XvToMv (const TVTrackHit &ht,
+ const TVector3 &xv) const
+ { return this->XvToMv(xv); }
+
+
+ /** Global to Local coordinates */
+ virtual TKalMatrix XvToMv (const TVector3 &xv) const;
+
+ /** Local to Global coordinates */
+ virtual TVector3 HitToXv (const TVTrackHit &ht) const;
+
+ /** Calculate Projector Matrix */
+ virtual void CalcDhDa (const TVTrackHit &ht,
+ const TVector3 &xv,
+ const TKalMatrix &dxphiada,
+ TKalMatrix &H) const;
+
+ /** Convert LCIO Tracker Hit to an ILDPLanarTrackHit */
+ virtual ILDVTrackHit* ConvertLCIOTrkHit(edm4hep::TrackerHit* trkhit) const ;
+
+private:
+
+ double _stripAngle;
+
+};
+
+
+
+#endif
diff --git a/Utilities/KalDet/kaldet/ILDSupportKalDetector.h b/Utilities/KalDet/kaldet/ILDSupportKalDetector.h
new file mode 100644
index 0000000000000000000000000000000000000000..b7e28fa929884ceadf7755395766d8f75c079c3f
--- /dev/null
+++ b/Utilities/KalDet/kaldet/ILDSupportKalDetector.h
@@ -0,0 +1,37 @@
+#ifndef __ILDSUPPORTDETECTOR__
+#define __ILDSUPPORTDETECTOR__
+
+/** Support Material to be used for ILD DBD studies
+ *
+ * @author S.Aplin DESY
+ */
+
+#include "kaltest/TVKalDetector.h"
+
+class TNode;
+
+namespace gear{
+ class GearMgr ;
+}
+class IGeoSvc;
+
+class ILDCylinderMeasLayer;
+
+class ILDSupportKalDetector : public TVKalDetector {
+public:
+
+ /** Initialize the support structures from GEAR */
+ ILDSupportKalDetector( const gear::GearMgr& gearMgr, IGeoSvc* geoSvc );
+
+ /** Returns the special layer inside the Beam Pipe used for propagation to the IP */
+ ILDCylinderMeasLayer* getIPLayer() { return _ipLayer; }
+
+private:
+
+ ILDCylinderMeasLayer* _ipLayer;
+
+ std::vector<std::string> _surface_names;
+
+};
+
+#endif
diff --git a/Utilities/KalDet/kaldet/ILDTPCKalDetector.h b/Utilities/KalDet/kaldet/ILDTPCKalDetector.h
new file mode 100644
index 0000000000000000000000000000000000000000..e5ab8db97c723357f2fbd8e964ab319ec7102ca6
--- /dev/null
+++ b/Utilities/KalDet/kaldet/ILDTPCKalDetector.h
@@ -0,0 +1,29 @@
+#ifndef __ILDTPCDETECTOR__
+#define __ILDTPCDETECTOR__
+
+/** TPC to be used for ILD DBD studies
+ *
+ * @author S.Aplin DESY
+ */
+
+#include "kaltest/TVKalDetector.h"
+
+class TNode;
+
+namespace gear{
+ class GearMgr ;
+}
+
+
+class ILDTPCKalDetector : public TVKalDetector {
+public:
+
+ /** Initialize the TPC from GEAR */
+ ILDTPCKalDetector( const gear::GearMgr& gearMgr );
+
+
+private:
+
+};
+
+#endif
diff --git a/Utilities/KalDet/kaldet/ILDVMeasLayer.h b/Utilities/KalDet/kaldet/ILDVMeasLayer.h
new file mode 100644
index 0000000000000000000000000000000000000000..3d213b3aadcc3f5c3b4ff693462ff2e746e22f53
--- /dev/null
+++ b/Utilities/KalDet/kaldet/ILDVMeasLayer.h
@@ -0,0 +1,88 @@
+#ifndef __ILDVMEASLAYER__
+#define __ILDVMEASLAYER__
+
+/** ILDVMeasLayer: Virtual measurement layer class used by ILD[X]MeasLayer Classes.
+ *
+ * @author S.Aplin DESY
+ */
+
+#include "TVector3.h"
+#include "kaltest/TKalMatrix.h"
+#include "kaltest/TCylinder.h"
+#include "kaltest/TVMeasLayer.h"
+#include "kaltest/TAttDrawable.h"
+#include "kaltest/KalTrackDim.h"
+#include "TString.h"
+
+#include <vector>
+
+class TVTrackHit;
+class TNode;
+class ILDVTrackHit;
+
+namespace edm4hep{
+ class TrackerHit;
+}
+
+class ILDVMeasLayer : public TVMeasLayer {
+public:
+
+ static Bool_t kActive;
+ static Bool_t kDummy;
+
+ /** Get the layer ID */
+ inline int getLayerID() const { return _layerID ; }
+
+ /** Get the Cell ID associated with this measurement layer */
+ inline const std::vector<int>& getCellIDs() const { return _cellIDs ; }
+
+ /** Get the number of Cell ID associated with this measurement layer */
+ inline unsigned int getNCellIDs() const { return _cellIDs.size() ; }
+
+ /** Get the Magnetic field at the measurement surface */
+ inline Double_t GetBz() const { return _Bz; }
+
+ /** Convert LCIO Tracker Hit to an ILDPLanarTrackHit */
+ virtual ILDVTrackHit* ConvertLCIOTrkHit(edm4hep::TrackerHit* trkhit) const = 0 ;
+
+ /** Check whether the measurement layer represents a series of detector elements */
+ bool isMultilayer() const { return _isMultiLayer; }
+
+ /** Get the intersection and the CellID, needed for multilayers */
+ virtual int getIntersectionAndCellID(const TVTrack &hel,
+ TVector3 &xx,
+ Double_t &phi,
+ Int_t &CellID,
+ Int_t mode,
+ Double_t eps = 1.e-8) const = 0 ;
+
+protected:
+
+ ILDVMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ Double_t Bz,
+ Bool_t is_active = ILDVMeasLayer::kActive,
+ int CellID = -1 ,
+ const Char_t *name = "ILDMeasL");
+
+ ILDVMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ Double_t Bz,
+ const std::vector<int>& cellIDs,
+ Bool_t is_active = ILDVMeasLayer::kActive,
+ const Char_t *name = "ILDMeasL");
+
+
+
+ Double_t _Bz ; // Magnitude of B-Field in Z
+ int _layerID ;
+ std::vector<int> _cellIDs ;
+
+ bool _isMultiLayer;
+
+private:
+
+
+};
+
+#endif
diff --git a/Utilities/KalDet/kaldet/ILDVTrackHit.h b/Utilities/KalDet/kaldet/ILDVTrackHit.h
new file mode 100644
index 0000000000000000000000000000000000000000..d47be083ee5e2bc1a8871d8ba1578301e8b352f1
--- /dev/null
+++ b/Utilities/KalDet/kaldet/ILDVTrackHit.h
@@ -0,0 +1,33 @@
+#ifndef ILDVTrackHIT_H
+#define ILDVTrackHIT_H
+
+/** ILDVMeasLayer: Virtual hit class used by ILD[X]Hit Classes, which should provide coordinate vector as defined by the MeasLayer
+ *
+ * @author S.Aplin DESY
+ */
+
+
+#include "kaltest/TVTrackHit.h"
+
+#include "ILDVMeasLayer.h"
+
+#include "edm4hep/TrackerHit.h"
+
+class ILDVTrackHit : public TVTrackHit {
+
+public:
+
+ /** Constructor Taking coordinates and associated measurement layer, with bfield and number of measurement dimentions*/
+ ILDVTrackHit(const TVMeasLayer &ms, Double_t *x, Double_t *dx,
+ Double_t bfield , Int_t dim, edm4hep::TrackerHit* trkhit)
+ : TVTrackHit(ms, x, dx, bfield, dim), _trkhit(trkhit)
+ { /* no op */ }
+
+ edm4hep::TrackerHit* getLCIOTrackerHit() const { return _trkhit; }
+
+private:
+
+ edm4hep::TrackerHit* _trkhit;
+
+};
+#endif
diff --git a/Utilities/KalDet/kaldet/ILDVXDKalDetector.h b/Utilities/KalDet/kaldet/ILDVXDKalDetector.h
new file mode 100644
index 0000000000000000000000000000000000000000..c0205e149f55b4ca2340cdfc7549b17fd020cdbc
--- /dev/null
+++ b/Utilities/KalDet/kaldet/ILDVXDKalDetector.h
@@ -0,0 +1,73 @@
+#ifndef __ILDVXDKALDETECTOR__
+#define __ILDVXDKALDETECTOR__
+
+/** Ladder based VXD to be used for ILD DBD studies
+ *
+ * @author S.Aplin DESY
+ */
+
+#include "kaltest/TVKalDetector.h"
+
+#include "TMath.h"
+
+class TNode;
+class IGeoSvc;
+
+namespace gear{
+ class GearMgr ;
+}
+
+
+class ILDVXDKalDetector : public TVKalDetector {
+
+public:
+
+ ILDVXDKalDetector( const gear::GearMgr& gearMgr, IGeoSvc* geoSvc);
+
+
+private:
+
+ void setupGearGeom( const gear::GearMgr& gearMgr, IGeoSvc* geoSvc) ;
+
+ int _nLayers ;
+ double _bZ ;
+
+ double _relative_position_of_measurement_surface ;
+
+ struct VXD_Layer {
+ int nLadders;
+ double phi0;
+ double dphi;
+ double senRMin;
+ double supRMin;
+ double length;
+ double width;
+ double offset;
+ double senThickness;
+ double supThickness;
+ };
+ std::vector<VXD_Layer> _VXDgeo;
+
+
+ struct VXD_Cryostat {
+ double alRadius;
+ double alThickness;
+ double alInnerR;
+ double alZEndCap;
+ double alHalfZ;
+ double shellRadius;
+ double shellThickness;
+ double shellInnerR;
+ double shellZEndCap;
+ double shelllHalfZ;
+
+ bool exists;
+ };
+
+ VXD_Cryostat _vxd_Cryostat;
+
+};
+
+
+
+#endif
diff --git a/Utilities/KalDet/kaldet/LCTPCKalDetector.h b/Utilities/KalDet/kaldet/LCTPCKalDetector.h
new file mode 100644
index 0000000000000000000000000000000000000000..744793a8a0a6f82e4e16f4cb66c56b4b48acfd54
--- /dev/null
+++ b/Utilities/KalDet/kaldet/LCTPCKalDetector.h
@@ -0,0 +1,39 @@
+#ifndef LCTPCKALDETECTOR_H
+#define LCTPCKALDETECTOR_H
+
+#include "kaltest/TVKalDetector.h"
+
+#include "ILDVMeasLayer.h"
+
+namespace gear{
+ class GearMgr ;
+}
+
+namespace kaldet{
+
+ /**
+ * The LCTPC implementation for a TPC which is completely instantiated from GEAR.
+ *
+ */
+class LCTPCKalDetector : public TVKalDetector {
+
+public:
+
+ LCTPCKalDetector() {};
+
+ /**
+ * The constructor. All information to initialise the TPC is taken from GEAR.
+ *
+ * The class has been copied from GearTPCKalDetector class and adopted for the use of MarlinTrk
+ * You can find comments and necessary information in the original class
+ *
+ */
+ LCTPCKalDetector(const gear::GearMgr& gearMgr);
+
+ /// The destructor.
+ virtual ~LCTPCKalDetector();
+
+};
+
+}// namespace kaldet
+#endif //LCTPCKALDETECTOR_H
diff --git a/Utilities/KalDet/kaldet/MaterialDataBase.h b/Utilities/KalDet/kaldet/MaterialDataBase.h
new file mode 100644
index 0000000000000000000000000000000000000000..d1ed28bf0af03621cfc6dc9a1d7935b6a3833131
--- /dev/null
+++ b/Utilities/KalDet/kaldet/MaterialDataBase.h
@@ -0,0 +1,76 @@
+#ifndef MaterialDataBase_h
+#define MaterialDataBase_h
+
+/** MaterialDataBase: Class to hold and manage collection of materials
+ *
+ * @author S.Aplin DESY
+ */
+
+#include <string>
+#include <map>
+#include <exception>
+
+#include "lcio.h"
+#include "Exceptions.h"
+
+class TMaterial;
+
+namespace gear{
+ class GearMgr ;
+}
+class IGeoSvc;
+// fg: define the MaterialDataBaseException as an lcio Exception to allow for
+// messages to be printed in what()
+typedef lcio::Exception MaterialDataBaseException ;
+
+class MaterialDataBase {
+
+public:
+
+ /** Accessor Method */
+ static MaterialDataBase& Instance() {
+
+ static MaterialDataBase singleton;
+
+ return singleton;
+
+ }
+
+ // Other non-static member functions
+
+public:
+
+ /** Destructor */
+ ~MaterialDataBase();
+
+ /** Get Material via name */
+ TMaterial* getMaterial(std::string mat_name) ;
+
+ void registerForService(const gear::GearMgr& gearMgr, IGeoSvc* geoSvc=0) ;
+
+
+private:
+
+ void initialise(const gear::GearMgr& gearMgr, IGeoSvc* geoSvc) ;
+
+ MaterialDataBase() { _material_map.clear(); _isInitialised = false ; _gearMgr = 0; } // Private constructor
+
+
+ MaterialDataBase(const MaterialDataBase&) ; // Prevent copy-construction
+ MaterialDataBase& operator=(const MaterialDataBase&) ; // Prevent assignment
+
+ void addMaterial(TMaterial* mat, std::string name);
+ void createMaterials(const gear::GearMgr& gearMgr, IGeoSvc* geoSvc);
+
+ // private member variables
+ std::map<std::string,TMaterial* > _material_map;
+
+ bool _isInitialised;
+
+ const gear::GearMgr* _gearMgr;
+
+};
+
+
+
+#endif
diff --git a/Utilities/KalDet/src/gen/EXEventGen.cxx b/Utilities/KalDet/src/gen/EXEventGen.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..fa509413209a5710ca377f56802ab7238c128753
--- /dev/null
+++ b/Utilities/KalDet/src/gen/EXEventGen.cxx
@@ -0,0 +1,140 @@
+#include "EXEventGen.h"
+//#include "EXVKalDetector.h"
+//#include <EXVMeasLayer.h>
+#include "kaldet/EXTPCKalDetector.h"
+#include <kaldet/EXTPCMeasLayer.h>
+#include <kaltest/TPlane.h>
+#include <TRandom.h>
+#include <TMath.h>
+
+#include <iostream>
+#include <typeinfo> // needed for std::bad_cast exception
+
+//-----------------------------------
+// Track Parameters
+//-----------------------------------
+
+#define __DR__ 0.
+#define __DZ__ 0.
+
+Double_t EXEventGen::fgT0 = 0.; // [nsec]
+
+THelicalTrack EXEventGen::GenerateHelix(Double_t pt,
+ Double_t cosmin,
+ Double_t cosmax,
+ Double_t phimin,
+ Double_t phimax,
+ TVector3 xv0)
+{
+ // ---------------------------
+ // Generate a helical track
+ // ---------------------------
+
+ Double_t dr = __DR__;
+ Double_t fi0 = gRandom->Uniform(phimin,phimax);
+ Double_t cpa = 1. / pt;
+ Double_t dz = __DZ__;
+ Double_t cs = gRandom->Uniform(cosmin, cosmax);
+ Double_t tnl = cs / TMath::Sqrt((1-cs)*(1+cs));
+ Double_t x0 = xv0.X();
+ Double_t y0 = xv0.Y();
+ Double_t z0 = xv0.Z();
+
+ EXTPCMeasLayer * measLayer = dynamic_cast<EXTPCMeasLayer *>(fCradlePtr->At(0));
+ if (measLayer==0)
+ {
+ std::cerr << "EXEventGen::GenerateHelix: cast of fCradlePtr->At(0) to EXVMeasLayer * failed"
+ << std::endl;
+ std::cerr << "Derive your measurement layer from EXTPCMeasLayer instead of "
+ << "TVMeasLayer to use EXEventGen." << std::endl;
+
+ throw std::bad_cast();
+ }
+
+ EXTPCKalDetector const & kalDetector = dynamic_cast<const EXTPCKalDetector &>(measLayer->GetParent(kFALSE));
+ if (measLayer==0)
+ {
+ std::cerr << "EXEventGen::GenerateHelix: cast of (measLayer->GetParent(kFALSE) to EXTPCKalDetector * failed" << std::endl;
+ std::cerr << "Derive your detector from EXTPCKalDetector instead of "
+ << "TVKalDetector to use EXEventGen." << std::endl;
+ throw std::bad_cast();
+ }
+
+ Double_t b = kalDetector.GetBfield();
+
+ return THelicalTrack(dr,fi0,cpa,dz,tnl,x0,y0,z0,b);
+}
+
+void EXEventGen::Swim(THelicalTrack &heltrk)
+{
+ // ---------------------------
+ // Swim track and Make hits
+ // ---------------------------
+
+ // killenb: I have no idea what dfi is (delta phi?), but dividing the sorting policy by a
+ // radius does not make sense. The sorting polily used to return GetR() + GetXc().X(),
+ // so let's use this. It will onyl work for the LP1, but this class is deprecated anyway.
+ TCylinder * firstMeasCylinder = dynamic_cast<TCylinder *>(fCradlePtr->At(0));
+ if (firstMeasCylinder==0)
+ {
+ std::cerr << "Cannot cast first object in the cradle to TCylinder*"<< std::endl;
+ std::cerr << "EXEventGen only works for cylindrical measuremnt layers, sorry."<< std::endl;
+ throw std::bad_cast();
+ }
+ Double_t dfi = - (firstMeasCylinder->GetR() + firstMeasCylinder->GetXc().X())
+ / heltrk.GetRho();
+
+ Int_t nLayers = fCradlePtr->GetEntries();
+ Int_t dLayer = 1;
+ Double_t dfisum = 0.;
+
+ for (Int_t layer = 0; layer >= 0; layer += dLayer) { // loop over layers
+ // change direction if it starts looping back
+ if (layer == nLayers - 1) dLayer = -1;
+
+ // FIXME: This assumes that the measurement layer implementation is derived from
+ // TVSurface. This is not ensured by the interface!
+ EXTPCMeasLayer const * measurementLayer
+ = dynamic_cast<EXTPCMeasLayer const *>(fCradlePtr->At(layer));
+ //check that the object is a measurement layer. It better should be...
+ if (measurementLayer==0)
+ {
+ std::cerr << "EXEventGen::Swim(): fCradlePtr->At(layer) is not an EXVMeasLayer" << std::endl;
+ throw std::bad_cast();
+ }
+
+ TVSurface const * measurementSurface = dynamic_cast<TVSurface const *>(fCradlePtr->At(layer));
+ //check that the object is a surface. This part is not ensured by the interface.
+ if (measurementSurface==0)
+ {
+ std::cerr << "EXEventGen::Swim(): fCradlePtr->At(layer) is not a TVSurface" << std::endl;
+ throw std::bad_cast();
+ }
+
+
+ TVector3 xx;
+ Double_t dfis = dfi;
+ if (!measurementSurface->CalcXingPointWith(heltrk,xx,dfi,1)
+ || TMath::Abs(dfi) > TMath::Pi()
+ || TMath::Abs(dfi + dfisum) > TMath::TwoPi()) {
+ dfi = dfis;
+ continue;
+ }
+ // should use the material behind the surface since dfi is measured
+ // from the last point to the current surface
+ // Bool_t dir = dKayer < 0 ? kTRUE : kFALSE;
+
+ dfisum += dfi;
+
+ heltrk.MoveTo(xx,dfi); // move pivot to current hit
+
+ // killenb: seriously: check if the detector is powered?
+ if (measurementLayer->IsActive() )
+ // This has been kickes as true was hard coded anyway
+ // && dynamic_cast<const EXVKalDetector &>(measurementLayer->GetParent(kFALSE)).IsPowerOn())
+ {
+ measurementLayer->ProcessHit(xx, *fHitBufPtr); // create hit point
+ }
+ if (layer == nLayers - 1) break;
+ }
+}
diff --git a/Utilities/KalDet/src/gen/EXEventGen.h b/Utilities/KalDet/src/gen/EXEventGen.h
new file mode 100644
index 0000000000000000000000000000000000000000..6da2209f8aaa1f56e62b1bbac10e5f29e0ae833b
--- /dev/null
+++ b/Utilities/KalDet/src/gen/EXEventGen.h
@@ -0,0 +1,33 @@
+#ifndef __EXEVENTGEN__
+#define __EXEVENTGEN__
+
+#include "kaltest/TKalDetCradle.h"
+#include "kaltest/THelicalTrack.h"
+#include "TMath.h"
+
+class EXEventGen {
+public:
+ EXEventGen(TKalDetCradle const &cradle, TObjArray &kalhits)
+ : fCradlePtr(&cradle), fHitBufPtr(&kalhits) {}
+ virtual ~EXEventGen() {}
+
+ THelicalTrack GenerateHelix(Double_t pt,
+ Double_t cosmin,
+ Double_t cosmax,
+ Double_t phimin=0.,
+ Double_t phimax=2*TMath::Pi(),
+ TVector3 xv0=TVector3(0.,0.,0.));
+ void Swim(THelicalTrack &heltrk);
+
+ static void SetT0(Double_t t0) { fgT0 = t0; }
+ static Double_t GetT0() { return fgT0; }
+
+private:
+ TKalDetCradle const *fCradlePtr; // pointer to detector system
+ TObjArray *fHitBufPtr; // pointer to hit array
+
+ static Double_t fgT0; // t0
+
+};
+
+#endif
diff --git a/Utilities/KalDet/src/gen/LinkDef.h b/Utilities/KalDet/src/gen/LinkDef.h
new file mode 100644
index 0000000000000000000000000000000000000000..8f90de8e245edab60e2090fed338ca5b5a0d50f6
--- /dev/null
+++ b/Utilities/KalDet/src/gen/LinkDef.h
@@ -0,0 +1,9 @@
+#ifdef __CINT__
+
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+
+#pragma link C++ class EXEventGen+;
+
+#endif
diff --git a/Utilities/KalDet/src/ild/common/ILDConeMeasLayer.cc b/Utilities/KalDet/src/ild/common/ILDConeMeasLayer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..7ed8a8269582f00058c947ac1df3a2784d15b613
--- /dev/null
+++ b/Utilities/KalDet/src/ild/common/ILDConeMeasLayer.cc
@@ -0,0 +1,136 @@
+//*************************************************************************
+//* ===================
+//* ILDConeMeasLayer Class
+//* ===================
+//*
+//* (Update Recored)
+//* 2012/01/19 K.Fujii Original version. (EXBPConeMeasLayer)
+//* 2012/01/24 R.Glattauer Adapted to ILD common in KalDet
+//*
+//*************************************************************************
+//
+
+#include "ILDConeMeasLayer.h"
+#include "TMath.h"
+
+
+ILDConeMeasLayer::ILDConeMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ Double_t z1,
+ Double_t r1,
+ Double_t z2,
+ Double_t r2,
+ Double_t Bz,
+ Double_t SortingPolicy,
+ Bool_t is_active,
+ Int_t CellID,
+ const Char_t *name)
+ : ILDVMeasLayer(min, mout, Bz, is_active, CellID, name),
+ TCutCone(r1*(z2-z1)/(r2-r1),
+ r2*(z2-z1)/(r2-r1),
+ (r2-r1)/(z2-z1),
+ 0.,0.,(r2*z1-r1*z2)/(r2-r1)),
+ fZ1(z1),
+ fR1(r1),
+ fZ2(z2),
+ fR2(r2),
+ fsortingPolicy(SortingPolicy)
+{
+}
+
+ILDConeMeasLayer::~ILDConeMeasLayer()
+{
+}
+
+TKalMatrix ILDConeMeasLayer::XvToMv(const TVector3 &xxv) const
+{
+ // Calculate hit coordinate information:
+ // mv(0,0) = r * phi
+ // (1,0) = z
+
+ TKalMatrix mv(kMdim,1);
+ TVector3 xv = xxv - GetXc();
+ Double_t r = xv.Z()*GetTanA();
+
+ mv(0,0) = r * TMath::ATan2(xv.Y(), xv.X());
+ mv(1,0) = xv.Z();
+ return mv;
+}
+
+TKalMatrix ILDConeMeasLayer::XvToMv(const TVTrackHit &,
+ const TVector3 &xv) const
+{
+ return XvToMv(xv);
+}
+
+TVector3 ILDConeMeasLayer::HitToXv(const TVTrackHit &vht) const
+{
+// const EXBPConeHit &ht = dynamic_cast<const EXBPConeHit &>(vht);
+//
+// Double_t r = ht(1,0) * GetTanA();
+// Double_t phi = ht(0,0) / r;
+// Double_t x = GetXc().X() + r * TMath::Cos(phi);
+// Double_t y = GetXc().Y() + r * TMath::Sin(phi);
+// Double_t z = GetXc().Z() + ht(1,0);
+
+ // streamlog_out( ERROR ) << "Don't use this, it's not implemented!";
+
+ return TVector3(0.,0.,0.);
+}
+
+void ILDConeMeasLayer::CalcDhDa(const TVTrackHit &vht,
+ const TVector3 &xxv,
+ const TKalMatrix &dxphiada,
+ TKalMatrix &H) const
+{
+ // Calculate
+ // H = (@h/@a) = (@phi/@a, @z/@a)^t
+ // where
+ // h(a) = (phi, z)^t: expected meas vector
+ // a = (drho, phi0, kappa, dz, tanl, t0)
+ //
+
+ Int_t sdim = H.GetNcols();
+ Int_t hdim = TMath::Max(5,sdim-1);
+
+ TVector3 xv = xxv - GetXc();
+ Double_t x = xv.X();
+ Double_t y = xv.Y();
+ Double_t z = xv.Z();
+ Double_t xxyy = x * x + y * y;
+ Double_t phi = TMath::ATan2(y, x);
+ Double_t tana = GetTanA();
+ Double_t r = z * GetTanA();
+
+ // Set H = (@h/@a) = (@d/@a, @z/@a)^t
+
+ for (Int_t i=0; i<hdim; i++) {
+ H(0,i) = - r * (y / xxyy) * dxphiada(0,i)
+ + r * (x / xxyy) * dxphiada(1,i)
+ + tana * phi * dxphiada(2,i);
+ H(1,i) = dxphiada(2,i);
+ }
+ if (sdim == 6) {
+ H(0,sdim-1) = 0.;
+ H(1,sdim-1) = 0.;
+ }
+}
+
+Bool_t ILDConeMeasLayer::IsOnSurface(const TVector3 &xx) const
+{
+ TVector3 xxc = xx - GetXc();
+ Double_t r = xxc.Perp();
+ Double_t z = xxc.Z();
+ Double_t s = (r - GetTanA()*z) * (r + GetTanA()*z);
+ const Double_t kTol = 1.e-8;
+
+#if 0
+ std::cout << this->TVMeasLayer::GetName() << ":" << this->GetIndex() << ":" << std::endl;
+ std::cout << "s=" << s << " xx=(" << xx.X() << "," << xx.Y() << "," << xx.Z() << ")" << std::endl;
+ std::cout << "bool=" << (TMath::Abs(s) < kTol && ((xx.Z()-fZ1)*(xx.Z()-fZ2) <= 0.)) << std::endl;
+ std::cout << "fZ1=" << fZ1 << " fZ2=" << fZ2 << std::endl;
+#endif
+
+ return (TMath::Abs(s) < kTol && ((xx.Z()-fZ1)*(xx.Z()-fZ2) <= 0.));
+}
+
diff --git a/Utilities/KalDet/src/ild/common/ILDConeMeasLayer.h b/Utilities/KalDet/src/ild/common/ILDConeMeasLayer.h
new file mode 100644
index 0000000000000000000000000000000000000000..00e9fb0611e760c211a854bbf55cf93b8f1ef25c
--- /dev/null
+++ b/Utilities/KalDet/src/ild/common/ILDConeMeasLayer.h
@@ -0,0 +1,99 @@
+#ifndef ILDCONEMEASLAYER_H
+#define ILDCONEMEASLAYER_H
+//*************************************************************************
+//* ===================
+//* ILDConeMeasLayer Class
+//* ===================
+//*
+//* (Update Recored)
+//* 2012/01/19 K.Fujii Original version. (EXBPConeMeasLayer)
+//* 2012/01/24 R.Glattauer Adapted to ILD common in KalDet
+//*
+//*************************************************************************
+//
+#include "TVector3.h"
+
+#include "kaltest/TKalMatrix.h"
+#include "kaltest/TCutCone.h"
+#include "kaltest/KalTrackDim.h"
+
+#include "ILDVMeasLayer.h"
+#include "iostream"
+/* #include "streamlog/streamlog.h" */
+#include "UTIL/ILDConf.h"
+#include "edm4hep/TrackerHit.h"
+
+class ILDConeMeasLayer : public ILDVMeasLayer, public TCutCone {
+public:
+ // Ctors and Dtor
+ /** Constructor Taking inner and outer materials, z and radius at start and end, B-Field, whether the layer is sensitive, Cell ID, and an optional name */
+ ILDConeMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ Double_t z1,
+ Double_t r1,
+ Double_t z2,
+ Double_t r2,
+ Double_t Bz,
+ Double_t SortingPolicy,
+ Bool_t is_active,
+ Int_t CellID = -1,
+ const Char_t *name = "BPCONEML");
+ virtual ~ILDConeMeasLayer();
+
+ // Parrent's pure virtuals that must be implemented
+ /** Global to Local coordinates */
+ virtual TKalMatrix XvToMv (const TVTrackHit &ht,
+ const TVector3 &xv) const;
+
+ /** Global to Local coordinates */
+ virtual TKalMatrix XvToMv (const TVector3 &xv) const;
+
+ /** Local to Global coordinates */
+ virtual TVector3 HitToXv (const TVTrackHit &ht) const;
+
+ /** Calculate Projector Matrix */
+ virtual void CalcDhDa (const TVTrackHit &ht,
+ const TVector3 &xv,
+ const TKalMatrix &dxphiada,
+ TKalMatrix &H) const;
+
+ Bool_t IsOnSurface(const TVector3 &xx) const;
+
+ /** Convert LCIO Tracker Hit to an ILDCylinderHit */
+ virtual ILDVTrackHit* ConvertLCIOTrkHit(edm4hep::TrackerHit* trkhit) const {
+
+ /* streamlog_out( ERROR ) << "Don't use this, it's not implemented!"; */
+ return NULL;
+ }
+
+ /** Get the intersection and the CellID, needed for multilayers */
+ virtual int getIntersectionAndCellID(const TVTrack &hel,
+ TVector3 &xx,
+ Double_t &phi,
+ Int_t &CellID,
+ Int_t mode,
+ Double_t eps = 1.e-8) const {
+
+ CellID = this->getCellIDs()[0]; // not multilayer
+ return this->CalcXingPointWith(hel,xx,phi,0,eps);
+
+
+ }
+
+ /** Get sorting policy for this plane */
+ virtual double GetSortingPolicy() const { return fsortingPolicy; }
+
+
+
+
+private:
+ Double_t fZ1; // z of front face
+ Double_t fR1; // r of front face
+ Double_t fZ2; // z of back end
+ Double_t fR2; // r of back end
+ Double_t fsortingPolicy; // used for sorting the layers in to out
+
+
+};
+
+#endif
diff --git a/Utilities/KalDet/src/ild/common/ILDCylinderHit.cc b/Utilities/KalDet/src/ild/common/ILDCylinderHit.cc
new file mode 100644
index 0000000000000000000000000000000000000000..27f1fc6fd07971b25c45ceb8b9c190eea01a300b
--- /dev/null
+++ b/Utilities/KalDet/src/ild/common/ILDCylinderHit.cc
@@ -0,0 +1,52 @@
+
+#include "ILDCylinderHit.h"
+#include "ILDCylinderMeasLayer.h"
+#include "TMath.h"
+
+#include <iostream>
+#include <iomanip>
+
+using std::cerr;
+using std::endl;
+using std::setw;
+using std::setprecision;
+using std::ios;
+using std::resetiosflags;
+
+//_________________________________________________________________________
+// --------------------------------
+// Implementation of public methods
+// --------------------------------
+//
+
+
+/** Global to Local coordinates */
+
+TKalMatrix ILDCylinderHit::XvToMv(const TVector3 &xv, Double_t t0) const
+{
+
+ return this->GetMeasLayer().XvToMv(*(this), xv);
+
+}
+
+/** Print Debug information */
+
+void ILDCylinderHit::DebugPrint(Option_t *) const
+{
+ cerr << "------------------- Site Info -------------------------" << endl;
+
+ for (Int_t i = 0; i < GetDimension(); i++) {
+ Double_t x = (*this)(i, 0);
+ Double_t dx = (*this)(i, 1);
+ cerr << " x[" << i << "] = " << setw(8) << setprecision(5) << x
+ << " "
+ << "dx[" << i << "] = " << setw(6) << setprecision(2) << dx
+ << setprecision(7)
+ << resetiosflags(ios::showpoint)
+ << endl;
+ }
+ cerr << " r of ILDCylinderMeasLayer = " << setw(8)
+ << static_cast<const ILDCylinderMeasLayer &>(GetMeasLayer()).GetR() << endl;
+ cerr << "-------------------------------------------------------" << endl;
+}
+
diff --git a/Utilities/KalDet/src/ild/common/ILDCylinderHit.h b/Utilities/KalDet/src/ild/common/ILDCylinderHit.h
new file mode 100644
index 0000000000000000000000000000000000000000..9dbe5b73ef225aa41f7b06cf54d5775166073da3
--- /dev/null
+++ b/Utilities/KalDet/src/ild/common/ILDCylinderHit.h
@@ -0,0 +1,38 @@
+#ifndef ILDCYLINDERHIT_H
+#define ILDCYLINDERHIT_H
+
+/** ILDCylinderHit: User defined KalTest hit class using R and Rphi coordinates, which provides coordinate vector as defined by the MeasLayer
+ *
+ * @author S.Aplin DESY
+ */
+
+#include "kaltest/KalTrackDim.h"
+#include "ILDVTrackHit.h"
+
+
+class ILDCylinderHit : public ILDVTrackHit {
+
+public:
+
+
+ /** Constructor Taking R and Rphi coordinates and associated measurement layer, with bfield */
+ ILDCylinderHit(const TVMeasLayer &ms, Double_t *x, Double_t *dx,
+ Double_t bfield, edm4hep::TrackerHit* trkhit )
+ : ILDVTrackHit(ms, x, dx, bfield, 2, trkhit)
+ { /* no op */ }
+
+
+ // TVTrackHit's pure virtuals that must be implemented
+
+ /** Global to Local coordinates */
+ virtual TKalMatrix XvToMv(const TVector3 &xv, Double_t t0) const;
+
+ /** Print Debug information */
+ virtual void DebugPrint(Option_t *opt = "") const;
+
+
+private:
+
+
+};
+#endif
diff --git a/Utilities/KalDet/src/ild/common/ILDCylinderMeasLayer.cc b/Utilities/KalDet/src/ild/common/ILDCylinderMeasLayer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..72cb1119747490f57a2ccc61b116108d051c2e76
--- /dev/null
+++ b/Utilities/KalDet/src/ild/common/ILDCylinderMeasLayer.cc
@@ -0,0 +1,165 @@
+/** User defined KalTest measurement layer class
+ *
+ * @author S.Aplin DESY
+ */
+#include "kaltest/TKalTrack.h"
+
+#include "ILDCylinderMeasLayer.h"
+#include "ILDCylinderHit.h"
+
+#include <lcio.h>
+#include <edm4hep/TrackerHit.h>
+//#include <EVENT/TrackerHitZCylinder.h>
+
+#include "GaudiKernel/CommonMessaging.h"
+// #include "streamlog/streamlog.h"
+
+#include "TMath.h"
+#include <cmath>
+
+
+/** Global to Local coordinates */
+
+TKalMatrix ILDCylinderMeasLayer::XvToMv(const TVector3 &xv) const
+{
+
+ // Calculate hit coordinate information:
+ // mv(0, 0) = r * phi
+ // (1, 0) = drift distance
+
+ // account for cylinder not centered at x=0.0, y=0.0
+ TVector3 xxv = xv - GetXc();
+
+ Double_t phi = TMath::ATan2(xxv.Y(), xxv.X());
+
+ // bring phi back into +/- Pi range
+ static Double_t kPi = TMath::Pi();
+ static Double_t kTwoPi = 2 * kPi;
+ while (phi < -kPi) phi += kTwoPi;
+ while (phi > kPi) phi -= kTwoPi;
+
+ TKalMatrix mv(kMdim, 1);
+
+ mv(0, 0) = GetR() * phi;
+
+ mv(1, 0) = xxv.Z();
+
+ return mv;
+}
+
+
+/** Local to Global coordinates */
+
+TVector3 ILDCylinderMeasLayer::HitToXv(const TVTrackHit &vht) const
+{
+
+ Double_t phi = vht(0, 0) / GetR() ;
+ Double_t z = vht(1, 0);
+
+ // account for cylinder not centered at x=0.0, y=0.0
+ Double_t x = GetR() * TMath::Cos(phi) + GetXc().X();
+ Double_t y = GetR() * TMath::Sin(phi) + GetXc().Y();
+
+ return TVector3(x, y, z);
+}
+
+
+/** Calculate Projector Matrix */
+
+void ILDCylinderMeasLayer::CalcDhDa(const TVTrackHit &vht, // tracker hit not used here
+ const TVector3 &xxv,
+ const TKalMatrix &dxphiada,
+ TKalMatrix &H) const
+{
+
+ // Calculate
+ // H = (@h/@a) = (@phi/@a, @z/@a)^t
+ // where
+ // h(a) = (phi, z)^t: expected meas vector
+ // a = (drho, phi0, kappa, dz, tanl, t0)
+ //
+
+ Int_t sdim = H.GetNcols();
+ Int_t hdim = TMath::Max(5, sdim - 1);
+
+ // account for cylinder not centered at x=0.0, y=0.0
+ TVector3 xxvc = xxv - GetXc();
+
+ Double_t xv = xxvc.X();
+ Double_t yv = xxvc.Y();
+ Double_t xxyy = xv * xv + yv * yv;
+
+ // Set H = (@h/@a) = (@d/@a, @z/@a)^t
+
+ for (Int_t i = 0; i < hdim; i++) {
+ H(0, i) = - (yv / xxyy) * dxphiada(0, i)
+ + (xv / xxyy) * dxphiada(1, i);
+ H(0, i) *= GetR();
+
+ H(1, i) = dxphiada(2, i);
+ }
+
+ if (sdim == 6) {
+ H(0, sdim - 1) = 0.;
+ }
+
+}
+
+
+/** Convert LCIO Tracker Hit to an ILDCylinderHit */
+
+ILDVTrackHit* ILDCylinderMeasLayer::ConvertLCIOTrkHit(edm4hep::TrackerHit* trkhit) const {
+ if ( ! trkhit) {
+ // streamlog_out(ERROR) << "ILDCylinderMeasLayer::ConvertLCIOTrkHit trkhit pointer is NULL" << std::endl;
+ return NULL;
+ }
+
+ const edm4hep::Vector3d& pos = trkhit->getPosition();
+ const TVector3 hit(pos.x, pos.y, pos.z) ;
+ //SJA:FIXME: this assumes that the cylinder is centred at 0,0
+
+ // convert to layer coordinates
+ TKalMatrix h = this->XvToMv(hit);
+
+ Double_t x[2] ;
+ Double_t dx[2] ;
+
+ x[0] = h(0, 0);
+ x[1] = h(1, 0);
+
+
+ //EVENT::TrackerHitZCylinder* cylinder_hit = dynamic_cast<EVENT::TrackerHitZCylinder*>( trkhit ) ;
+ if(trkhit->getType()==16){
+ //if(cylinder_hit){
+ // convert errors
+ dx[0] = trkhit->getCovMatrix(0);
+ dx[1] = trkhit->getCovMatrix(1);
+ }
+ else {
+ // convert errors
+ dx[0] = sqrt(trkhit->getCovMatrix(0) + trkhit->getCovMatrix(2)) ;
+ dx[1] = sqrt(trkhit->getCovMatrix(5));
+ }
+
+
+ bool hit_on_surface = IsOnSurface(hit);
+
+ //debug() << "ILDCylinderMeasLayer::ConvertLCIOTrkHit ILDCylinderHit created"
+ // streamlog_out(DEBUG1) << "ILDCylinderMeasLayer::ConvertLCIOTrkHit ILDCylinderHit created"
+ // << " R = " << hit.Perp()
+ // << " Layer R = " << this->GetR()
+ // << " RPhi = " << x[0]
+ // << " Z = " << x[1]
+ // << " dRPhi = " << dx[0]
+ // << " dZ = " << dx[1]
+ // << " x = " << pos.x
+ // << " y = " << pos.y
+ // << " z = " << pos.z
+ // << " onSurface = " << hit_on_surface
+ // << std::endl ;
+ //<<endmsg;
+
+ return hit_on_surface ? new ILDCylinderHit( *this , x, dx, this->GetBz(), trkhit) : NULL;
+
+}
+
diff --git a/Utilities/KalDet/src/ild/common/ILDCylinderMeasLayer.h b/Utilities/KalDet/src/ild/common/ILDCylinderMeasLayer.h
new file mode 100644
index 0000000000000000000000000000000000000000..04740cc81edde2029bc347dc50a481001a2f2740
--- /dev/null
+++ b/Utilities/KalDet/src/ild/common/ILDCylinderMeasLayer.h
@@ -0,0 +1,93 @@
+#ifndef ILDCYLINDERMEASLAYER_H
+#define ILDCYLINDERMEASLAYER_H
+
+/** ILDCylinderMeasLayer: User defined KalTest measurement layer class
+ *
+ * @author S.Aplin DESY
+ */
+
+
+#include "ILDVMeasLayer.h"
+#include <iostream>
+#include <cmath>
+/* #include "streamlog/streamlog.h" */
+
+
+class ILDCylinderMeasLayer : public ILDVMeasLayer, public TCylinder {
+
+public:
+
+ /** Constructor Taking inner and outer materials, radius and half length, B-Field, whether the layer is sensitive, Cell ID, and an optional name */
+ ILDCylinderMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ Double_t r0,
+ Double_t lhalf,
+ Double_t x0,
+ Double_t y0,
+ Double_t z0,
+ Double_t Bz,
+ Bool_t is_active,
+ Int_t CellID = -1,
+ const Char_t *name = "ILDCylinderMeasL")
+ : ILDVMeasLayer(min, mout, Bz, is_active, CellID, name),
+ TCylinder(r0, lhalf,x0,y0,z0)
+ { /* no op */ }
+
+
+ Bool_t IsOnSurface(const TVector3 &xx) const {
+
+ bool z = (xx.Z() >= GetZmin() && xx.Z() <= GetZmax());
+ bool r = std::fabs( (xx-this->GetXc()).Perp() - this->GetR() ) < 1.e-3; // for very short, very stiff tracks this can be poorly defined, so we relax this here a bit to 1 micron
+
+// streamlog_out(DEBUG0) << "ILDCylinderMeasLayer IsOnSurface for " << this->TVMeasLayer::GetName() << " R = " << this->GetR() << " GetZmin() = " << GetZmin() << " GetZmax() = " << GetZmax()
+// << " dr = " << std::fabs( (xx-this->GetXc()).Perp() - this->GetR() ) << " r = " << r << " z = " << z
+// << std::endl;
+
+ return r && z;
+ }
+
+
+
+ // Parent's pure virtuals that must be implemented
+
+ /** Global to Local coordinates */
+ virtual TKalMatrix XvToMv (const TVector3 &xv) const;
+
+ /** Global to Local coordinates */
+ virtual TKalMatrix XvToMv (const TVTrackHit &ht,
+ const TVector3 &xv) const
+
+ { return this->XvToMv(xv); }
+
+
+ /** Local to Global coordinates */
+ virtual TVector3 HitToXv (const TVTrackHit &ht) const;
+
+
+ /** Calculate Projector Matrix */
+ virtual void CalcDhDa (const TVTrackHit &ht,
+ const TVector3 &xv,
+ const TKalMatrix &dxphiada,
+ TKalMatrix &H) const;
+
+ /** Convert LCIO Tracker Hit to an ILDCylinderHit */
+ virtual ILDVTrackHit* ConvertLCIOTrkHit(edm4hep::TrackerHit* trkhit) const ;
+
+ /** Get the intersection and the CellID, needed for multilayers */
+ virtual int getIntersectionAndCellID(const TVTrack &hel,
+ TVector3 &xx,
+ Double_t &phi,
+ Int_t &CellID,
+ Int_t mode,
+ Double_t eps = 1.e-8) const {
+
+ CellID = this->getCellIDs()[0]; // not multilayer
+ return this->CalcXingPointWith(hel,xx,phi,0,eps);
+
+ }
+
+
+private:
+
+};
+#endif
diff --git a/Utilities/KalDet/src/ild/common/ILDDiscMeasLayer.cc b/Utilities/KalDet/src/ild/common/ILDDiscMeasLayer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..d8d476fc30abc2b30711a4cbce25f03104fc28aa
--- /dev/null
+++ b/Utilities/KalDet/src/ild/common/ILDDiscMeasLayer.cc
@@ -0,0 +1,271 @@
+
+#include <iostream>
+
+#include "ILDDiscMeasLayer.h"
+#include "ILDPlanarHit.h"
+
+#include "kaltest/TVTrack.h"
+#include "TVector3.h"
+#include "TMath.h"
+#include "TRotMatrix.h"
+#include "TBRIK.h"
+#include "TNode.h"
+#include "TString.h"
+
+#include <edm4hep/TrackerHit.h>
+
+#include "gearimpl/Vector3D.h"
+
+// #include "streamlog/streamlog.h"
+
+
+TKalMatrix ILDDiscMeasLayer::XvToMv(const TVector3 &xv) const
+{
+
+ // Calculate measurement vector (hit coordinates) from global coordinates:
+
+ TKalMatrix mv(kMdim,1);
+
+ mv(0,0) = xv.X() ;
+
+
+ mv(1,0) = xv.Y() ;
+ return mv;
+
+}
+
+
+TVector3 ILDDiscMeasLayer::HitToXv(const TVTrackHit &vht) const
+{
+ // const ILDPlanarHit &mv = dynamic_cast<const ILDPlanarHit &>(vht);
+
+ double x = vht(0,0) ;
+ double y = vht(1,0) ;
+
+ double z = GetXc().Z() ;
+
+ return TVector3(x,y,z);
+}
+
+void ILDDiscMeasLayer::CalcDhDa(const TVTrackHit &vht,
+ const TVector3 &xxv,
+ const TKalMatrix &dxphiada,
+ TKalMatrix &H) const
+{
+ // Calculate
+ // H = (@h/@a) = (@phi/@a, @z/@a)^t
+ // where
+ // h(a) = (phi, z)^t: expected meas vector
+ // a = (drho, phi0, kappa, dz, tanl, t0)
+ //
+
+ Int_t sdim = H.GetNcols();
+ Int_t hdim = TMath::Max(5,sdim-1);
+
+ // Set H = (@h/@a) = (@d/@a, @z/@a)^t
+
+ for (Int_t i=0; i<hdim; i++) {
+
+ H(0,i) = dxphiada(0,i);
+ H(1,i) = dxphiada(1,i) ;
+
+ }
+ if (sdim == 6) {
+ H(0,sdim-1) = 0.;
+ H(1,sdim-1) = 0.;
+ }
+
+}
+
+Int_t ILDDiscMeasLayer::CalcXingPointWith(const TVTrack &hel,
+ TVector3 &xx,
+ Double_t &phi,
+ Int_t mode,
+ Double_t eps) const{
+
+ phi = 0.0;
+
+ xx.SetX(0.0);
+ xx.SetY(0.0);
+ xx.SetZ(0.0);
+
+
+ // check that direction has one of the correct values
+ if( !( mode == 0 || mode == 1 || mode == -1) ) return -1 ;
+
+ // get helix parameters
+ Double_t dr = hel.GetDrho();
+ Double_t phi0 = hel.GetPhi0(); //
+ Double_t kappa = hel.GetKappa();
+ Double_t rho = hel.GetRho();
+ Double_t omega = 1.0 / rho;
+ Double_t z0 = hel.GetDz();
+ Double_t tanl = hel.GetTanLambda();
+
+ TVector3 ref_point = hel.GetPivot();
+
+
+ //
+ // Check if charge is nonzero.
+ //
+
+ Int_t chg = (Int_t)TMath::Sign(1.1,kappa);
+ if (!chg) {
+ // streamlog_out(ERROR) << ">>>> Error >>>> ILDDiscMeasLayer::CalcXingPointWith" << std::endl
+ // << " Kappa = 0 is invalid for a helix " << std::endl;
+ return -1;
+ }
+
+ const double sin_phi0 = sin(phi0);
+ const double cos_phi0 = cos(phi0);
+
+ const double x_pca = ref_point.x() + dr * cos_phi0 ;
+ const double y_pca = ref_point.y() + dr * sin_phi0 ;
+ const double z_pca = ref_point.z() + z0 ;
+
+ const double z = this->GetXc().Z() ;
+ // get path length to crossing point
+
+ const double s = ( z - z_pca ) / tanl ;
+
+// streamlog_out(DEBUG0) << "ILDDiscMeasLayer::CalcXingPointWith "
+// << " ref_point.z() = " << ref_point.z()
+// << " z = " << z
+// << " z0 = " << z0
+// << " z_pca = " << z_pca
+// << " tanl = " << tanl
+// << " z - z_pca = " << z - z_pca
+// << std::endl;
+
+// TVector3 xx_n;
+// int cuts = TVSurface::CalcXingPointWith(hel, xx_n, phi, 0, eps);
+// streamlog_out(DEBUG0) << "ILDDiscMeasLayer::CalcXingPointWith from Newton: cuts = " << cuts << " x = " << xx_n.x() << " y = "<< xx_n.y() << " z = " << xx_n.z() << " r = " << xx_n.Perp() << " phi = " << xx_n.Phi() << " dphi = " << phi << std::endl;
+
+
+ phi = -omega * s;
+
+ const double delta_phi_half = -phi/2.0 ;
+
+
+ double x;
+ double y;
+
+ if( fabs(s) > FLT_MIN ){ // protect against starting on the plane
+
+ x = x_pca - s * ( sin(delta_phi_half) / delta_phi_half ) * sin( phi0 - delta_phi_half ) ;
+
+ y = y_pca + s * ( sin(delta_phi_half) / delta_phi_half ) * cos( phi0 - delta_phi_half ) ;
+
+ }
+ else{
+ // streamlog_out(DEBUG0) << "ILDDiscMeasLayer::CalcXingPointWith Using PCA values " << std::endl;
+ x = x_pca;
+ y = y_pca;
+ phi = 0;
+ }
+
+
+ // check if intersection with plane is within boundaries
+
+ xx.SetXYZ(x, y, z);
+
+
+ // streamlog_out(DEBUG0) << "ILDDiscMeasLayer::CalcXingPointWith : cuts = " << (IsOnSurface(xx) ? 1 : 0) << " x = " << xx.x() << " y = "<< xx.y() << " z = " << xx.z() << " r = " << xx.Perp() << " phi = " << xx.Phi() << " dphi = " << phi << " s = " << s << " " << this->TVMeasLayer::GetName() << std::endl;
+
+ if( mode!=0 && fabs(phi)>1.e-10 ){ // (+1,-1) = (fwd,bwd)
+ if( chg*phi*mode > 0){
+ return 0;
+ }
+ }
+
+ return (IsOnSurface(xx) ? 1 : 0);
+
+}
+
+
+Bool_t ILDDiscMeasLayer::IsOnSurface(const TVector3 &xx) const
+{
+
+ bool onSurface = false ;
+
+ TKalMatrix mv = XvToMv(xx);
+
+ // check whether the hit lies in the same plane as the surface
+ if( TMath::Abs((xx.X()-GetXc().X())*GetNormal().X() + (xx.Y()-GetXc().Y())*GetNormal().Y() + (xx.Z()-GetXc().Z())*GetNormal().Z()) < 1e-4){
+ // check whether the hit lies within the boundary of the surface
+
+ double r2 = mv(0,0) * mv(0,0) + mv(1,0) * mv(1,0) ;
+
+ if( r2 <= _rMax*_rMax && r2 >= _rMin*_rMin )
+ {
+ onSurface = true ;
+ }
+ }
+
+ return onSurface;
+
+}
+
+
+ILDVTrackHit* ILDDiscMeasLayer::ConvertLCIOTrkHit(edm4hep::TrackerHit* trkhit) const {
+
+ //edm4hep::TrackerHitPlane* plane_hit = dynamic_cast<EVENT::TrackerHitPlane*>( trkhit ) ;
+ //edm4hep::TrackerHitPlane* plane_hit = trkhit;
+ if((trkhit->getType()&8)!=8) return NULL;
+
+ //edm4hep::TrackerHit* plane_hit = trkhit;
+ //if( plane_hit == NULL ) return NULL; // SJA:FIXME: should be replaced with an exception
+
+ //gear::Vector3D U(1.0,plane_hit->getU()[1],plane_hit->getU()[0],gear::Vector3D::spherical);
+ //gear::Vector3D V(1.0,plane_hit->getV()[1],plane_hit->getV()[0],gear::Vector3D::spherical);
+ gear::Vector3D U(1.0,trkhit->getCovMatrix(1),trkhit->getCovMatrix(0),gear::Vector3D::spherical);
+ gear::Vector3D V(1.0,trkhit->getCovMatrix(5),trkhit->getCovMatrix(4),gear::Vector3D::spherical);
+ gear::Vector3D X(1.0,0.0,0.0);
+ gear::Vector3D Y(0.0,1.0,0.0);
+
+ const float eps = 1.0e-07;
+ // U must be the global X axis
+ if( fabs(1.0 - U.dot(X)) > eps ) {
+ // streamlog_out(ERROR) << "ILDDiscMeasLayer: TrackerHitPlane measurment vectors U is not equal to the global X axis. \n\n exit(1) called from file " << __FILE__ << " and line " << __LINE__ << std::endl;
+ exit(1);
+ }
+
+ // V must be the global X axis
+ if( fabs(1.0 - V.dot(Y)) > eps ) {
+ // streamlog_out(ERROR) << "ILDDiscMeasLayer: TrackerHitPlane measurment vectors V is not equal to the global Y axis. \n\n exit(1) called from file " << __FILE__ << " and line " << __LINE__ << std::endl;
+ exit(1);
+ }
+
+ const edm4hep::Vector3d& pos=trkhit->getPosition();
+ const TVector3 hit(pos.x, pos.y, pos.z);
+
+ // convert to layer coordinates
+ TKalMatrix h = this->XvToMv(hit);
+
+ double x[2] ;
+ double dx[2] ;
+
+ x[0] = h(0, 0);
+ x[1] = h(1, 0);
+
+ //dx[0] = plane_hit->getdU() ;
+ //dx[1] = plane_hit->getdV() ;
+ dx[0] = trkhit->getCovMatrix(2);
+ dx[1] = trkhit->getCovMatrix(5);
+
+ bool hit_on_surface = IsOnSurface(hit);
+
+ // streamlog_out(DEBUG1) << "ILDDiscMeasLayer::ConvertLCIOTrkHit ILDPlanarHit created"
+ // << " u = " << x[0]
+ // << " v = " << x[1]
+ // << " du = " << dx[0]
+ // << " dv = " << dx[1]
+ // << " x = " << pos.x
+ // << " y = " << pos.y
+ // << " z = " << pos.z
+ // << " onSurface = " << hit_on_surface
+ // << std::endl ;
+
+ return hit_on_surface ? new ILDPlanarHit( *this , x, dx, this->GetBz(), trkhit) : NULL;
+
+}
diff --git a/Utilities/KalDet/src/ild/common/ILDDiscMeasLayer.h b/Utilities/KalDet/src/ild/common/ILDDiscMeasLayer.h
new file mode 100644
index 0000000000000000000000000000000000000000..fe3ff82672144da1330120ebe3a8a26d56ae21d4
--- /dev/null
+++ b/Utilities/KalDet/src/ild/common/ILDDiscMeasLayer.h
@@ -0,0 +1,101 @@
+#ifndef __ILDDISCMEASLAYER__
+#define __ILDDISCMEASLAYER__
+
+/** ILDDiscMeasLayer: User defined KalTest Disc measurement layer class used with ILDPLanarTrackHit.
+ *
+ * @author S.Aplin DESY
+ */
+
+#include "TVector3.h"
+
+#include "kaltest/TKalMatrix.h"
+#include "kaltest/TPlane.h"
+#include "kaltest/KalTrackDim.h"
+#include "ILDVMeasLayer.h"
+
+#include "TMath.h"
+#include <sstream>
+
+class TVTrackHit;
+
+
+class ILDDiscMeasLayer : public ILDVMeasLayer, public TPlane {
+
+public:
+
+ /** Constructor Taking inner and outer materials, center and normal to the plane, B-Field, sorting policy, min and max r, whether the layer is sensitive, Cell ID, and an optional name */
+
+ ILDDiscMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ const TVector3 ¢er,
+ const TVector3 &normal,
+ double Bz,
+ double SortingPolicy,
+ double rMin,
+ double rMax,
+ Bool_t is_active,
+ Int_t CellID = -1,
+ const Char_t *name = "ILDDiscMeasL")
+ : ILDVMeasLayer(min, mout, Bz, is_active, CellID, name),
+ TPlane(center, normal),
+ _sortingPolicy(SortingPolicy), _rMin(rMin), _rMax(rMax)
+ { /* no op */ }
+
+
+
+ // Parrent's pure virtuals that must be implemented
+
+ /** Global to Local coordinates */
+ virtual TKalMatrix XvToMv (const TVTrackHit &ht,
+ const TVector3 &xv) const
+ { return this->XvToMv(xv); }
+
+ /** Global to Local coordinates */
+ virtual TKalMatrix XvToMv (const TVector3 &xv) const;
+
+ /** Local to Global coordinates */
+ virtual TVector3 HitToXv (const TVTrackHit &ht) const;
+
+ /** Calculate Projector Matrix */
+ virtual void CalcDhDa (const TVTrackHit &ht,
+ const TVector3 &xv,
+ const TKalMatrix &dxphiada,
+ TKalMatrix &H) const;
+
+ virtual Int_t CalcXingPointWith(const TVTrack &hel,
+ TVector3 &xx,
+ Double_t &phi,
+ Int_t mode,
+ Double_t eps) const;
+
+
+ /** Convert LCIO Tracker Hit to an ILDPLanarTrackHit */
+ virtual ILDVTrackHit* ConvertLCIOTrkHit(edm4hep::TrackerHit* trkhit) const ;
+
+ /** Check if global point is on surface */
+ inline virtual Bool_t IsOnSurface (const TVector3 &xx) const;
+
+ /** Get sorting policy for this plane */
+ double GetSortingPolicy() const { return _sortingPolicy; }
+
+ /** Get the intersection and the CellID, needed for multilayers */
+ virtual int getIntersectionAndCellID(const TVTrack &hel,
+ TVector3 &xx,
+ Double_t &phi,
+ Int_t &CellID,
+ Int_t mode,
+ Double_t eps = 1.e-8) const {
+
+ CellID = this->getCellIDs()[0]; // not multilayer
+ return this->CalcXingPointWith(hel,xx,phi,0,eps);
+
+ }
+
+private:
+ double _sortingPolicy;
+ double _rMin;
+ double _rMax;
+
+};
+
+#endif
diff --git a/Utilities/KalDet/src/ild/common/ILDMeasurementSurfaceStoreFiller.cc b/Utilities/KalDet/src/ild/common/ILDMeasurementSurfaceStoreFiller.cc
new file mode 100644
index 0000000000000000000000000000000000000000..1d7e527aa65f823abb4cbbb852d549628704334f
--- /dev/null
+++ b/Utilities/KalDet/src/ild/common/ILDMeasurementSurfaceStoreFiller.cc
@@ -0,0 +1,403 @@
+
+#include "ILDMeasurementSurfaceStoreFiller.h"
+
+#include "UTIL/ILDConf.h"
+
+#include <gear/ZPlanarParameters.h>
+#include <gear/ZPlanarLayerLayout.h>
+#include <gear/FTDLayerLayout.h>
+#include <gear/FTDParameters.h>
+#include <gear/GEAR.h>
+#include <gear/GearMgr.h>
+
+// #include "streamlog/streamlog.h"
+
+
+#include "gear/gearsurf/CartesianCoordinateSystem.h"
+#include "gear/gearsurf/MeasurementSurface.h"
+#include "gear/gearsurf/BoundaryRectangle.h"
+#include "gear/gearsurf/BoundaryTrapezoid.h"
+
+void ILDMeasurementSurfaceStoreFiller::get_gear_parameters(const gear::GearMgr& gear_mgr) {
+
+ _paramVXD = 0 ; try { _paramVXD = &(gear_mgr.getVXDParameters()); } catch( gear::UnknownParameterException& e){}
+ _paramSIT = 0 ; try { _paramSIT = &(gear_mgr.getSITParameters()); } catch( gear::UnknownParameterException& e){}
+ _paramSET = 0 ; try { _paramSET = &(gear_mgr.getSETParameters()); } catch( gear::UnknownParameterException& e){}
+ _paramFTD = 0 ; try { _paramFTD = &(gear_mgr.getFTDParameters()); } catch( gear::UnknownParameterException& e){}
+
+
+ if( _paramVXD ){
+ unsigned nVTXLayers = _paramVXD->getZPlanarLayerLayout().getNLayers() ;
+
+ for( unsigned i=0; i<nVTXLayers; i++) {
+
+ _VTXStripAngles.push_back( 0. );
+
+ //*****************************************************************
+ // Note currently the VXD is constructed as single sensor ladders
+ //*****************************************************************
+ _VTXNSensors.push_back( 1 );
+
+ }
+ }
+
+ if( _paramSIT ){
+
+ unsigned nSITLayers = _paramSIT->getZPlanarLayerLayout().getNLayers();
+
+ try {
+
+ double strip_angle_deg = _paramSIT->getDoubleVal("strip_angle_deg");
+
+ for( unsigned i=0; i<nSITLayers; i++) {
+
+ _SITStripAngles.push_back( pow(-1,i) * strip_angle_deg * M_PI/180 ); // alternately + and - 5°
+ _SITNSensors.push_back(_paramSIT->getIntVals("n_sensors_per_ladder")[i]);
+
+ }
+
+ } catch (gear::UnknownParameterException& e) {
+
+ for( unsigned i=0; i<nSITLayers; i++) {
+ _SITStripAngles.push_back( 0. );
+ _SITNSensors.push_back(_paramSIT->getIntVals("n_sensors_per_ladder")[i]);
+ }
+
+ }
+ }
+
+ if( _paramSET ){
+
+ unsigned nSETLayers = _paramSET->getZPlanarLayerLayout().getNLayers();
+
+ try {
+
+ double strip_angle_deg = _paramSET->getDoubleVal("strip_angle_deg");
+
+ for( unsigned i=0; i<nSETLayers; i++) {
+
+ _SETStripAngles.push_back( pow(-1,i) * strip_angle_deg * M_PI/180 ); // alternately + and - 5°
+ _SETNSensors.push_back(_paramSET->getIntVals("n_sensors_per_ladder")[i]);
+
+ }
+
+ } catch (gear::UnknownParameterException& e) {
+
+ for( unsigned i=0; i<nSETLayers; i++) {
+ _SETStripAngles.push_back( 0. );
+ _SETNSensors.push_back(_paramSET->getIntVals("n_sensors_per_ladder")[i]);
+
+ }
+ }
+ }
+
+
+ if( _paramFTD ){
+
+ const gear::FTDLayerLayout& ftdLayers = _paramFTD->getFTDLayerLayout() ;
+ unsigned nFTDLayers = ftdLayers.getNLayers();
+
+ for( unsigned layer=0; layer<nFTDLayers; layer++ ){
+
+ std::vector< double > angles;
+
+ unsigned nSensors = ftdLayers.getNSensors( layer );
+
+ if (ftdLayers.getSensorType(layer) == gear::FTDParameters::STRIP ){
+
+ double strip_angle_deg = _paramFTD->getDoubleVal("strip_angle_deg");
+
+ for( unsigned sensor=1; sensor <= nSensors; sensor++ ){
+
+
+ if ( sensor <= nSensors/2 ) angles.push_back( strip_angle_deg * M_PI/180. ); // the first half of the sensors is in front with one angle,
+ else angles.push_back( -strip_angle_deg * M_PI/180. ); // the other is in the back with the opposite angle
+
+ }
+
+ }
+ else{ // a pixel detector, so no stripAngle
+
+ double strip_angle_deg = 0.0 ;
+ for( unsigned sensor=1; sensor <= nSensors; sensor++ ) angles.push_back(strip_angle_deg);
+
+ }
+
+ _FTDStripAngles.push_back( angles );
+
+ }
+ }
+ //#endif
+
+}
+
+
+
+
+void ILDMeasurementSurfaceStoreFiller::getMeasurementSurfaces( std::vector<MeasurementSurface*>& surface_list ) const {
+
+ if( _paramVXD )
+ this->storeZPlanar( _paramVXD , UTIL::ILDDetID::VXD, surface_list );
+
+ if( _paramSIT )
+ this->storeZPlanar( _paramSIT , UTIL::ILDDetID::SIT, surface_list );
+
+ if(_paramSET )
+ this->storeZPlanar( _paramSET , UTIL::ILDDetID::SET, surface_list );
+
+ if( _paramFTD )
+ this->storeFTD( _paramFTD , surface_list);
+
+}
+
+
+void ILDMeasurementSurfaceStoreFiller::storeZPlanar( const gear::ZPlanarParameters* param , int det_id, std::vector<MeasurementSurface*>& surface_list ) const {
+
+
+ std::vector< double > angles;
+ std::vector< int > nsensors;
+
+ if( det_id == UTIL::ILDDetID::VXD ) {
+
+ angles = _VTXStripAngles;
+ nsensors = _VTXNSensors;
+ }
+ else if ( det_id == UTIL::ILDDetID::SIT ){
+ angles = _SITStripAngles;
+ nsensors = _SITNSensors;
+ }
+
+ else if ( det_id == UTIL::ILDDetID::SET ){
+ angles = _SETStripAngles;
+ nsensors = _SETNSensors;
+
+ }
+
+ else {
+ return;
+ }
+
+
+ const gear::ZPlanarLayerLayout& layerLayout = param->getZPlanarLayerLayout();
+
+ unsigned nLayers = layerLayout.getNLayers();
+
+ for( unsigned layerNumber = 0; layerNumber < nLayers; layerNumber++ ){
+
+ unsigned nLadders = layerLayout.getNLadders( layerNumber );
+
+ double ladder_r = layerLayout.getSensitiveDistance(layerNumber); // the distance of the ladders from (0,0,0)
+ double sensitive_offset = layerLayout.getSensitiveOffset(layerNumber); // the offset, see ZPlanarLayerLayout.h for more details
+ double deltaPhi = ( 2 * M_PI ) / nLadders ; // the phi difference between two ladders
+ double phi0 = layerLayout.getPhi0( layerNumber );
+ double sensitive_length = layerLayout.getSensitiveLength(layerNumber) * 2.0 ; // note: gear for historical reasons uses the halflength
+ double sensitive_width = layerLayout.getSensitiveWidth(layerNumber);
+ double sensitive_thickness = layerLayout.getSensitiveThickness(layerNumber);
+
+ double stripAngle = angles.at(layerNumber);
+
+ for( unsigned ladderNumber = 0; ladderNumber < nLadders; ladderNumber++ ){
+
+ for( int sensorNumber = 0; sensorNumber < nsensors.at(layerNumber); sensorNumber++ ){
+
+ // determine the CellID0 for the ladder
+ UTIL::BitField64 cellID( UTIL::ILDCellID0::encoder_string );
+ cellID[ lcio::ILDCellID0::subdet ] = det_id ;
+ cellID[ lcio::ILDCellID0::side ] = 0 ;
+ cellID[ lcio::ILDCellID0::layer ] = layerNumber ;
+ cellID[ lcio::ILDCellID0::module ] = ladderNumber ;
+ cellID[ lcio::ILDCellID0::sensor ] = sensorNumber ;
+ int cellID0 = cellID.lowWord();
+
+
+ // **************
+ // SJA:FIXME: sensors for now will be placed running from 1 to n will be placed from -z to z
+ // as is done in the drivers sit_simple_planar and set_simple_planar
+ double sensor_length = sensitive_length / nsensors.at(layerNumber);
+ double pos_z = -0.5*sensitive_length + (0.5*sensor_length) + (sensorNumber*sensor_length) ;
+ // **************
+
+ // Let's start with the translation T: the new center of coordinates:
+ // The center of the first sensor (when we ignore an offset and phi0 for now) is (R,0,pos_z)
+ // If we include the offset, the center gets shifted to (R,offset,pos_z)
+ CLHEP::Hep3Vector T( ladder_r + sensitive_thickness/2., sensitive_offset, pos_z );
+ // Now we have to take into account phi0 and that the number of the ladder.
+ // Together the center is rotated by phi0 + ladderNumber*deltaPhi around the z axis
+ CLHEP::HepRotation rot;
+ rot.rotateZ( deltaPhi * ladderNumber + phi0 );
+
+ T = rot * T;
+
+ // Next, we want to determinte the rotation matrix R
+ // We start with u,v,w alligned with x,y,z.
+ // As u is perpendicular to the strip orientation it looks like this.
+ // y
+ // |
+ // ---|---
+ // | | |
+ // | | |
+ // <--------|--------> x
+ // | | |
+ // | | |
+ // ---|---
+ // |
+ // To get this sensor in place we have to do a few rotations:
+ // First we'll rotate around the z axis. With a strip angle of 0,
+ // we would just rotate by 90°, but with a strip angle by
+ // 90°-stripAngle in clockwise direction.
+ CLHEP::HepRotation R;
+ // printRotation( R );
+ R.rotateZ( stripAngle - M_PI/2. );
+ // printRotation( R );
+
+ // Next we rotate 90° clockwise around y, so the strip now points in z direction (if strip angle == 0)
+ R.rotateY( -M_PI/2. );
+
+ // Finally we have to get the ladder in place w.r. to its number and the resulting phi angle
+ R.rotateZ( deltaPhi * ladderNumber + phi0 );
+
+ CartesianCoordinateSystem* cartesian = new CartesianCoordinateSystem( T, R );
+
+ BoundaryRectangle* b = new BoundaryRectangle( sensitive_width, sensor_length, 1., -stripAngle );
+ MeasurementSurface* ms = new MeasurementSurface( cellID0, cartesian, b );
+ surface_list.push_back(ms);
+
+ }
+
+ }
+
+ }
+
+}
+
+
+void ILDMeasurementSurfaceStoreFiller::storeFTD( const gear::FTDParameters* param, std::vector<MeasurementSurface*>& surface_list ) const {
+
+ const gear::FTDLayerLayout& ftdLayers = param->getFTDLayerLayout() ;
+ unsigned nLayers = ftdLayers.getNLayers();
+
+ UTIL::BitField64 cellID( UTIL::ILDCellID0::encoder_string );
+ cellID[ lcio::ILDCellID0::subdet ] = UTIL::ILDDetID::FTD ;
+
+ for( unsigned layer = 0; layer < nLayers; layer++ ){
+
+
+ cellID[ lcio::ILDCellID0::layer ] = layer ;
+
+ unsigned nPetals = ftdLayers.getNPetals( layer );
+ double deltaPhi = ( 2 * M_PI ) / nPetals;
+ double phi0 = ftdLayers.getPhi0( layer );
+ double lengthMin = ftdLayers.getSensitiveLengthMin( layer );
+ double lengthMax = ftdLayers.getSensitiveLengthMax( layer );
+ double width = ftdLayers.getSensitiveWidth( layer );
+ unsigned nSensors = ftdLayers.getNSensors( layer );
+ bool isDoubleSided = ftdLayers.isDoubleSided( layer );
+ // Get some information about the petal (a trapezoid, see gear for in depth description)
+ double distMin = ftdLayers.getSensitiveRinner(layer); // the xy-distance from (0,0) of the center of the inner base
+ double distMax = distMin + width; // the xy-distance from (0,0) of the center of the outer base
+ unsigned nSensorsOn1Side = nSensors;
+ if( isDoubleSided ) nSensorsOn1Side = nSensorsOn1Side / 2;
+
+ for( unsigned petal=0; petal< nPetals; petal++ ){
+
+
+ cellID[ lcio::ILDCellID0::module ] = petal ;
+
+
+ for ( unsigned sensor = 1; sensor <=nSensors; sensor++ ){
+
+ double stripAngle = 0.;
+
+
+ stripAngle = _FTDStripAngles[layer][sensor-1]; // NOTE HERE WE ARE COUNTING FROM 1!!!!
+
+ // streamlog_out(DEBUG1) << "FTD layer = " << layer << "\tpetal = " << petal << "\tsensor = " << sensor << " stripAngle = " << stripAngle << "\n";
+
+ cellID[ lcio::ILDCellID0::side ] = -1 ;
+ cellID[ lcio::ILDCellID0::sensor ] = sensor ;
+ int cellID0 = cellID.lowWord();
+
+ // We start with the Translation Vector T (=origin of new CoordinateSystem )
+ // the first petal (if phi0 = 0) sits with its symmetry axis on the x axis.
+ // It starts at x= rInner (lMin)nand reaches rInner+ width (lMax) on the x axis
+ // So far the center of Mass will be on the x axis.
+ //
+ // Now we have to take into account how many sensors there are on the petal, and where they sit.
+ double deltaX = (distMax-distMin) / double( nSensorsOn1Side ); //how much delta x one sensor covers
+
+ // The first sensor is the outermost one. Let's calculate its center
+ double xFirst = distMax - deltaX/2.;
+
+ // From here, all we have to do is go down in steps of deltaX until we reach the right sensor.
+ // We have to be careful: when there are sensors on the back, they start again at the top.
+ // If we for example have 6 sensors on a doublesided petal: on the front it is from out to inside: 1,2,3
+ // and on the back: 4,5,6. So 1 and 4 will be (apart from z) at the same position. So will 2 and 5, as well
+ // as 3 and 6
+ unsigned steps = (sensor-1)%nSensorsOn1Side; // the number of steps to go deltaX (in negative direction)
+ // In our example with 6 sensors, this gives sensor 1: 0 steps, 2:1, 3:2, 4:0, 5:1, 6:2
+
+ double x = xFirst - steps * deltaX;
+ double y = 0.;
+ double z = -ftdLayers.getSensitiveZposition( layer, petal, sensor ); // we first calculate for the petals at -z
+ //(because the imagination of the rotation is easier, as w point the same direction as z)
+ // later we from the result we can calculate R and T for +z pretty easy.
+
+ // Calculate lengths of the inner and outer base of the trapezoid
+ double baseOuter = lengthMax - steps * (lengthMax - lengthMin);
+ double baseInner = baseOuter - (lengthMax - lengthMin) / nSensorsOn1Side;
+
+ CLHEP::Hep3Vector T( x , y, z);
+ // printVector( T );
+ // Now we only have to rotate the petal around the z-axis into its place
+ CLHEP::HepRotation rot;
+ rot.rotateZ( petal * deltaPhi + phi0 );
+ T = rot * T;
+ // printVector( T );
+
+ //On to the rotation matrix
+ CLHEP::HepRotation R;
+ // printRotation( R );
+ R.rotateZ( petal * deltaPhi + phi0 + stripAngle - M_PI/2. );
+ // printRotation( R );
+
+ BoundaryTrapezoid* b1 = new BoundaryTrapezoid( baseInner, baseOuter, deltaX, 1., -stripAngle);
+ CartesianCoordinateSystem* cartesian = new CartesianCoordinateSystem( T, R );
+ MeasurementSurface* ms = new MeasurementSurface( cellID0, cartesian, b1);
+ surface_list.push_back(ms);
+
+
+ // Once more for the other side
+ cellID[ lcio::ILDCellID0::side ] = 1 ;
+ cellID0 = cellID.lowWord();
+
+ T.setZ( -T.z() ); // switch to -z
+
+ // R is pretty much the same as the strip orientation will be the same,
+ // but as (by chosen definition) w should point towards the IP,
+ // we have to flip u around. So we acutally have to rotate 180° around v
+ // So first we get the vector v
+ CLHEP::Hep3Vector v = R*CLHEP::Hep3Vector(0,1,0);
+ // Then we rotate around it
+ R.rotate( M_PI , v );
+ // printRotation( R );
+
+ BoundaryTrapezoid* b2 = new BoundaryTrapezoid( baseInner, baseOuter, deltaX, 1., stripAngle);
+ CartesianCoordinateSystem* cartesian2 = new CartesianCoordinateSystem( T, R );
+ MeasurementSurface* ms2 = new MeasurementSurface( cellID0, cartesian2, b2);
+ surface_list.push_back(ms2);
+
+
+ }
+
+ }
+
+ }
+
+}
+
+
+
+
+
+
+
diff --git a/Utilities/KalDet/src/ild/common/ILDMeasurementSurfaceStoreFiller.h b/Utilities/KalDet/src/ild/common/ILDMeasurementSurfaceStoreFiller.h
new file mode 100644
index 0000000000000000000000000000000000000000..79ff8e1ea0aafc6123eed869b85573f5f8580aee
--- /dev/null
+++ b/Utilities/KalDet/src/ild/common/ILDMeasurementSurfaceStoreFiller.h
@@ -0,0 +1,81 @@
+#ifndef ILDMEASUREMENTSURFACESTOREFILLER_H
+#define ILDMEASUREMENTSURFACESTOREFILLER_H
+
+#include "gearsurf/MeasurementSurfaceStore.h"
+
+#include <vector>
+
+namespace gear{
+ class GearMgr;
+ class ZPlanarParameters;
+ class FTDParameters;
+}
+
+using namespace gear;
+
+class ILDMeasurementSurfaceStoreFiller : public MeasurementSurfaceStoreFiller{
+
+ public:
+
+
+ ILDMeasurementSurfaceStoreFiller(const gear::GearMgr& gear_mgr) :
+ _nVTXLayers(0),
+ _nSITLayers(0),
+ _nFTDLayers(0),
+ _nSETLayers(0) {
+
+ this->get_gear_parameters(gear_mgr);
+
+ }
+
+ ~ILDMeasurementSurfaceStoreFiller() { /* no op */ }
+
+ void getMeasurementSurfaces( std::vector<MeasurementSurface*>& surface_list ) const;
+
+ std::string getName() const { return "ILDMeasurementSurfaceStoreFiller" ; } ;
+
+ private:
+
+ /** adds MeasurementSufaces to the store
+ * @param param: the ZPlanarParameters pointer of the detector, of which the measurement surfaces shall be added
+ *
+ * @param det_id: the detector id (as in ILDConf)
+ */
+ void storeZPlanar( const gear::ZPlanarParameters* param , int det_id, std::vector<MeasurementSurface*>& surface_list ) const;
+
+ void storeFTD( const gear::FTDParameters* param, std::vector<MeasurementSurface*>& surface_list ) const;
+
+
+ void get_gear_parameters(const gear::GearMgr& gear_mgr);
+
+ /** the strip angles for every layer */
+ std::vector< double > _VTXStripAngles;
+ std::vector< double > _SITStripAngles;
+ std::vector< double > _SETStripAngles;
+
+ /** the number of sensors for every layer */
+ std::vector< int > _VTXNSensors;
+ std::vector< int > _SITNSensors;
+ std::vector< int > _SETNSensors;
+
+
+ /** the strip angles for every layer and sensor */
+ std::vector< std::vector< double > > _FTDStripAngles;
+
+ unsigned _nVTXLayers;
+ unsigned _nSITLayers;
+ unsigned _nFTDLayers;
+ unsigned _nSETLayers;
+
+
+ const gear::ZPlanarParameters* _paramVXD;
+ const gear::ZPlanarParameters* _paramSIT;
+ const gear::ZPlanarParameters* _paramSET;
+ const gear::FTDParameters* _paramFTD;
+
+
+
+};
+
+#endif
+
diff --git a/Utilities/KalDet/src/ild/common/ILDParallelPlanarMeasLayer.cc b/Utilities/KalDet/src/ild/common/ILDParallelPlanarMeasLayer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..40eb8aebe58bc6efcf49b87470675c4b0e2636d5
--- /dev/null
+++ b/Utilities/KalDet/src/ild/common/ILDParallelPlanarMeasLayer.cc
@@ -0,0 +1,317 @@
+
+#include "ILDParallelPlanarMeasLayer.h"
+#include "kaltest/TVTrack.h"
+
+// #include "streamlog/streamlog.h"
+
+
+Int_t ILDParallelPlanarMeasLayer::CalcXingPointWith(const TVTrack &hel,
+ TVector3 &xx,
+ Double_t &phi,
+ Int_t mode,
+ Double_t eps) const{
+
+
+ // check that direction has one of the correct values
+ if( !( mode == 0 || mode == 1 || mode == -1) ) return -1 ;
+
+
+
+ // This assumes nonzero B field.
+ //
+ // Copy helix parameters to local variables.
+ //
+
+ Double_t dr = hel.GetDrho();
+ Double_t phi0 = hel.GetPhi0(); //
+ Double_t kappa = hel.GetKappa();
+ Double_t rho = hel.GetRho();
+ Double_t omega = 1.0 / rho;
+ Double_t r = TMath::Abs(rho);
+ Double_t z0 = hel.GetDz();
+ Double_t tanl = hel.GetTanLambda();
+
+ TVector3 ref_point = hel.GetPivot();
+
+ //
+ // Check if charge is nonzero.
+ //
+
+ Int_t chg = (Int_t)TMath::Sign(1.1,kappa);
+ if (!chg) {
+ // streamlog_out(ERROR) << ">>>> Error >>>> ILDParallelPlanarMeasLayer::CalcXingPointWith" << std::endl
+ // << " Kappa = 0 is invalid for a helix " << std::endl;
+ return -1;
+ }
+
+ //
+ // Project everything to XY plane and calculate crossing points.
+ //
+ // taken from http://paulbourke.net/geometry/sphereline/
+
+
+ const double sin_phi0 = sin(phi0);
+ const double cos_phi0 = cos(phi0);
+
+ const double x_pca = ref_point.x() + dr * cos_phi0 ;
+ const double y_pca = ref_point.y() + dr * sin_phi0 ;
+ const double z_pca = ref_point.z() + z0 ;
+
+ const double x_c = ref_point.x() + ( rho + dr) * cos_phi0 ;
+ const double y_c = ref_point.y() + ( rho + dr) * sin_phi0 ;
+
+ // get the extreams of the plane in x and y
+ const double x1 = this->GetXc().x() - 0.5*this->GetXiwidth()*sin(this->GetXc().Phi()) - this->GetXioffset() * sin(this->GetXc().Phi());
+ const double x2 = this->GetXc().x() + 0.5*this->GetXiwidth()*sin(this->GetXc().Phi()) - this->GetXioffset() * sin(this->GetXc().Phi());
+
+ const double y1 = this->GetXc().y() + 0.5*this->GetXiwidth()*cos(this->GetXc().Phi()) + this->GetXioffset() * cos(this->GetXc().Phi());
+ const double y2 = this->GetXc().y() - 0.5*this->GetXiwidth()*cos(this->GetXc().Phi()) + this->GetXioffset() * cos(this->GetXc().Phi());
+
+ // streamlog_out(DEBUG0) << "ILDParallelPlanarMeasLayer::CalcXingPointWith: Xc = " << this->GetXc().x() << " Yc = " << this->GetXc().y() << " Rc = " << this->GetXc().Perp() << " Phi = " << this->GetXc().Phi() << std::endl;
+ // streamlog_out(DEBUG0) << "ILDParallelPlanarMeasLayer::CalcXingPointWith: x1 = " << x1 << " y1 = " << y1 << " R " << TVector3(x1,y1,0).Perp() << " phi = " << TVector3(x1,y1,0).Phi() << std::endl ;
+ // streamlog_out(DEBUG0) << "ILDParallelPlanarMeasLayer::CalcXingPointWith: x2 = " << x2 << " y2 = " << y2 << " R " << TVector3(x2,y2,0).Perp() << " phi = " << TVector3(x2,y2,0).Phi() << std::endl ;
+
+ const double dx = x2 - x1 ;
+ const double dy = y2 - y1 ;
+
+ const double a = dx * dx + dy * dy ;
+
+ const double b = 2.0 * ( dx * (x1 - x_c) + dy * (y1 - y_c) ) ;
+
+ double c = x_c * x_c + y_c * y_c;
+ c += x1 * x1 + y1 * y1 ;
+
+ c -= 2.0 * ( x_c * x1 + y_c * y1 );
+ c -= rho * rho;
+
+ const double bb4ac = b * b - 4.0 * a * c;
+
+ double u1 ; // first solution
+ double u2 ; // second solution
+
+ double x_ins = DBL_MAX;
+ double y_ins = DBL_MAX;
+ double s_ins = DBL_MAX;
+
+ /* Check for solvability. */
+ if (bb4ac + eps < 0.0 ) { // no intersection
+ return 0;
+ }
+ else if(bb4ac - eps < 0.0) { // circle intersects at one point, tangential
+ return 0;
+ }
+ else{
+ u1 = (-b + sqrt(bb4ac)) / (2.0 * a);
+ u2 = (-b - sqrt(bb4ac)) / (2.0 * a);
+ }
+
+ // test values of u
+ // case i) ( u1 < 0 && u2 < 0 ) || ( u1 > 1 && u2 > 1 )
+ // Line segment doesn't intersect and is on outside of the circle
+ if ( ( u1 <= 0 && u2 <= 0 ) || ( u1 >= 1 && u2 >= 1 ) ) {
+
+ // streamlog_out(DEBUG0) << "ILDParallelPlanarMeasLayer::CalcXingPointWith: Line segment doesn't intersect and is outside the circle " << std::endl;
+ // const double x_ins1 = x1 + u1 * (dx) ;
+ // const double y_ins1 = y1 + u1 * (dy) ;
+ //
+ // const double x_ins2 = x1 + u2 * (dx) ;
+ // const double y_ins2 = y1 + u2 * (dy) ;
+ //
+ // streamlog_out(DEBUG0) << "ILDParallelPlanarMeasLayer::CalcXingPointWith: 1st solution u = " << u1 << " : " << u1 * dx << " " << u1 * dy << std::endl ;
+ // streamlog_out(DEBUG0) << "ILDParallelPlanarMeasLayer::CalcXingPointWith: 2nd solution u = " << u2 << " : " << u2 * dx << " " << u2 * dy << std::endl ;
+ // streamlog_out(DEBUG0) << "ILDParallelPlanarMeasLayer::CalcXingPointWith: 1st solution x:y = " << x_ins1 << " : " << y_ins1 << std::endl ;
+ // streamlog_out(DEBUG0) << "ILDParallelPlanarMeasLayer::CalcXingPointWith: 2nd solution x:y = " << x_ins2 << " : " << y_ins2 << std::endl ;
+
+ return 0 ;
+ }
+
+ // case ii) ( u1 < 0 && u2 > 1 ) || ( u1 > 1 && u2 < 0 )
+ // Line segment doesn't intersect and is inside the circle
+ else if ( ( u1 <= 0 && u2 >= 1 ) || ( u1 >= 1 && u2 <= 0 ) ) {
+
+ // streamlog_out(DEBUG0) << "ILDParallelPlanarMeasLayer::CalcXingPointWith: Line segment doesn't intersect and is inside the circle " << std::endl;
+ //
+ // const double x_ins1 = x1 + u1 * (dx) ;
+ // const double y_ins1 = y1 + u1 * (dy) ;
+ //
+ // const double x_ins2 = x1 + u2 * (dx) ;
+ // const double y_ins2 = y1 + u2 * (dy) ;
+ //
+ // streamlog_out(DEBUG0) << "ILDParallelPlanarMeasLayer::CalcXingPointWith: 1st solution u = " << u1 << " : " << u1 * dx << " " << u1 * dy << std::endl ;
+ // streamlog_out(DEBUG0) << "ILDParallelPlanarMeasLayer::CalcXingPointWith: 2nd solution u = " << u2 << " : " << u2 * dx << " " << u2 * dy << std::endl ;
+ // streamlog_out(DEBUG0) << "ILDParallelPlanarMeasLayer::CalcXingPointWith: 1st solution x:y = " << x_ins1 << " : " << y_ins1 << std::endl ;
+ // streamlog_out(DEBUG0) << "ILDParallelPlanarMeasLayer::CalcXingPointWith: 2nd solution x:y = " << x_ins2 << " : " << y_ins2 << std::endl ;
+
+
+ return 0 ;
+ }
+
+ // case iii) ( u1 > 0 && u1 < 1 && u2 < 0 && u2 > 1 ) || ( u2 > 0 && u2 < 1 && u1 < 0 && u1 > 1 )
+ // Line segment intersects at one point
+ else if ( ( u1 > 0 && u1 < 1 && (u2 <= 0 || u2 >= 1) ) || ( u2 > 0 && u2 < 1 && ( u1 <= 0 || u1 >= 1 )) ) {
+
+ // streamlog_out(DEBUG0) << "ILDParallelPlanarMeasLayer::CalcXingPointWith: Only one possible solution" << std::endl;
+ // streamlog_out(DEBUG0) << "ILDParallelPlanarMeasLayer::CalcXingPointWith: 1st solution u = " << u1 << " : " << u1 * dx << " " << u1 * dy << std::endl ;
+ // streamlog_out(DEBUG0) << "ILDParallelPlanarMeasLayer::CalcXingPointWith: 2nd solution u = " << u2 << " : " << u2 * dx << " " << u2 * dy << std::endl ;
+
+ if ( u1 > 0 && u1 < 1 ) { // use u1
+
+ x_ins = x1 + u1 * (dx) ;
+ y_ins = y1 + u1 * (dy) ;
+
+ // streamlog_out(DEBUG0) << "ILDParallelPlanarMeasLayer::CalcXingPointWith: take 1st solution x:y:z = " << x_ins << " : " << y_ins ;
+ }
+ else{ // use u2
+
+ x_ins = x1 + u2 * (dx) ;
+ y_ins = y1 + u2 * (dy) ;
+
+ // streamlog_out(DEBUG0) << "ILDParallelPlanarMeasLayer::CalcXingPointWith: take 2nd solution x:y:z = " << x_ins << " : " << y_ins ;
+ }
+
+ const double delta_x = x_ins - x_pca ;
+ const double delta_y = y_ins - y_pca ;
+
+ const double sin_delta_phi = omega*delta_x*sin_phi0 - omega*delta_y*cos_phi0 ;
+ const double cos_delta_phi = 1.0 - omega*delta_x*cos_phi0 - omega*delta_y*sin_phi0 ;
+
+ // const double sin_delta_phi = - omega*delta_x*cos_phi0 - omega*delta_y*sin_phi0 ;
+ // const double cos_delta_phi = 1.0 - omega*delta_x*sin_phi0 + omega*delta_y*cos_phi0 ;
+
+ s_ins = atan2(-sin_delta_phi,cos_delta_phi) / omega ;
+
+ //SJA:FIXME: do we need to consider the mode here ...
+
+ // streamlog_out(DEBUG0) << " : " << z_pca + s_ins * tanl << std::endl ;
+
+ }
+
+ // case iv) ( u1 > 0 && u1 < 1 && u2 > 0 && u2 < 1 )
+ // Line segment intersects at two points
+ else{
+
+ const double x_ins1 = x1 + u1 * (dx) ;
+ const double y_ins1 = y1 + u1 * (dy) ;
+
+ const double x_ins2 = x1 + u2 * (dx) ;
+ const double y_ins2 = y1 + u2 * (dy) ;
+
+ // streamlog_out(DEBUG0) << "ILDParallelPlanarMeasLayer::CalcXingPointWith: 1st solution u = " << u1 << " : " << u1 * dx << " " << u1 * dy << std::endl ;
+ // streamlog_out(DEBUG0) << "ILDParallelPlanarMeasLayer::CalcXingPointWith: 2nd solution u = " << u2 << " : " << u2 * dx << " " << u2 * dy << std::endl ;
+ // streamlog_out(DEBUG0) << "ILDParallelPlanarMeasLayer::CalcXingPointWith: 1st solution x:y = " << x_ins1 << " : " << y_ins1 << std::endl ;
+ // streamlog_out(DEBUG0) << "ILDParallelPlanarMeasLayer::CalcXingPointWith: 2nd solution x:y = " << x_ins2 << " : " << y_ins2 << std::endl ;
+
+ // now calculate the path lengths
+ double s_1 = 0.0 ;
+ double s_2 = 0.0 ;
+
+ const double delta_x1 = x_ins1 - x_pca ;
+ const double delta_y1 = y_ins1 - y_pca ;
+
+ // const double sin_delta_phi1 = - omega*delta_x1*cos_phi0 - omega*delta_y1*sin_phi0 ;
+ // const double cos_delta_phi1 = 1.0 - omega*delta_x1*sin_phi0 + omega*delta_y1*cos_phi0 ;
+
+ const double sin_delta_phi1 = omega*delta_x1*sin_phi0 - omega*delta_y1*cos_phi0 ;
+ const double cos_delta_phi1 = 1.0 - omega*delta_x1*cos_phi0 - omega*delta_y1*sin_phi0 ;
+
+ s_1 = atan2(-sin_delta_phi1,cos_delta_phi1) / omega ;
+
+
+ const double delta_x2 = x_ins2 - x_pca ;
+ const double delta_y2 = y_ins2 - y_pca ;
+
+ // const double sin_delta_phi2 = - omega*delta_x2*cos_phi0 - omega*delta_y2*sin_phi0 ;
+ // const double cos_delta_phi2 = 1.0 - omega*delta_x2*sin_phi0 + omega*delta_y2*cos_phi0 ;
+
+ const double sin_delta_phi2 = omega*delta_x2*sin_phi0 - omega*delta_y2*cos_phi0 ;
+ const double cos_delta_phi2 = 1.0 - omega*delta_x2*cos_phi0 - omega*delta_y2*sin_phi0 ;
+
+ s_2 = atan2(-sin_delta_phi2,cos_delta_phi2) / omega ;
+
+
+ if( mode == 0 ) { // take closest intersection
+ if( TMath::Abs(s_1) < TMath::Abs(s_2) ) {
+ // streamlog_out(DEBUG0) << "ILDParallelPlanarMeasLayer::CalcXingPointWith: take 1st solution " << std::endl;
+ x_ins = x_ins1;
+ y_ins = y_ins1;
+ s_ins = s_1;
+ }
+ else {
+ // streamlog_out(DEBUG0) << "ILDParallelPlanarMeasLayer::CalcXingPointWith: take 2nd solution " << std::endl;
+ x_ins = x_ins2;
+ y_ins = y_ins2;
+ s_ins = s_2;
+ }
+ }
+
+ else{
+
+ if ( s_1 < 0.0 ) s_1 += TMath::TwoPi() * r ;
+ if ( s_2 < 0.0 ) s_2 += TMath::TwoPi() * r ;
+
+ if( mode == 1 ){ // take the intersection with smallest s
+ if( s_1 < s_2 ) {
+ // streamlog_out(DEBUG0) << "ILDParallelPlanarMeasLayer::CalcXingPointWith: take 1st solution " << std::endl;
+ x_ins = x_ins1;
+ y_ins = y_ins1;
+ s_ins = s_1;
+ }
+ else {
+ // streamlog_out(DEBUG0) << "ILDParallelPlanarMeasLayer::CalcXingPointWith: take 2nd solution " << std::endl;
+ x_ins = x_ins2;
+ y_ins = y_ins2;
+ s_ins = s_2;
+ }
+ }
+ else if( mode == -1 ) { // else take the intersection with largest s
+ if( s_1 > s_2 ){
+ // streamlog_out(DEBUG0) << "ILDParallelPlanarMeasLayer::CalcXingPointWith: take 1st solution " << std::endl;
+ x_ins = x_ins1;
+ y_ins = y_ins1;
+ s_ins = s_1;
+ }
+ else{
+ // streamlog_out(DEBUG0) << "ILDParallelPlanarMeasLayer::CalcXingPointWith: take 2nd solution " << std::endl;
+ x_ins = x_ins2;
+ y_ins = y_ins2;
+ s_ins = s_2;
+ }
+ }
+ }
+ }
+
+
+
+// streamlog_out(DEBUG0) << "ILDParallelPlanarMeasLayer::CalcXingPointWith mode = " << mode << " dr = " << dr << " dz = " << z0 << " x = " << ref_point.x() << " y = "<< ref_point.y() << " z = " << ref_point.z() << " r = " << ref_point.Perp() << std::endl;
+
+// TVector3 xx_n;
+// int cuts = TVSurface::CalcXingPointWith(hel, xx_n, phi, mode, eps);
+// streamlog_out(DEBUG0) << "ILDParallelPlanarMeasLayer::CalcXingPointWith from Newton: cuts = " << cuts << " x = " << xx_n.x() << " y = "<< xx_n.y() << " z = " << xx_n.z() << " r = " << xx_n.Perp() << " phi = " << xx_n.Phi() << " dphi = " << phi << " " << this->TVMeasLayer::GetName() << std::endl;
+
+ xx.SetXYZ(x_ins, y_ins, z_pca + s_ins * tanl);
+
+ phi = -s_ins * omega ;
+
+ // streamlog_out(DEBUG0) << "ILDParallelPlanarMeasLayer::CalcXingPointWith: cuts = " << (IsOnSurface(xx) && (chg*phi*mode)<0)
+ // << " x = " << xx.X()
+ // << " y = " << xx.Y()
+ // << " z = " << xx.Z()
+ // << " r = " << xx.Perp()
+ // << " phi = " << xx.Phi()
+ // << " dphi = " << phi
+ // << " " << this->TVMeasLayer::GetName()
+ // << std::endl;
+
+ if( mode!=0 && fabs(phi)>1.e-10){ // (+1,-1) = (fwd,bwd)
+ if( chg*phi*mode > 0){
+ return 0;
+ }
+ }
+
+ return (IsOnSurface(xx) ? 1 : 0);
+
+}
+
+
+
+
diff --git a/Utilities/KalDet/src/ild/common/ILDParallelPlanarMeasLayer.h b/Utilities/KalDet/src/ild/common/ILDParallelPlanarMeasLayer.h
new file mode 100644
index 0000000000000000000000000000000000000000..7262a3e84e248b8eb03ad0d6afbea283b06750cc
--- /dev/null
+++ b/Utilities/KalDet/src/ild/common/ILDParallelPlanarMeasLayer.h
@@ -0,0 +1,80 @@
+#ifndef __ILDParallelPlanarMeasLayer__
+#define __ILDParallelPlanarMeasLayer__
+
+/** ILDParallelPlanarMeasLayer: User defined KalTest measurement layer class
+ *
+ * @author S.Aplin DESY
+ */
+
+
+#include "ILDPlanarMeasLayer.h"
+
+class ILDParallelPlanarMeasLayer : public ILDPlanarMeasLayer {
+
+public:
+
+ /** Constructor Taking inner and outer materials, distance and phi of plane pca to origin, B-Field, Sorting policy, plane transverse witdth and offset of centre, longitudinal width, whether the layer is sensitive, Cell ID, and an optional name */
+ ILDParallelPlanarMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ Double_t r,
+ Double_t phi,
+ Double_t Bz,
+ Double_t SortingPolicy,
+ Double_t xiwidth,
+ Double_t zetawidth,
+ Double_t xioffset,
+ Double_t zoffset,
+ Double_t UOrigin,
+ Bool_t is_active,
+ Int_t CellID = -1,
+ const Char_t *name = "ILDParallelPlanarMeasLayer")
+ :
+ ILDPlanarMeasLayer(min,mout,TVector3(r*cos(phi),r*sin(phi),zoffset),TVector3(cos(phi),sin(phi),0.0),Bz,SortingPolicy,xiwidth,zetawidth,xioffset,UOrigin,is_active,CellID,name), _r(r),_phi(phi),_cos_phi(cos(_phi)),_sin_phi(sin(_phi))
+ { /* no op */ }
+
+
+ // Parent's pure virtuals that must be implemented
+
+ /** overloaded version of CalcXingPointWith using closed solution */
+ virtual Int_t CalcXingPointWith(const TVTrack &hel,
+ TVector3 &xx,
+ Double_t &phi,
+ Int_t mode,
+ Double_t eps = 1.e-8) const;
+
+ /** overloaded version of CalcXingPointWith using closed solution */
+ virtual Int_t CalcXingPointWith(const TVTrack &hel,
+ TVector3 &xx,
+ Double_t &phi,
+ Double_t eps = 1.e-8) const{
+
+ return CalcXingPointWith(hel,xx,phi,0,eps);
+
+ }
+
+ /** Get the intersection and the CellID, needed for multilayers */
+ virtual int getIntersectionAndCellID(const TVTrack &hel,
+ TVector3 &xx,
+ Double_t &phi,
+ Int_t &CellID,
+ Int_t mode,
+ Double_t eps = 1.e-8) const {
+
+ CellID = this->getCellIDs()[0]; // not multilayer
+ return CalcXingPointWith(hel,xx,phi,0,eps);
+
+ }
+
+
+protected:
+
+ Double_t _r;
+ Double_t _phi;
+ Double_t _cos_phi;
+ Double_t _sin_phi;
+
+
+};
+
+#endif
+
diff --git a/Utilities/KalDet/src/ild/common/ILDParallelPlanarStripMeasLayer.cc b/Utilities/KalDet/src/ild/common/ILDParallelPlanarStripMeasLayer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..b7064d810dd30f5dd559f3769f58fff65b29a408
--- /dev/null
+++ b/Utilities/KalDet/src/ild/common/ILDParallelPlanarStripMeasLayer.cc
@@ -0,0 +1,224 @@
+
+#include "ILDParallelPlanarStripMeasLayer.h"
+#include "ILDPlanarStripHit.h"
+#include "kaltest/TVTrack.h"
+#include "kaltest/TVTrackHit.h"
+
+//#include <EVENT/TrackerHitPlane.h>
+
+#include "gearimpl/Vector3D.h"
+
+// #include "streamlog/streamlog.h"
+
+
+TKalMatrix ILDParallelPlanarStripMeasLayer::XvToMv(const TVector3 &xv) const
+{
+
+// streamlog_out(DEBUG0) << "\t ILDParallelPlanarStripMeasLayer::XvToMv: "
+// << " x = " << xv.X()
+// << " y = " << xv.Y()
+// << " z = " << xv.Z()
+// << std::endl;
+
+
+ double cos_phi = GetNormal().X()/GetNormal().Perp();
+ double sin_phi = GetNormal().Y()/GetNormal().Perp();
+
+ // theta is the strip angle rotation in the plane of the wafer
+ double cos_theta = cos(_stripAngle);
+ double sin_theta = sin(_stripAngle);
+
+ double delta_x = xv.X() - GetXc().X();
+ double delta_y = xv.Y() - GetXc().Y();
+
+ double delta_t = (delta_x * sin_phi - delta_y * cos_phi) ;
+ double delta_z = xv.Z() - GetXc().Z();
+
+
+ TKalMatrix mv(ILDPlanarStripHit_DIM,1);
+
+ mv(0,0) = ( (delta_t + fUOrigin) * cos_theta ) + delta_z * sin_theta ;
+
+ if (ILDPlanarStripHit_DIM == 2) {
+ mv(1,0) = delta_z * cos_theta - delta_t * sin_theta;
+ }
+
+// streamlog_out(DEBUG0) << "\t ILDParallelPlanarStripMeasLayer::XvToMv: "
+// << " mv(0,0) = " << mv(0,0) ;
+// if (ILDPlanarStripHit_DIM == 2) {
+// streamlog_out(DEBUG0) << " mv(1,0) = " << mv(1,0);
+// }
+// streamlog_out(DEBUG0) << std::endl;
+
+
+ return mv;
+
+}
+
+
+TVector3 ILDParallelPlanarStripMeasLayer::HitToXv(const TVTrackHit &vht) const
+{
+
+// streamlog_out(DEBUG0) << "\t ILDParallelPlanarStripMeasLayer::HitToXv: "
+// << " vht(0,0) = " << vht(0,0);
+// if (ILDPlanarStripHit_DIM == 2) {
+// streamlog_out(DEBUG0) << " vht(1,0) = " << vht(1,0);
+// }
+// streamlog_out(DEBUG0) << std::endl;
+
+ double cos_phi = GetNormal().X()/GetNormal().Perp();
+ double sin_phi = GetNormal().Y()/GetNormal().Perp();
+
+ // theta is the strip angle rotation in the plane of the wafer
+ double cos_theta = cos(_stripAngle);
+ double sin_theta = sin(_stripAngle);
+
+ double t = (vht(0,0) - fUOrigin ) * cos_theta ;
+
+ double x = t * sin_phi + this->GetXc().X();
+ double y = -t * cos_phi + this->GetXc().Y();
+
+ double dz = 0.0;
+
+ if (ILDPlanarStripHit_DIM == 2) {
+ dz = vht(1,0) * cos_theta ;
+ }
+
+
+ double z = vht(0,0) * sin_theta + this->GetXc().Z() + dz;
+
+// streamlog_out(DEBUG0) << "\t ILDParallelPlanarStripMeasLayer::HitToXv: "
+// << " x = " << x
+// << " y = " << y
+// << " z = " << z
+// << std::endl;
+
+
+ this->IsOnSurface(TVector3(x,y,z));
+
+ return TVector3(x,y,z);
+
+}
+
+void ILDParallelPlanarStripMeasLayer::CalcDhDa(const TVTrackHit &vht,
+ const TVector3 &xxv,
+ const TKalMatrix &dxphiada,
+ TKalMatrix &H) const
+{
+
+ // Calculate
+ // H = (@h/@a) = (@phi/@a, @z/@a)^t
+ // where
+ // h(a) = (phi, z)^t: expected meas vector
+ // a = (drho, phi0, kappa, dz, tanl, t0)
+ //
+
+ double cos_phi = GetNormal().X()/GetNormal().Perp();
+ double sin_phi = GetNormal().Y()/GetNormal().Perp();
+
+ // theta is the strip angle rotation in the plane of the wafer
+ double cos_theta = cos(_stripAngle);
+ double sin_theta = sin(_stripAngle);
+
+ Int_t sdim = H.GetNcols();
+ Int_t hdim = TMath::Max(5,sdim-1);
+
+ // Set H = (@h/@a) = (@d/@a, @z/@a)^t
+
+ double dudx = cos_theta * sin_phi;
+ double dudy = -cos_theta * cos_phi;
+ double dudz = sin_theta;
+
+ double dvdx = -sin_theta * sin_phi;
+ double dvdy = sin_theta * cos_phi;
+ double dvdz = cos_theta;
+
+
+// streamlog_out(DEBUG0) << "\t ILDParallelPlanarStripMeasLayer::CalcDhDa: dudx = " << dudx << " dudy = " << dudy << " dudz = " << dudz << std::endl ;
+// if (ILDPlanarStripHit_DIM == 2) streamlog_out(DEBUG0) << "\t ILDParallelPlanarStripMeasLayer::CalcDhDa: dvdx = " << dvdx << " dvdy = " << dvdy << " dvdz = " << dvdz << std::endl ;
+
+ for (Int_t i=0; i<hdim; i++) {
+
+ H(0,i) = dudx * dxphiada(0,i) + dudy * dxphiada(1,i) + dudz * dxphiada(2,i) ;
+
+// streamlog_out(DEBUG0) << " H(0,"<< i <<") = " << H(0,i) ;
+
+ if (ILDPlanarStripHit_DIM == 2) {
+
+ H(1,i) = dvdx * dxphiada(0,i) + dvdy * dxphiada(1,i) + dvdz * dxphiada(2,i);
+// streamlog_out(DEBUG0) << " H(1,"<< i <<") = " << H(1,i);
+
+ }
+
+ }
+ if (sdim == 6) {
+ H(0,sdim-1) = 0.;
+ if (ILDPlanarStripHit_DIM == 2) {
+ H(1,sdim-1) = 0.;
+ }
+ }
+
+// streamlog_out(DEBUG0) << std::endl;
+
+}
+
+ILDVTrackHit* ILDParallelPlanarStripMeasLayer::ConvertLCIOTrkHit(edm4hep::TrackerHit* trkhit) const {
+
+ //EVENT::TrackerHitPlane* plane_hit = dynamic_cast<EVENT::TrackerHitPlane*>( trkhit ) ;
+ //if( plane_hit == NULL ) {
+ if((trkhit->getType()&8)!=8) {
+ std::cout << "ILDParallelPlanarStripMeasLayer::ConvertLCIOTrkHit dynamic_cast to ILDPlanarStripHit failed " << std::endl;
+ throw std::logic_error("Invalid invoke ILDParallelPlanarStripMeasLayer by TrackerHit trkhit");
+ }
+
+
+ // remember here the "position" of the hit in fact defines the origin of the plane it defines so u and v are per definition 0.
+ // this is still the case for a 1-dimentional measurement, and is then used to calculate the u coordinate according to the origin of the actual measurement plane.
+ //const TVector3 hit( plane_hit->getPosition()[0], plane_hit->getPosition()[1], plane_hit->getPosition()[2]) ;
+ const edm4hep::Vector3d& pos=trkhit->getPosition();
+ const TVector3 hit(pos.x, pos.y, pos.z);
+
+ // convert to layer coordinates
+ TKalMatrix h(ILDPlanarStripHit_DIM,1);
+ h = this->XvToMv(hit);
+
+ Double_t x[ILDPlanarStripHit_DIM] ;
+ Double_t dx[ILDPlanarStripHit_DIM] ;
+
+ x[0] = h(0, 0);
+ if(ILDPlanarStripHit_DIM == 2) x[1] = h(1, 0);
+
+ //dx[0] = plane_hit->getdU() ;
+ //if(ILDPlanarStripHit_DIM == 2) dx[1] = plane_hit->getdV() ;
+ dx[0] = trkhit->getCovMatrix(2);
+ if(ILDPlanarStripHit_DIM == 2) dx[1] = trkhit->getCovMatrix(5);
+
+ bool hit_on_surface = IsOnSurface(hit);
+ /*
+ std::cout << "ILDParallelPlanarStripMeasLayer::ConvertLCIOTrkHit ILDPlanarStripHit created"
+ << " for CellID " << trkhit->getCellID()
+ << " Layer R = " << this->GetXc().Perp()
+ << " Layer phi = " << this->GetXc().Phi()
+ << " Layer z0 = " << this->GetXc().Z()
+ << " u = " << x[0]
+ << " du = " << dx[0];
+
+ if(ILDPlanarStripHit_DIM == 2) std::cout << " v = " << x[1] << " dv = " << dx[1];
+
+ std::cout << " x = " << pos.x
+ << " y = " << pos.y
+ << " z = " << pos.z
+ << " r = " << sqrt(pos.x*pos.x + pos.y*pos.y)
+ << " onSurface = " << hit_on_surface
+ << std::endl ;
+ */
+ ILDPlanarStripHit hh( *this , x, dx, this->GetBz(),trkhit);
+
+ this->HitToXv(hh);
+
+ return hit_on_surface ? new ILDPlanarStripHit( *this , x, dx, this->GetBz(),trkhit) : NULL;
+
+
+}
+
+
diff --git a/Utilities/KalDet/src/ild/common/ILDParallelPlanarStripMeasLayer.h b/Utilities/KalDet/src/ild/common/ILDParallelPlanarStripMeasLayer.h
new file mode 100644
index 0000000000000000000000000000000000000000..c717f4c13a37397762a9aaf6d63980d8e0dfe61c
--- /dev/null
+++ b/Utilities/KalDet/src/ild/common/ILDParallelPlanarStripMeasLayer.h
@@ -0,0 +1,62 @@
+#ifndef __ILDParallelPlanarStripMeasLayer__
+#define __ILDParallelPlanarStripMeasLayer__
+
+/** ILDParallelPlanarStripMeasLayer: User defined KalTest measurement layer class
+ *
+ * @author S.Aplin DESY
+ */
+
+//#include "TKalMatrix.h"
+//#include "TVector3.h"
+//#include "TVTrackHit.h"
+
+
+#include "ILDParallelPlanarMeasLayer.h"
+
+class ILDParallelPlanarStripMeasLayer : public ILDParallelPlanarMeasLayer {
+
+public:
+
+ /** Constructor Taking inner and outer materials, distance and phi of plane pca to origin, B-Field, Sorting policy, plane transverse witdth and offset of centre, longitudinal width, whether the layer is sensitive, Cell ID, and an optional name */
+ ILDParallelPlanarStripMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ Double_t r,
+ Double_t phi,
+ Double_t Bz,
+ Double_t SortingPolicy,
+ Double_t xiwidth,
+ Double_t zetawidth,
+ Double_t xioffset,
+ Double_t zoffset,
+ Double_t UOrigin,
+ Double_t stripAngle,
+ Int_t CellID = -1,
+ const Char_t *name = "ILDParallelPlanarStripMeasLayer")
+ :
+ ILDParallelPlanarMeasLayer(min,mout,r,phi,Bz,SortingPolicy,xiwidth,zetawidth,xioffset,zoffset,UOrigin,true,CellID,name), _stripAngle(stripAngle)
+
+ { /* no op */ }
+
+
+ // Parent's pure virtuals that must be implemented
+
+ TKalMatrix XvToMv(const TVector3 &xv) const;
+
+ TKalMatrix XvToMv(const TVTrackHit &, const TVector3 &xv) const {
+ return XvToMv(xv);
+ }
+
+ TVector3 HitToXv(const TVTrackHit &vht) const ;
+
+ void CalcDhDa(const TVTrackHit &vht, const TVector3 &xxv, const TKalMatrix &dxphiada, TKalMatrix &H) const;
+
+ ILDVTrackHit* ConvertLCIOTrkHit(edm4hep::TrackerHit* trkhit) const;
+
+private:
+
+ double _stripAngle;
+
+};
+
+#endif
+
diff --git a/Utilities/KalDet/src/ild/common/ILDPlanarHit.cc b/Utilities/KalDet/src/ild/common/ILDPlanarHit.cc
new file mode 100644
index 0000000000000000000000000000000000000000..c4fc4ae173a4a42bf80f93ac4ebedc3a5f119f6d
--- /dev/null
+++ b/Utilities/KalDet/src/ild/common/ILDPlanarHit.cc
@@ -0,0 +1,47 @@
+
+#include "ILDPlanarHit.h"
+#include "ILDPlanarMeasLayer.h"
+#include "ILDSegmentedDiscMeasLayer.h"
+#include "ILDDiscMeasLayer.h"
+#include "TMath.h"
+
+#include <iostream>
+#include <iomanip>
+
+using namespace std;
+
+
+
+//_____________________________________________________________________
+// ----------------------------------
+// Implementation of public methods
+// ----------------------------------
+
+/** Global to Local coordinates */
+
+TKalMatrix ILDPlanarHit::XvToMv(const TVector3 &xv, Double_t /*t0*/) const
+{
+
+ return this->GetMeasLayer().XvToMv(*(this),xv);
+
+}
+
+
+/** Print Debug information */
+
+void ILDPlanarHit::DebugPrint(Option_t *) const
+{
+ cerr << "------------------- Site Info -------------------------" << endl;
+
+ for (Int_t i=0; i<GetDimension(); i++) {
+ Double_t x = (*this)(i,0);
+ Double_t dx = (*this)(i,1);
+ cerr << " x[" << i << "] = " << setw(8) << setprecision(5) << x
+ << " "
+ << "dx[" << i << "] = " << setw(6) << setprecision(2) << dx
+ << setprecision(7)
+ << resetiosflags(ios::showpoint)
+ << endl;
+ }
+ cerr << "-------------------------------------------------------" << endl;
+}
diff --git a/Utilities/KalDet/src/ild/common/ILDPlanarHit.h b/Utilities/KalDet/src/ild/common/ILDPlanarHit.h
new file mode 100644
index 0000000000000000000000000000000000000000..e54f0cf7e053dda87041fd4d9e80fc010b5787fa
--- /dev/null
+++ b/Utilities/KalDet/src/ild/common/ILDPlanarHit.h
@@ -0,0 +1,41 @@
+#ifndef ILDPLANARHIT_H
+#define ILDPLANARHIT_H
+
+/** ILDPlanarHit: User defined KalTest hit class using u and v coordinates, which provides coordinate vector as defined by the MeasLayer
+ *
+ * @author S.Aplin DESY
+ */
+
+#include "kaltest/KalTrackDim.h"
+
+#include "ILDVTrackHit.h"
+
+#define ILDPlanarHit_DIM 2
+
+class ILDPlanarHit : public ILDVTrackHit {
+
+public:
+
+ /** Constructor Taking u and v coordinates and associated measurement layer, with bfield */
+ ILDPlanarHit(const TVMeasLayer &ms,
+ Double_t *x,
+ Double_t *dx,
+ Double_t bfield,
+ edm4hep::TrackerHit* trkhit)
+ : ILDVTrackHit(ms, x, dx, bfield, ILDPlanarHit_DIM,trkhit)
+ { /* no op */ }
+
+ // TVTrackHit's pure virtuals that must be implemented
+
+ /** Global to Local coordinates */
+ virtual TKalMatrix XvToMv (const TVector3 &xv, Double_t t0) const;
+
+ /** Print Debug information */
+ virtual void DebugPrint(Option_t *opt = "") const;
+
+
+private:
+
+
+};
+#endif
diff --git a/Utilities/KalDet/src/ild/common/ILDPlanarMeasLayer.cc b/Utilities/KalDet/src/ild/common/ILDPlanarMeasLayer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..ad196d2e6bbefe4ec76f572264ba1b1dd8f2e620
--- /dev/null
+++ b/Utilities/KalDet/src/ild/common/ILDPlanarMeasLayer.cc
@@ -0,0 +1,310 @@
+//*************************************************************************
+//* ===================
+//* ILDPlanarMeasLayer Class
+//* ===================
+//*
+//* (Description)
+//* Sample measurement layer class used by ILDPlanarHit.
+//* (Requires)
+//* ILDVMeasLayer
+//* (Provides)
+//* class ILDPlanarMeasLayer
+//*
+//*************************************************************************
+//
+#include <iostream>
+#include <cmath>
+
+#include "ILDPlanarMeasLayer.h"
+#include "ILDPlanarHit.h"
+
+#include "kaltest/TVTrack.h"
+#include "TVector3.h"
+#include "TMath.h"
+#include "TRotMatrix.h"
+#include "TBRIK.h"
+#include "TNode.h"
+#include "TString.h"
+
+#include "gearimpl/Vector3D.h"
+
+//#include <EVENT/TrackerHitPlane.h>
+
+// #include "streamlog/streamlog.h"
+
+ILDPlanarMeasLayer::ILDPlanarMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ const TVector3 ¢er,
+ const TVector3 &normal,
+ Double_t Bz,
+ Double_t SortingPolicy,
+ Double_t xiwidth,
+ Double_t zetawidth,
+ Double_t xioffset,
+ Double_t UOrigin,
+ Bool_t is_active,
+ Int_t CellID,
+ const Char_t *name)
+: ILDVMeasLayer(min, mout, Bz, is_active, CellID, name),
+TPlane(center, normal),
+fSortingPolicy(SortingPolicy),
+fXiwidth(xiwidth),
+fZetawidth(zetawidth),
+fXioffset(xioffset),
+fUOrigin(UOrigin)
+
+{
+
+ // streamlog_out(DEBUG0) << "ILDPlanarMeasLayer created"
+ // << " Layer x0 = " << this->GetXc().X()
+ // << " y0 = " << this->GetXc().Y()
+ // << " z0 = " << this->GetXc().Z()
+ // << " R = " << this->GetXc().Perp()
+ // << " phi = " << this->GetXc().Phi()
+ // << " xiwidth = " << fXiwidth
+ // << " zetawidth = " << fZetawidth
+ // << " xioffset = " << fXioffset
+ // << " UOrigin = " << UOrigin
+ // << " is_active = " << is_active
+ // << " CellID = " << CellID
+ // << " name = " << this->ILDVMeasLayer::GetName()
+ // << std::endl ;
+
+
+}
+
+ILDPlanarMeasLayer::~ILDPlanarMeasLayer()
+{
+}
+
+TKalMatrix ILDPlanarMeasLayer::XvToMv(const TVector3 &xv) const
+{
+ // Calculate hit coordinate information:
+ // mv(0,0) = xi
+ // (1,0) = zeta
+
+// streamlog_out(DEBUG0) << "\t ILDPlanarMeasLayer::XvToMv: "
+// << " x = " << xv.X()
+// << " y = " << xv.Y()
+// << " z = " << xv.Z()
+// << std::endl;
+
+ TKalMatrix mv(kMdim,1);
+
+ double cos_phi = GetNormal().X()/GetNormal().Perp();
+ double sin_phi = GetNormal().Y()/GetNormal().Perp();
+
+ double delta_x = xv.X() - GetXc().X();
+ double delta_y = xv.Y() - GetXc().Y();
+ double delta_z = xv.Z() - GetXc().Z();
+
+ double delta_t = (delta_x * sin_phi - delta_y * cos_phi) ;
+
+ mv(0,0) = delta_t + fUOrigin;
+
+ mv(1,0) = delta_z ;
+
+// streamlog_out(DEBUG0) << "\t ILDPlanarMeasLayer::XvToMv: "
+// << " mv(0,0) = " << mv(0,0)
+// << " mv(1,0) = " << mv(1,0)
+// << std::endl;
+
+
+ return mv;
+}
+
+TKalMatrix ILDPlanarMeasLayer::XvToMv(const TVTrackHit &,
+ const TVector3 &xv) const
+{
+ return XvToMv(xv);
+}
+
+TVector3 ILDPlanarMeasLayer::HitToXv(const TVTrackHit &vht) const
+{
+
+
+// streamlog_out(DEBUG0) << "\t ILDPlanarMeasLayer::HitToXv: "
+// << " vht(0,0) = " << vht(0,0)
+// << " vht(1,0) = " << vht(1,0)
+// << std::endl;
+
+
+ //const ILDPlanarHit &ht = dynamic_cast<const ILDPlanarHit &>(vht);
+
+ double cos_phi = GetNormal().X()/GetNormal().Perp();
+ double sin_phi = GetNormal().Y()/GetNormal().Perp();
+
+ double delta_t = vht(0,0) - fUOrigin;
+
+ double x = delta_t * sin_phi + this->GetXc().X();
+ double y = -delta_t * cos_phi + this->GetXc().Y();
+
+ double z = vht(1,0) + this->GetXc().Z();
+
+// streamlog_out(DEBUG0) << "\t ILDPlanarMeasLayer::HitToXv: "
+// << " x = " << x
+// << " y = " << y
+// << " z = " << z
+// << std::endl;
+
+
+ return TVector3(x,y,z);
+}
+
+void ILDPlanarMeasLayer::CalcDhDa(const TVTrackHit &vht,
+ const TVector3 &xxv,
+ const TKalMatrix &dxphiada,
+ TKalMatrix &H) const
+{
+ // Calculate
+ // H = (@h/@a) = (@phi/@a, @z/@a)^t
+ // where
+ // h(a) = (phi, z)^t: expected meas vector
+ // a = (drho, phi0, kappa, dz, tanl, t0)
+ //
+
+ double cos_phi = GetNormal().X()/GetNormal().Perp();
+ double sin_phi = GetNormal().Y()/GetNormal().Perp();
+
+
+ Int_t sdim = H.GetNcols();
+ Int_t hdim = TMath::Max(5,sdim-1);
+
+ // Set H = (@h/@a) = (@d/@a, @z/@a)^t
+
+ for (Int_t i=0; i<hdim; i++) {
+
+ H(0,i) = sin_phi * dxphiada(0,i) - cos_phi * dxphiada(1,i) ;
+ H(1,i) = dxphiada(2,i);
+
+ }
+ if (sdim == 6) {
+ H(0,sdim-1) = 0.;
+ H(1,sdim-1) = 0.;
+ }
+
+}
+
+
+//#define DEBUG_ISONSURFACE 1
+Bool_t ILDPlanarMeasLayer::IsOnSurface(const TVector3 &xx) const
+{
+ Double_t xi = (xx.Y()-GetXc().Y())*GetNormal().X()/GetNormal().Perp() - (xx.X()-GetXc().X())*GetNormal().Y()/GetNormal().Perp() ;
+ Double_t zeta = xx.Z() - GetXc().Z();
+
+ bool onSurface = false ;
+
+ if( (xx.X()-GetXc().X())*GetNormal().X() + (xx.Y()-GetXc().Y())*GetNormal().Y() < 1e-4){
+ if( xi <= GetXioffset() + GetXiwidth()/2 && xi >= GetXioffset() - GetXiwidth()/2 && TMath::Abs(zeta) <= GetZetawidth()/2){
+ onSurface = true;
+ }
+
+#ifdef DEBUG_ISONSURFACE
+ else{
+ // streamlog_out(DEBUG4) << "ILDPlanarMeasLayer::IsOnSurface: Point not within boundary x = " << xx.x() << " y = " << xx.y() << " z = " << xx.z() << " r = " << xx.Perp() << " phi = " << xx.Phi() << std::endl;
+ // streamlog_out(DEBUG4) << "xi = " << xi << " xi_max = " << GetXioffset() + GetXiwidth()/2 << " xi_min = " << GetXioffset() - GetXiwidth()/2 << " zeta = " << zeta << " zeta_min = " << -GetZetawidth()/2 << " zeta_max " << GetZetawidth()/2 << " Xioffset = " << GetXioffset() << std::endl;
+ onSurface = false;
+ // streamlog_out(DEBUG4) << " xi <= GetXioffset() + GetXiwidth()/2 = " << (xi <= GetXioffset() + GetXiwidth()/2) << std::endl ;
+ // streamlog_out(DEBUG4) << " xi >= GetXioffset() - GetXiwidth()/2 = " << (xi >= GetXioffset() - GetXiwidth()/2) << std::endl;
+ // streamlog_out(DEBUG4) << " TMath::Abs(zeta) <= GetZetawidth()/2 = " << (TMath::Abs(zeta) <= GetZetawidth()/2) << std::endl;
+ }
+#endif
+
+ }
+
+#ifdef DEBUG_ISONSURFACE
+ else{
+ // streamlog_out(DEBUG4) << "ILDPlanarMeasLayer::IsOnSurface: Point not on surface x = " << xx.x() << " y = " << xx.y() << " z = " << xx.z() << " r = " << xx.Perp() << " phi = " << xx.Phi() << std::endl;
+ // streamlog_out(DEBUG4) << "Distance from plane " << (xx.X()-GetXc().X())*GetNormal().X() + (xx.Y()-GetXc().Y())*GetNormal().Y() << std::endl;
+ }
+ if( onSurface == false ) {
+ // streamlog_out(DEBUG) << "x0 " << GetXc().X() << std::endl;
+ // streamlog_out(DEBUG) << "y0 " << GetXc().Y() << std::endl;
+ // streamlog_out(DEBUG) << "z0 " << GetXc().Z() << std::endl;
+ // streamlog_out(DEBUG) << "GetNormal().X() " << GetNormal().X() << std::endl;
+ // streamlog_out(DEBUG4) << "GetNormal().Y() " << GetNormal().Y() << std::endl;
+ // streamlog_out(DEBUG4) << "GetNormal().Perp() " << GetNormal().Perp() << std::endl;
+ // streamlog_out(DEBUG4) << "GetNormal().X()/GetNormal().Perp() " << GetNormal().X()/GetNormal().Perp() << std::endl;
+ // streamlog_out(DEBUG4) << "GetNormal().Y()/GetNormal().Perp() " << GetNormal().Y()/GetNormal().Perp() << std::endl;
+ // streamlog_out(DEBUG4) << "xx.X()-GetXc().X() " << xx.X()-GetXc().X() << std::endl;
+ // streamlog_out(DEBUG4) << "xx.Y()-GetXc().Y() " << xx.Y()-GetXc().Y() << std::endl;
+
+ // streamlog_out(DEBUG4) << "zeta " << zeta << std::endl;
+ // streamlog_out(DEBUG4) << "xi " << xi << std::endl;
+ // streamlog_out(DEBUG4) << "zeta half width " << GetZetawidth()/2 << std::endl;
+ // streamlog_out(DEBUG4) << "xi half width " << GetXiwidth()/2 << std::endl;
+ // streamlog_out(DEBUG4) << "offset " << GetXioffset() << std::endl;
+
+ // streamlog_out(DEBUG4) << "distance from plane " << (xx.X()-GetXc().X())*GetNormal().X() + (xx.Y()-GetXc().Y())*GetNormal().Y() << std::endl;
+ }
+#endif
+
+ return onSurface;
+
+}
+
+
+ILDVTrackHit* ILDPlanarMeasLayer::ConvertLCIOTrkHit(edm4hep::TrackerHit* trkhit) const {
+ //std::cout << "ILDPlanarMeasLayer::ConvertLCIOTrkHit " << trkhit << " type=" << trkhit->getType() << std::endl;
+ //EVENT::TrackerHitPlane* plane_hit = dynamic_cast<EVENT::TrackerHitPlane*>( trkhit ) ;
+ if((trkhit->getType()&8)!=8){
+ std::cout << "ILDPlanarMeasLayer::ConvertLCIOTrkHit Warning: type is not 8, but " << (trkhit->getType()&8) << std::endl;
+ return NULL;
+ }
+ //if( plane_hit == NULL ) return NULL; // SJA:FIXME: should be replaced with an exception
+
+ //gear::Vector3D U(1.0,plane_hit->getU()[1],plane_hit->getU()[0],gear::Vector3D::spherical);
+ //gear::Vector3D V(1.0,plane_hit->getV()[1],plane_hit->getV()[0],gear::Vector3D::spherical);
+ gear::Vector3D U(1.0,trkhit->getCovMatrix(1),trkhit->getCovMatrix(0),gear::Vector3D::spherical);
+ gear::Vector3D V(1.0,trkhit->getCovMatrix(4),trkhit->getCovMatrix(3),gear::Vector3D::spherical);
+ gear::Vector3D Z(0.0,0.0,1.0);
+
+ const float eps = 1.0e-07;
+ // U must be the global z axis
+ if( fabs(1.0 - V.dot(Z)) > eps ) {
+ std::cout << "ILDPlanarMeasLayer: TrackerHitPlane measurment vectors V is not equal to the global Z axis. \n\n exit(1) called from file " << __FILE__ << " and line " << __LINE__ << std::endl;
+ exit(1);
+ }
+
+ if( fabs(U.dot(Z)) > eps ) {
+ std::cout << "ILDPlanarMeasLayer: TrackerHitPlane measurment vectors U is not in the global X-Y plane. \n\n exit(1) called from file " << __FILE__ << " and line " << __LINE__ << std::endl;
+ exit(1);
+ }
+
+ // remember here the "position" of the hit in fact defines the origin of the plane it defines so u and v are per definition 0.
+ const edm4hep::Vector3d& pos=trkhit->getPosition();
+ const TVector3 hit(pos.x, pos.y, pos.z) ;
+
+ // convert to layer coordinates
+ TKalMatrix h = this->XvToMv(hit);
+
+ Double_t x[2] ;
+ Double_t dx[2] ;
+
+ x[0] = h(0, 0);
+ x[1] = h(1, 0);
+
+ dx[0] = trkhit->getCovMatrix(2);
+ dx[1] = trkhit->getCovMatrix(5);
+
+ bool hit_on_surface = IsOnSurface(hit);
+ /*
+ std::cout << "ILDPlanarMeasLayer::ConvertLCIOTrkHit ILDPlanarHit created"
+ << " for CellID " << trkhit->getCellID()
+ << " Layer R = " << this->GetXc().Perp()
+ << " Layer phi = " << this->GetXc().Phi()
+ << " Layer z0 = " << this->GetXc().Z()
+ << " u = " << x[0]
+ << " v = " << x[1]
+ << " du = " << dx[0]
+ << " dv = " << dx[1]
+ << " x = " << hit.x()
+ << " y = " << hit.y()
+ << " z = " << hit.z()
+ << " r = " << hit.Perp()
+ << " onSurface = " << hit_on_surface
+ << std::endl ;
+ */
+
+ return hit_on_surface ? new ILDPlanarHit( *this , x, dx, this->GetBz(), trkhit) : NULL;
+}
diff --git a/Utilities/KalDet/src/ild/common/ILDPlanarMeasLayer.h b/Utilities/KalDet/src/ild/common/ILDPlanarMeasLayer.h
new file mode 100644
index 0000000000000000000000000000000000000000..500f2a233093f6409eb3428fa1f23b82bb45c95b
--- /dev/null
+++ b/Utilities/KalDet/src/ild/common/ILDPlanarMeasLayer.h
@@ -0,0 +1,84 @@
+#ifndef __ILDPLANARMEASLAYER__
+#define __ILDPLANARMEASLAYER__
+//*************************************************************************
+//* ===================
+//* ILDPlanarMeasLayer Class
+//* ===================
+//*
+//* (Description)
+//* Planar measurement layer class used with ILDPLanarTrackHit.
+//* (Requires)
+//* ILDVMeasLayer
+//* (Provides)
+//* class ILDPlanarMeasLayer
+//* (Update Recored)
+//* 2003/09/30 Y.Nakashima Original version.
+//*
+//* 2011/06/17 D.Kamai Modified to handle ladder structure.
+//*************************************************************************
+//
+#include "TVector3.h"
+
+#include "kaltest/TKalMatrix.h"
+#include "kaltest/TPlane.h"
+#include "kaltest/KalTrackDim.h"
+#include "ILDVMeasLayer.h"
+
+#include "TMath.h"
+#include <sstream>
+
+class TVTrackHit;
+
+class ILDPlanarMeasLayer : public ILDVMeasLayer, public TPlane {
+public:
+ // Ctors and Dtor
+
+ ILDPlanarMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ const TVector3 ¢er,
+ const TVector3 &normal,
+ Double_t Bz,
+ Double_t SortingPolicy,
+ Double_t xiwidth,
+ Double_t zetawidth,
+ Double_t xioffset,
+ Double_t fUOrigin,
+ Bool_t is_active,
+ Int_t CellID = -1,
+ const Char_t *name = "ILDPlanarMeasL");
+
+ virtual ~ILDPlanarMeasLayer();
+
+ // Parrent's pure virtuals that must be implemented
+
+ virtual TKalMatrix XvToMv (const TVTrackHit &ht,
+ const TVector3 &xv) const;
+
+ virtual TKalMatrix XvToMv (const TVector3 &xv) const;
+
+ virtual TVector3 HitToXv (const TVTrackHit &ht) const;
+
+ virtual void CalcDhDa (const TVTrackHit &ht,
+ const TVector3 &xv,
+ const TKalMatrix &dxphiada,
+ TKalMatrix &H) const;
+
+ virtual ILDVTrackHit* ConvertLCIOTrkHit(edm4hep::TrackerHit* trkhit) const ;
+
+ virtual Bool_t IsOnSurface (const TVector3 &xx) const;
+
+ Double_t GetSortingPolicy() const { return fSortingPolicy; }
+ Double_t GetXiwidth() const { return fXiwidth; }
+ Double_t GetZetawidth() const { return fZetawidth; }
+ Double_t GetXioffset() const { return fXioffset; }
+
+protected:
+ Double_t fSortingPolicy;
+ Double_t fXiwidth;
+ Double_t fZetawidth;
+ Double_t fXioffset; //determines how far the centre of the plane is translated in the direction positive rotation
+ Double_t fUOrigin; //determines origin of the transverse coordinate
+
+};
+
+#endif
diff --git a/Utilities/KalDet/src/ild/common/ILDPlanarStripHit.cc b/Utilities/KalDet/src/ild/common/ILDPlanarStripHit.cc
new file mode 100644
index 0000000000000000000000000000000000000000..613e34dfd49c67a5f2ba16f7fc453d998bfcd0b6
--- /dev/null
+++ b/Utilities/KalDet/src/ild/common/ILDPlanarStripHit.cc
@@ -0,0 +1,47 @@
+
+#include "ILDPlanarStripHit.h"
+#include "ILDPlanarMeasLayer.h"
+#include "ILDSegmentedDiscMeasLayer.h"
+#include "ILDDiscMeasLayer.h"
+#include "TMath.h"
+
+#include <iostream>
+#include <iomanip>
+
+using namespace std;
+
+
+
+//_____________________________________________________________________
+// ----------------------------------
+// Implementation of public methods
+// ----------------------------------
+
+/** Global to Local coordinates */
+
+TKalMatrix ILDPlanarStripHit::XvToMv(const TVector3 &xv, Double_t /*t0*/) const
+{
+
+ return this->GetMeasLayer().XvToMv(*(this),xv);
+
+}
+
+
+/** Print Debug information */
+
+void ILDPlanarStripHit::DebugPrint(Option_t *) const
+{
+ cerr << "------------------- Site Info -------------------------" << endl;
+
+ for (Int_t i=0; i<GetDimension(); i++) {
+ Double_t x = (*this)(i,0);
+ Double_t dx = (*this)(i,1);
+ cerr << " x[" << i << "] = " << setw(8) << setprecision(5) << x
+ << " "
+ << "dx[" << i << "] = " << setw(6) << setprecision(2) << dx
+ << setprecision(7)
+ << resetiosflags(ios::showpoint)
+ << endl;
+ }
+ cerr << "-------------------------------------------------------" << endl;
+}
diff --git a/Utilities/KalDet/src/ild/common/ILDPlanarStripHit.h b/Utilities/KalDet/src/ild/common/ILDPlanarStripHit.h
new file mode 100644
index 0000000000000000000000000000000000000000..1103eeda84a5e6729d204ac6385a11b5de909ac3
--- /dev/null
+++ b/Utilities/KalDet/src/ild/common/ILDPlanarStripHit.h
@@ -0,0 +1,42 @@
+#ifndef ILDPLANARSTRIPHIT_H
+#define ILDPLANARSTRIPHIT_H
+
+/** ILDPlanarStripHit: User defined KalTest hit class using u coordinate, which provides coordinate vector as defined by the MeasLayer
+ *
+ * @author S.Aplin DESY
+ */
+
+#include "kaltest/KalTrackDim.h"
+
+#include "ILDVTrackHit.h"
+
+
+#define ILDPlanarStripHit_DIM 1 // set to 2 if one want to debug strip hits by using the 2nd dimention
+
+class ILDPlanarStripHit : public ILDVTrackHit {
+
+public:
+
+ /** Constructor Taking a single coordinate and associated measurement layer, with bfield */
+ ILDPlanarStripHit(const TVMeasLayer &ms,
+ Double_t *x,
+ Double_t *dx,
+ Double_t bfield,
+ edm4hep::TrackerHit* trkhit)
+ : ILDVTrackHit(ms, x, dx, bfield, ILDPlanarStripHit_DIM,trkhit)
+ { /* no op */ }
+
+ // TVTrackHit's pure virtuals that must be implemented
+
+ /** Global to Local coordinates */
+ virtual TKalMatrix XvToMv (const TVector3 &xv, Double_t t0) const;
+
+ /** Print Debug information */
+ virtual void DebugPrint(Option_t *opt = "") const;
+
+
+private:
+
+
+};
+#endif
diff --git a/Utilities/KalDet/src/ild/common/ILDPolygonBarrelMeasLayer.cc b/Utilities/KalDet/src/ild/common/ILDPolygonBarrelMeasLayer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..c1348fd0fdfd875f91901675ef0c964c3f403334
--- /dev/null
+++ b/Utilities/KalDet/src/ild/common/ILDPolygonBarrelMeasLayer.cc
@@ -0,0 +1,215 @@
+
+#include "ILDPolygonBarrelMeasLayer.h"
+
+#include <UTIL/BitField64.h>
+#include <UTIL/ILDConf.h>
+
+#include "kaltest/TVTrack.h"
+#include "TVector3.h"
+#include "TMath.h"
+#include "TRotMatrix.h"
+#include "TBRIK.h"
+#include "TNode.h"
+#include "TString.h"
+
+//#include <EVENT/TrackerHitPlane.h>
+#include <edm4hep/TrackerHit.h>
+
+#include <math.h>
+#include <assert.h>
+#include <algorithm>
+
+// #include "streamlog/streamlog.h"
+
+
+ILDPolygonBarrelMeasLayer::ILDPolygonBarrelMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ double Bz,
+ double sortingPolicy,
+ double r0, // min distance to the z-axis
+ double lhalf, // half length
+ int nsides,
+ double zpos, // z of the centre
+ double phi0, // phi of the first normal following the xaxis positive rotation
+ std::vector<int> CellIDs,
+ bool is_active,
+ const Char_t *name) :
+ILDVMeasLayer(min, mout, Bz, CellIDs, is_active, name), _sortingPolicy(0.),
+_r0(r0),_lhalf(lhalf),_nsides(nsides),_zpos(zpos),_phi0(phi0)
+
+{
+
+ _segment_dphi = 2.0*M_PI / _nsides;
+
+ phi0 = angular_range_2PI(phi0);
+
+ _start_phi = phi0 - 0.5*_segment_dphi;
+
+ _start_phi = angular_range_2PI(_start_phi);
+
+ for (int i = 0; i < _nsides; ++i) {
+
+ const TVector3 center(r0*cos(phi0),r0*sin(phi0),zpos);
+ const TVector3 normal(center);
+ double width = 2*(_r0*tan(_segment_dphi*0.5));
+
+ double phi = i*_segment_dphi+_start_phi;
+
+ ILDParallelPlanarMeasLayer p(min,mout,r0,phi,Bz,sortingPolicy,width,2*lhalf,0.0,0.0,0.0,false); // NOTE: No Physical Offset or Coordinate Offset allowed
+ _planes.push_back(p);
+
+ }
+
+
+ _rmax = r0*sin((_r0*tan(_segment_dphi*0.5)));
+
+ _enclosing_cylinder = new TCylinder(_rmax, lhalf, 0., 0., 0.);
+
+
+}
+
+
+TKalMatrix ILDPolygonBarrelMeasLayer::XvToMv(const TVector3 &xv) const
+{
+
+ // Calculate measurement vector (hit coordinates) from global coordinates:
+ int index = this->get_plane_index(xv.Phi());
+
+ return _planes[index].XvToMv(xv);
+
+}
+
+
+TVector3 ILDPolygonBarrelMeasLayer::HitToXv(const TVTrackHit &vht) const
+{
+
+ //SJA:FIXME: in order to use real local coordinates we would have to get the CELLID from the ILDPlanarHit, this would tell us in which segment the hit was in
+
+ // streamlog_out(ERROR) << "ILDPolygonBarrelMeasLayer::HitToXv Not implemented: exit(1) called from " << __FILE__ << " line " << __LINE__ << std::endl;
+ exit(1);
+
+ return TVector3(0.,0.,0.);
+
+}
+
+void ILDPolygonBarrelMeasLayer::CalcDhDa(const TVTrackHit &vht,
+ const TVector3 &xxv,
+ const TKalMatrix &dxphiada,
+ TKalMatrix &H) const
+{
+
+ //SJA:FIXME: in order to use real local coordinates we would have to get the CELLID from the ILDPlanarHit, this would tell us in which segment the hit was in
+
+ // streamlog_out(ERROR) << "ILDPolygonBarrelMeasLayer::CalcDhDa Not implemented: exit(1) called from " << __FILE__ << " line " << __LINE__ << std::endl;
+ exit(1);
+
+}
+
+
+Int_t ILDPolygonBarrelMeasLayer::CalcXingPointWith(const TVTrack &hel,
+ TVector3 &xx,
+ Double_t &phi,
+ Int_t mode,
+ Double_t eps) const{
+
+ int crosses = _enclosing_cylinder->CalcXingPointWith(hel, xx, phi, mode);
+
+ if (crosses == 0) {
+ return 0;
+ }
+
+ int index = this->get_plane_index(xx.Phi());
+
+ return _planes[index].CalcXingPointWith(hel,xx,phi,mode,eps);
+
+
+}
+
+Bool_t ILDPolygonBarrelMeasLayer::IsOnSurface(const TVector3 &xx) const
+{
+
+ // streamlog_out(DEBUG0) << "IsOnSurface " << std::endl;
+ int index = this->get_plane_index(xx.Phi());
+
+ return _planes[index].IsOnSurface(xx);
+
+}
+
+
+ILDVTrackHit* ILDPolygonBarrelMeasLayer::ConvertLCIOTrkHit(edm4hep::TrackerHit* trkhit) const {
+
+ std::cout << "ILDPolygonBarrelMeasLayer::ConvertLCIOTrkHit Not implemented: exit(1) called from " << __FILE__ << " line " << __LINE__ << std::endl;
+ exit(1);
+
+}
+
+bool ILDPolygonBarrelMeasLayer::IsOutside(const TVector3 &xx) const
+{
+ int index = this->get_plane_index(xx.Phi());
+ return _planes[index].IsOutside(xx);
+}
+
+double ILDPolygonBarrelMeasLayer::CalcS(const TVector3 &xx) const {
+
+ int index = this->get_plane_index(xx.Phi());
+ return _planes[index].CalcS(xx);
+
+}
+
+TMatrixD ILDPolygonBarrelMeasLayer::CalcDSDx(const TVector3 &xx) const {
+
+ int index = this->get_plane_index(xx.Phi());
+ return _planes[index].CalcDSDx(xx);
+
+}
+
+/** Get the intersection and the CellID, needed for multilayers */
+int ILDPolygonBarrelMeasLayer::getIntersectionAndCellID(const TVTrack &hel,
+ TVector3 &xx,
+ Double_t &phi,
+ Int_t &CellID,
+ Int_t mode,
+ Double_t eps) const {
+
+
+ int crosses = this->CalcXingPointWith(hel, xx, phi, mode, eps);
+
+ if ( crosses != 0 ) {
+
+ unsigned int plane = this->get_plane_index( xx.Phi() );
+
+ lcio::BitField64 bf( UTIL::ILDCellID0::encoder_string ) ;
+ bf.setValue( this->getCellIDs()[0] ) ; // get the first cell_ID, this will have the correct sensor value
+
+ bf[lcio::ILDCellID0::module] = plane;
+ CellID = bf.lowWord();
+
+ }
+
+ return crosses;
+
+}
+
+
+unsigned int ILDPolygonBarrelMeasLayer::get_plane_index(double phi) const {
+
+ phi = angular_range_2PI(phi-_start_phi);
+ return unsigned(floor(phi/_segment_dphi));
+
+}
+
+
+double ILDPolygonBarrelMeasLayer::angular_range_2PI( double phi ) const {
+
+ //bring phi_point into range 0 < phi < +2PI
+ while (phi < 0) {
+ phi += 2.0 * M_PI;
+ }
+ while (phi >= 2.0*M_PI) {
+ phi -= 2.0 * M_PI;
+ }
+
+ return phi;
+
+}
+
diff --git a/Utilities/KalDet/src/ild/common/ILDPolygonBarrelMeasLayer.h b/Utilities/KalDet/src/ild/common/ILDPolygonBarrelMeasLayer.h
new file mode 100644
index 0000000000000000000000000000000000000000..684bb876e7e0be4e48381ca59528c9871b6ffb1d
--- /dev/null
+++ b/Utilities/KalDet/src/ild/common/ILDPolygonBarrelMeasLayer.h
@@ -0,0 +1,138 @@
+#ifndef __ILDSEGMENTEDDISCMEASLAYER_H__
+#define __ILDSEGMENTEDDISCMEASLAYER_H__
+
+/** ILDPolygonBarrelMeasLayer: User defined Polygonal Barrel KalTest measurement layer class to be used only for dead material. Segments are planes parallel to the z axis
+ *
+ * NOTE: ALL METHODS INVOLVING HITS ARE DISABLED AND CALL EXIT(1)
+ * THIS CLASS IS ONLY MEANT FOR DEAD MATERIAL
+ *
+ * @author S.Aplin DESY
+ */
+
+#include "TVector3.h"
+
+#include "kaltest/TKalMatrix.h"
+#include "kaltest/TVSurface.h"
+#include "kaltest/KalTrackDim.h"
+#include "ILDVMeasLayer.h"
+
+#include "TMath.h"
+#include <sstream>
+
+#include "ILDParallelPlanarMeasLayer.h"
+
+#include <vector>
+
+class TVTrackHit;
+
+
+class ILDPolygonBarrelMeasLayer : public ILDVMeasLayer, public TVSurface {
+public:
+ // Ctors and Dtor
+
+
+
+ ILDPolygonBarrelMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ double Bz,
+ double SortingPolicy,
+ double r0, // min distance to the z-axis
+ double lhalf, // half length
+ int nsides,
+ double zpos, // z of the centre
+ double phi0, // phi of the first normal following the xaxis positive rotation
+ std::vector<int> CellIDs,
+ bool is_active,
+ const Char_t *name = "ILDPolygonBarrelMeasL");
+
+
+ ~ILDPolygonBarrelMeasLayer(){ delete _enclosing_cylinder;}
+
+
+ // Parrent's pure virtuals that must be implemented
+
+ /** Global to Local coordinates */
+ virtual TKalMatrix XvToMv (const TVTrackHit &ht,
+ const TVector3 &xv) const
+ { return this->XvToMv(xv); }
+
+
+ /** Global to Local coordinates */
+ virtual TKalMatrix XvToMv (const TVector3 &xv) const;
+
+ /** Local to Global coordinates */
+ virtual TVector3 HitToXv (const TVTrackHit &ht) const;
+
+ /** Calculate Projector Matrix */
+ virtual void CalcDhDa (const TVTrackHit &ht,
+ const TVector3 &xv,
+ const TKalMatrix &dxphiada,
+ TKalMatrix &H) const;
+
+ /** Convert LCIO Tracker Hit to an ILDPLanarTrackHit */
+ virtual ILDVTrackHit* ConvertLCIOTrkHit(edm4hep::TrackerHit* trkhit) const ;
+
+ /** overloaded version of CalcXingPointWith using closed solution*/
+ virtual Int_t CalcXingPointWith(const TVTrack &hel,
+ TVector3 &xx,
+ Double_t &phi,
+ Int_t mode,
+ Double_t eps = 1.e-8) const;
+
+ /** overloaded version of CalcXingPointWith using closed solution*/
+ virtual Int_t CalcXingPointWith(const TVTrack &hel,
+ TVector3 &xx,
+ Double_t &phi,
+ Double_t eps = 1.e-8) const{
+
+ return CalcXingPointWith(hel,xx,phi,0,eps);
+
+ }
+
+
+ /** Get the intersection and the CellID, needed for multilayers */
+ virtual int getIntersectionAndCellID(const TVTrack &hel,
+ TVector3 &xx,
+ Double_t &phi,
+ Int_t &CellID,
+ Int_t mode,
+ Double_t eps = 1.e-8) const ;
+
+
+ bool IsOutside(const TVector3 &xx) const;
+
+ double CalcS(const TVector3 &xx) const;
+
+ TMatrixD CalcDSDx(const TVector3 &xx) const;
+
+ /** Check if global point is on surface */
+ inline virtual Bool_t IsOnSurface (const TVector3 &xx) const;
+
+ /** Get sorting policy for this plane */
+ double GetSortingPolicy() const { return _sortingPolicy; }
+
+private:
+
+ double angular_range_2PI( double phi ) const;
+
+ unsigned int get_plane_index(double phi) const;
+
+ double _sortingPolicy;
+
+ double _r0; // min distance to the z-axis
+ double _lhalf; // half length
+ int _nsides;
+ double _zpos; // z of the centre
+ double _phi0; // phi of the first normal following the xaxis positive rotation
+
+ double _segment_dphi;
+ double _start_phi;
+ double _rmax;
+
+ std::vector<ILDParallelPlanarMeasLayer> _planes;
+ TCylinder* _enclosing_cylinder;
+};
+
+
+
+#endif
diff --git a/Utilities/KalDet/src/ild/common/ILDRotatedTrapMeaslayer.cc b/Utilities/KalDet/src/ild/common/ILDRotatedTrapMeaslayer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..c9f855e0bbd9c0257b7501ea8ab0f85b58dcb08b
--- /dev/null
+++ b/Utilities/KalDet/src/ild/common/ILDRotatedTrapMeaslayer.cc
@@ -0,0 +1,194 @@
+#include <iostream>
+
+#include "ILDRotatedTrapMeaslayer.h"
+#include "ILDPlanarHit.h"
+
+#include "kaltest/TVTrack.h"
+#include "TVector3.h"
+#include "TMath.h"
+#include "TRotMatrix.h"
+#include "TBRIK.h"
+#include "TNode.h"
+#include "TString.h"
+
+//#include <EVENT/TrackerHitPlane.h>
+
+// #include "streamlog/streamlog.h"
+
+ILDRotatedTrapMeaslayer::ILDRotatedTrapMeaslayer(TMaterial &min,
+ TMaterial &mout,
+ const TVector3 ¢er,
+ const TVector3 &normal,
+ Double_t Bz,
+ Double_t SortingPolicy,
+ Double_t height,
+ Double_t innerBaseLength,
+ Double_t outerBaseLength,
+ Double_t alpha,
+ Int_t half_petal,
+ Bool_t is_active,
+ Int_t CellID,
+ const Char_t *name)
+: ILDVMeasLayer(min, mout, Bz, is_active, CellID, name),
+TPlane(center, normal),
+_sortingPolicy(SortingPolicy), _innerBaseLength(innerBaseLength), _outerBaseLength(outerBaseLength), _halfPetal(half_petal)
+{
+
+ if( GetXc().Z() >= 0 ) {
+ _signZ = +1.0 ;
+ }
+ else {
+ _signZ = -1.0 ;
+ }
+
+ _innerR = GetXc().Perp() - 0.5 * height ;
+ _outerR = GetXc().Perp() + 0.5 * height ;
+ _cosPhi = GetXc().X() / GetXc().Perp() ;
+ _sinPhi = GetXc().Y() / GetXc().Perp() ;
+
+ // alpha should be limited to +/- Pi/2
+ _cosAlpha = cos(alpha) ;
+ _sinAlpha = sin(alpha) ;
+
+ _tanBeta = 0.5 * _outerBaseLength / _outerR ;
+
+}
+
+TKalMatrix ILDRotatedTrapMeaslayer::XvToMv(const TVector3 &xv) const
+{
+
+ // Calculate measurement vector (hit coordinates) from global coordinates:
+
+ TKalMatrix mv(kMdim,1);
+
+ // SJA:FIXME: what to do with the -z hits, are they reflective, i.e. that means that the transverse coordinate with be reversed
+ // transverse coordinate, measured from the centre line of the petal ( the axis of symmetry of the trapizoid )
+ mv(0,0) = _cosAlpha * _signZ * ( _cosPhi*xv.Y() - _sinPhi*xv.X() ) + _sinAlpha * ( xv.Z() - GetXc().Z() ) ;
+
+ // radial coordinate, measured from R = 0 ( x=0, y=0)
+ mv(1,0) = _cosPhi * xv.X() + _sinPhi * xv.Y() ;
+ return mv;
+
+}
+
+
+TVector3 ILDRotatedTrapMeaslayer::HitToXv(const TVTrackHit &vht) const
+{
+ // const ILDPlanarHit &mv = dynamic_cast<const ILDPlanarHit &>(vht);
+
+ Double_t x = vht(1,0) * _cosPhi - _signZ * _cosAlpha * vht(0,0) * _sinPhi ;
+ Double_t y = vht(1,0) * _sinPhi + _signZ * _cosAlpha * vht(0,0) * _cosPhi ;
+
+ Double_t z = GetXc().Z() + _signZ * vht(0,0) * _sinAlpha;
+
+ return TVector3(x,y,z);
+}
+
+void ILDRotatedTrapMeaslayer::CalcDhDa(const TVTrackHit &vht,
+ const TVector3 &xxv,
+ const TKalMatrix &dxphiada,
+ TKalMatrix &H) const
+{
+ // Calculate
+ // H = (@h/@a) = (@phi/@a, @z/@a)^t
+ // where
+ // h(a) = (phi, z)^t: expected meas vector
+ // a = (drho, phi0, kappa, dz, tanl, t0)
+ //
+
+ Int_t sdim = H.GetNcols();
+ Int_t hdim = TMath::Max(5,sdim-1);
+
+ // Set H = (@h/@a) = (@d/@a, @z/@a)^t
+
+ for (Int_t i=0; i<hdim; i++) {
+
+ H(0,i) = _cosAlpha * _signZ * ( _cosPhi*dxphiada(1,i) - _sinPhi*dxphiada(0,i) ) + _sinAlpha*dxphiada(2,i) ;
+ H(1,i) = _cosPhi * dxphiada(0,i) + _sinPhi*dxphiada(1,i);
+
+ }
+ if (sdim == 6) {
+ H(0,sdim-1) = 0.;
+ H(1,sdim-1) = 0.;
+ }
+
+}
+
+
+
+Bool_t ILDRotatedTrapMeaslayer::IsOnSurface(const TVector3 &xx) const
+{
+
+ // streamlog_out(DEBUG0) << "IsOnSurface " << std::endl;
+
+ bool onSurface = false ;
+
+ TKalMatrix mv = XvToMv(xx);
+
+ // check whether the hit lies in the same plane as the surface
+ if( TMath::Abs((xx.X()-GetXc().X())*GetNormal().X() + (xx.Y()-GetXc().Y())*GetNormal().Y() + (xx.Z()-GetXc().Z())*GetNormal().Z()) < 1e-4){
+ // check whether the hit lies within the boundary of the surface
+ if( mv(1,0) <= _outerR && mv(1,0) >= _innerR
+ &&
+ TMath::Abs(mv(0,0)) <= mv(1,0) * _tanBeta )
+ {
+
+ // meaning of _halfPetal:
+ // 0 complete trapezoid
+ // +1 positive half only, i.e. the side of the petal in which the transverse coordinate, mv(0,0), is positive
+ // -1 negative half only, i.e. the side of the petal in which the transverse coordinate, mv(0,0), is negative
+
+ if( _halfPetal == 0 || ( _halfPetal * mv(0,0) ) >= 0) { // check if the point lies in the correct half
+ onSurface = true ;
+ }
+
+ }
+
+ else{
+ onSurface = false;
+ }
+
+ }
+
+ return onSurface;
+
+}
+
+
+ILDVTrackHit* ILDRotatedTrapMeaslayer::ConvertLCIOTrkHit(edm4hep::TrackerHit* trkhit) const {
+
+ //EVENT::TrackerHitPlane* plane_hit = dynamic_cast<EVENT::TrackerHitPlane*>( trkhit ) ;
+ if(trkhit->getType()!=8) return NULL;
+ //if( plane_hit == NULL ) return NULL; // SJA:FIXME: should be replaced with an exception
+ const edm4hep::Vector3d& pos=trkhit->getPosition();
+ const TVector3 hit(pos.x, pos.y, pos.z);
+
+ // convert to layer coordinates
+ TKalMatrix h = this->XvToMv(hit);
+
+ Double_t x[2] ;
+ Double_t dx[2] ;
+
+ x[0] = h(0, 0);
+ x[1] = h(1, 0);
+
+ dx[0] = trkhit->getCovMatrix(2);
+ dx[1] = trkhit->getCovMatrix(5);
+
+ bool hit_on_surface = IsOnSurface(hit);
+
+ // streamlog_out(DEBUG1) << "ILDRotatedTrapMeaslayer::ConvertLCIOTrkHit ILDPlanarHit created"
+ // << " u = " << x[0]
+ // << " v = " << x[1]
+ // << " du = " << dx[0]
+ // << " dv = " << dx[1]
+ // << " x = " << hit.x()
+ // << " y = " << hit.y()
+ // << " z = " << hit.z()
+ // << " onSurface = " << hit_on_surface
+ // << std::endl ;
+
+ return hit_on_surface ? new ILDPlanarHit( *this , x, dx, this->GetBz(),trkhit) : NULL;
+
+
+}
diff --git a/Utilities/KalDet/src/ild/common/ILDRotatedTrapMeaslayer.h b/Utilities/KalDet/src/ild/common/ILDRotatedTrapMeaslayer.h
new file mode 100644
index 0000000000000000000000000000000000000000..8cb7e4e07bd142df53533ca42b88333a818327d1
--- /dev/null
+++ b/Utilities/KalDet/src/ild/common/ILDRotatedTrapMeaslayer.h
@@ -0,0 +1,106 @@
+#ifndef __ILDPLANARMEASLAYER__
+#define __ILDPLANARMEASLAYER__
+/** ILDRotatedTrapMeaslayer: User defined Rotated Trapezoid Planar KalTest measurement layer class used with ILDPLanarTrackHit.
+ *
+ * @author S.Aplin DESY
+ */
+
+#include "TVector3.h"
+
+#include "kaltest/TKalMatrix.h"
+#include "kaltest/TPlane.h"
+#include "kaltest/KalTrackDim.h"
+#include "ILDVMeasLayer.h"
+
+#include "TMath.h"
+#include <sstream>
+class TVTrackHit;
+
+class ILDRotatedTrapMeaslayer : public ILDVMeasLayer, public TPlane {
+
+public:
+
+ /** Constructor Taking inner and outer materials, centre and normal of the plane, B-Field, sorting policy, height, inner base length, outer base length, tilt angle around axis of symmetry, represents full or half petal, whether the layer is sensitive, Cell ID, and an optional name */
+ ILDRotatedTrapMeaslayer(TMaterial &min,
+ TMaterial &mout,
+ const TVector3 ¢er,
+ const TVector3 &normal,
+ Double_t Bz,
+ Double_t SortingPolicy,
+ Double_t height,
+ Double_t innerBaseLength,
+ Double_t outerBaseLength,
+ Double_t alpha,
+ Int_t half_petal,
+ Bool_t is_active,
+ Int_t CellID = -1,
+ const Char_t *name = "ILDRotatedTrapMeasL");
+
+
+ // Parrent's pure virtuals that must be implemented
+
+ /** Global to Local coordinates */
+ virtual TKalMatrix XvToMv (const TVTrackHit &ht,
+ const TVector3 &xv) const
+ { return this->XvToMv(xv); }
+
+ /** Global to Local coordinates */
+ virtual TKalMatrix XvToMv (const TVector3 &xv) const;
+
+ /** Local to Global coordinates */
+ virtual TVector3 HitToXv (const TVTrackHit &ht) const;
+
+ /** Calculate Projector Matrix */
+ virtual void CalcDhDa (const TVTrackHit &ht,
+ const TVector3 &xv,
+ const TKalMatrix &dxphiada,
+ TKalMatrix &H) const;
+
+ /** Convert LCIO Tracker Hit to an ILDPLanarTrackHit */
+ virtual ILDVTrackHit* ConvertLCIOTrkHit(edm4hep::TrackerHit* trkhit) const ;
+
+ /** Check if global point is on surface */
+ inline virtual Bool_t IsOnSurface (const TVector3 &xx) const;
+
+ /** Get sorting policy for this plane */
+ Double_t GetSortingPolicy() const { return _sortingPolicy; }
+
+ /** Get the intersection and the CellID, needed for multilayers */
+ virtual int getIntersectionAndCellID(const TVTrack &hel,
+ TVector3 &xx,
+ Double_t &phi,
+ Int_t &CellID,
+ Int_t mode,
+ Double_t eps = 1.e-8) const {
+
+ CellID = this->getCellIDs()[0]; // not multilayer
+ return this->CalcXingPointWith(hel,xx,phi,0,eps);
+
+ }
+
+
+
+private:
+ Double_t _sortingPolicy ;
+ Double_t _signZ ;
+ Double_t _innerR ;
+ Double_t _outerR ;
+ Double_t _innerBaseLength ;
+ Double_t _outerBaseLength ;
+ Double_t _cosPhi ; //** cos of the azimuthal angle of the petal
+ Double_t _sinPhi ; //** sin of the azimuthal angle of the petal
+ Double_t _cosAlpha ; //** cos of the tilt angle of the petal
+ Double_t _sinAlpha ; //** sin of the tilt angle of the petal
+ Double_t _tanBeta ; //** tan of the openning angle of the petal
+
+ // meaning of _halfPetal:
+ // 0 complete trapezoid
+ // +1 positive half only, i.e. the side of the petal in which the transverse coordinate, mv(0,0), is positive
+ // -1 negative half only, i.e. the side of the petal in which the transverse coordinate, mv(0,0), is negative
+ Int_t _halfPetal ;
+
+
+
+};
+
+#endif
diff --git a/Utilities/KalDet/src/ild/common/ILDSegmentedDiscMeasLayer.cc b/Utilities/KalDet/src/ild/common/ILDSegmentedDiscMeasLayer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..87cac85cb5b7cb15f1c72a4d57887199be03e437
--- /dev/null
+++ b/Utilities/KalDet/src/ild/common/ILDSegmentedDiscMeasLayer.cc
@@ -0,0 +1,617 @@
+
+#include "ILDSegmentedDiscMeasLayer.h"
+#include "ILDPlanarHit.h"
+
+#include <UTIL/BitField64.h>
+#include <UTIL/ILDConf.h>
+
+#include "kaltest/TVTrack.h"
+#include "TVector3.h"
+#include "TMath.h"
+#include "TRotMatrix.h"
+#include "TBRIK.h"
+#include "TNode.h"
+#include "TString.h"
+
+//#include <EVENT/TrackerHitPlane.h>
+
+#include <math.h>
+#include <assert.h>
+#include <algorithm>
+
+// #include "streamlog/streamlog.h"
+
+
+ILDSegmentedDiscMeasLayer::ILDSegmentedDiscMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ double Bz,
+ double sortingPolicy,
+ int nsegments,
+ double zpos,
+ double phi0, // defined by the axis of symmerty of the first petal
+ double trap_rmin,
+ double trap_height,
+ double trap_inner_base_length,
+ double trap_outer_base_length,
+ bool is_active,
+ std::vector<int> CellIDs,
+ const Char_t *name) :
+ILDVMeasLayer(min, mout, Bz, CellIDs, is_active, name),
+TPlane(TVector3(0.,0.,zpos), TVector3(0.,0.,zpos)),
+_sortingPolicy(sortingPolicy),_nsegments(nsegments),_trap_rmin(trap_rmin),_trap_height(trap_height),_trap_inner_base_length(trap_inner_base_length),_trap_outer_base_length(trap_outer_base_length)
+{
+
+ double h = _trap_rmin + _trap_height;
+ double w = 0.5 * _trap_outer_base_length;
+ _rmax = sqrt(h*h + w*w);
+
+ _trap_tan_beta = 0.5*(_trap_outer_base_length - _trap_inner_base_length) / _trap_height;
+
+ _segment_dphi = 2.0*M_PI / _nsegments;
+
+ phi0 = angular_range_2PI(phi0);
+
+ _start_phi = phi0 - 0.5*_segment_dphi;
+
+ _start_phi = angular_range_2PI(_start_phi);
+
+ // now check for constistency
+ double phi_max = std::max( ((0.5 * _trap_outer_base_length) / h ) , ((0.5 * _trap_inner_base_length) / _trap_rmin));
+
+ if( phi_max > _segment_dphi ) {
+ // streamlog_out(ERROR) << "ILDSegmentedDiscMeasLayer::ILDSegmentedDiscMeasLayer trapezoids overlaps: exit(1) called from " << __FILE__ << " line " << __LINE__ << std::endl;
+ exit(1);
+ }
+
+}
+
+
+
+
+
+
+ILDSegmentedDiscMeasLayer::ILDSegmentedDiscMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ double Bz,
+ double sortingPolicy,
+ int nsegments,
+ double zpos,
+ double phi0, // defined by the axis of symmerty of the first petal
+ double trap_rmin,
+ double trap_height,
+ double trap_inner_base_length,
+ double trap_outer_base_length,
+ bool is_active,
+ const Char_t *name) :
+ILDVMeasLayer(min, mout, Bz, is_active, -1, name),
+TPlane(TVector3(0.,0.,zpos), TVector3(0.,0.,zpos)),
+_sortingPolicy(sortingPolicy),_nsegments(nsegments),_trap_rmin(trap_rmin),_trap_height(trap_height),_trap_inner_base_length(trap_inner_base_length),_trap_outer_base_length(trap_outer_base_length)
+{
+
+ double h = _trap_rmin + _trap_height;
+ double w = 0.5 * _trap_outer_base_length;
+ _rmax = sqrt(h*h + w*w);
+
+ _trap_tan_beta = 0.5*(_trap_outer_base_length - _trap_inner_base_length) / _trap_height;
+
+ _segment_dphi = 2.0*M_PI / _nsegments;
+
+ phi0 = angular_range_2PI(phi0);
+
+ _start_phi = phi0 - 0.5*_segment_dphi;
+
+ _start_phi = angular_range_2PI(_start_phi);
+
+ // now check for constistency
+ double phi_max = std::max( ((0.5 * _trap_outer_base_length) / h ) , ((0.5 * _trap_inner_base_length) / _trap_rmin));
+
+ if( phi_max > _segment_dphi ) {
+ // streamlog_out(ERROR) << "ILDSegmentedDiscMeasLayer::ILDSegmentedDiscMeasLayer trapezoids overlaps: exit(1) called from " << __FILE__ << " line " << __LINE__ << std::endl;
+ exit(1);
+ }
+
+}
+
+
+TKalMatrix ILDSegmentedDiscMeasLayer::XvToMv(const TVector3 &xv) const
+{
+
+ // Calculate measurement vector (hit coordinates) from global coordinates:
+
+// TKalMatrix mv(kMdim,1);
+//
+// mv(0,0) = xv.X() ;
+//
+//
+// mv(1,0) = xv.Y() ;
+ /*
+ std::cout << "\t ILDSegmentedDiscMeasLayer::XvToMv: "
+ << " x = " << xv.X()
+ << " y = " << xv.Y()
+ << " z = " << xv.Z()
+ << std::endl;
+ */
+ // coordinate matrix to return
+ TKalMatrix mv(ILDPlanarHit_DIM,1);
+
+ int segmentIndex = get_segment_index(xv.Phi()) ;
+
+ TVector3 XC = this->get_segment_centre(segmentIndex);
+
+ double sensor_x0 = XC.X();
+ double sensor_y0 = XC.Y();
+
+ // here we are assuming that there is no offset of the centre of the sensor in the x-y plane.
+
+ double phi_sensor = XC.Phi();
+
+ // for ILDSegmentedDiscMeasLayer the Normal is pointing from the IP to the Plane
+ double sign_z = GetNormal().Z() < 0 ? -1.0 : 1.0 ;
+
+ double phi = phi_sensor + sign_z*M_PI/2 ;
+
+ double cos_phi = cos(phi);
+ double sin_phi = sin(phi);
+
+ double delta_x = xv.X() - sensor_x0;
+ double delta_y = xv.Y() - sensor_y0;
+
+
+ double cos_theta = -sign_z;
+
+ double u = delta_x * cos_phi + delta_y * sin_phi ;
+ mv(0,0) = u ;
+
+ double v = ( cos_theta * delta_y * cos_phi - cos_theta * delta_x * sin_phi) ;
+ mv(1,0) = v ;
+
+ /*
+ std::cout << "\t ILDSegmentedDiscMeasLayer::XvToMv: phi_sensor = " << phi_sensor << " phi = " << phi << " sign_z = " << sign_z<< std::endl;
+
+ std::cout << "\t ILDSegmentedDiscMeasLayer::XvToMv: "
+ << " mv(0,0) = " << mv(0,0)
+ << " mv(1,0) = " << mv(1,0)
+ << std::endl;
+ */
+ return mv;
+
+}
+
+
+TVector3 ILDSegmentedDiscMeasLayer::HitToXv(const TVTrackHit &vht) const {
+
+ //std::cout << "\t ILDSegmentedDiscMeasLayer::HitToXv: "
+ // << " vht(0,0) = " << vht(0,0) << " vht(1,0) = " << vht(1,0) << std::endl;
+
+ const ILDPlanarHit &mv = dynamic_cast<const ILDPlanarHit &>(vht);
+
+// double x = mv(0,0) ;
+// double y = mv(1,0) ;
+//
+// double z = this->GetXc().Z() ;
+
+ UTIL::BitField64 encoder( lcio::ILDCellID0::encoder_string ) ;
+ edm4hep::TrackerHit* hit = mv.getLCIOTrackerHit();
+ encoder.setValue(hit->getCellID());
+ int segmentIndex = encoder[lcio::ILDCellID0::module] / 2 ;
+
+
+ TVector3 XC = this->get_segment_centre(segmentIndex);
+
+ double sensor_x0 = XC.X();
+ double sensor_y0 = XC.Y();
+ double sensor_z0 = XC.Z();
+
+ double phi_sensor = XC.Phi();
+ // for ILDSegmentedDiscMeasLayer the Normal is pointing from the IP to the Plane
+ double sign_z = GetNormal().Z() < 0 ? -1.0 : 1.0 ;;
+
+ double phi = phi_sensor + sign_z*M_PI/2 ;
+
+ double cos_phi = cos(phi);
+ double sin_phi = sin(phi);
+
+ double cos_theta = -sign_z;
+
+ double u = mv(0,0);
+ double v = mv(1,0);
+
+ double delta_x = (u * cos_phi - cos_theta * v * sin_phi) ;
+ double delta_y = (u * sin_phi + cos_theta * v * cos_phi) ;
+
+ double x = delta_x + sensor_x0;
+ double y = delta_y + sensor_y0;
+
+ double z = sensor_z0 ;
+ /*
+ std::cout << "\t ILDSegmentedDiscMeasLayer::HitToXv: "
+ << " x = " << x
+ << " y = " << y
+ << " z = " << z
+ << std::endl;
+ */
+ return TVector3(x,y,z);
+
+}
+
+void ILDSegmentedDiscMeasLayer::CalcDhDa(const TVTrackHit &vht,
+ const TVector3 &xxv,
+ const TKalMatrix &dxphiada,
+ TKalMatrix &H) const
+{
+ // Calculate
+ // H = (@h/@a) = (@phi/@a, @z/@a)^t
+ // where
+ // h(a) = (phi, z)^t: expected meas vector
+ // a = (drho, phi0, kappa, dz, tanl, t0)
+ //
+
+// Int_t sdim = H.GetNcols();
+// Int_t hdim = TMath::Max(5,sdim-1);
+//
+// // Set H = (@h/@a) = (@d/@a, @z/@a)^t
+//
+// for (Int_t i=0; i<hdim; i++) {
+//
+// H(0,i) = dxphiada(0,i);
+// H(1,i) = dxphiada(1,i) ;
+//
+// }
+// if (sdim == 6) {
+// H(0,sdim-1) = 0.;
+// H(1,sdim-1) = 0.;
+// }
+
+
+ int segmentIndex = get_segment_index(xxv.Phi()) ;
+
+ TVector3 XC = this->get_segment_centre(segmentIndex);
+
+ double phi_sensor = XC.Phi();
+ // for ILDSegmentedDiscMeasLayer the Normal is pointing from the IP to the Plane
+ double sign_z = GetNormal().Z() < 0 ? -1.0 : 1.0 ;
+
+ double phi = phi_sensor + sign_z*M_PI/2 ;
+
+ double cos_phi = cos(phi);
+ double sin_phi = sin(phi);
+
+ double cos_theta = -sign_z;
+
+ Int_t sdim = H.GetNcols();
+ Int_t hdim = TMath::Max(5,sdim-1);
+
+ // Set H = (@h/@a) = (@d/@a, @z/@a)^t
+
+ double dudx = cos_phi;
+ double dudy = sin_phi;
+
+ double dvdx = -cos_theta * sin_phi;
+ double dvdy = cos_theta * cos_phi;
+ /*
+ std::cout << "\t ILDSegmentedDiscMeasLayer::CalcDhDa: "
+ << " dudx = " << dudx
+ << " dudy = " << dudy
+ << " dvdx = " << dvdx
+ << " dvdy = " << dvdy
+ << std::endl;
+ */
+ for (Int_t i=0; i<hdim; i++) {
+
+ H(0,i) = dudx * dxphiada(0,i) + dudy * dxphiada(1,i) ;
+ H(1,i) = dvdx * dxphiada(0,i) + dvdy * dxphiada(1,i) ;
+
+ }
+ if (sdim == 6) {
+
+ H(0,sdim-1) = 0.0;
+ H(1,sdim-1) = 0.;
+
+ }
+}
+
+
+Int_t ILDSegmentedDiscMeasLayer::CalcXingPointWith(const TVTrack &hel,
+ TVector3 &xx,
+ Double_t &phi,
+ Int_t mode,
+ Double_t eps) const{
+
+ // streamlog_out(DEBUG0) << "ILDSegmentedDiscMeasLayer::CalcXingPointWith" << std::endl;
+
+ phi = 0.0;
+
+ xx.SetX(0.0);
+ xx.SetY(0.0);
+ xx.SetZ(0.0);
+
+ // check that direction has one of the correct values
+ if( !( mode == 0 || mode == 1 || mode == -1) ) return -1 ;
+
+//
+
+ // get helix parameters
+ Double_t dr = hel.GetDrho();
+ Double_t phi0 = hel.GetPhi0(); //
+ Double_t kappa = hel.GetKappa();
+ Double_t rho = hel.GetRho();
+ Double_t omega = 1.0 / rho;
+ Double_t z0 = hel.GetDz();
+ Double_t tanl = hel.GetTanLambda();
+
+ TVector3 ref_point = hel.GetPivot();
+
+ //
+ // Check if charge is nonzero.
+ //
+
+ Int_t chg = (Int_t)TMath::Sign(1.1,kappa);
+ if (!chg) {
+ // streamlog_out(ERROR) << ">>>> Error >>>> ILDSegmentedDiscMeasLayer::CalcXingPointWith" << std::endl
+ // << " Kappa = 0 is invalid for a helix " << std::endl;
+ return -1;
+ }
+
+ const double sin_phi0 = sin(phi0);
+ const double cos_phi0 = cos(phi0);
+
+ const double x_pca = ref_point.x() + dr * cos_phi0 ;
+ const double y_pca = ref_point.y() + dr * sin_phi0 ;
+ const double z_pca = ref_point.z() + z0 ;
+
+ const double z = this->GetXc().Z() ;
+ // get path length to crossing point
+
+ const double s = ( z - z_pca ) / tanl ;
+
+
+// streamlog_out(DEBUG0) << "ILDSegmentedDiscMeasLayer::CalcXingPointWith "
+// << " ref_point.z() = " << ref_point.z()
+// << " z = " << z
+// << " z0 = " << z0
+// << " z_pca = " << z_pca
+// << " tanl = " << tanl
+// << " z - z_pca = " << z - z_pca
+// << std::endl;
+//
+// TVector3 xx_n;
+// int cuts = TVSurface::CalcXingPointWith(hel, xx_n, phi, mode, eps);
+// streamlog_out(DEBUG0) << "ILDSegmentedDiscMeasLayer::CalcXingPointWith from Newton: cuts = " << cuts << " x = " << xx_n.x() << " y = "<< xx_n.y() << " z = " << xx_n.z() << " r = " << xx_n.Perp() << " phi = " << xx_n.Phi() << " dphi = " << phi << std::endl;
+
+
+ phi = -omega * s;
+
+ const double delta_phi_half = -phi/2.0 ;
+
+ double x;
+ double y;
+
+ if( fabs(s) > FLT_MIN ){ // protect against starting on the plane
+
+ x = x_pca - s * ( sin(delta_phi_half) / delta_phi_half ) * sin( phi0 - delta_phi_half ) ;
+
+ y = y_pca + s * ( sin(delta_phi_half) / delta_phi_half ) * cos( phi0 - delta_phi_half ) ;
+
+ }
+ else{
+ // streamlog_out(DEBUG0) << "ILDSegmentedDiscMeasLayer::CalcXingPointWith Using PCA values " << std::endl;
+ x = x_pca;
+ y = y_pca;
+ phi = 0.0;
+ }
+
+
+ xx.SetXYZ(x, y, z);
+
+
+ // streamlog_out(DEBUG0) << "ILDSegmentedDiscMeasLayer::CalcXingPointWith : cuts = " << (IsOnSurface(xx) && (chg*phi*mode)<0) << " x = " << xx.x() << " y = "<< xx.y() << " z = " << xx.z() << " r = " << xx.Perp() << " phi = " << xx.Phi() << " dphi = " << phi << " s = " << s << " " << this->TVMeasLayer::GetName() << std::endl;
+//
+// streamlog_out(DEBUG0) << "ILDSegmentedDiscMeasLayer::CalcXingPointWith : xdiff = " << xx.x() - xx_n.x() << " ydiff = "<< xx.y() - xx_n.y() << " zdiff = " << xx.z() - xx_n.z() << std::endl;
+
+ // check if intersection with plane is within boundaries
+
+ if( mode!=0 && fabs(phi)>1.e-10 ){ // (+1,-1) = (fwd,bwd)
+ if( chg*phi*mode > 0){
+ return 0;
+ }
+ }
+
+
+ return (IsOnSurface(xx) ? 1 : 0);
+
+
+}
+
+Bool_t ILDSegmentedDiscMeasLayer::IsOnSurface(const TVector3 &xx) const
+{
+
+ // streamlog_out(DEBUG0) << "IsOnSurface " << std::endl;
+
+ bool onSurface = false ;
+
+ // TKalMatrix mv = XvToMv(xx);
+
+ // check whether the hit lies in the same plane as the surface, here we are resticted to planes perpendicular to z
+
+ // streamlog_out(DEBUG0) << "ILDSegmentedDiscMeasLayer::IsOnSurface Xc.Z = " << GetXc().Z() << std::endl;
+
+ if (TMath::Abs(xx.Z()-GetXc().Z()) < 1e-4) {
+ // streamlog_out(DEBUG0) << "ILDSegmentedDiscMeasLayer::IsOnSurface z passed " << std::endl;
+ double r2 = xx.Perp2();
+
+ // quick check to see weather the hit lies inside the min max r
+ if( r2 <= _rmax*_rmax && r2 >= _trap_rmin*_trap_rmin ) {
+ // streamlog_out(DEBUG0) << "ILDSegmentedDiscMeasLayer::IsOnSurface r2 passed " << std::endl;
+
+ double phi_point = angular_range_2PI(xx.Phi());
+
+ // get the angle in the local system
+ double gamma = angular_range_2PI(phi_point - _start_phi);
+
+ // the angle local to the sector
+ double local_phi = fmod(gamma, _segment_dphi) - (0.5*_segment_dphi) ;
+
+ double dist_along_centre_line = xx.Perp()*cos(local_phi);
+
+ // check if the point projected onto the centre line is within the limits of the trapezoid
+ if( dist_along_centre_line > _trap_rmin && dist_along_centre_line < _trap_rmin + _trap_height){
+ // streamlog_out(DEBUG0) << "ILDSegmentedDiscMeasLayer::IsOnSurface dist_along_centre_line passed " << std::endl;
+
+ double adj = dist_along_centre_line - _trap_rmin ;
+
+ double dist_from_centre_line = fabs(xx.Perp()*sin(local_phi));
+
+ double opp = dist_from_centre_line - 0.5*_trap_inner_base_length;
+
+ double tan_delta_angle = opp/adj;
+
+ // check if the point is within the angular limits of the trapezoid
+ if (tan_delta_angle < _trap_tan_beta) {
+ // streamlog_out(DEBUG0) << "ILDSegmentedDiscMeasLayer::IsOnSurface tan_delta_angle passed " << std::endl;
+ onSurface = true ;
+
+ }
+ }
+ }
+ }
+
+ return onSurface;
+
+}
+
+
+ILDVTrackHit* ILDSegmentedDiscMeasLayer::ConvertLCIOTrkHit(edm4hep::TrackerHit* trkhit) const {
+ //EVENT::TrackerHitPlane* plane_hit = dynamic_cast<EVENT::TrackerHitPlane*>( trkhit ) ;
+ //if( plane_hit == NULL ) {
+ // streamlog_out(ERROR) << "ILDSegmentedDiscMeasLayer::ConvertLCIOTrkHit dynamic_cast to TrackerHitPlane failed " << std::endl;
+ //return NULL; // SJA:FIXME: should be replaced with an exception
+ //}
+ if((trkhit->getType()&8)!=8) {
+ std::cout << "ILDSegmentedDiscMeasLayer::ConvertLCIOTrkHit dynamic_cast to ILDPlanarHit failed " << std::endl;
+ throw std::logic_error("Invalid invoke ILDSegmentedDiscMeasLayer by TrackerHit trkhit");
+ }
+
+ // remember here the "position" of the hit in fact defines the origin of the plane it defines so u and v are per definition 0.
+ const edm4hep::Vector3d& pos=trkhit->getPosition();
+ const TVector3 hit(pos.x, pos.y, pos.z) ;
+
+ // convert to layer coordinates
+ TKalMatrix h(ILDPlanarHit_DIM,1);
+
+ h = this->XvToMv(hit);
+
+ double x[ILDPlanarHit_DIM] ;
+ double dx[ILDPlanarHit_DIM] ;
+
+ x[0] = h(0, 0);
+ x[1] = h(1, 0);
+
+ dx[0] = trkhit->getCovMatrix(2);
+ dx[1] = trkhit->getCovMatrix(5);
+
+ bool hit_on_surface = IsOnSurface(hit);
+ /*
+ std::cout << "ILDSegmentedDiscMeasLayer::ConvertLCIOTrkHit: ILDPlanarHit created"
+ << " for CellID " << trkhit->getCellID()
+ << " u = " << x[0]
+ << " v = " << x[1]
+ << " du = " << dx[0]
+ << " dv = " << dx[1]
+ << " x = " << pos.x
+ << " y = " << pos.y
+ << " z = " << pos.z
+ << " onSurface = " << hit_on_surface
+ << std::endl ;
+ */
+ ILDPlanarHit hh( *this , x, dx, this->GetBz(),trkhit);
+
+ this->HitToXv(hh);
+
+ return hit_on_surface ? new ILDPlanarHit( *this , x, dx, this->GetBz(),trkhit) : NULL;
+
+}
+
+
+/** Get the intersection and the CellID, needed for multilayers */
+int ILDSegmentedDiscMeasLayer::getIntersectionAndCellID(const TVTrack &hel,
+ TVector3 &xx,
+ Double_t &phi,
+ Int_t &CellID,
+ Int_t mode,
+ Double_t eps) const {
+
+
+ int crosses = this->CalcXingPointWith(hel, xx, phi, mode, eps);
+
+ if ( crosses != 0 ) {
+
+ unsigned int segment = this->get_segment_index( xx.Phi() );
+
+ const std::vector<int>& cellIds = this->getCellIDs();
+
+ lcio::BitField64 bf( UTIL::ILDCellID0::encoder_string ) ;
+ bf.setValue( this->getCellIDs()[0] ) ; // get the first cell_ID, this will have the correct sensor value
+
+ bf[lcio::ILDCellID0::module] = cellIds.at(segment);
+ CellID = bf.lowWord();
+
+ }
+
+
+ return crosses;
+
+}
+
+unsigned int ILDSegmentedDiscMeasLayer::get_segment_index(double phi) const {
+
+ phi = angular_range_2PI(phi-_start_phi);
+ return unsigned(floor(phi/_segment_dphi));
+
+}
+
+double ILDSegmentedDiscMeasLayer::get_segment_phi(unsigned int index) const{
+
+ return angular_range_2PI(_start_phi + 0.5*_segment_dphi + index * _segment_dphi);
+
+}
+
+
+TVector3 ILDSegmentedDiscMeasLayer::get_segment_centre(unsigned int index) const{
+
+// streamlog_out(DEBUG0) << "ILDSegmentedDiscMeasLayer::get_segment_centre index = " << index << std::endl;
+
+ double phi = this->get_segment_phi(index);
+
+// streamlog_out(DEBUG0) << "ILDSegmentedDiscMeasLayer::get_segment_centre phi = " << phi << std::endl;
+
+
+ double rc = _trap_rmin + _trap_height/2;
+
+// streamlog_out(DEBUG0) << "ILDSegmentedDiscMeasLayer::get_segment_centre rc = " << rc << std::endl;
+
+ double xc = rc * cos(phi);
+ double yc = rc * sin(phi);;
+
+ double zc = this->GetXc().Z();
+
+ TVector3 XC(xc,yc,zc);
+
+
+ return XC;
+
+}
+
+double ILDSegmentedDiscMeasLayer::angular_range_2PI( double phi ) const {
+
+ //bring phi_point into range 0 < phi < +2PI
+ while (phi < 0) {
+ phi += 2.0 * M_PI;
+ }
+ while (phi >= 2.0*M_PI) {
+ phi -= 2.0 * M_PI;
+ }
+
+ return phi;
+
+}
+
diff --git a/Utilities/KalDet/src/ild/common/ILDSegmentedDiscMeasLayer.h b/Utilities/KalDet/src/ild/common/ILDSegmentedDiscMeasLayer.h
new file mode 100644
index 0000000000000000000000000000000000000000..6133570279f935d889f3e5ed76f3f51ed2f1205b
--- /dev/null
+++ b/Utilities/KalDet/src/ild/common/ILDSegmentedDiscMeasLayer.h
@@ -0,0 +1,144 @@
+#ifndef __ILDSEGMENTEDDISCMEASLAYER_H__
+#define __ILDSEGMENTEDDISCMEASLAYER_H__
+
+/** ILDSegmentedDiscMeasLayer: User defined Segemented Disk Planar KalTest measurement layer class used with ILDPLanarTrackHit. Segments are isosolese trapezoids whose axis of symmetry points to the origin
+ * WARNING: ONLY IMPLEMENTED FOR X AND Y COORDINATES AT FIXED Z
+ *
+ * @author S.Aplin DESY
+ */
+
+#include "TVector3.h"
+
+#include "kaltest/TKalMatrix.h"
+#include "kaltest/TPlane.h"
+#include "kaltest/KalTrackDim.h"
+#include "ILDVMeasLayer.h"
+
+#include "TMath.h"
+#include <sstream>
+#include <iostream>
+
+#include <vector>
+
+class TVTrackHit;
+
+class ILDSegmentedDiscMeasLayer : public ILDVMeasLayer, public TPlane {
+public:
+ // Ctors and Dtor
+
+ ILDSegmentedDiscMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ double Bz,
+ double SortingPolicy,
+ int nsegments,
+ double zpos,
+ double phi0, // defined by the axis of symmerty of the first petal
+ double trap_rmin,
+ double trap_height,
+ double trap_innerBaseLength,
+ double trap_outerBaseLength,
+ bool is_active,
+ std::vector<int> CellIDs,
+ const Char_t *name = "ILDDiscMeasL");
+
+ ILDSegmentedDiscMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ double Bz,
+ double SortingPolicy,
+ int nsegments,
+ double zpos,
+ double phi0, // defined by the axis of symmerty of the first petal
+ double trap_rmin,
+ double trap_height,
+ double trap_innerBaseLength,
+ double trap_outerBaseLength,
+ bool is_active,
+ const Char_t *name = "ILDDiscMeasL");
+
+
+ // Parrent's pure virtuals that must be implemented
+
+ /** Global to Local coordinates */
+ virtual TKalMatrix XvToMv (const TVTrackHit &ht,
+ const TVector3 &xv) const
+ { return this->XvToMv(xv); }
+
+
+ /** Global to Local coordinates */
+ virtual TKalMatrix XvToMv (const TVector3 &xv) const;
+
+ /** Local to Global coordinates */
+ virtual TVector3 HitToXv (const TVTrackHit &ht) const;
+
+ /** Calculate Projector Matrix */
+ virtual void CalcDhDa (const TVTrackHit &ht,
+ const TVector3 &xv,
+ const TKalMatrix &dxphiada,
+ TKalMatrix &H) const;
+
+ /** Convert LCIO Tracker Hit to an ILDPLanarTrackHit */
+ virtual ILDVTrackHit* ConvertLCIOTrkHit(edm4hep::TrackerHit* trkhit) const ;
+
+ /** overloaded version of CalcXingPointWith using closed solution*/
+ virtual Int_t CalcXingPointWith(const TVTrack &hel,
+ TVector3 &xx,
+ Double_t &phi,
+ Int_t mode,
+ Double_t eps = 1.e-8) const;
+
+ /** overloaded version of CalcXingPointWith using closed solution*/
+ virtual Int_t CalcXingPointWith(const TVTrack &hel,
+ TVector3 &xx,
+ Double_t &phi,
+ Double_t eps = 1.e-8) const{
+
+ return CalcXingPointWith(hel,xx,phi,0,eps);
+
+ }
+
+
+
+ /** Get the intersection and the CellID, needed for multilayers */
+ virtual int getIntersectionAndCellID(const TVTrack &hel,
+ TVector3 &xx,
+ Double_t &phi,
+ Int_t &CellID,
+ Int_t mode,
+ Double_t eps = 1.e-8) const ;
+
+
+
+ /** Check if global point is on surface */
+ virtual Bool_t IsOnSurface (const TVector3 &xx) const;
+
+ /** Get sorting policy for this plane */
+ double GetSortingPolicy() const { return _sortingPolicy; }
+
+protected:
+
+ double angular_range_2PI( double phi ) const;
+ unsigned int get_segment_index(double phi) const;
+ double get_segment_phi(unsigned int index) const;
+ TVector3 get_segment_centre(unsigned int index) const;
+
+private:
+
+ double _sortingPolicy;
+ int _nsegments;
+ double _trap_rmin;
+ double _trap_height;
+ double _trap_inner_base_length;
+ double _trap_outer_base_length;
+ double _trap_tan_beta; // tan of the openning angle of the petal
+
+ double _rmax;
+ double _start_phi; // trailing edge of the first sector
+ double _segment_dphi;
+
+
+
+};
+
+
+
+#endif
diff --git a/Utilities/KalDet/src/ild/common/ILDSegmentedDiscStripMeasLayer.cc b/Utilities/KalDet/src/ild/common/ILDSegmentedDiscStripMeasLayer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..590032d20c53e5c4fc058f32293f6a4b88fa751a
--- /dev/null
+++ b/Utilities/KalDet/src/ild/common/ILDSegmentedDiscStripMeasLayer.cc
@@ -0,0 +1,299 @@
+
+#include "ILDSegmentedDiscStripMeasLayer.h"
+
+#include "ILDPlanarStripHit.h"
+
+#include <UTIL/BitField64.h>
+#include <UTIL/ILDConf.h>
+
+#include "kaltest/TVTrack.h"
+#include "TVector3.h"
+#include "TMath.h"
+#include "TRotMatrix.h"
+#include "TBRIK.h"
+#include "TNode.h"
+#include "TString.h"
+
+//#include <EVENT/TrackerHitPlane.h>
+
+#include <math.h>
+#include <assert.h>
+#include <algorithm>
+
+// #include "streamlog/streamlog.h"
+
+
+TKalMatrix ILDSegmentedDiscStripMeasLayer::XvToMv(const TVector3 &xv) const
+{
+
+ // Calculate measurement vector (hit coordinates) from global coordinates:
+ /*
+ std::cout << "\t ILDSegmentedDiscStripMeasLayer::XvToMv: "
+ << " x = " << xv.X()
+ << " y = " << xv.Y()
+ << " z = " << xv.Z()
+ << std::endl;
+ */
+ // let's start with the sensor whose axis of symmetry is
+ // aligned with the y-axis and whose sensitive face is facing towards the IP.
+ // For a zero strip angle then:
+ // u = -x
+ // v = y
+ // w = -z
+
+ // coordinate matrix to return
+ TKalMatrix mv(ILDPlanarStripHit_DIM,1);
+
+ int segmentIndex = get_segment_index(xv.Phi()) ;
+
+ TVector3 XC = this->get_segment_centre(segmentIndex);
+
+ double sensor_x0 = XC.X();
+ double sensor_y0 = XC.Y();
+
+ // here we are assuming that there is no offset of the centre of the sensor in the x-y plane.
+ // SJA:FIXME: We need to get the segment we are in to get phi
+
+ double phi_sensor = XC.Phi();
+
+ // for ILDSegmentedDiscMeasLayer the Normal is pointing from the IP to the Plane
+ double sign_z = GetNormal().Z() < 0 ? -1.0 : 1.0 ;
+
+ double phi = phi_sensor + sign_z*M_PI/2 ;
+
+ phi += _stripAngle; // the strip rotation is around the w vector which is pointing at the IP
+
+ double cos_phi = cos(phi);
+ double sin_phi = sin(phi);
+
+ double delta_x = xv.X() - sensor_x0;
+ double delta_y = xv.Y() - sensor_y0;
+
+ // is the sensitive facing the IP (+1) or facing away from it (-1)
+ // const double sign_z = GetNormal().Z() < 0 ? 1.0 : -1.0 ;
+
+ // double u = sign_z * (delta_y * cos_phi - delta_x * sin_phi) ;
+
+ double cos_theta = -sign_z;
+
+ // double u = delta_x * cos_phi - cos_theta * delta_y * sin_phi ;
+ double u = delta_x * cos_phi + delta_y * sin_phi ;
+
+ mv(0,0) = u ;
+
+ if (ILDPlanarStripHit_DIM == 2) {
+ // double v = (delta_x * sin_phi + cos_theta * delta_y * cos_phi) ;
+ double v = ( cos_theta * delta_y * cos_phi - cos_theta * delta_x * sin_phi) ;
+ mv(1,0) = v ;
+ }
+
+ /*
+ std::cout << "\t ILDSegmentedDiscStripMeasLayer::XvToMv: phi_sensor = " << phi_sensor << " phi = " << phi << " stripAngle = " << _stripAngle << " sign_z = " << sign_z<< std::endl;
+
+ std::cout << "\t ILDSegmentedDiscStripMeasLayer::XvToMv: "
+ << " mv(0,0) = " << mv(0,0) ;
+ if (ILDPlanarStripHit_DIM == 2) {
+ std::cout << " mv(1,0) = " << mv(1,0);
+ }
+ std::cout << std::endl;
+ */
+ return mv;
+
+}
+
+TVector3 ILDSegmentedDiscStripMeasLayer::HitToXv(const TVTrackHit &vht) const {
+ /*
+ std::cout << "\t ILDSegmentedDiscStripMeasLayer::HitToXv: "
+ << " vht(0,0) = " << vht(0,0);
+ if (ILDPlanarStripHit_DIM == 2) {
+ std::cout << " vht(1,0) = " << vht(1,0);
+ }
+ std::cout << std::endl;
+ */
+ const ILDPlanarStripHit &mv = dynamic_cast<const ILDPlanarStripHit &>(vht);
+
+ UTIL::BitField64 encoder( lcio::ILDCellID0::encoder_string ) ;
+ edm4hep::TrackerHit* hit = mv.getLCIOTrackerHit();
+ encoder.setValue(hit->getCellID());
+ int segmentIndex = encoder[lcio::ILDCellID0::module] / 2 ;
+
+
+ TVector3 XC = this->get_segment_centre(segmentIndex);
+
+ double sensor_x0 = XC.X();
+ double sensor_y0 = XC.Y();
+ double sensor_z0 = XC.Z();
+
+ ////std::cout << "\t ILDSegmentedDiscStripMeasLayer::HitToXv: segmentIndex = " << segmentIndex << " x0 = " << sensor_x0 << " y0 = " << sensor_y0 << " z0 = " << sensor_z0 << " segment Phi = " << XC.Phi() << std::endl;
+
+ // here we are assuming that there is no offset of the centre of the sensor in the x-y plane.
+ // SJA:FIXME: We need to get the segment we are in to get phi
+
+ double phi_sensor = XC.Phi();
+ // for ILDSegmentedDiscMeasLayer the Normal is pointing from the IP to the Plane
+ double sign_z = GetNormal().Z() < 0 ? -1.0 : 1.0 ;;
+
+ double phi = phi_sensor + sign_z*M_PI/2 ;
+
+ phi += _stripAngle; // the strip rotation is around the w vector which is pointing at the IP
+
+ double cos_phi = cos(phi);
+ double sin_phi = sin(phi);
+
+ double cos_theta = -sign_z;
+
+ double u = mv(0,0);
+ double v = 0.0;
+
+ if (ILDPlanarStripHit_DIM == 2) {
+ v = mv(1,0);
+ }
+
+// double delta_x = (u * cos_phi - cos_theta * v * sin_phi) ;
+// double delta_y = (u * sin_phi + cos_theta * v * cos_phi) ;
+
+ double delta_x = (u * cos_phi - cos_theta * v * sin_phi) ;
+ double delta_y = (u * sin_phi + cos_theta * v * cos_phi) ;
+
+ double x = delta_x + sensor_x0;
+ double y = delta_y + sensor_y0;
+
+ double z = sensor_z0 ;
+ /*
+ std::cout << "\t ILDSegmentedDiscStripMeasLayer::HitToXv: "
+ << " x = " << x
+ << " y = " << y
+ << " z = " << z
+ << std::endl;
+ */
+ return TVector3(x,y,z);
+}
+
+void ILDSegmentedDiscStripMeasLayer::CalcDhDa(const TVTrackHit &vht,
+ const TVector3 &xxv,
+ const TKalMatrix &dxphiada,
+ TKalMatrix &H) const
+{
+ // Calculate
+ // H = (@h/@a) = (@phi/@a, @z/@a)^t
+ // where
+ // h(a) = (phi, z)^t: expected meas vector
+ // a = (drho, phi0, kappa, dz, tanl, t0)
+ //
+
+ int segmentIndex = get_segment_index(xxv.Phi()) ;
+
+ TVector3 XC = this->get_segment_centre(segmentIndex);
+
+
+ double phi_sensor = XC.Phi();
+ // for ILDSegmentedDiscMeasLayer the Normal is pointing from the IP to the Plane
+ double sign_z = GetNormal().Z() < 0 ? -1.0 : 1.0 ;
+
+ double phi = phi_sensor + sign_z*M_PI/2 ;
+
+ phi += _stripAngle; // the strip rotation is around the w vector which is pointing at the IP
+
+ double cos_phi = cos(phi);
+ double sin_phi = sin(phi);
+
+ double cos_theta = -sign_z;
+
+ Int_t sdim = H.GetNcols();
+ Int_t hdim = TMath::Max(5,sdim-1);
+
+ // Set H = (@h/@a) = (@d/@a, @z/@a)^t
+
+
+ double dudx = cos_phi;
+ double dudy = sin_phi;
+
+ double dvdx = -cos_theta * sin_phi;
+ double dvdy = cos_theta * cos_phi;
+ /*
+ std::cout << "\t ILDSegmentedDiscStripMeasLayer::CalcDhDa: "
+ << " dudx = " << dudx
+ << " dudy = " << dudy
+ << " dvdx = " << dvdx
+ << " dvdy = " << dvdy
+ << std::endl;
+ */
+ for (Int_t i=0; i<hdim; i++) {
+
+ H(0,i) = dudx * dxphiada(0,i) + dudy * dxphiada(1,i) ;
+
+ if (ILDPlanarStripHit_DIM == 2) {
+ H(1,i) = dvdx * dxphiada(0,i) + dvdy * dxphiada(1,i) ;
+ }
+
+ }
+ if (sdim == 6) {
+ H(0,sdim-1) = 0.0;
+ if (ILDPlanarStripHit_DIM == 2) {
+ H(1,sdim-1) = 0.;
+ }
+
+ }
+
+}
+
+
+
+ILDVTrackHit* ILDSegmentedDiscStripMeasLayer::ConvertLCIOTrkHit(edm4hep::TrackerHit* trkhit) const {
+
+ //EVENT::TrackerHitPlane* plane_hit = dynamic_cast<EVENT::TrackerHitPlane*>( trkhit ) ;
+ //if( plane_hit == NULL ) {
+ // streamlog_out(ERROR) << "ILDSegmentedDiscStripMeasLayer::ConvertLCIOTrkHit dynamic_cast to TrackerHitPlane failed " << std::endl;
+ //return NULL; // SJA:FIXME: should be replaced with an exception
+ //}
+ if((trkhit->getType()&8)!=8) {
+ std::cout << "ILDSegmentedDiscStripMeasLayer::ConvertLCIOTrkHit dynamic_cast to ILDPlanarStripHit failed " << std::endl;
+ throw std::logic_error("Invalid invoke ILDSegmentedDiscStripMeasLayer by TrackerHit trkhit");
+ }
+
+ // remember here the "position" of the hit in fact defines the origin of the plane it defines so u and v are per definition 0.
+ // this is still the case for a 1-dimentional measurement, and is then used to calculate the u coordinate according to the origin of the actual measurement plane.
+ const edm4hep::Vector3d& pos=trkhit->getPosition();
+ const TVector3 hit(pos[0], pos[1], pos[2]) ;
+
+ // convert to layer coordinates
+ TKalMatrix h(ILDPlanarStripHit_DIM,1);
+
+ h = this->XvToMv(hit);
+
+ double x[ILDPlanarStripHit_DIM] ;
+ double dx[ILDPlanarStripHit_DIM] ;
+
+ x[0] = h(0, 0);
+ if(ILDPlanarStripHit_DIM == 2) x[1] = h(1, 0);
+
+ dx[0] = trkhit->getCovMatrix(2);
+ if(ILDPlanarStripHit_DIM == 2) dx[1] = trkhit->getCovMatrix(5);
+
+ bool hit_on_surface = IsOnSurface(hit);
+ /*
+ std::cout << "ILDSegmentedDiscStripMeasLayer::ConvertLCIOTrkHit ILDPlanarStripHit created"
+ << " for CellID " << trkhit->getCellID()
+ << " Disc Z = " << this->GetXc().Z()
+ << " u = " << x[0]
+ << " du = " << dx[0];
+
+ if(ILDPlanarStripHit_DIM == 2) std::cout << " v = " << x[1] << " dv = " << dx[1];
+
+ std::cout << " x = " << hit.x()
+ << " y = " << hit.y()
+ << " z = " << hit.z()
+ << " r = " << hit.Perp()
+ << " onSurface = " << hit_on_surface
+ << std::endl ;
+ */
+ ILDPlanarStripHit hh( *this , x, dx, this->GetBz(),trkhit);
+
+ this->HitToXv(hh);
+
+ return hit_on_surface ? new ILDPlanarStripHit( *this , x, dx, this->GetBz(),trkhit) : NULL;
+
+}
+
+
+
diff --git a/Utilities/KalDet/src/ild/common/ILDSegmentedDiscStripMeasLayer.h b/Utilities/KalDet/src/ild/common/ILDSegmentedDiscStripMeasLayer.h
new file mode 100644
index 0000000000000000000000000000000000000000..8bdab6686dcc7ba6d2ac04bcc3e7a7eae1dc84b8
--- /dev/null
+++ b/Utilities/KalDet/src/ild/common/ILDSegmentedDiscStripMeasLayer.h
@@ -0,0 +1,80 @@
+#ifndef __ILDSEGMENTEDDISCSTRIPMEASLAYER_H__
+#define __ILDSEGMENTEDDISCSTRIPMEASLAYER_H__
+
+/** ILDSegmentedDiscStripMeasLayer: User defined Segemented Disk Planar KalTest measurement layer class used with ILDPLanarTrackHit. Segments are isosolese trapezoids whose axis of symmetry points to the origin
+ * WARNING: ONLY IMPLEMENTED FOR X AND Y COORDINATES AT FIXED Z
+ *
+ * @author S.Aplin DESY
+ */
+#include "TVector3.h"
+
+#include "kaltest/TKalMatrix.h"
+#include "kaltest/TPlane.h"
+#include "kaltest/KalTrackDim.h"
+#include "ILDSegmentedDiscMeasLayer.h"
+
+#include "TMath.h"
+#include <sstream>
+#include <iostream>
+
+#include <vector>
+
+class TVTrackHit;
+
+class ILDSegmentedDiscStripMeasLayer : public ILDSegmentedDiscMeasLayer {
+
+public:
+ // Ctors and Dtor
+
+ ILDSegmentedDiscStripMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ double Bz,
+ double SortingPolicy,
+ int nsegments,
+ double zpos,
+ double phi0, // defined by the axis of symmerty of the first petal
+ double trap_rmin,
+ double trap_height,
+ double trap_innerBaseLength,
+ double trap_outerBaseLength,
+ double stripAngle,
+ bool is_active,
+ std::vector<int> CellIDs,
+ const Char_t *name = "ILDDiscMeasL")
+ : ILDSegmentedDiscMeasLayer(min,mout,Bz,SortingPolicy,nsegments,zpos,phi0,trap_rmin,trap_height,trap_innerBaseLength,trap_outerBaseLength,is_active,CellIDs,name),
+ _stripAngle(stripAngle)
+ { /* no op */ }
+
+
+ // Parrent's pure virtuals that must be implemented
+
+ /** Global to Local coordinates */
+ virtual TKalMatrix XvToMv (const TVTrackHit &ht,
+ const TVector3 &xv) const
+ { return this->XvToMv(xv); }
+
+
+ /** Global to Local coordinates */
+ virtual TKalMatrix XvToMv (const TVector3 &xv) const;
+
+ /** Local to Global coordinates */
+ virtual TVector3 HitToXv (const TVTrackHit &ht) const;
+
+ /** Calculate Projector Matrix */
+ virtual void CalcDhDa (const TVTrackHit &ht,
+ const TVector3 &xv,
+ const TKalMatrix &dxphiada,
+ TKalMatrix &H) const;
+
+ /** Convert LCIO Tracker Hit to an ILDPLanarTrackHit */
+ virtual ILDVTrackHit* ConvertLCIOTrkHit(edm4hep::TrackerHit* trkhit) const ;
+
+private:
+
+ double _stripAngle;
+
+};
+
+
+
+#endif
diff --git a/Utilities/KalDet/src/ild/common/ILDVMeasLayer.cc b/Utilities/KalDet/src/ild/common/ILDVMeasLayer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..6770585173502a72f0490f8a1db7a446309a3587
--- /dev/null
+++ b/Utilities/KalDet/src/ild/common/ILDVMeasLayer.cc
@@ -0,0 +1,62 @@
+
+#include "ILDVMeasLayer.h"
+
+#include <UTIL/BitField64.h>
+#include <UTIL/ILDConf.h>
+
+// #include "streamlog/streamlog.h"
+
+Bool_t ILDVMeasLayer::kActive = kTRUE;
+Bool_t ILDVMeasLayer::kDummy = kFALSE;
+
+//ClassImp(ILDVMeasLayer)
+
+ILDVMeasLayer::ILDVMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ Double_t Bz,
+ Bool_t is_active,
+ int cellID ,
+ const Char_t *name)
+: TVMeasLayer(min, mout, is_active, name),
+_Bz(Bz),
+_isMultiLayer(false)
+{
+ _cellIDs.push_back(cellID);
+
+ UTIL::BitField64 encoder( lcio::ILDCellID0::encoder_string ) ;
+ encoder.setValue(cellID);
+ encoder[lcio::ILDCellID0::module] = 0;
+ encoder[lcio::ILDCellID0::sensor] = 0;
+
+ _layerID = encoder.lowWord();
+
+}
+
+
+ILDVMeasLayer::ILDVMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ Double_t Bz,
+ const std::vector<int>& cellIDs,
+ Bool_t is_active,
+ const Char_t *name)
+: TVMeasLayer(min, mout, is_active, name),
+_Bz(Bz),
+_cellIDs(cellIDs),
+_isMultiLayer(true)
+{
+
+ if (cellIDs.size() == 0 ) {
+ // streamlog_out(ERROR) << __FILE__ << " line " << __LINE__ << " size of cellIDs == 0" << std::endl;
+ }
+
+ UTIL::BitField64 encoder( lcio::ILDCellID0::encoder_string ) ;
+ encoder.setValue(cellIDs.at(0));
+ encoder[lcio::ILDCellID0::module] = 0;
+ encoder[lcio::ILDCellID0::sensor] = 0;
+
+ _layerID = encoder.lowWord();
+
+}
+
+
+
diff --git a/Utilities/KalDet/src/ild/common/ILDVMeasLayer.h b/Utilities/KalDet/src/ild/common/ILDVMeasLayer.h
new file mode 100644
index 0000000000000000000000000000000000000000..3d213b3aadcc3f5c3b4ff693462ff2e746e22f53
--- /dev/null
+++ b/Utilities/KalDet/src/ild/common/ILDVMeasLayer.h
@@ -0,0 +1,88 @@
+#ifndef __ILDVMEASLAYER__
+#define __ILDVMEASLAYER__
+
+/** ILDVMeasLayer: Virtual measurement layer class used by ILD[X]MeasLayer Classes.
+ *
+ * @author S.Aplin DESY
+ */
+
+#include "TVector3.h"
+#include "kaltest/TKalMatrix.h"
+#include "kaltest/TCylinder.h"
+#include "kaltest/TVMeasLayer.h"
+#include "kaltest/TAttDrawable.h"
+#include "kaltest/KalTrackDim.h"
+#include "TString.h"
+
+#include <vector>
+
+class TVTrackHit;
+class TNode;
+class ILDVTrackHit;
+
+namespace edm4hep{
+ class TrackerHit;
+}
+
+class ILDVMeasLayer : public TVMeasLayer {
+public:
+
+ static Bool_t kActive;
+ static Bool_t kDummy;
+
+ /** Get the layer ID */
+ inline int getLayerID() const { return _layerID ; }
+
+ /** Get the Cell ID associated with this measurement layer */
+ inline const std::vector<int>& getCellIDs() const { return _cellIDs ; }
+
+ /** Get the number of Cell ID associated with this measurement layer */
+ inline unsigned int getNCellIDs() const { return _cellIDs.size() ; }
+
+ /** Get the Magnetic field at the measurement surface */
+ inline Double_t GetBz() const { return _Bz; }
+
+ /** Convert LCIO Tracker Hit to an ILDPLanarTrackHit */
+ virtual ILDVTrackHit* ConvertLCIOTrkHit(edm4hep::TrackerHit* trkhit) const = 0 ;
+
+ /** Check whether the measurement layer represents a series of detector elements */
+ bool isMultilayer() const { return _isMultiLayer; }
+
+ /** Get the intersection and the CellID, needed for multilayers */
+ virtual int getIntersectionAndCellID(const TVTrack &hel,
+ TVector3 &xx,
+ Double_t &phi,
+ Int_t &CellID,
+ Int_t mode,
+ Double_t eps = 1.e-8) const = 0 ;
+
+protected:
+
+ ILDVMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ Double_t Bz,
+ Bool_t is_active = ILDVMeasLayer::kActive,
+ int CellID = -1 ,
+ const Char_t *name = "ILDMeasL");
+
+ ILDVMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ Double_t Bz,
+ const std::vector<int>& cellIDs,
+ Bool_t is_active = ILDVMeasLayer::kActive,
+ const Char_t *name = "ILDMeasL");
+
+
+
+ Double_t _Bz ; // Magnitude of B-Field in Z
+ int _layerID ;
+ std::vector<int> _cellIDs ;
+
+ bool _isMultiLayer;
+
+private:
+
+
+};
+
+#endif
diff --git a/Utilities/KalDet/src/ild/common/ILDVTrackHit.h b/Utilities/KalDet/src/ild/common/ILDVTrackHit.h
new file mode 100644
index 0000000000000000000000000000000000000000..d47be083ee5e2bc1a8871d8ba1578301e8b352f1
--- /dev/null
+++ b/Utilities/KalDet/src/ild/common/ILDVTrackHit.h
@@ -0,0 +1,33 @@
+#ifndef ILDVTrackHIT_H
+#define ILDVTrackHIT_H
+
+/** ILDVMeasLayer: Virtual hit class used by ILD[X]Hit Classes, which should provide coordinate vector as defined by the MeasLayer
+ *
+ * @author S.Aplin DESY
+ */
+
+
+#include "kaltest/TVTrackHit.h"
+
+#include "ILDVMeasLayer.h"
+
+#include "edm4hep/TrackerHit.h"
+
+class ILDVTrackHit : public TVTrackHit {
+
+public:
+
+ /** Constructor Taking coordinates and associated measurement layer, with bfield and number of measurement dimentions*/
+ ILDVTrackHit(const TVMeasLayer &ms, Double_t *x, Double_t *dx,
+ Double_t bfield , Int_t dim, edm4hep::TrackerHit* trkhit)
+ : TVTrackHit(ms, x, dx, bfield, dim), _trkhit(trkhit)
+ { /* no op */ }
+
+ edm4hep::TrackerHit* getLCIOTrackerHit() const { return _trkhit; }
+
+private:
+
+ edm4hep::TrackerHit* _trkhit;
+
+};
+#endif
diff --git a/Utilities/KalDet/src/ild/common/MaterialDataBase.cc b/Utilities/KalDet/src/ild/common/MaterialDataBase.cc
new file mode 100644
index 0000000000000000000000000000000000000000..2911317f7990c2ec2deb56eadabaab5ab7ce787b
--- /dev/null
+++ b/Utilities/KalDet/src/ild/common/MaterialDataBase.cc
@@ -0,0 +1,239 @@
+
+#include "MaterialDataBase.h"
+
+#include <stdexcept>
+#include <vector>
+#include <algorithm>
+
+#include <gear/GEAR.h>
+#include "gearimpl/Util.h"
+#include <gear/SimpleMaterial.h>
+#include <gearimpl/GearParametersImpl.h>
+#include "DetInterface/IGeoSvc.h"
+
+#include "TMaterial.h"
+
+MaterialDataBase::~MaterialDataBase(){
+
+ std::map<std::string,TMaterial* >::iterator it = _material_map.begin();
+ std::vector<TMaterial*> deleted_objects;
+
+ for( /**/; it!=_material_map.end(); ++it)
+
+ if( std::find( deleted_objects.begin(), deleted_objects.end(), (*it).second ) != deleted_objects.end() ) {
+ delete (*it).second ;
+ deleted_objects.push_back((*it).second) ;
+ }
+}
+
+TMaterial* MaterialDataBase::getMaterial(std::string mat_name){
+
+ if (_isInitialised == false) {
+ MaterialDataBaseException exp ( mat_name ) ;
+
+
+ throw exp;
+ }
+
+ std::map<std::string,TMaterial* >::iterator it = _material_map.find(mat_name) ;
+
+ if ( it == _material_map.end() ) {
+ MaterialDataBaseException exp( mat_name ) ;
+ throw exp ;
+ }
+ else {
+ return (*it).second ;
+ }
+
+}
+
+void MaterialDataBase::initialise( const gear::GearMgr& gearMgr, IGeoSvc* geoSvc ){
+
+ if( !_isInitialised ){
+ this->createMaterials(gearMgr, geoSvc);
+ _isInitialised = true ;
+ _gearMgr = &gearMgr;
+ }
+
+}
+
+void MaterialDataBase::registerForService(const gear::GearMgr& gearMgr, IGeoSvc* geoSvc ) {
+
+ if( !_isInitialised ){
+ //std::cout << "debug fucd: " << "--------------------" << std::endl;
+ this->initialise(gearMgr, geoSvc);
+ }
+
+ else {
+ if ( _gearMgr != &gearMgr ) {
+ MaterialDataBaseException exp( " MaterialDataBase::registerForService : _gearMgr != &gearMgr ! " ) ;
+ throw exp;
+ }
+ }
+
+}
+
+
+void MaterialDataBase::addMaterial(TMaterial* mat, std::string name) {
+ std::map<std::string, TMaterial*>::iterator it = _material_map.find(name) ;
+ //std::cout << name << " " << mat << std::endl;
+ std::string what( name ) ;
+ what += " - already exists [MaterialDataBase::addMaterial() ] " ;
+ MaterialDataBaseException exp( what ) ;
+
+ if ( it != _material_map.end() ) {
+ //std::cout << what << std::endl;
+ throw exp;
+ }
+ else {
+ _material_map[name] = mat ;
+ }
+}
+
+
+void MaterialDataBase::createMaterials(const gear::GearMgr& gearMgr, IGeoSvc* geoSvc ){
+
+ Double_t A, Z, density, radlen ;
+ std::string name;
+
+ // Beam
+ A = 14.00674 * 0.7 + 15.9994 * 0.3 ;
+ Z = 7.3 ;
+ density = 1.0e-25 ; // density set to very low value
+ radlen = 1.0e25 ; // give huge radiation length
+ name = "beam" ;
+
+ TMaterial& beam = *new TMaterial(name.c_str(), "", A, Z, density, radlen, 0.) ;
+ this->addMaterial(&beam, name);
+
+ // Air
+ A = 14.00674 * 0.7 + 15.9994 * 0.3 ;
+ Z = 7.3 ;
+ density = 1.205e-3 ; // g/cm^3
+ radlen = 3.42e4 ; // cm // SJA:FIXME using the standard formular for the radiation length and the above values gives 3.06e4
+ name = "air" ;
+
+ TMaterial &air = *new TMaterial(name.c_str(), "", A, Z, density, radlen, 0.) ;
+ this->addMaterial(&air, name) ;
+
+ // Si
+ A = 28.09 ;
+ Z = 14.0 ;
+ density = 2.33 ; // g/cm^3
+ radlen = 9.36607 ; // cm
+ name = "silicon";
+
+ TMaterial &silicon = *new TMaterial(name.c_str(), "", A, Z, density, radlen, 0.) ;
+ this->addMaterial(&silicon, name);
+
+ // C
+ A = 12.01 ;
+ Z = 6.0 ;
+ density = 2.00 ; // g/cm^3
+ radlen = 21.3485 ; // cm
+ name = "carbon" ;
+
+ TMaterial &carbon = *new TMaterial(name.c_str(), "", A, Z, density, radlen, 0.) ;
+ this->addMaterial(&carbon, name);
+
+ // Aluminium
+ A = 26.9815 ;
+ Z = 13.0 ;
+ density = 2.699 ; // g/cm^3
+ radlen = 8.9 ; // cm
+ name = "aluminium" ;
+
+ TMaterial &aluminium = *new TMaterial(name.c_str(), "", A, Z, density, radlen, 0.) ;
+ this->addMaterial(&aluminium, name);
+
+ // Beryllium
+ A = 9.012 ;
+ Z = 4.0 ;
+ density = 1.85 ; // g/cm^3
+ radlen = 35.28 ; // cm
+ name = "beryllium" ;
+
+ TMaterial &beryllium = *new TMaterial(name.c_str(), "", A, Z, density, radlen, 0.) ;
+ this->addMaterial(&beryllium, name);
+
+
+ // TPC Gas
+ A = 39.948*0.9+(12.011*0.2+1.00794*0.8)*0.1;
+ Z = 16.4;
+ density = 1.749e-3 ;
+// radlen = 1.196e4*2;
+ radlen = 0.5*1.196e4*2; // SJA:FIXME: reduce by a factor of 10%
+ name = "tpcgas" ;
+
+ TMaterial &tpcgas = *new TMaterial(name.c_str(), "", A, Z, density, radlen, 0.);
+ this->addMaterial(&tpcgas, name);
+
+ // TPC Field Cage
+ A = air.GetA()*0.97 + aluminium.GetA()*0.03 ; // SJA:FIXME just use this simple approximation for now
+ Z = air.GetZ()*0.97 + aluminium.GetZ()*0.03 ; // SJA:FIXME just use this simple approximation for now
+ density = 0.0738148 ;
+ radlen = 489.736 * 0.5 ; // SJA:FIXME just use factor of two for now as the amount differs by ~ factor of 2 from observation in GEANT4
+ name = "tpcinnerfieldcage" ;
+
+ TMaterial &tpcinnerfieldcage = *new TMaterial(name.c_str(), "", A, Z, density, radlen, 0.);
+ this->addMaterial(&tpcinnerfieldcage, name);
+
+ // TPC Field Cage
+ A = air.GetA()*0.97 + aluminium.GetA()*0.03 ; // SJA:FIXME just use this simple approximation for now
+ Z = air.GetZ()*0.97 + aluminium.GetZ()*0.03 ; // SJA:FIXME just use this simple approximation for now
+ density = 0.0738148 ;
+ radlen = 489.736 ;
+ name = "tpcouterfieldcage" ;
+
+ TMaterial &tpcouterfieldcage = *new TMaterial(name.c_str(), "", A, Z, density, radlen, 0.);
+ this->addMaterial(&tpcouterfieldcage, name);
+
+
+ // FTD Support Material
+ // Needed because of the lack of space frame in the Tracking Geometry description
+ // Carbon with density and rad-length changed by a factor of 2
+
+ A = 12.01 ;
+ Z = 6.0 ;
+ density = 0.5 * 2.00 ; // g/cm^3
+ radlen = 2.0 * 21.3485 ; // cm
+ name = "FTDSupportMaterial" ;
+
+ TMaterial &ftdsupport = *new TMaterial(name.c_str(), "", A, Z, density, radlen, 0.) ;
+ this->addMaterial(&ftdsupport, name);
+
+
+ // VXD Support Material
+
+ try{
+
+ //const gear::SimpleMaterial& vxd_sup_mat = gearMgr.getSimpleMaterial("VXDSupportMaterial");
+ /*
+ const gear::GearParametersImpl* vxd_sup_mat = geoSvc->getDetParameters("VXDSupportMaterial");
+
+ A = vxd_sup_mat->getDoubleVal("A");
+ Z = vxd_sup_mat->getDoubleVal("Z");
+ density = vxd_sup_mat->getDoubleVal("Density");
+ radlen = vxd_sup_mat->getDoubleVal("RadL");
+ name = vxd_sup_mat->getStringVal("Name");
+ */
+ //A = vxd_sup_mat.getA();
+ //Z = vxd_sup_mat.getZ();
+ //density = vxd_sup_mat.getDensity() * (1000.0/ 1000000.0); // kg/m^3 -> g/cm^3
+ //radlen = vxd_sup_mat.getRadLength() / 10.0 ; // mm -> cm
+ //name = vxd_sup_mat.getName() ;
+ //std::cout << "debug fucd: " << "==================" << geoSvc << std::endl;
+ //TMaterial &vxdsupport = *new TMaterial(name.c_str(), "", A, Z, density, radlen, 0.);
+ //this->addMaterial(&vxdsupport, name);
+ TMaterial* vxdsupport = geoSvc->getMaterial("VXDSupportMaterial");
+ //std::cout << "debug fucd: " << "==================" << std::endl;
+ if(vxdsupport) this->addMaterial(vxdsupport, "VXDSupportMaterial");
+ else std::cout << "Material VXDSupportMaterial not found" << std::endl;
+ }
+ catch( gear::UnknownParameterException& e){
+ std::cout << "Error while read material from GeoSvc!" << std::endl;
+ }
+
+
+}
+
diff --git a/Utilities/KalDet/src/ild/common/MaterialDataBase.h b/Utilities/KalDet/src/ild/common/MaterialDataBase.h
new file mode 100644
index 0000000000000000000000000000000000000000..d1ed28bf0af03621cfc6dc9a1d7935b6a3833131
--- /dev/null
+++ b/Utilities/KalDet/src/ild/common/MaterialDataBase.h
@@ -0,0 +1,76 @@
+#ifndef MaterialDataBase_h
+#define MaterialDataBase_h
+
+/** MaterialDataBase: Class to hold and manage collection of materials
+ *
+ * @author S.Aplin DESY
+ */
+
+#include <string>
+#include <map>
+#include <exception>
+
+#include "lcio.h"
+#include "Exceptions.h"
+
+class TMaterial;
+
+namespace gear{
+ class GearMgr ;
+}
+class IGeoSvc;
+// fg: define the MaterialDataBaseException as an lcio Exception to allow for
+// messages to be printed in what()
+typedef lcio::Exception MaterialDataBaseException ;
+
+class MaterialDataBase {
+
+public:
+
+ /** Accessor Method */
+ static MaterialDataBase& Instance() {
+
+ static MaterialDataBase singleton;
+
+ return singleton;
+
+ }
+
+ // Other non-static member functions
+
+public:
+
+ /** Destructor */
+ ~MaterialDataBase();
+
+ /** Get Material via name */
+ TMaterial* getMaterial(std::string mat_name) ;
+
+ void registerForService(const gear::GearMgr& gearMgr, IGeoSvc* geoSvc=0) ;
+
+
+private:
+
+ void initialise(const gear::GearMgr& gearMgr, IGeoSvc* geoSvc) ;
+
+ MaterialDataBase() { _material_map.clear(); _isInitialised = false ; _gearMgr = 0; } // Private constructor
+
+
+ MaterialDataBase(const MaterialDataBase&) ; // Prevent copy-construction
+ MaterialDataBase& operator=(const MaterialDataBase&) ; // Prevent assignment
+
+ void addMaterial(TMaterial* mat, std::string name);
+ void createMaterials(const gear::GearMgr& gearMgr, IGeoSvc* geoSvc);
+
+ // private member variables
+ std::map<std::string,TMaterial* > _material_map;
+
+ bool _isInitialised;
+
+ const gear::GearMgr* _gearMgr;
+
+};
+
+
+
+#endif
diff --git a/Utilities/KalDet/src/ild/ftd/ILDFTDDiscBasedKalDetector.cc b/Utilities/KalDet/src/ild/ftd/ILDFTDDiscBasedKalDetector.cc
new file mode 100644
index 0000000000000000000000000000000000000000..db2b578d211ff0dc8f80f5a0aa5198eb43be0907
--- /dev/null
+++ b/Utilities/KalDet/src/ild/ftd/ILDFTDDiscBasedKalDetector.cc
@@ -0,0 +1,174 @@
+
+#include "ILDFTDDiscBasedKalDetector.h"
+
+#include "kaldet/MaterialDataBase.h"
+
+#include <sstream>
+
+#include "gear/GEAR.h"
+#include "gear/BField.h"
+#include "gearimpl/Util.h"
+#include "gear/FTDLayerLayout.h"
+
+#include "kaldet/ILDDiscMeasLayer.h"
+
+#include <UTIL/BitField64.h>
+#include <UTIL/ILDConf.h>
+
+// #include "streamlog/streamlog.h"
+
+#include "TVector3.h"
+
+ILDFTDDiscBasedKalDetector::ILDFTDDiscBasedKalDetector( const gear::GearMgr& gearMgr ) :
+TVKalDetector(30), _nDisks(0) // SJA:FIXME initial size, 300 looks reasonable for ILD, though this would be better stored as a const somewhere
+{
+
+ // streamlog_out(DEBUG1) << "ILDFTDDiscBasedKalDetector building Simple Disc Based FTD detector using GEAR " << std::endl ;
+
+ MaterialDataBase::Instance().registerForService(gearMgr);
+ setupGearGeom( gearMgr ) ;
+
+ TMaterial & air = *MaterialDataBase::Instance().getMaterial("air") ;
+ TMaterial & silicon = *MaterialDataBase::Instance().getMaterial("silicon") ;
+ TMaterial & carbon = *MaterialDataBase::Instance().getMaterial("carbon") ;
+
+
+ Bool_t active = true ;
+ Bool_t dummy = false ;
+
+ std::string name = "FTD" ;
+
+ double eps1 = 1.0e-04 ; // disk
+ double eps3 = 1.0e-06 ; // layer in disk
+ double eps4 = 1.0e-08 ; // forward or backwards
+
+
+ UTIL::BitField64 encoder( lcio::ILDCellID0::encoder_string ) ;
+
+ for (int idisk = 0; idisk < _nDisks; ++idisk) {
+
+
+ double rOuter = _FTDgeo[idisk].rOuter ;
+ double rInner = _FTDgeo[idisk].rInner ;
+ double senThickness = _FTDgeo[idisk].senThickness ;
+ double supThickness = _FTDgeo[idisk].supThickness ;
+ double zPos = _FTDgeo[idisk].zPos;
+
+ encoder[lcio::ILDCellID0::subdet] = lcio::ILDDetID::FTD ;
+ encoder[lcio::ILDCellID0::side] = 1 ;
+ encoder[lcio::ILDCellID0::layer] = idisk ;
+ encoder[lcio::ILDCellID0::module] = 0 ;
+ encoder[lcio::ILDCellID0::sensor] = 0 ;
+
+ int CellID_FWD = encoder.lowWord() ;
+
+ encoder[lcio::ILDCellID0::side] = -1 ;
+
+ int CellID_BWD = encoder.lowWord() ;
+
+ // note the z position given in gear is actually the mid point (z) of the sensitive i.e. the z of the measurement plane
+ TVector3 sen_front_face_centre_fwd( 0.0, 0.0, zPos - senThickness*0.5); // for +z
+
+ TVector3 measurement_plane_centre_fwd( sen_front_face_centre_fwd.X(),
+ sen_front_face_centre_fwd.Y(),
+ sen_front_face_centre_fwd.Z() + senThickness*0.5 );
+
+ TVector3 sen_rear_face_centre_fwd( sen_front_face_centre_fwd.X(),
+ sen_front_face_centre_fwd.Y(),
+ sen_front_face_centre_fwd.Z() + senThickness );
+
+ TVector3 sup_rear_face_centre_fwd( sen_rear_face_centre_fwd.X(),
+ sen_rear_face_centre_fwd.Y(),
+ sen_rear_face_centre_fwd.Z() + supThickness );
+
+ TVector3 normal_fwd(sen_front_face_centre_fwd) ;
+ normal_fwd.SetMag(1.0) ;
+
+
+ double sort_policy = rOuter + eps1 * idisk ;
+
+
+ sort_policy += eps3 * 1;
+ Add(new ILDDiscMeasLayer( air, silicon, sen_front_face_centre_fwd, normal_fwd, _bZ, sort_policy, rInner, rOuter, dummy ) );
+
+ sort_policy += eps3 * 2;
+ Add(new ILDDiscMeasLayer( silicon, silicon, measurement_plane_centre_fwd, normal_fwd, _bZ, sort_policy, rInner, rOuter, active, CellID_FWD ) );
+
+ sort_policy += eps3 * 3;
+ Add(new ILDDiscMeasLayer( silicon, carbon, sen_rear_face_centre_fwd, normal_fwd, _bZ, sort_policy, rInner, rOuter, dummy ) );
+
+ sort_policy += eps3 * 4;
+ Add(new ILDDiscMeasLayer( carbon, air, sup_rear_face_centre_fwd, normal_fwd, _bZ, sort_policy, rInner, rOuter, dummy ) );
+
+
+ // note the z position given in gear is actually the mid point (z) of the sensitive i.e. the z of the measurement plane
+ TVector3 sen_front_face_centre_bwd( 0.0, 0.0, -zPos + senThickness*0.5 ); // for -z
+
+ TVector3 measurement_plane_centre_bwd( sen_front_face_centre_bwd.X(),
+ sen_front_face_centre_bwd.Y(),
+ sen_front_face_centre_bwd.Z() - senThickness*0.5 );
+
+ TVector3 sen_rear_face_centre_bwd( sen_front_face_centre_bwd.X(),
+ sen_front_face_centre_bwd.Y(),
+ sen_front_face_centre_bwd.Z() - senThickness );
+
+ TVector3 sup_rear_face_centre_bwd( sen_rear_face_centre_bwd.X(),
+ sen_rear_face_centre_bwd.Y(),
+ sen_rear_face_centre_bwd.Z() - supThickness );
+
+ TVector3 normal_bwd(sen_front_face_centre_bwd) ;
+ normal_bwd.SetMag(1.0) ;
+
+
+ sort_policy += eps4 ; // for backward
+
+ sort_policy += eps3 * 1;
+ Add(new ILDDiscMeasLayer( air, silicon, sen_front_face_centre_bwd, normal_bwd, _bZ, sort_policy, rInner, rOuter, dummy ) );
+
+ sort_policy += eps3 * 2;
+ Add(new ILDDiscMeasLayer( silicon, silicon, measurement_plane_centre_bwd, normal_bwd, _bZ, sort_policy, rInner, rOuter, active, CellID_BWD ) );
+
+ sort_policy += eps3 * 3;
+ Add(new ILDDiscMeasLayer( silicon, carbon, sen_rear_face_centre_bwd, normal_bwd, _bZ, sort_policy, rInner, rOuter, dummy ) );
+
+ sort_policy += eps3 * 4;
+ Add(new ILDDiscMeasLayer( carbon, air, sup_rear_face_centre_bwd, normal_bwd, _bZ, sort_policy, rInner, rOuter, dummy ) );
+
+
+ }
+
+ SetOwner();
+
+}
+
+
+
+void ILDFTDDiscBasedKalDetector::setupGearGeom( const gear::GearMgr& gearMgr ){
+
+
+ const gear::GearParameters& pFTD = gearMgr.getGearParameters("FTD");
+
+ _bZ = gearMgr.getBField().at( gear::Vector3D( 0.,0.,0.) ).z() ;
+
+ const std::vector<double>& FTD_si = pFTD.getDoubleVals("FTDDiskSiThickness" ) ;
+ const std::vector<double>& FTD_sp = pFTD.getDoubleVals("FTDDiskSupportThickness" ) ;
+ const std::vector<double>& FTD_ri = pFTD.getDoubleVals("FTDInnerRadius" ) ;
+ const std::vector<double>& FTD_ro = pFTD.getDoubleVals("FTDOuterRadius" ) ;
+ const std::vector<double>& FTD_z = pFTD.getDoubleVals("FTDZCoordinate" ) ;
+
+ _nDisks = FTD_si.size() ;
+ _FTDgeo.resize(_nDisks);
+
+ for(int disk=0; disk< _nDisks; ++disk){
+
+ _FTDgeo[disk].rInner = FTD_ri[disk];
+ _FTDgeo[disk].rOuter = FTD_ro[disk];
+ _FTDgeo[disk].senThickness = FTD_si[disk];
+ _FTDgeo[disk].supThickness = FTD_sp[disk];
+ _FTDgeo[disk].zPos = FTD_z[disk];
+
+
+ }
+
+
+}
diff --git a/Utilities/KalDet/src/ild/ftd/ILDFTDDiscBasedKalDetector.h b/Utilities/KalDet/src/ild/ftd/ILDFTDDiscBasedKalDetector.h
new file mode 100644
index 0000000000000000000000000000000000000000..c8536c6403b54d650ac0418ab2e845ec5f21053b
--- /dev/null
+++ b/Utilities/KalDet/src/ild/ftd/ILDFTDDiscBasedKalDetector.h
@@ -0,0 +1,44 @@
+#ifndef __ILDFTDDISCBASEDDETECTOR__
+#define __ILDFTDDISCBASEDDETECTOR__
+
+/** Disk based version of the FTD alla LOI
+*
+* @author S.Aplin DESY
+*/
+
+#include "kaltest/TVKalDetector.h"
+
+class TNode;
+
+namespace gear{
+ class GearMgr ;
+}
+
+
+class ILDFTDDiscBasedKalDetector : public TVKalDetector {
+public:
+
+ /** Initialize the FTD from GEAR */
+ ILDFTDDiscBasedKalDetector( const gear::GearMgr& gearMgr );
+
+
+private:
+
+ void setupGearGeom( const gear::GearMgr& gearMgr ) ;
+
+ int _nDisks ;
+ double _bZ ;
+
+ struct FTD_Disk {
+ double rInner;
+ double rOuter;
+ double senThickness;
+ double supThickness;
+ double zPos;
+
+ };
+ std::vector<FTD_Disk> _FTDgeo;
+
+};
+
+#endif
diff --git a/Utilities/KalDet/src/ild/ftd/ILDFTDKalDetector.cc b/Utilities/KalDet/src/ild/ftd/ILDFTDKalDetector.cc
new file mode 100644
index 0000000000000000000000000000000000000000..3ac020812669ae175d17c9f9df6c983ce506790e
--- /dev/null
+++ b/Utilities/KalDet/src/ild/ftd/ILDFTDKalDetector.cc
@@ -0,0 +1,501 @@
+
+#include "ILDFTDKalDetector.h"
+
+#include "kaldet/MaterialDataBase.h"
+
+#include <sstream>
+
+#include "gear/GEAR.h"
+#include "gear/BField.h"
+#include "gearimpl/Util.h"
+#include "gear/FTDLayerLayout.h"
+
+#include "kaldet/ILDRotatedTrapMeaslayer.h"
+#include "kaldet/ILDSegmentedDiscMeasLayer.h"
+#include "kaldet/ILDSegmentedDiscStripMeasLayer.h"
+#include "kaldet/ILDDiscMeasLayer.h"
+
+#include <UTIL/BitField64.h>
+#include <UTIL/ILDConf.h>
+
+// #include "streamlog/streamlog.h"
+
+#include "TVector3.h"
+
+ILDFTDKalDetector::ILDFTDKalDetector( const gear::GearMgr& gearMgr ) :
+TVKalDetector(300), _nDisks(0) // SJA:FIXME initial size, 300 looks reasonable for ILD, though this would be better stored as a const somewhere
+{
+
+ // streamlog_out(DEBUG1) << "ILDFTDKalDetector building FTD detector using GEAR " << std::endl ;
+
+ MaterialDataBase::Instance().registerForService(gearMgr);
+ setupGearGeom( gearMgr ) ;
+
+ this->build_staggered_design();
+
+
+ SetOwner();
+
+}
+
+
+
+
+void ILDFTDKalDetector::build_staggered_design() {
+
+ // streamlog_out(DEBUG) << "ILDFTDKalDetector::build_staggered_design " << std::endl;
+
+
+ std::string name = "FTD" ;
+
+ UTIL::BitField64 encoder( lcio::ILDCellID0::encoder_string ) ;
+
+
+
+ for (int idisk = 0; idisk < _nDisks; ++idisk) {
+
+ // streamlog_out(DEBUG) << "ILDFTDKalDetector::build_staggered_design build disk " << idisk << std::endl;
+
+ int npetals = _FTDgeo[idisk].nPetals ;
+ double phi0 = _FTDgeo[idisk].phi0 ;
+
+ double senZPos_even_front = _FTDgeo[idisk].senZPos_even_front;
+ double senZPos_odd_front = _FTDgeo[idisk].senZPos_odd_front;
+
+
+ // check that the number of petals is divisible by 2
+ int nsegments = npetals/2;
+
+ // even segments forward
+ this->create_segmented_disk_layers(idisk, nsegments, true, phi0, senZPos_even_front );
+
+ // even segments backwards
+ this->create_segmented_disk_layers(idisk, nsegments, true, phi0, -senZPos_even_front );
+
+
+ // odd segements
+ // update phi0 by the angular distance of one petal
+ phi0 += 2.0 * M_PI / npetals;
+
+ // odd segments forward
+ this->create_segmented_disk_layers(idisk, nsegments, false, phi0, senZPos_odd_front );
+
+ // odd segments backward
+ this->create_segmented_disk_layers(idisk, nsegments, false, phi0, -senZPos_odd_front );
+
+
+
+
+ // make the air disks
+
+ TMaterial & air = *MaterialDataBase::Instance().getMaterial("air") ;
+
+ Bool_t dummy = false ;
+
+ // place air discs to help transport during track extrapolation
+ if( idisk < _nDisks-1 ){
+
+ // place the disc half way between the two discs
+ double z = ( _FTDgeo[idisk].senZPos_even_front + _FTDgeo[idisk+1].senZPos_even_front ) * 0.5 ;
+
+ TVector3 xc_fwd(0.0, 0.0, z) ;
+ TVector3 normal_fwd(xc_fwd) ;
+ normal_fwd.SetMag(1.0) ;
+
+ double eps1 = 1.0e-04 ; // offset for disk number
+ double eps2 = 1.0e-05 ; // odd or even
+ double eps4 = 1.0e-08 ; // offset for forwards and backwards
+
+ double height = _FTDgeo[idisk].height ;
+ double rInner = _FTDgeo[idisk].rInner ;
+
+
+ double sort_policy = rInner+height + eps1 * idisk + eps2 * 2 ; // we need to be after the even and odd
+
+ // streamlog_out(DEBUG) << "ILDFTDKalDetector::create air support disk at " << xc_fwd.z() << " sort_policy = " << sort_policy << std::endl;
+
+ Add(new ILDDiscMeasLayer( air, air, xc_fwd, normal_fwd, _bZ, sort_policy,
+ rInner, rInner+height, dummy,-1, "FTDAirSupportDiscFront" ) );
+
+ TVector3 xc_bwd(0.0, 0.0, -z) ;
+ TVector3 normal_bwd(xc_bwd) ;
+ normal_bwd.SetMag(1.0) ;
+
+ // offset needed for rear disks
+ sort_policy += eps4 ;
+
+ // streamlog_out(DEBUG) << "ILDFTDKalDetector::create air support disk at " << xc_bwd.z() << " sort_policy = " << sort_policy << std::endl;
+ Add(new ILDDiscMeasLayer( air, air, xc_bwd, normal_bwd, _bZ, sort_policy,
+ rInner, rInner+height, dummy,-1, "FTDAirSupportDiscRear" ) );
+
+
+
+ }
+
+ }
+
+}
+
+
+
+
+
+
+void ILDFTDKalDetector::create_segmented_disk_layers( int idisk, int nsegments, bool even_petals, double phi0, double zpos ){
+
+ Bool_t active = true ;
+ Bool_t dummy = false ;
+
+ TMaterial & air = *MaterialDataBase::Instance().getMaterial("air") ;
+ TMaterial & silicon = *MaterialDataBase::Instance().getMaterial("silicon") ;
+ TMaterial & carbon = *MaterialDataBase::Instance().getMaterial("carbon") ;
+ TMaterial & stripsupport = *MaterialDataBase::Instance().getMaterial("FTDSupportMaterial") ;
+
+ double senThickness = _FTDgeo[idisk].senThickness ;
+ double supThickness = _FTDgeo[idisk].supThickness ;
+ double innerBaseLength = _FTDgeo[idisk].innerBaseLength ;
+ double outerBaseLength = _FTDgeo[idisk].outerBaseLength ;
+ double height = _FTDgeo[idisk].height ;
+ double rInner = _FTDgeo[idisk].rInner ;
+ bool isDoubleSided = _FTDgeo[idisk].isDoubleSided ;
+ int nSensors = _FTDgeo[idisk].nSensors ;
+ int zsign = zpos > 0 ? +1 : -1 ;
+ double stripAngle = _FTDgeo[idisk].stripAngle ;
+ bool isStripReadout = _FTDgeo[idisk].isStripReadout ;
+
+ //SJA:FIXME: due to the space frame design of the strip layers there is far too much support so just leave it out for now ...
+ TMaterial & support = isStripReadout == false ? carbon : stripsupport;
+
+ UTIL::BitField64 encoder( lcio::ILDCellID0::encoder_string ) ;
+ encoder.reset() ; // reset to 0
+
+ encoder[lcio::ILDCellID0::subdet] = lcio::ILDDetID::FTD ;
+ encoder[lcio::ILDCellID0::side] = zsign ;
+ encoder[lcio::ILDCellID0::layer] = idisk ;
+
+ int start_index = even_petals ? 0 : 1 ;
+ std::vector<int> sensors_front;
+ std::vector<int> sensors_back;
+ std::vector<int> module_ids_front;
+ std::vector<int> module_ids_back;
+
+ if( isDoubleSided ){ // sensors on front and back double supZPos_odd_front = _FTDgeo[idisk].supZPos_odd;
+
+ // first half is on the front, second half on the back, sensors start with sensor number 1
+ for( int iSensor=1; iSensor <= nSensors/2; iSensor++ ) sensors_front.push_back( iSensor );
+ for( int iSensor=nSensors/2 + 1; iSensor <= nSensors; iSensor++ ) sensors_back.push_back( iSensor );
+
+ }
+ else{ // only sensors on the front
+
+ for( int iSensor=1; iSensor <= nSensors; iSensor++ ) sensors_front.push_back( iSensor );
+
+ }
+
+ for (int i=0; i<nsegments; ++i) {
+
+ encoder[lcio::ILDCellID0::module] = start_index + i*2 ;
+
+ for( unsigned j=0; j<sensors_front.size(); j++ ){
+
+ encoder[lcio::ILDCellID0::sensor] = sensors_front[j];
+ module_ids_front.push_back( encoder.lowWord() );
+
+ }
+
+ for( unsigned j=0; j<sensors_back.size(); j++ ){
+
+ encoder[lcio::ILDCellID0::sensor] = sensors_back[j];
+ module_ids_back.push_back( encoder.lowWord() );
+
+ }
+
+ }
+
+ // create segmented disk
+
+ // front face of sensitive
+ double z = zpos - zsign*0.5*(senThickness) ;
+ // double sort_policy = fabs(z) ;
+ double eps1 = 1.0e-04 ; // disk
+ double eps2 = 1.0e-05 ; // odd or even
+ double eps3 = 1.0e-06 ; // layer in disk
+ double eps4 = 1.0e-08 ; // forward or backwards
+
+ double sort_policy = rInner+height + eps1 * idisk + eps3 * 1 ;
+ if ( ! even_petals ) sort_policy += eps2;
+
+ // if this is the negative z disk add epsilon to the policy
+ if( z < 0 ) sort_policy += eps4 ;
+ const char *name1 = z > 0 ? "FTDSenFrontPositiveZ" : "FTDSenFrontNegativeZ";
+
+ // streamlog_out(DEBUG) << "ILDFTDKalDetector::create_segmented_disk_layers add front face of sensitive at " << z << " sort_policy = " << sort_policy << std::endl;
+ Add( new ILDSegmentedDiscMeasLayer(air, silicon, _bZ, sort_policy, nsegments, z, phi0, rInner, height, innerBaseLength, outerBaseLength, dummy,name1) );
+
+ // measurement plane
+
+ z += zsign*0.5*senThickness;
+ //sort_policy = fabs(z) ;
+ sort_policy = rInner+height + eps1 * idisk + eps3 * 2 ;
+ if( z < 0 ) sort_policy += eps4 ;
+
+ if ( ! even_petals ) {
+ sort_policy += eps2;
+
+ const char *name2 = z > 0 ? "FTDMeasLayerFrontPositiveZOdd" : "FTDMeasLayerFrontNegativeZOdd";
+ // streamlog_out(DEBUG) << "ILDFTDKalDetector::create_segmented_disk_layers add measurement plane at " << z << " sort_policy = " << sort_policy << " Strip Readout = " << isStripReadout << " number of module_ids = " << module_ids_front.size();
+ if (isStripReadout) {
+ Add( new ILDSegmentedDiscStripMeasLayer(silicon, silicon, _bZ, sort_policy, nsegments, z, phi0, rInner, height, innerBaseLength, outerBaseLength, stripAngle, active, module_ids_front,name2));
+ // streamlog_out(DEBUG) << " stripAngle = " << stripAngle ;
+
+ } else {
+ Add( new ILDSegmentedDiscMeasLayer(silicon, silicon, _bZ, sort_policy, nsegments, z, phi0, rInner, height, innerBaseLength, outerBaseLength, active, module_ids_front,name2));
+ }
+ // streamlog_out(DEBUG) << std::endl;
+ }
+ else{
+ const char *name2 = z > 0 ? "FTDMeasLayerFrontPositiveZEven" : "FTDMeasLayerFrontNegativeZEven";
+ // streamlog_out(DEBUG) << "ILDFTDKalDetector::create_segmented_disk_layers add measurement plane at " << z << " sort_policy = " << sort_policy << " Strip Readout = " << isStripReadout << " number of module_ids = " << module_ids_front.size();
+ if (isStripReadout) {
+ Add( new ILDSegmentedDiscStripMeasLayer(silicon, silicon, _bZ, sort_policy, nsegments, z, phi0, rInner, height, innerBaseLength, outerBaseLength, stripAngle, active, module_ids_front,name2));
+ // streamlog_out(DEBUG) << " stripAngle = " << stripAngle ;
+ } else {
+ Add( new ILDSegmentedDiscMeasLayer(silicon, silicon, _bZ, sort_policy, nsegments, z, phi0, rInner, height, innerBaseLength, outerBaseLength, active, module_ids_front,name2));
+ }
+ // streamlog_out(DEBUG) << std::endl;
+ }
+
+ // interface between sensitive and support
+ z += zsign*0.5*senThickness;
+ // sort_policy = fabs(z) ;
+ sort_policy = rInner+height + eps1 * idisk + eps3 * 3 ;
+ if( z < 0 ) sort_policy += eps4 ;
+ if ( ! even_petals ) sort_policy += eps2;
+
+ const char *name3 = z > 0 ? "FTDSenSupportIntfPositiveZ" : "FTDSenSupportIntfNegativeZ";
+
+ // streamlog_out(DEBUG) << "ILDFTDKalDetector::create_segmented_disk_layers add interface between sensitive and support at " << z << " sort_policy = " << sort_policy << std::endl;
+ Add( new ILDSegmentedDiscMeasLayer(silicon, support, _bZ, sort_policy, nsegments, z, phi0, rInner, height, innerBaseLength, outerBaseLength, dummy,name3));
+
+ if( isDoubleSided ){
+
+ // interface between support and sensitive
+ z += zsign*supThickness;
+ // sort_policy = fabs(z) ;
+ sort_policy = rInner+height + eps1 * idisk + eps3 * 4 ;
+ if( z < 0 ) sort_policy += eps4 ;
+ if ( ! even_petals ) sort_policy += eps2;
+
+ const char *name4 = z > 0 ? "FTDSupportSenIntfPositiveZ" : "FTDSupportSenIntfNegativeZ";
+
+ // streamlog_out(DEBUG) << "ILDFTDKalDetector::create_segmented_disk_layers add interface between support and sensitive at " << z << " sort_policy = " << sort_policy << std::endl;
+ Add( new ILDSegmentedDiscMeasLayer(support, silicon , _bZ, sort_policy, nsegments, z, phi0, rInner, height, innerBaseLength, outerBaseLength, dummy,name4));
+
+
+ // measurement plane at the back
+ z += zsign*0.5*senThickness;
+ // sort_policy = fabs(z) ;
+ sort_policy = rInner+height + eps1 * idisk + eps3 * 5 ;
+ if( z < 0 ) sort_policy += eps4 ;
+ if ( ! even_petals ){
+
+ sort_policy += eps2;
+
+ const char *name5 = z > 0 ? "FTDMeasLayerBackPositiveZOdd" : "FTDMeasLayerBackNegativeZOdd";
+ // streamlog_out(DEBUG) << "ILDFTDKalDetector::create_segmented_disk_layers add measurement plane at " << z << " sort_policy = " << sort_policy << " Strip Readout = " << isStripReadout << " number of module_ids = " << module_ids_back.size() ;
+ if (isStripReadout) {
+ Add( new ILDSegmentedDiscStripMeasLayer(silicon, silicon, _bZ, sort_policy, nsegments, z, phi0, rInner, height, innerBaseLength, outerBaseLength, -stripAngle,active, module_ids_back,name5));
+ // streamlog_out(DEBUG) << " stripAngle = " << -stripAngle ;
+
+ } else {
+ Add( new ILDSegmentedDiscMeasLayer(silicon, silicon, _bZ, sort_policy, nsegments, z, phi0, rInner, height, innerBaseLength, outerBaseLength, active, module_ids_back,name5));
+ }
+ // streamlog_out(DEBUG) << std::endl;
+
+ }
+ else{
+ const char *name5 = z > 0 ? "FTDMeasLayerBackPositiveZEven" : "FTDMeasLayerBackNegativeZEven";
+ // streamlog_out(DEBUG) << "ILDFTDKalDetector::create_segmented_disk_layers add measurement plane at " << z << " sort_policy = " << sort_policy<< " Strip Readout = " << isStripReadout << " number of module_ids = " << module_ids_back.size();
+ if (isStripReadout) {
+ Add( new ILDSegmentedDiscStripMeasLayer(silicon, silicon, _bZ, sort_policy, nsegments, z, phi0, rInner, height, innerBaseLength, outerBaseLength, -stripAngle,active, module_ids_back,name5));
+ // streamlog_out(DEBUG) << " stripAngle = " << -stripAngle ;
+ } else {
+ Add( new ILDSegmentedDiscMeasLayer(silicon, silicon, _bZ, sort_policy, nsegments, z, phi0, rInner, height, innerBaseLength, outerBaseLength, active, module_ids_back,name5));
+ }
+ // streamlog_out(DEBUG) << std::endl;
+ }
+
+ // rear face of sensitive
+ z += zsign*0.5*senThickness;
+ // sort_policy = fabs(z) ;
+ sort_policy = rInner+height + eps1 * idisk + eps3 * 6 ;
+ if( z < 0 ) sort_policy += eps4 ;
+ if ( ! even_petals ) sort_policy += eps2;
+
+ const char *name6 = z > 0 ? "FTDSenRearPositiveZ" : "FTDSenRearNegativeZ";
+
+ // streamlog_out(DEBUG) << "ILDFTDKalDetector::create_segmented_disk_layers add rear face of sensitive at " << z << " sort_policy = " << sort_policy << std::endl;
+ Add( new ILDSegmentedDiscMeasLayer(silicon, air, _bZ, sort_policy, nsegments, z, phi0, rInner, height, innerBaseLength, outerBaseLength, dummy,name6));
+
+
+
+ }
+ else{
+
+ // rear face of support
+ z += zsign*supThickness;
+ // sort_policy = fabs(z) ;
+ sort_policy = rInner+height + eps1 * idisk + eps3 * 4 ;
+ if( z < 0 ) sort_policy += eps4 ;
+ if ( ! even_petals ) sort_policy += eps2;
+
+ const char *name4 = z > 0 ? "FTDSupRearPositiveZ" : "FTDSupRearNegativeZ";
+
+ // streamlog_out(DEBUG) << "ILDFTDKalDetector::create_segmented_disk_layers add rear face of support at " << z << " sort_policy = " << sort_policy << std::endl;
+ Add( new ILDSegmentedDiscMeasLayer(support, air, _bZ, sort_policy, nsegments, z, phi0, rInner, height, innerBaseLength, outerBaseLength, dummy,name4));
+
+ }
+
+}
+
+
+
+void ILDFTDKalDetector::setupGearGeom( const gear::GearMgr& gearMgr ){
+
+ const gear::FTDParameters& ftdParams = gearMgr.getFTDParameters() ;
+ const gear::FTDLayerLayout& ftdlayers = ftdParams.getFTDLayerLayout() ;
+
+ _bZ = gearMgr.getBField().at( gear::Vector3D( 0.,0.,0.) ).z() ;
+
+ double strip_angle_deg = 0.0;
+ bool strip_angle_present = true;
+
+ try {
+
+ strip_angle_deg = ftdParams.getDoubleVal("strip_angle_deg");
+
+ } catch (gear::UnknownParameterException& e) {
+
+ strip_angle_present = false;
+
+ }
+
+
+ _nDisks = ftdlayers.getNLayers() ; // just do the first disk for now
+ _FTDgeo.resize(_nDisks);
+
+ //SJA:FIXME: for now the support is taken as the same size the sensitive
+ // if this is not done then the exposed areas of the support would leave a carbon - air boundary,
+ // which if traversed in the reverse direction to the next boundary then the track be propagated through carbon
+ // for a significant distance
+
+ double eps = 1.0e-08;
+
+ for(int disk=0; disk< _nDisks; ++disk){
+
+ // numbers taken from the ILD_01 gear file for the sensitive part
+ _FTDgeo[disk].nPetals = ftdlayers.getNPetals(disk) ;
+ _FTDgeo[disk].dphi = 2*M_PI / _FTDgeo[disk].nPetals ;
+ _FTDgeo[disk].phi0 = ftdlayers.getPhi0(disk) ;
+ _FTDgeo[disk].alpha = ftdlayers.getAlpha(disk) ;
+ _FTDgeo[disk].rInner = ftdlayers.getSensitiveRinner(disk) ;
+ _FTDgeo[disk].height = ftdlayers.getSensitiveWidth(disk) ;
+ _FTDgeo[disk].innerBaseLength = ftdlayers.getSensitiveLengthMin(disk) ;
+ _FTDgeo[disk].outerBaseLength = ftdlayers.getSensitiveLengthMax(disk) ;
+ _FTDgeo[disk].senThickness = ftdlayers.getSensitiveThickness(disk) ;
+ _FTDgeo[disk].supThickness = ftdlayers.getSupportThickness(disk) ;
+
+ _FTDgeo[disk].senZPos_even_front = ftdlayers.getSensitiveZposition(disk, 0, 1) ;
+ _FTDgeo[disk].senZPos_odd_front = ftdlayers.getSensitiveZposition(disk, 1, 1) ;
+
+ _FTDgeo[disk].isDoubleSided = ftdlayers.isDoubleSided( disk );
+ _FTDgeo[disk].isStripReadout = ftdlayers.getSensorType(disk) == gear::FTDParameters::STRIP ? true : false;
+ _FTDgeo[disk].nSensors = ftdlayers.getNSensors( disk );
+
+
+ if (strip_angle_present) {
+ _FTDgeo[disk].stripAngle = strip_angle_deg * M_PI/180 ;
+ } else {
+ _FTDgeo[disk].stripAngle = 0.0 ;
+ }
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Assertions ////////////////////////////////////////////////////////////////////////////////////
+
+ // there should be an even number of petals per disk
+ assert( _FTDgeo[disk].nPetals%2 == 0 );
+
+ // support and sensitive should have the same size an position in xy
+ assert( fabs( ftdlayers.getSupportLengthMin(disk) - ftdlayers.getSensitiveLengthMin(disk) ) < eps );
+ assert( fabs( ftdlayers.getSupportLengthMax(disk) - ftdlayers.getSensitiveLengthMax(disk) ) < eps );
+ assert( fabs( ftdlayers.getSupportWidth(disk) - ftdlayers.getSensitiveWidth(disk) ) < eps );
+ assert( fabs( ftdlayers.getSupportRinner(disk) - ftdlayers.getSensitiveRinner(disk) ) < eps );
+
+ // double sided petals should have as many sensors on the front as on the back
+ if( _FTDgeo[disk].isDoubleSided ) assert( _FTDgeo[disk].nSensors%2 == 0 );
+
+
+ // petals should not be rotated around their symmetry axis
+ assert( fabs( ftdlayers.getAlpha( disk ) ) < eps );
+
+
+ // the z positions of the sensors should be all the same on one side of the petal
+ // and in case of double sided petals, the second half of the sensors should be behind the first half
+
+ if( _FTDgeo[disk].isDoubleSided ){ // double sided: first half of sensors should have one z value, and second half as well
+
+ for( int iPetal=0; iPetal< _FTDgeo[disk].nPetals; iPetal++){
+
+ int sensors1Side = _FTDgeo[disk].nSensors/2;
+
+ //check first half
+ for( int iSensor=2; iSensor <= sensors1Side; iSensor++ ){
+
+ assert( fabs( ftdlayers.getSensitiveZposition( disk, iPetal, iSensor) - ftdlayers.getSensitiveZposition( disk, iPetal, iSensor-1) ) < eps );
+
+ }
+
+ // check second half
+ for( int iSensor=sensors1Side + 2; iSensor <= _FTDgeo[disk].nSensors; iSensor++ ){
+
+ assert( fabs( ftdlayers.getSensitiveZposition( disk, iPetal, iSensor) - ftdlayers.getSensitiveZposition( disk, iPetal, iSensor-1) ) < eps );
+
+ // also check if the sensors on the back are farther away from the origin:
+ assert( fabs( ftdlayers.getSensitiveZposition( disk, iPetal, iSensor) ) - fabs( ftdlayers.getSensitiveZposition( disk, iPetal, iSensor-sensors1Side ) ) >= 0. );
+ }
+ }
+ }
+ else{ // single sided: all sensors should have the same z
+
+ for( int iPetal=0; iPetal< _FTDgeo[disk].nPetals; iPetal++){
+
+ for(int iSensor=2; iSensor <= _FTDgeo[disk].nSensors; iSensor++ ){
+
+ assert( fabs( ftdlayers.getSensitiveZposition( disk, iPetal, iSensor) - ftdlayers.getSensitiveZposition( disk, iPetal, iSensor-1) ) < eps );
+
+ }
+ }
+ }
+
+ // there should be no gap between support and sensitive
+
+ for( int iPetal=0; iPetal< _FTDgeo[disk].nPetals; iPetal++){
+
+
+ int side = ftdlayers.getSupportZposition( disk, iPetal ) > 0? 1 : -1;
+
+ double endSensitive = ftdlayers.getSensitiveZposition( disk, iPetal, 1) + side * _FTDgeo[disk].senThickness/2.;
+ double endSupport = ftdlayers.getSupportZposition( disk, iPetal ) -side * _FTDgeo[disk].supThickness/2.;
+
+ assert( fabs( endSensitive- endSupport ) < eps );
+
+ }
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+
+ }
+
+
+}
diff --git a/Utilities/KalDet/src/ild/ftd/ILDFTDKalDetector.h b/Utilities/KalDet/src/ild/ftd/ILDFTDKalDetector.h
new file mode 100644
index 0000000000000000000000000000000000000000..36cf54b8e5a889a09431635740c3e2c3035d6d6a
--- /dev/null
+++ b/Utilities/KalDet/src/ild/ftd/ILDFTDKalDetector.h
@@ -0,0 +1,92 @@
+#ifndef __ILDFTDDETECTOR__
+#define __ILDFTDDETECTOR__
+
+/** Petal based FTD to be used for ILD DBD studies
+ * WARNING: Still very experimental
+ *
+ * @author S.Aplin DESY, Robin Glattauer HEPHY
+ */
+
+#include "kaltest/TVKalDetector.h"
+
+class TNode;
+class TVector3;
+
+namespace gear{
+ class GearMgr ;
+}
+
+
+class ILDFTDKalDetector : public TVKalDetector {
+public:
+
+ /** Initialize the FTD from GEAR */
+ ILDFTDKalDetector( const gear::GearMgr& gearMgr );
+
+
+private:
+
+ struct FTD_Petal {
+
+ int ipetal;
+ double phi;
+ double alpha;
+ double rInner;
+ double height;
+ double innerBaseLength;
+ double outerBaseLength;
+ double senThickness;
+ double supThickness;
+ double senZPos;
+ bool faces_ip;
+
+ };
+
+
+ struct FTD_Disk {
+ int nPetals;
+ double phi0;
+ double dphi;
+
+ double alpha;
+ double rInner;
+ double height;
+ double innerBaseLength;
+ double outerBaseLength;
+ double senThickness;
+ double supThickness;
+
+ double stripAngle;
+
+ double senZPos_even_front;
+ double senZPos_odd_front;
+
+ bool isDoubleSided;
+ bool isStripReadout;
+
+ int nSensors;
+
+
+ };
+
+
+ void build_staggered_design();
+
+ //void create_petal(TVector3 measurement_plane_centre, FTD_Petal petal, int CellID);
+ /**
+ * @param zpos the z position of the front measurement surface (middle of front sensitive)
+ */
+ void create_segmented_disk_layers(int idisk, int nsegments, bool even_petals, double phi0, double zpos );
+
+
+ void setupGearGeom( const gear::GearMgr& gearMgr ) ;
+
+ int _nDisks ;
+ double _bZ ;
+
+
+ std::vector<FTD_Disk> _FTDgeo;
+
+};
+
+#endif
diff --git a/Utilities/KalDet/src/ild/lctpc/LCTPCKalDetector.cc b/Utilities/KalDet/src/ild/lctpc/LCTPCKalDetector.cc
new file mode 100644
index 0000000000000000000000000000000000000000..18fa3a853a7d1238f89b9e275527e30d5241657d
--- /dev/null
+++ b/Utilities/KalDet/src/ild/lctpc/LCTPCKalDetector.cc
@@ -0,0 +1,226 @@
+// STL
+#include <vector>
+
+// GEAR
+#include <gear/GEAR.h>
+#include <gear/TPCParameters.h>
+#include <gear/PadRowLayout2D.h>
+#include <gear/BField.h>
+#include <gearimpl/TPCModuleImpl.h>
+#include <gearxml/GearXML.h>
+
+#include <UTIL/BitField64.h>
+#include <UTIL/ILDConf.h>
+
+// #include <streamlog/streamlog.h>
+
+#include "kaldet/LCTPCKalDetector.h"
+#include "kaldet/ILDCylinderMeasLayer.h"
+
+namespace kaldet
+{
+
+LCTPCKalDetector::LCTPCKalDetector(const gear::GearMgr& gearMgr)
+ : TVKalDetector(210)
+{
+ gear::TPCParameters const & tpcParameters = gearMgr.getTPCParameters();
+
+ // Try to read the material properties from the GEAR file.
+ // If it cannot be found use an Argon based mixture instead.
+ Double_t A, Z, density, radlen;
+
+ try{
+ // One try/catch block for all.
+ // It does not make sense to only replace part of the parameters,
+ // they all have to be there.
+ A = tpcParameters.getDoubleVal("TPCGas_A");
+ Z = tpcParameters.getDoubleVal("TPCGas_Z");
+ density = tpcParameters.getDoubleVal("TPCGas_density");
+ radlen = tpcParameters.getDoubleVal("TPCGas_radlen");
+ }
+ catch( gear::UnknownParameterException & )
+ {
+ // streamlog_out(MESSAGE) << "LCTPCKalDetector: No TPCGas parameters found in the gear file."
+ // << " Using Ar/CH4 90/10." << std::endl;
+
+ // Is this supposed to be Ar/CH4 90/10?
+ // I think it's wrong. A CH4 module does not consist of 0.2 carbon
+ // and 0.8 hydrogen atoms, but 1 C and 4 H, so it should be
+ // A = 39.948 * 0.9 + (12.011 + 1.00794 * 4) * 0.1;
+ A = 39.948 * 0.9 + (12.011 * 0.2 + 1.00794 * 0.8) * 0.1;
+ Z = 16.4; // now how does this calculate?
+ density = 0.749e-3; // in which units?
+ radlen = 1.196e4 * 2; // in which units?
+ }
+
+ TMaterial &gas = *new TMaterial("TPCGas", "", A, Z, density, radlen, 0.);
+
+ // FIXME: what about the cathode tickness. Sensitivity gap in the middle?
+ // And what about the LP? There it's not the half length...
+ Double_t lhalf
+ = tpcParameters.getMaxDriftLength(); // half length
+
+ // FIXME:: needed more careful B calculation ??
+ const Double_t bz = gearMgr.getBField().at( gear::Vector3D( 0.,0.,0.) ).z() ;
+
+// gear::BField const & bField = gearMgr.getBField();
+// // get the BField at 0,0,0. Check that there are no transverse components
+// // FIXME: Event though there are no transverse components at 0, 0, 0 does not mean
+// // there are no transverse components somewhere else.
+// gear::Vector3D bFieldVector = bField.at(gear::Vector3D(0., 0., 0.));
+// if (bFieldVector[0]!=0 || bFieldVector[1]!=0)
+// {
+// streamlog_out(ERROR) << "B-field has transverse components."
+// << " LCTPCKalDetector only works with homogeneous B-field"
+// << " in z direction" << std::endl;
+// throw gear::Exception("Magnetic field not homogeneous");
+// }
+
+ // set the protected member variable of EXVKalDetector
+ // fBfield = bFieldVector[2];
+
+ // FIXME: Just don't put dummy modules into the gear file?
+ // No, we might need the radiation length
+ // Damn it, the description in GEAR is not complete, grrrr.
+ // Bool_t active = GearTPCMeasLayer::kActive;
+ // Bool_t dummy = GearTPCMeasLayer::kDummy;
+
+ // The index where in the TObjectArray the next element will be stored. Unfortunately we have to
+ // do the bookkeeping manually :-(
+ Int_t arrayIndex = 0;
+
+ // ILD-type Encoder
+ UTIL::BitField64 encoder( lcio::ILDCellID0::encoder_string ) ;
+
+ // A map to store if a layer, which is a full cylinder, already exists. If it has the same
+ // offset and the same radius, this is the case. Then to not add a Kalman layer but add the module
+ // to the layer.
+ std::map< std::pair<double, double> , Int_t > uniqueLayerMap;// <offset, r>, LayerIndex
+
+ for (std::vector<gear::TPCModule *>::const_iterator moduleIter = tpcParameters.getModules().begin();
+ moduleIter < tpcParameters.getModules().end(); ++moduleIter)
+ {
+ gear::TPCModule *module = *moduleIter;
+
+ // FIXME: Implementation for RectangularPadRowLayout missing
+ switch (module->getLocalPadLayout().getCoordinateType())
+ {
+ case gear::PadRowLayout2D::POLAR :
+ //Unfortunately cylinder segments are not implemented in KalDet yet.
+ //Perhaps in a future implementation...
+ // Get the phi min and phi max of the module, plus the right rotation
+ // in the global coordinate system. This is not the global angle because it is
+ // relative to the origin of the module, which has a shift in global coordinates.
+ //Double_t phimin = module->getLocalModuleExtent()[2] + module->getAngle();
+ //Double_t phimax = module->getLocalModuleExtent()[3] + module->getAngle();
+
+ // the offset is either in r/phi or in x/y, depending on the global coordinate system
+ double xOffset, yOffset;
+ switch (module->getCoordinateType())
+ {
+ case gear::PadRowLayout2D::POLAR :
+ xOffset=module->getOffset()[0]*cos(module->getOffset()[1]);
+ yOffset=module->getOffset()[0]*sin(module->getOffset()[1]);
+ break;
+ case gear::PadRowLayout2D::CARTESIAN :
+ xOffset=module->getOffset()[0];
+ yOffset=module->getOffset()[1];
+ break;
+ default:
+ throw gear::UnknownParameterException("Unknown global coordinate system in LCTPCKalDetector");
+
+ }
+
+ if (yOffset!=0)
+ {
+ // streamlog_out(ERROR) << "yOffset not 0. The current implementation of LCTPCKalDetector"
+ // << "only allows an offset in x direction." << std::endl;
+ throw gear::UnknownParameterException("Offset in y is not 0.");
+ }
+
+ // Loop the pad rows and place one cylinder segment each
+ for (int row = 0; row < module->getNRows(); ++row)
+ {
+ // To get the radius we have to ask for the center of one one the pads,
+ // just take pad 0 in this row.
+ int padIndex = module->getPadIndex(row, 0);
+
+ // The radius only makes sense in local module coordinates.
+ // So we have to ask the local pad layout. The module always answers in global coordinates.
+ Double_t r = module->getLocalPadLayout().getPadCenter(padIndex)[0];
+
+ std::map< std::pair<double, double> , Int_t >::iterator uniqueLayerIterator=
+ uniqueLayerMap.find( std::pair<double, double>(xOffset, r) );
+
+ if ( uniqueLayerIterator==uniqueLayerMap.end() )
+ {
+ // streamlog_out(DEBUG2) << "adding new layer "<<arrayIndex<< " (xOffset="<<xOffset
+ // <<", r="<<r
+ // <<") with module "<< module->getModuleID()
+ // <<" and row "<<row << std::endl;
+ // add the measurement layer to this object, and remember where we put it
+ encoder.reset() ; // reset to 0
+
+ encoder[lcio::ILDCellID0::subdet] = lcio::ILDDetID::TPC ;
+
+ int mod = module -> getModuleID() ;
+ int row_global =
+ // Modules 0 and 1 get the same row index
+ ( mod==0 || mod==1 ) ? row :
+ /* For modules 2, 3 and 4 the row gets increased
+ * by the number of rows in modules 0/1
+ */
+ ( ( mod==2 || mod==3 || mod==4) ? tpcParameters.getModule(0).getNRows() + row :
+ /* For modules 5 and 6 the row gets increased
+ * by the number of rows in modules 0/1 and 2/3/4
+ */
+ tpcParameters.getModule(0).getNRows() + tpcParameters.getModule(2).getNRows() + row );
+
+ encoder[lcio::ILDCellID0::layer] = row_global ;
+
+ // encoder[lcio::ILDCellID0::module] = mod ;
+
+ int CellID = encoder.lowWord() ;
+
+ Add(new ILDCylinderMeasLayer(gas, gas,
+ r, lhalf,
+ xOffset, yOffset, 0, // FIXME: cathode thickness?
+ bz,
+ true, // active
+ CellID,
+ "ILDCylinderMeasLayer"));
+
+ // add the layer to the uniqueLayerMap
+ uniqueLayerMap[std::pair<double, double>(xOffset, r)] = arrayIndex;
+
+ // count up the array index
+ ++arrayIndex;
+ }
+ else // layer already exists
+ {
+ // streamlog_out(DEBUG2)
+ // << "A new layer will not be added as the layer with the same parameters already exist"<< std::endl;
+ }
+
+ }// loop rows in module
+ break;
+
+ case gear::PadRowLayout2D::CARTESIAN :
+ throw gear::NotImplementedException("Cartesian local coordinates not yet supported by LCTPCKalDetector");
+
+ default:
+ throw gear::UnknownParameterException("Unknown local coordinate system in LCTPCKalDetector");
+ }//switch coordinate type
+
+ }
+
+ SetOwner();// make the KalDetector (TObjectArry) owner of the measurement layers so they are
+ // deleted when the detector is deleted
+
+}
+
+LCTPCKalDetector::~LCTPCKalDetector()
+{
+}
+
+}//namespace kaldet
diff --git a/Utilities/KalDet/src/ild/lctpc/LCTPCKalDetector.h b/Utilities/KalDet/src/ild/lctpc/LCTPCKalDetector.h
new file mode 100644
index 0000000000000000000000000000000000000000..452aaaad178e497f5ffdbe9e0520c9e5fe2718d6
--- /dev/null
+++ b/Utilities/KalDet/src/ild/lctpc/LCTPCKalDetector.h
@@ -0,0 +1,39 @@
+#ifndef LCTPCKALDETECTOR_H
+#define LCTPCKALDETECTOR_H
+
+#include "kaltest/TVKalDetector.h"
+
+#include "kaldet/ILDVMeasLayer.h"
+
+namespace gear{
+ class GearMgr ;
+}
+
+namespace kaldet{
+
+ /**
+ * The LCTPC implementation for a TPC which is completely instantiated from GEAR.
+ *
+ */
+class LCTPCKalDetector : public TVKalDetector {
+
+public:
+
+ LCTPCKalDetector() {};
+
+ /**
+ * The constructor. All information to initialise the TPC is taken from GEAR.
+ *
+ * The class has been copied from GearTPCKalDetector class and adopted for the use of MarlinTrk
+ * You can find comments and necessary information in the original class
+ *
+ */
+ LCTPCKalDetector(const gear::GearMgr& gearMgr);
+
+ /// The destructor.
+ virtual ~LCTPCKalDetector();
+
+};
+
+}// namespace kaldet
+#endif //LCTPCKALDETECTOR_H
diff --git a/Utilities/KalDet/src/ild/set/ILDSETKalDetector.cc b/Utilities/KalDet/src/ild/set/ILDSETKalDetector.cc
new file mode 100644
index 0000000000000000000000000000000000000000..a8ae3eda05e97f1c3b659f9213e505a67f1db102
--- /dev/null
+++ b/Utilities/KalDet/src/ild/set/ILDSETKalDetector.cc
@@ -0,0 +1,286 @@
+
+#include "kaldet/ILDSETKalDetector.h"
+
+#include "kaldet/MaterialDataBase.h"
+
+#include "kaldet/ILDParallelPlanarStripMeasLayer.h"
+
+
+#include <UTIL/BitField64.h>
+#include <UTIL/ILDConf.h>
+
+#include <gear/GEAR.h>
+#include "gear/BField.h"
+#include <gear/ZPlanarParameters.h>
+#include <gear/ZPlanarLayerLayout.h>
+#include "gearimpl/Util.h"
+
+#include "TMath.h"
+
+#include "math.h"
+#include <sstream>
+
+// #include "streamlog/streamlog.h"
+
+ILDSETKalDetector::ILDSETKalDetector( const gear::GearMgr& gearMgr )
+: TVKalDetector(300) // SJA:FIXME initial size, 300 looks reasonable for ILD, though this would be better stored as a const somewhere
+{
+
+
+ // streamlog_out(DEBUG4) << "ILDSETKalDetector building SET detector using GEAR " << std::endl ;
+
+ MaterialDataBase::Instance().registerForService(gearMgr);
+
+ TMaterial & air = *MaterialDataBase::Instance().getMaterial("air");
+ TMaterial & silicon = *MaterialDataBase::Instance().getMaterial("silicon");
+ TMaterial & carbon = *MaterialDataBase::Instance().getMaterial("carbon");
+
+ this->setupGearGeom(gearMgr) ;
+
+ if (_isStripDetector) {
+ // streamlog_out(DEBUG4) << "\t\t building SET detector as STRIP Detector." << std::endl ;
+ } else {
+ // streamlog_out(DEBUG4) << "\t\t building SET detector as PIXEL Detector." << std::endl ;
+ }
+
+
+ //--The Ladder structure (realistic ladder)--
+ int nLadders;
+
+// Bool_t active = true;
+ Bool_t dummy = false;
+
+ static const double eps_layer = 1e-6;
+ static const double eps_sensor = 1e-8;
+
+ UTIL::BitField64 encoder( lcio::ILDCellID0::encoder_string ) ;
+
+ for (int layer=0; layer<_nLayers; ++layer) {
+
+ double offset = _SETgeo[layer].offset ;
+
+ if( offset!=0.0 ) {
+ std::cerr << "SET can not have offsets using the current implementation: exit(1)" << std::endl ;
+ exit(1) ;
+ }
+
+ nLadders = _SETgeo[layer].nLadders ;
+
+ const double phi0 = _SETgeo[layer].phi0 ;
+
+ const double ladder_distance = _SETgeo[layer].supRMin ;
+ const double ladder_thickness = _SETgeo[layer].supThickness ;
+
+ const double sensitive_distance = _SETgeo[layer].senRMin ;
+ const double sensitive_thickness = _SETgeo[layer].senThickness ;
+
+ const double width = _SETgeo[layer].width ;
+ const double length = _SETgeo[layer].length;
+
+ double currPhi;
+ const double dphi = _SETgeo[layer].dphi ;
+
+ const double stripAngle = pow(-1,layer) *_SETgeo[layer].stripAngle;
+
+ const int nsensors = _SETgeo[layer].nSensorsPerLadder;
+
+ const double sensor_length = _SETgeo[layer].sensorLength;
+
+
+ for (int ladder=0; ladder<nLadders; ++ladder) {
+
+
+ currPhi = phi0 + (dphi * ladder);
+
+ encoder.reset() ; // reset to 0
+
+ encoder[lcio::ILDCellID0::subdet] = lcio::ILDDetID::SET ;
+ encoder[lcio::ILDCellID0::side] = 0 ;
+ encoder[lcio::ILDCellID0::layer] = layer ;
+ encoder[lcio::ILDCellID0::module] = ladder ;
+
+ double z_centre_support = 0.0;
+
+ // check if the sensitive is inside or outside for the support
+ if( sensitive_distance < ladder_distance ) {
+
+ double sen_front_sorting_policy = sensitive_distance + (4 * ladder+0) * eps_layer ;
+ double sen_back_sorting_policy = sensitive_distance + (4 * ladder+2) * eps_layer ;
+ double sup_back_sorting_policy = ladder_distance + (4 * ladder+3) * eps_layer ;
+
+ // air - sensitive boundary
+ Add(new ILDParallelPlanarMeasLayer(air, silicon, sensitive_distance, currPhi, _bZ, sen_front_sorting_policy, width, length, offset,z_centre_support, offset, dummy,-1,"SETSenFront")) ;
+
+ for (int isensor=0; isensor<nsensors; ++isensor) {
+
+ encoder[lcio::ILDCellID0::sensor] = isensor ;
+ int CellID = encoder.lowWord() ;
+
+ double measurement_plane_sorting_policy = sensitive_distance + (4 * ladder+1) * eps_layer + eps_sensor * isensor ;
+
+ double z_centre_sensor = -0.5*length + (0.5*sensor_length) + (isensor*sensor_length) ;
+
+
+ if (_isStripDetector) {
+
+ // measurement plane defined as the middle of the sensitive volume
+ Add(new ILDParallelPlanarStripMeasLayer(silicon, silicon, sensitive_distance+sensitive_thickness*0.5, currPhi, _bZ, measurement_plane_sorting_policy, width, sensor_length, offset, z_centre_sensor, offset, stripAngle, CellID, "SETMeaslayer" )) ;
+
+ } else {
+ // measurement plane defined as the middle of the sensitive volume
+ Add(new ILDParallelPlanarMeasLayer(silicon, silicon, sensitive_distance+sensitive_thickness*0.5, currPhi, _bZ, measurement_plane_sorting_policy, width, sensor_length, offset, z_centre_sensor, offset, true, CellID, "SETMeaslayer" )) ;
+ }
+
+
+ // streamlog_out(DEBUG0) << "ILDSETKalDetector add surface with CellID = "
+ // << CellID
+ // << std::endl ;
+
+ }
+
+
+ // sensitive - support boundary
+ Add(new ILDParallelPlanarMeasLayer(silicon, carbon, sensitive_distance+sensitive_thickness, currPhi, _bZ, sen_back_sorting_policy, width, length, offset,z_centre_support, offset, dummy,-1,"SETSenSupportIntf" )) ;
+
+ // support - air boundary
+ Add(new ILDParallelPlanarMeasLayer(carbon, air, ladder_distance+ladder_thickness, currPhi, _bZ, sup_back_sorting_policy, width, length, offset,z_centre_support, offset, dummy,-1,"SETSupRear" )) ;
+ }
+ else {
+
+ double sup_front_sorting_policy = ladder_distance + (4 * ladder+0) * eps_layer ;
+ double sen_front_sorting_policy = sensitive_distance + (4 * ladder+1) * eps_layer ;
+ double sen_back_sorting_policy = sensitive_distance + (4 * ladder+3) * eps_layer ;
+
+ // air - support boundary
+ Add(new ILDParallelPlanarMeasLayer(air, carbon, ladder_distance, currPhi, _bZ, sup_front_sorting_policy, width, length, offset,z_centre_support, offset, dummy,-1,"SETSupFront")) ;
+
+ // support boundary - sensitive
+ Add(new ILDParallelPlanarMeasLayer(carbon, silicon, sensitive_distance, currPhi, _bZ, sen_front_sorting_policy, width, length, offset,z_centre_support, offset, dummy,-1,"SETSenSupportIntf" )) ;
+
+
+ for (int isensor=0; isensor<nsensors; ++isensor) {
+
+ encoder[lcio::ILDCellID0::sensor] = isensor ;
+ int CellID = encoder.lowWord() ;
+
+ double measurement_plane_sorting_policy = sensitive_distance + (4 * ladder+2) * eps_layer + eps_sensor * isensor ;
+
+ double z_centre_sensor = -0.5*length + (0.5*sensor_length) + (isensor*sensor_length) ;
+
+
+ if (_isStripDetector) {
+
+ // measurement plane defined as the middle of the sensitive volume
+ Add(new ILDParallelPlanarStripMeasLayer(silicon, silicon, sensitive_distance+sensitive_thickness*0.5, currPhi, _bZ, measurement_plane_sorting_policy, width, sensor_length, offset, z_centre_sensor, offset, stripAngle, CellID, "SETMeaslayer" )) ;
+
+ } else {
+ // measurement plane defined as the middle of the sensitive volume
+ Add(new ILDParallelPlanarMeasLayer(silicon, silicon, sensitive_distance+sensitive_thickness*0.5, currPhi, _bZ, measurement_plane_sorting_policy, width, sensor_length, offset, z_centre_sensor, offset, true, CellID, "SETMeaslayer" )) ;
+ }
+
+
+ // streamlog_out(DEBUG0) << "ILDSETKalDetector add surface with CellID = "
+ // << CellID
+ // << std::endl ;
+
+
+ }
+
+
+ // support - air boundary
+ Add(new ILDParallelPlanarMeasLayer(silicon, air, sensitive_distance+sensitive_thickness, currPhi, _bZ, sen_back_sorting_policy, width, length, offset,z_centre_support, offset, dummy,-1,"SETSenRear" )) ;
+ }
+
+
+ }
+
+ }
+
+ SetOwner();
+}
+
+
+
+void ILDSETKalDetector::setupGearGeom( const gear::GearMgr& gearMgr ){
+
+ const gear::ZPlanarParameters& pSETDetMain = gearMgr.getSETParameters();
+ const gear::ZPlanarLayerLayout& pSETLayerLayout = pSETDetMain.getZPlanarLayerLayout();
+
+ _bZ = gearMgr.getBField().at( gear::Vector3D( 0.,0.,0.) ).z() ;
+
+ _nLayers = pSETLayerLayout.getNLayers();
+ _SETgeo.resize(_nLayers);
+
+ bool n_sensors_per_ladder_present = true;
+
+ try {
+
+ std::vector<int> v = pSETDetMain.getIntVals("n_sensors_per_ladder");
+
+ } catch (gear::UnknownParameterException& e) {
+
+ n_sensors_per_ladder_present = false;
+
+ }
+
+ double strip_angle_deg = 0.0;
+
+ try {
+
+ strip_angle_deg = pSETDetMain.getDoubleVal("strip_angle_deg");
+ _isStripDetector = true;
+
+ } catch (gear::UnknownParameterException& e) {
+
+ _isStripDetector = false;
+
+ }
+
+
+ //SJA:FIXME: for now the support is taken as the same size the sensitive
+ // if this is not done then the exposed areas of the support would leave a carbon - air boundary,
+ // which if traversed in the reverse direction to the next boundary then the track would be propagated through carbon
+ // for a significant distance
+
+ for( int layer=0; layer < _nLayers; ++layer){
+
+
+ _SETgeo[layer].nLadders = pSETLayerLayout.getNLadders(layer);
+ _SETgeo[layer].phi0 = pSETLayerLayout.getPhi0(layer);
+ _SETgeo[layer].dphi = 2*M_PI / _SETgeo[layer].nLadders;
+ _SETgeo[layer].senRMin = pSETLayerLayout.getSensitiveDistance(layer);
+ _SETgeo[layer].supRMin = pSETLayerLayout.getLadderDistance(layer);
+ _SETgeo[layer].length = pSETLayerLayout.getSensitiveLength(layer)*2.0; // note: gear for historical reasons uses the halflength
+ _SETgeo[layer].width = pSETLayerLayout.getSensitiveWidth(layer);
+ _SETgeo[layer].offset = pSETLayerLayout.getSensitiveOffset(layer);
+ _SETgeo[layer].senThickness = pSETLayerLayout.getSensitiveThickness(layer);
+ _SETgeo[layer].supThickness = pSETLayerLayout.getLadderThickness(layer);
+
+ if (n_sensors_per_ladder_present) {
+ _SETgeo[layer].nSensorsPerLadder = pSETDetMain.getIntVals("n_sensors_per_ladder")[layer];
+ }
+ else{
+ _SETgeo[layer].nSensorsPerLadder = 1 ;
+ }
+
+ _SETgeo[layer].sensorLength = _SETgeo[layer].length / _SETgeo[layer].nSensorsPerLadder;
+
+
+ if (_isStripDetector) {
+ _SETgeo[layer].stripAngle = strip_angle_deg * M_PI/180 ;
+ } else {
+ _SETgeo[layer].stripAngle = 0.0 ;
+ }
+
+ // streamlog_out(DEBUG0) << " layer = " << layer << std::endl;
+ // streamlog_out(DEBUG0) << " nSensorsPerLadder = " << _SETgeo[layer].nSensorsPerLadder << std::endl;
+ // streamlog_out(DEBUG0) << " sensorLength = " << _SETgeo[layer].sensorLength << std::endl;
+ // streamlog_out(DEBUG0) << " stripAngle = " << _SETgeo[layer].stripAngle << std::endl;
+ // streamlog_out(DEBUG0) << " _isStripDetector = " << _isStripDetector << std::endl;
+
+ }
+
+
+
+
+}
diff --git a/Utilities/KalDet/src/ild/set/ILDSETKalDetector.h b/Utilities/KalDet/src/ild/set/ILDSETKalDetector.h
new file mode 100644
index 0000000000000000000000000000000000000000..9327aa8a065e8ff6243df53193df544e37389381
--- /dev/null
+++ b/Utilities/KalDet/src/ild/set/ILDSETKalDetector.h
@@ -0,0 +1,58 @@
+#ifndef __ILDSETKALDETECTOR__
+#define __ILDSETKALDETECTOR__
+
+/** Ladder based SET to be used for ILD DBD studies
+ *
+ * @author S.Aplin DESY
+ */
+
+#include "kaltest/TVKalDetector.h"
+
+#include "TMath.h"
+
+class TNode;
+
+namespace gear{
+ class GearMgr ;
+}
+
+
+class ILDSETKalDetector : public TVKalDetector {
+
+public:
+
+ /** Initialize the SET from GEAR */
+ ILDSETKalDetector( const gear::GearMgr& gearMgr );
+
+
+private:
+
+ void setupGearGeom( const gear::GearMgr& gearMgr ) ;
+
+ int _nLayers ;
+ double _bZ ;
+
+ bool _isStripDetector;
+
+ struct SET_Layer {
+ int nLadders;
+ int nSensorsPerLadder;
+ double phi0;
+ double dphi;
+ double senRMin;
+ double supRMin;
+ double length;
+ double width;
+ double offset;
+ double senThickness;
+ double supThickness;
+ double sensorLength;
+ double stripAngle;
+ };
+ std::vector<SET_Layer> _SETgeo;
+
+};
+
+
+
+#endif
diff --git a/Utilities/KalDet/src/ild/sit/ILDSITCylinderKalDetector.cc b/Utilities/KalDet/src/ild/sit/ILDSITCylinderKalDetector.cc
new file mode 100644
index 0000000000000000000000000000000000000000..5cbc808f582932fd9086dd06a1b005618c821890
--- /dev/null
+++ b/Utilities/KalDet/src/ild/sit/ILDSITCylinderKalDetector.cc
@@ -0,0 +1,133 @@
+
+#include "kaldet/ILDSITCylinderKalDetector.h"
+#include "kaldet/ILDCylinderMeasLayer.h"
+#include "kaldet/ILDCylinderHit.h"
+
+#include "kaldet/MaterialDataBase.h"
+
+#include <sstream>
+#include <cstdlib>
+
+#include "gear/GEAR.h"
+#include "gear/BField.h"
+#include "gearimpl/Util.h"
+
+#include <UTIL/BitField64.h>
+#include <UTIL/ILDConf.h>
+
+// #include "streamlog/streamlog.h"
+
+
+ILDSITCylinderKalDetector::ILDSITCylinderKalDetector( const gear::GearMgr& gearMgr ) :
+TVKalDetector(100)
+{
+
+ // streamlog_out(DEBUG1) << "ILDSITCylinderKalDetector building SIT Simple Cylinder Based Detector using GEAR " << std::endl ;
+
+ ;
+
+ this->setupGearGeom(gearMgr);
+
+ MaterialDataBase::Instance().registerForService(gearMgr);
+ TMaterial & air = *MaterialDataBase::Instance().getMaterial("air");
+ TMaterial & silicon = *MaterialDataBase::Instance().getMaterial("silicon");
+ TMaterial & carbon = *MaterialDataBase::Instance().getMaterial("carbon");
+
+ Bool_t active = true;
+ Bool_t dummy = false;
+
+ std::string name = "SIT";
+
+ UTIL::BitField64 encoder( lcio::ILDCellID0::encoder_string ) ;
+
+ for ( unsigned int ilayer = 0 ; ilayer<_nLayers ; ++ilayer) {
+
+ encoder[lcio::ILDCellID0::subdet] = lcio::ILDDetID::SIT ;
+ encoder[lcio::ILDCellID0::layer] = ilayer ;
+ encoder[lcio::ILDCellID0::module] = 0 ;
+ encoder[lcio::ILDCellID0::sensor] = 0 ;
+
+ int CellID = encoder.lowWord() ;
+
+ double rad = _SITgeo[ilayer].radius - 0.5 * _SITgeo[ilayer].senThickness;
+ double lhalf = _SITgeo[ilayer].half_length;
+
+ const double x0 = 0.0;
+ const double y0 = 0.0;
+ const double z0 = 0.0;
+
+ Add( new ILDCylinderMeasLayer(air, silicon , rad, lhalf, x0, y0, z0, _bZ, dummy,-1,"SITSenFront" ) );
+
+ // streamlog_out( DEBUG0 ) << " *** adding " << name << " Front face Measurement layer at R = " << rad << " and half length = " << lhalf
+ // << " X0_in = " << air.GetRadLength() << " X0_out = " << silicon.GetRadLength()
+ // << std::endl ;
+
+ rad += 0.5 * _SITgeo[ilayer].senThickness;
+
+ Add( new ILDCylinderMeasLayer(silicon , silicon, rad, lhalf, x0, y0, z0, _bZ, active,CellID,"SITMeaslayer" ) );
+
+ // streamlog_out( DEBUG0 ) << " *** adding " << name << " Measurement layer using CellID: " << CellID << " at R = " << rad << " and half length = " << lhalf
+ // << " X0_in = " << silicon.GetRadLength() << " X0_out = " << silicon.GetRadLength()
+ // << std::endl ;
+
+ rad += 0.5 * _SITgeo[ilayer].senThickness;
+
+ Add( new ILDCylinderMeasLayer(silicon , carbon, rad, lhalf, x0, y0, z0, _bZ, dummy, -1,"SITSenSupInterFace" ) );
+
+ // streamlog_out( DEBUG0 ) << " *** adding " << name << " Interface between senstive and support Measurement layer at R = " << rad << " and half length = " << lhalf
+ // << " X0_in = " << silicon.GetRadLength() << " X0_out = " << carbon.GetRadLength()
+ // << std::endl ;
+
+ rad += _SITgeo[ilayer].supThickness;
+
+ Add( new ILDCylinderMeasLayer(carbon , air, rad, lhalf, x0, y0, z0, _bZ, dummy, -1,"SITSupRear" ) );
+
+ // streamlog_out( DEBUG0 ) << " *** adding " << name << " Rear face Measurement layer using at R = " << rad << " and half length = " << lhalf
+ // << " X0_in = " << carbon.GetRadLength() << " X0_out = " << air.GetRadLength()
+ // << std::endl ;
+
+
+
+ }
+
+ SetOwner();
+}
+
+
+void ILDSITCylinderKalDetector::setupGearGeom( const gear::GearMgr& gearMgr ){
+
+
+ const gear::GearParameters& pSIT = gearMgr.getGearParameters("SIT");
+
+ _bZ = gearMgr.getBField().at( gear::Vector3D( 0.,0.,0.) ).z() ;
+
+ double SIT_si = pSIT.getDoubleVal("SITLayerThickness" ) ;
+ double SIT_sp = pSIT.getDoubleVal("SITSupportLayerThickness" ) ;
+ const std::vector<double>& SIT_r = pSIT.getDoubleVals("SITLayerRadius" ) ;
+ const std::vector<double>& SIT_hl = pSIT.getDoubleVals("SITSupportLayerHalfLength" ) ;
+
+ _nLayers = SIT_r.size() ;
+ _SITgeo.resize(_nLayers);
+
+
+ if (_nLayers != SIT_r.size() || _nLayers != SIT_hl.size()) {
+
+ // streamlog_out( ERROR ) << "ILDSITCylinderKalDetector miss-match between DoubleVec and nlayers exit(1) called from file " << __FILE__ << " line " << __LINE__ << std::endl ;
+ exit(1);
+
+ }
+
+
+ for(unsigned int layer=0; layer< _nLayers; ++layer){
+
+ _SITgeo[layer].senThickness = SIT_si;
+ _SITgeo[layer].supThickness = SIT_sp;
+ _SITgeo[layer].radius = SIT_r[layer];
+ _SITgeo[layer].half_length = SIT_hl[layer];
+
+
+ }
+
+
+}
+
diff --git a/Utilities/KalDet/src/ild/sit/ILDSITCylinderKalDetector.h b/Utilities/KalDet/src/ild/sit/ILDSITCylinderKalDetector.h
new file mode 100644
index 0000000000000000000000000000000000000000..29f13f6f7cf5eaf3fba067693d475a9c6fa47449
--- /dev/null
+++ b/Utilities/KalDet/src/ild/sit/ILDSITCylinderKalDetector.h
@@ -0,0 +1,44 @@
+#ifndef __ILDSITCYLINDERKALDETECTOR__
+#define __ILDSITCYLINDERKALDETECTOR__
+
+/** SIT Cylinder based detector to be used for ILD DBD studies when using the old LOI base SIT
+ *
+ * @author S.Aplin DESY
+ */
+
+#include "kaltest/TVKalDetector.h"
+
+class TNode;
+
+namespace gear{
+ class GearMgr ;
+}
+
+
+class ILDSITCylinderKalDetector : public TVKalDetector {
+public:
+
+ /** Initialize the TPC from GEAR */
+ ILDSITCylinderKalDetector( const gear::GearMgr& gearMgr );
+
+
+private:
+
+ void setupGearGeom( const gear::GearMgr& gearMgr ) ;
+
+ unsigned int _nLayers ;
+ double _bZ ;
+
+ struct SIT_Layer {
+ double radius;
+ double half_length;
+ double senThickness;
+ double supThickness;
+
+ };
+ std::vector<SIT_Layer> _SITgeo;
+
+
+};
+
+#endif
diff --git a/Utilities/KalDet/src/ild/sit/ILDSITKalDetector.cc b/Utilities/KalDet/src/ild/sit/ILDSITKalDetector.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e58b9d6e773e9afabad21e3179be18e2891f4f69
--- /dev/null
+++ b/Utilities/KalDet/src/ild/sit/ILDSITKalDetector.cc
@@ -0,0 +1,286 @@
+
+#include "ILDSITKalDetector.h"
+
+#include "MaterialDataBase.h"
+
+#include "ILDParallelPlanarStripMeasLayer.h"
+
+
+#include <UTIL/BitField64.h>
+#include <UTIL/ILDConf.h>
+
+#include <gear/GEAR.h>
+#include "gear/BField.h"
+#include <gear/ZPlanarParameters.h>
+#include <gear/ZPlanarLayerLayout.h>
+#include "gearimpl/Util.h"
+
+#include "TMath.h"
+
+#include "math.h"
+#include <sstream>
+
+// #include "streamlog/streamlog.h"
+
+ILDSITKalDetector::ILDSITKalDetector( const gear::GearMgr& gearMgr )
+: TVKalDetector(300) // SJA:FIXME initial size, 300 looks reasonable for ILD, though this would be better stored as a const somewhere
+{
+
+
+ // streamlog_out(DEBUG4) << "ILDSITKalDetector building SIT detector using GEAR " << std::endl ;
+
+ MaterialDataBase::Instance().registerForService(gearMgr);
+
+ TMaterial & air = *MaterialDataBase::Instance().getMaterial("air");
+ TMaterial & silicon = *MaterialDataBase::Instance().getMaterial("silicon");
+ TMaterial & carbon = *MaterialDataBase::Instance().getMaterial("carbon");
+
+ this->setupGearGeom(gearMgr) ;
+
+ if (_isStripDetector) {
+ // streamlog_out(DEBUG4) << "\t\t building SIT detector as STRIP Detector." << std::endl ;
+ } else {
+ // streamlog_out(DEBUG4) << "\t\t building SIT detector as PIXEL Detector." << std::endl ;
+ }
+
+
+ //--The Ladder structure (realistic ladder)--
+ int nLadders;
+
+ // Bool_t active = true;
+ Bool_t dummy = false;
+
+ static const double eps_layer = 1e-6;
+ static const double eps_sensor = 1e-8;
+
+ UTIL::BitField64 encoder( lcio::ILDCellID0::encoder_string ) ;
+
+ for (int layer=0; layer<_nLayers; ++layer) {
+
+ double offset = _SITgeo[layer].offset ;
+
+ if( offset!=0.0 ) {
+ std::cerr << "SIT can not have offsets using the current implementation: exit(1)" << std::endl ;
+ exit(1) ;
+ }
+
+ nLadders = _SITgeo[layer].nLadders ;
+
+ const double phi0 = _SITgeo[layer].phi0 ;
+
+ const double ladder_distance = _SITgeo[layer].supRMin ;
+ const double ladder_thickness = _SITgeo[layer].supThickness ;
+
+ const double sensitive_distance = _SITgeo[layer].senRMin ;
+ const double sensitive_thickness = _SITgeo[layer].senThickness ;
+
+ const double width = _SITgeo[layer].width ;
+ const double length = _SITgeo[layer].length;
+
+ double currPhi;
+ const double dphi = _SITgeo[layer].dphi ;
+
+ const double stripAngle = pow(-1,layer) *_SITgeo[layer].stripAngle;
+
+ const int nsensors = _SITgeo[layer].nSensorsPerLadder;
+
+ const double sensor_length = _SITgeo[layer].sensorLength;
+
+
+ for (int ladder=0; ladder<nLadders; ++ladder) {
+
+
+ currPhi = phi0 + (dphi * ladder);
+
+ encoder.reset() ; // reset to 0
+
+ encoder[lcio::ILDCellID0::subdet] = lcio::ILDDetID::SIT ;
+ encoder[lcio::ILDCellID0::side] = 0 ;
+ encoder[lcio::ILDCellID0::layer] = layer ;
+ encoder[lcio::ILDCellID0::module] = ladder ;
+
+ double z_centre_support = 0.0;
+
+ // check if the sensitive is inside or outside for the support
+ if( sensitive_distance < ladder_distance ) {
+
+ double sen_front_sorting_policy = sensitive_distance + (4 * ladder+0) * eps_layer ;
+ double sen_back_sorting_policy = sensitive_distance + (4 * ladder+2) * eps_layer ;
+ double sup_back_sorting_policy = ladder_distance + (4 * ladder+3) * eps_layer ;
+
+ // air - sensitive boundary
+ Add(new ILDParallelPlanarMeasLayer(air, silicon, sensitive_distance, currPhi, _bZ, sen_front_sorting_policy, width, length, offset,z_centre_support, offset, dummy,-1,"SITSenFront")) ;
+
+ for (int isensor=0; isensor<nsensors; ++isensor) {
+
+ encoder[lcio::ILDCellID0::sensor] = isensor ;
+ int CellID = encoder.lowWord() ;
+
+ double measurement_plane_sorting_policy = sensitive_distance + (4 * ladder+1) * eps_layer + eps_sensor * isensor ;
+
+ double z_centre_sensor = -0.5*length + (0.5*sensor_length) + (isensor*sensor_length) ;
+
+
+ if (_isStripDetector) {
+
+ // measurement plane defined as the middle of the sensitive volume
+ Add(new ILDParallelPlanarStripMeasLayer(silicon, silicon, sensitive_distance+sensitive_thickness*0.5, currPhi, _bZ, measurement_plane_sorting_policy, width, sensor_length, offset, z_centre_sensor, offset, stripAngle, CellID, "SITMeaslayer" )) ;
+
+ } else {
+ // measurement plane defined as the middle of the sensitive volume
+ Add(new ILDParallelPlanarMeasLayer(silicon, silicon, sensitive_distance+sensitive_thickness*0.5, currPhi, _bZ, measurement_plane_sorting_policy, width, sensor_length, offset, z_centre_sensor, offset, true, CellID, "SITMeaslayer" )) ;
+ }
+
+
+ // streamlog_out(DEBUG0) << "ILDSITKalDetector add surface with CellID = "
+ // << CellID
+ // << std::endl ;
+
+ }
+
+
+ // sensitive - support boundary
+ Add(new ILDParallelPlanarMeasLayer(silicon, carbon, sensitive_distance+sensitive_thickness, currPhi, _bZ, sen_back_sorting_policy, width, length, offset,z_centre_support, offset, dummy,-1,"SITSenSupportIntf" )) ;
+
+ // support - air boundary
+ Add(new ILDParallelPlanarMeasLayer(carbon, air, ladder_distance+ladder_thickness, currPhi, _bZ, sup_back_sorting_policy, width, length, offset,z_centre_support, offset, dummy,-1,"SITSupRear" )) ;
+ }
+ else {
+
+ double sup_front_sorting_policy = ladder_distance + (4 * ladder+0) * eps_layer ;
+ double sen_front_sorting_policy = sensitive_distance + (4 * ladder+1) * eps_layer ;
+ double sen_back_sorting_policy = sensitive_distance + (4 * ladder+3) * eps_layer ;
+
+ // air - support boundary
+ Add(new ILDParallelPlanarMeasLayer(air, carbon, ladder_distance, currPhi, _bZ, sup_front_sorting_policy, width, length, offset,z_centre_support, offset, dummy,-1,"SITSupFront")) ;
+
+ // support boundary - sensitive
+ Add(new ILDParallelPlanarMeasLayer(carbon, silicon, sensitive_distance, currPhi, _bZ, sen_front_sorting_policy, width, length, offset,z_centre_support, offset, dummy,-1,"SITSenSupportIntf" )) ;
+
+
+ for (int isensor=0; isensor<nsensors; ++isensor) {
+
+ encoder[lcio::ILDCellID0::sensor] = isensor ;
+ int CellID = encoder.lowWord() ;
+
+ double measurement_plane_sorting_policy = sensitive_distance + (4 * ladder+2) * eps_layer + eps_sensor * isensor ;
+
+ double z_centre_sensor = -0.5*length + (0.5*sensor_length) + (isensor*sensor_length) ;
+
+
+ if (_isStripDetector) {
+
+ // measurement plane defined as the middle of the sensitive volume
+ Add(new ILDParallelPlanarStripMeasLayer(silicon, silicon, sensitive_distance+sensitive_thickness*0.5, currPhi, _bZ, measurement_plane_sorting_policy, width, sensor_length, offset, z_centre_sensor, offset, stripAngle, CellID, "SITMeaslayer" )) ;
+
+ } else {
+ // measurement plane defined as the middle of the sensitive volume
+ Add(new ILDParallelPlanarMeasLayer(silicon, silicon, sensitive_distance+sensitive_thickness*0.5, currPhi, _bZ, measurement_plane_sorting_policy, width, sensor_length, offset, z_centre_sensor, offset, true, CellID, "SITMeaslayer" )) ;
+ }
+
+
+ // streamlog_out(DEBUG0) << "ILDSITKalDetector add surface with CellID = "
+ // << CellID
+ // << std::endl ;
+
+
+ }
+
+
+ // support - air boundary
+ Add(new ILDParallelPlanarMeasLayer(silicon, air, sensitive_distance+sensitive_thickness, currPhi, _bZ, sen_back_sorting_policy, width, length, offset,z_centre_support, offset, dummy,-1,"SITSenRear" )) ;
+ }
+
+
+ }
+
+ }
+
+ SetOwner();
+}
+
+
+
+void ILDSITKalDetector::setupGearGeom( const gear::GearMgr& gearMgr ){
+
+ const gear::ZPlanarParameters& pSITDetMain = gearMgr.getSITParameters();
+ const gear::ZPlanarLayerLayout& pSITLayerLayout = pSITDetMain.getZPlanarLayerLayout();
+
+ _bZ = gearMgr.getBField().at( gear::Vector3D( 0.,0.,0.) ).z() ;
+
+ _nLayers = pSITLayerLayout.getNLayers();
+ _SITgeo.resize(_nLayers);
+
+ bool n_sensors_per_ladder_present = true;
+
+ try {
+
+ std::vector<int> v = pSITDetMain.getIntVals("n_sensors_per_ladder");
+
+ } catch (gear::UnknownParameterException& e) {
+
+ n_sensors_per_ladder_present = false;
+
+ }
+
+ double strip_angle_deg = 0.0;
+
+ try {
+
+ strip_angle_deg = pSITDetMain.getDoubleVal("strip_angle_deg");
+ _isStripDetector = true;
+
+ } catch (gear::UnknownParameterException& e) {
+
+ _isStripDetector = false;
+
+ }
+
+
+ //SJA:FIXME: for now the support is taken as the same size the sensitive
+ // if this is not done then the exposed areas of the support would leave a carbon - air boundary,
+ // which if traversed in the reverse direction to the next boundary then the track would be propagated through carbon
+ // for a significant distance
+
+ for( int layer=0; layer < _nLayers; ++layer){
+
+
+ _SITgeo[layer].nLadders = pSITLayerLayout.getNLadders(layer);
+ _SITgeo[layer].phi0 = pSITLayerLayout.getPhi0(layer);
+ _SITgeo[layer].dphi = 2*M_PI / _SITgeo[layer].nLadders;
+ _SITgeo[layer].senRMin = pSITLayerLayout.getSensitiveDistance(layer);
+ _SITgeo[layer].supRMin = pSITLayerLayout.getLadderDistance(layer);
+ _SITgeo[layer].length = pSITLayerLayout.getSensitiveLength(layer)*2.0; // note: gear for historical reasons uses the halflength
+ _SITgeo[layer].width = pSITLayerLayout.getSensitiveWidth(layer);
+ _SITgeo[layer].offset = pSITLayerLayout.getSensitiveOffset(layer);
+ _SITgeo[layer].senThickness = pSITLayerLayout.getSensitiveThickness(layer);
+ _SITgeo[layer].supThickness = pSITLayerLayout.getLadderThickness(layer);
+
+ if (n_sensors_per_ladder_present) {
+ _SITgeo[layer].nSensorsPerLadder = pSITDetMain.getIntVals("n_sensors_per_ladder")[layer];
+ }
+ else{
+ _SITgeo[layer].nSensorsPerLadder = 1 ;
+ }
+
+ _SITgeo[layer].sensorLength = _SITgeo[layer].length / _SITgeo[layer].nSensorsPerLadder;
+
+
+ if (_isStripDetector) {
+ _SITgeo[layer].stripAngle = strip_angle_deg * M_PI/180 ;
+ } else {
+ _SITgeo[layer].stripAngle = 0.0 ;
+ }
+
+ // streamlog_out(DEBUG0) << " layer = " << layer << std::endl;
+ // streamlog_out(DEBUG0) << " nSensorsPerLadder = " << _SITgeo[layer].nSensorsPerLadder << std::endl;
+ // streamlog_out(DEBUG0) << " sensorLength = " << _SITgeo[layer].sensorLength << std::endl;
+ // streamlog_out(DEBUG0) << " stripAngle = " << _SITgeo[layer].stripAngle << std::endl;
+ // streamlog_out(DEBUG0) << " _isStripDetector = " << _isStripDetector << std::endl;
+
+ }
+
+
+
+
+}
diff --git a/Utilities/KalDet/src/ild/sit/ILDSITKalDetector.h b/Utilities/KalDet/src/ild/sit/ILDSITKalDetector.h
new file mode 100644
index 0000000000000000000000000000000000000000..639e1b27bb76512ad05c8570814b218a9480cb5b
--- /dev/null
+++ b/Utilities/KalDet/src/ild/sit/ILDSITKalDetector.h
@@ -0,0 +1,58 @@
+#ifndef __ILDSITKALDETECTOR__
+#define __ILDSITKALDETECTOR__
+
+/** Ladder based SIT to be used for ILD DBD studies
+ *
+ * @author S.Aplin DESY
+ */
+
+#include "kaltest/TVKalDetector.h"
+
+#include "TMath.h"
+
+class TNode;
+
+namespace gear{
+ class GearMgr ;
+}
+
+
+class ILDSITKalDetector : public TVKalDetector {
+
+public:
+
+ /** Initialize the SIT from GEAR */
+ ILDSITKalDetector( const gear::GearMgr& gearMgr );
+
+
+private:
+
+ void setupGearGeom( const gear::GearMgr& gearMgr ) ;
+
+ int _nLayers ;
+ double _bZ ;
+
+ bool _isStripDetector;
+
+ struct SIT_Layer {
+ int nLadders;
+ int nSensorsPerLadder;
+ double phi0;
+ double dphi;
+ double senRMin;
+ double supRMin;
+ double length;
+ double width;
+ double offset;
+ double senThickness;
+ double supThickness;
+ double sensorLength;
+ double stripAngle;
+ };
+ std::vector<SIT_Layer> _SITgeo;
+
+};
+
+
+
+#endif
diff --git a/Utilities/KalDet/src/ild/support/ILDSupportKalDetector.cc b/Utilities/KalDet/src/ild/support/ILDSupportKalDetector.cc
new file mode 100644
index 0000000000000000000000000000000000000000..3b59a6af44c926aaa2d88a9b8217b8e98bdec813
--- /dev/null
+++ b/Utilities/KalDet/src/ild/support/ILDSupportKalDetector.cc
@@ -0,0 +1,329 @@
+
+#include "ILDSupportKalDetector.h"
+#include "ILDCylinderMeasLayer.h"
+#include "ILDConeMeasLayer.h"
+#include "ILDPolygonBarrelMeasLayer.h"
+#include "ILDDiscMeasLayer.h"
+
+#include "TMath.h"
+#include "TTUBE.h"
+
+#include <UTIL/BitField64.h>
+#include <UTIL/ILDConf.h>
+
+#include "MaterialDataBase.h"
+
+#include <sstream>
+#include <cmath>
+
+#include "gear/GEAR.h"
+#include "gear/BField.h"
+#include "gearimpl/Util.h"
+#include "gear/CalorimeterParameters.h"
+// #include "streamlog/streamlog.h"
+#include "DetInterface/IGeoSvc.h"
+
+ILDSupportKalDetector::ILDSupportKalDetector( const gear::GearMgr& gearMgr, IGeoSvc* geoSvc ) :
+TVKalDetector(10)
+{
+
+ // streamlog_out(DEBUG1) << "ILDSupportKalDetector building beampipe using GEAR " << std::endl ;
+
+ const gear::GearParameters& pBeamPipe = gearMgr.getGearParameters("BeamPipe");
+ const Double_t bz = gearMgr.getBField().at( gear::Vector3D( 0.,0.,0.) ).z() ;
+
+ // switch gear to dd4hep::rec, once validated, gear will been removed.
+ const dd4hep::rec::ConicalSupportData* pBeamPipeData = geoSvc->getBeamPipeData();
+ const std::vector<dd4hep::rec::ConicalSupportData::Section>& sections = pBeamPipeData->sections;
+ std::cout << "======================BeamPipe===================" << std::endl;
+ for(int i=0;i<sections.size();i++){
+ std::cout << sections[i].zPos << " " << sections[i].rInner << " " << sections[i].rOuter << std::endl;
+ }
+ std::cout << "vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv" << std::endl;
+ // the beampipe is supposed to be a chain of cut cones (cut, that means the spike is cut off, also called a cone frustum).
+ // as they are connected, RStart[i] == REnd[i-1]. With this all we need are the z values and the radii at the place.
+ const std::vector<double> z = pBeamPipe.getDoubleVals("Z");
+ const std::vector<double> rInner = pBeamPipe.getDoubleVals("RInner"); //inner radius of the cone
+ const std::vector<double> rOuter = pBeamPipe.getDoubleVals("ROuter"); //outer radius of the cone
+ for(int i=0;i<sections.size();i++){
+ std::cout << z[i] << " " << rInner[i] << " " << rOuter[i] << std::endl;
+ }
+ MaterialDataBase::Instance().registerForService(gearMgr, geoSvc);
+ TMaterial & beam = *MaterialDataBase::Instance().getMaterial("beam");
+ TMaterial & air = *MaterialDataBase::Instance().getMaterial("air");
+ // TMaterial & aluminium = *MaterialDataBase::Instance().getMaterial("aluminium");
+ TMaterial & beryllium = *MaterialDataBase::Instance().getMaterial("beryllium");
+
+ Bool_t dummy = false;
+
+ double eps_side = 1.0e-8;
+ double eps_section = 1.0e-6;
+
+ // first check the sizes of the beam-pipe values r_in r_out and z
+
+ if ( ( z.size() != rInner.size() ) || ( z.size() != rOuter.size() ) ) {
+ // streamlog_out(ERROR) << "ILDSupportKalDetector::ILDSupportKalDetector miss-match in number of double values for beam-pipe: Z = " << z.size() << " RInner = " << rInner.size() << " ROuter = " << rOuter.size() << " exit(1) called from "<< __FILE__ << " line " << __LINE__ << std::endl;
+ exit(1);
+ }
+
+ double epsilon = 1.e-6;
+
+ double rInnerStart_last = -DBL_MAX;
+ double rInnerEnd_last = -DBL_MAX;
+ double rOuterStart_last = -DBL_MAX;
+ double rOuterEnd_last = -DBL_MAX;
+
+ // add beam pipe cones
+ for( unsigned i=0; i<z.size()-1; i++){
+
+ double zStart = z[i];
+ double zEnd = z[i+1];
+ double rInnerStart = rInner[i];
+ double rInnerEnd = rInner[i+1];
+ double rOuterStart = rOuter[i];
+ double rOuterEnd = rOuter[i+1];
+
+
+ //SJA:FIXME: HERE WE NEED TO MAKE SURE THAT THE BEAM PIPE IS NEVER DECREASING IN RADII OTHERWISE THE SORTING GOES WRONG
+ if ( rInnerStart < rInnerStart_last ) rInnerStart = rInnerStart_last; rInnerStart_last = rInnerStart;
+ if ( rInnerEnd < rInnerEnd_last ) rInnerEnd = rInnerEnd_last ; rInnerEnd_last = rInnerEnd;
+ if ( rOuterStart < rOuterStart_last ) rOuterStart = rOuterStart_last; rOuterStart_last = rOuterStart;
+ if ( rOuterEnd < rOuterEnd_last ) rOuterEnd = rOuterEnd_last; rOuterEnd_last = rOuterEnd;
+
+
+ std::stringstream sname;
+
+ const double x0 = 0.0;
+ const double y0 = 0.0;
+ const double z0 = 0.0;
+
+
+ // central part has to be treated separately as it should not be composed of two halves but a single section.
+ if (i==0) {
+ // check that z values start a zero
+ if (fabs(zStart) > epsilon) {
+ // streamlog_out(ERROR) << "ILDSupportKalDetector::ILDSupportKalDetector first z value for beam-pipe must equal zero: Z = " << zStart << " exit(1) called from "<< __FILE__ << " line " << __LINE__ << std::endl;
+ exit(1);
+ }
+
+ // just make a minimal beam pipe (tube) no cone for now as the sorting policy does not works as expected
+
+ double zhalf = zEnd;
+
+
+ sname << "BeamPipeInnerWallCentralSection_" << i;
+ _surface_names.push_back(sname.str());
+
+
+ Add( new ILDCylinderMeasLayer(beam, beryllium , rInnerStart , zhalf, x0, y0, z0, bz, dummy,-1, _surface_names.back().c_str() ));
+
+ // streamlog_out( DEBUG0 ) << " *** adding " << _surface_names.back() << " Measurement layer using CellID: [ beampipe ] at R = " << rInnerStart
+ // << " zHalf = " << zhalf << " X0_in = " << beam.GetRadLength() << " X0_out = " << beryllium.GetRadLength()
+ // << std::endl ;
+
+ sname.str(std::string());
+ sname << "BeamPipeOuterWallCentralSection_" << i;
+ _surface_names.push_back(sname.str());
+
+ Add( new ILDCylinderMeasLayer(beryllium, air , rOuterStart , zhalf, x0, y0, z0, bz, dummy,-1, _surface_names.back().c_str() ));
+
+ // streamlog_out( DEBUG0 ) << " *** adding " << _surface_names.back() << " Measurement layer using CellID: [ beampipe ] at R = " << rOuterStart
+ // << " zHalf = " << zhalf << " X0_in = " << beryllium.GetRadLength() << " X0_out = " << air.GetRadLength()
+ // << std::endl ;
+
+
+
+ } else {
+
+
+ if( fabs( zEnd-zStart ) > epsilon ){
+
+
+ double SortingPolicy = rInnerStart+i*eps_section;
+
+ if (fabs(rInnerEnd-rInnerStart) > epsilon) { // use cone
+
+ sname.str(std::string());
+ sname << "BeamPipeConeInnerFwd" << i;
+ _surface_names.push_back(sname.str());
+
+ Add( new ILDConeMeasLayer(beam, beryllium , zStart, rInnerStart, zEnd, rInnerEnd, bz, SortingPolicy, dummy,-1, _surface_names.back().c_str() ) );
+
+ sname.str(std::string());
+ sname << "BeamPipeConeInnerBwd" << i;
+ _surface_names.push_back(sname.str());
+
+ Add( new ILDConeMeasLayer(beam, beryllium , -zStart, rInnerStart, -zEnd, rInnerEnd, bz, SortingPolicy+eps_side, dummy,-1, _surface_names.back().c_str() ) );
+
+ } else { // use cylinder
+
+ sname.str(std::string());
+ sname << "BeamPipeCylindeInnerFwd" << i;
+ _surface_names.push_back(sname.str());
+
+ const double zhalf = fabs(zEnd-zStart);
+
+ const double zoffset = zStart + zhalf;
+
+ Add( new ILDCylinderMeasLayer(beam, beryllium , rInnerStart+i*eps_section , zhalf, x0, y0, zoffset, bz, dummy,-1, _surface_names.back().c_str() ));
+
+ sname.str(std::string());
+ sname << "BeamPipeCylindeInnerBwd" << i;
+ _surface_names.push_back(sname.str());
+
+ Add( new ILDCylinderMeasLayer(beam, beryllium , rInnerStart+i*eps_section+eps_side , zhalf, x0, y0, -zoffset, bz, dummy,-1, _surface_names.back().c_str() ));
+
+
+ }
+
+
+ // streamlog_out( DEBUG0 ) << " *** adding inner " << _surface_names[_surface_names.size()-2] << " and " << _surface_names.back() << " Measurement layer using CellID: [ beampipe ] at"
+ // << " z1 = +-" << zStart
+ // << " z2 = +-" << zEnd
+ // << " r1 = " << rInnerStart
+ // << " r2 = " << rInnerEnd
+ // << " X0_in = " << beam.GetRadLength() << " X0_out = " << beryllium.GetRadLength()
+ // << std::endl ;
+
+ SortingPolicy = rOuterStart+i*eps_section;
+
+ if (fabs(rOuterEnd-rOuterStart) > epsilon) { // use cone
+
+ sname.str(std::string());
+ sname << "BeamPipeConeOuterFwd" << i;
+ _surface_names.push_back(sname.str());
+
+ Add( new ILDConeMeasLayer(beryllium , air , zStart, rOuterStart, zEnd, rOuterEnd, bz, SortingPolicy, dummy,-1, _surface_names.back().c_str() ) );
+
+ sname.str(std::string());
+ sname << "BeamPipeConeOuterBwd" << i;
+ _surface_names.push_back(sname.str());
+
+ Add( new ILDConeMeasLayer(beryllium , air , -zStart, rOuterStart, -zEnd, rOuterEnd, bz, SortingPolicy+eps_side, dummy,-1, _surface_names.back().c_str() ) );
+
+
+ } else { // use cylinder
+
+ sname.str(std::string());
+ sname << "BeamPipeCylindeOuterFwd" << i;
+ _surface_names.push_back(sname.str());
+
+ const double zhalf = fabs(zEnd-zStart);
+
+ const double zoffset = zStart + zhalf;
+
+ Add( new ILDCylinderMeasLayer(beryllium, air , rOuterStart+i*eps_section , zhalf, x0, y0, zoffset, bz, dummy,-1, _surface_names.back().c_str() ));
+
+ sname.str(std::string());
+ sname << "BeamPipeCylindeOuterBwd" << i;
+ _surface_names.push_back(sname.str());
+
+ Add( new ILDCylinderMeasLayer(beryllium, air , rOuterStart+i*eps_section+eps_side , zhalf, x0, y0, -zoffset, bz, dummy,-1, _surface_names.back().c_str() ));
+
+ }
+
+
+ // streamlog_out( DEBUG0 ) << " *** adding outer " << _surface_names[_surface_names.size()-2] << " and " << _surface_names.back() << " Measurement layer using CellID: [ beampipe ] at"
+ // << " z1 = +-" << zStart
+ // << " z2 = +-" << zEnd
+ // << " r1 = " << rOuterStart
+ // << " r2 = " << rOuterEnd
+ // << " X0_in = " << beryllium.GetRadLength() << " X0_out = " << air.GetRadLength()
+ // << std::endl ;
+
+ }
+
+ }
+
+ }
+
+
+ // add vacuum layer 1mm inside the beam pipe to assist propagation to the IP
+ // therefore make a cylinder that is 1mm smaller than the lowest RInner value of the cones
+ // and make it so long that it gets as long as the beamtube
+ const double rvacuum = *min_element(rInner.begin(), rInner.end()) - 1.0;
+ const double zHalfVacuum = z.back();
+
+ const double x0 = 0.0;
+ const double y0 = 0.0;
+ const double z0 = 0.0;
+
+
+ _ipLayer = new ILDCylinderMeasLayer(beam, beam , rvacuum , zHalfVacuum, x0, y0, z0, bz, dummy,-1,"IPLayer" );
+
+ Add( _ipLayer );
+ // streamlog_out( DEBUG0 ) << " *** adding " << "IPLayer" << " Measurement layer using CellID: [ beampipe ] at R = " << rvacuum
+ // << " zHalf = " << zHalfVacuum << " X0_in = " << beam.GetRadLength() << " X0_out = " << beam.GetRadLength()
+ // << std::endl ;
+
+
+ // add calo bounding inner surface as ILDPolygonBarrelMeasLayer and two planes at the inner z of the calo endcaps with ILDDiscMeasLayer
+
+ // SJA:FIXME: OK for now we will just use a set of planes as there is not yet an implementation to propagate to a multilayer
+
+ const gear::CalorimeterParameters& ecalB = gearMgr.getEcalBarrelParameters();
+ const gear::CalorimeterParameters& ecalE = gearMgr.getEcalEndcapParameters();
+
+ if (ecalB.getSymmetryOrder()!=8) {
+ // streamlog_out(ERROR) << "ILDSupportKalDetector::ILDSupportKalDetector ECal barrel is not eightfold symmetry: exit(1) called from " << __FILE__ << " line " << __LINE__ << std::endl;
+ exit(1);
+
+ }
+
+ double phi0 = ecalB.getPhi0();
+ double r_min_ecal_bar = ecalB.getExtent()[0];
+ double z_max_ecal_bar = ecalB.getExtent()[3];
+
+ UTIL::BitField64 encoder( lcio::ILDCellID0::encoder_string ) ;
+ encoder.reset() ; // reset to 0
+
+ encoder[lcio::ILDCellID0::subdet] = lcio::ILDDetID::ECAL ;
+ encoder[lcio::ILDCellID0::side] = lcio::ILDDetID::barrel;
+ encoder[lcio::ILDCellID0::layer] = 0 ;
+
+ std::vector<int> module_ids;
+
+ for (int i=0; i<8; ++i) {
+
+ encoder[lcio::ILDCellID0::module] = i;
+ module_ids.push_back(encoder.lowWord());
+
+ double segment_dphi = 2.0*M_PI / 8;
+ double phi = i*segment_dphi+phi0;
+ double width = 2.0*(r_min_ecal_bar*tan(segment_dphi*0.5));
+ double length = 2.0*z_max_ecal_bar;
+ Add ( new ILDParallelPlanarMeasLayer(air,air,r_min_ecal_bar,phi,bz,r_min_ecal_bar+i*1.0e-06,width,length,0.0,0.0,0.0,true,encoder.lowWord(),"ECalBarrelFace"));
+
+ }
+
+ // Add ( new ILDPolygonBarrelMeasLayer(air,air,bz,r_min_ecal_bar,r_min_ecal_bar,z_max_ecal_bar*0.5,8,0.0,phi0,module_ids,"ECalBarrelFace"));
+
+ // streamlog_out( DEBUG0 ) << " *** adding ECalBarrelFace Measurement layer at Rmin = " << r_min_ecal_bar << std::endl ;
+
+ double r_max_ecal_ecap = ecalE.getExtent()[1];
+ double z_min_ecal_ecap = ecalE.getExtent()[2];
+
+ encoder[lcio::ILDCellID0::module] = 0;
+
+ encoder[lcio::ILDCellID0::side] = lcio::ILDDetID::fwd;
+
+ TVector3 front_face_centre_fwd( 0.0, 0.0, z_min_ecal_ecap); // for +z
+ TVector3 front_face_normal_fwd(front_face_centre_fwd);
+ front_face_normal_fwd.SetMag(1.0);
+
+ Add (new ILDDiscMeasLayer(air, air, front_face_centre_fwd,front_face_normal_fwd, bz, z_min_ecal_ecap, 0., r_max_ecal_ecap/cos(M_PI/8.0), true, encoder.lowWord(),"ECalEndcapFace+Z") );
+
+ // streamlog_out( DEBUG0 ) << " *** adding ECalEndcapFace+Z Measurement layer at Zmin = " << front_face_centre_fwd.z() << " and Rmax = " << r_max_ecal_ecap/cos(M_PI/8.0) << std::endl ;
+
+ encoder[lcio::ILDCellID0::side] = lcio::ILDDetID::bwd;
+ TVector3 front_face_centre_bwd( -front_face_centre_fwd ); // for -z
+ TVector3 front_face_normal_bwd(front_face_centre_bwd);
+ front_face_normal_bwd.SetMag(1.0);
+
+ Add (new ILDDiscMeasLayer(air, air, front_face_centre_bwd,front_face_normal_bwd, bz, z_min_ecal_ecap+1.0e-06, 0., r_max_ecal_ecap/cos(M_PI/8.0), true, encoder.lowWord(),"ECalEndcapFace-Z"));
+
+ // streamlog_out( DEBUG0 ) << " *** adding ECalEndcapFace-Z Measurement layer at Zmin = " << front_face_centre_bwd.z() << " and Rmax = " << r_max_ecal_ecap/cos(M_PI/8.0) << std::endl ;
+
+ SetOwner();
+}
+
diff --git a/Utilities/KalDet/src/ild/support/ILDSupportKalDetector.h b/Utilities/KalDet/src/ild/support/ILDSupportKalDetector.h
new file mode 100644
index 0000000000000000000000000000000000000000..b7e28fa929884ceadf7755395766d8f75c079c3f
--- /dev/null
+++ b/Utilities/KalDet/src/ild/support/ILDSupportKalDetector.h
@@ -0,0 +1,37 @@
+#ifndef __ILDSUPPORTDETECTOR__
+#define __ILDSUPPORTDETECTOR__
+
+/** Support Material to be used for ILD DBD studies
+ *
+ * @author S.Aplin DESY
+ */
+
+#include "kaltest/TVKalDetector.h"
+
+class TNode;
+
+namespace gear{
+ class GearMgr ;
+}
+class IGeoSvc;
+
+class ILDCylinderMeasLayer;
+
+class ILDSupportKalDetector : public TVKalDetector {
+public:
+
+ /** Initialize the support structures from GEAR */
+ ILDSupportKalDetector( const gear::GearMgr& gearMgr, IGeoSvc* geoSvc );
+
+ /** Returns the special layer inside the Beam Pipe used for propagation to the IP */
+ ILDCylinderMeasLayer* getIPLayer() { return _ipLayer; }
+
+private:
+
+ ILDCylinderMeasLayer* _ipLayer;
+
+ std::vector<std::string> _surface_names;
+
+};
+
+#endif
diff --git a/Utilities/KalDet/src/ild/tpc/ILDTPCKalDetector.cc b/Utilities/KalDet/src/ild/tpc/ILDTPCKalDetector.cc
new file mode 100644
index 0000000000000000000000000000000000000000..cb41bf467d2a208fbc8b6ff0587f08bf5aca2ba7
--- /dev/null
+++ b/Utilities/KalDet/src/ild/tpc/ILDTPCKalDetector.cc
@@ -0,0 +1,137 @@
+
+#include "ILDTPCKalDetector.h"
+#include "ILDCylinderMeasLayer.h"
+#include "ILDCylinderHit.h"
+
+#include "TMath.h"
+#include "TTUBE.h"
+
+#include "MaterialDataBase.h"
+
+#include <sstream>
+
+#include "gear/GEAR.h"
+#include "gear/BField.h"
+#include "gear/TPCParameters.h"
+#include "gear/PadRowLayout2D.h"
+#include "gearimpl/Util.h"
+
+#include <UTIL/BitField64.h>
+#include <UTIL/ILDConf.h>
+
+// #include "streamlog/streamlog.h"
+
+
+ILDTPCKalDetector::ILDTPCKalDetector( const gear::GearMgr& gearMgr ) :
+TVKalDetector(250) // SJA:FIXME initial size, 250 looks reasonable for ILD, though this would be better stored as a const somewhere
+{
+
+ // streamlog_out(DEBUG1) << "ILDTPCKalDetector building TPC detector using GEAR " << std::endl ;
+
+ const gear::TPCParameters& tpcParams = gearMgr.getTPCParameters();
+
+ const gear::PadRowLayout2D& pL = tpcParams.getPadLayout() ;
+
+ // streamlog_out(DEBUG1) << "ILDTPCKalDetector - got padlayout with nLayers = " << pL.getNRows() << std::endl ;
+
+ const Double_t bz = gearMgr.getBField().at( gear::Vector3D( 0.,0.,0.) ).z() ;
+
+ static const Int_t nlayers = pL.getNRows() ; // n rows
+ static const Double_t lhalf = tpcParams.getMaxDriftLength() ; // half length
+
+ static const Double_t rstep = pL.getRowHeight(0) ; // step length of radius
+
+ // assuming that this is the radius of the first measurment layer ....
+ static const Double_t rmin = tpcParams.getPlaneExtent()[0] + rstep/2. ; // minimum radius
+
+ // streamlog_out( DEBUG0 ) << tpcParams << std::endl ;
+
+ static const Double_t rtub = tpcParams.getDoubleVal("tpcInnerRadius") ; // inner r of support tube
+ static const Double_t outerr = tpcParams.getDoubleVal("tpcOuterRadius") ; // outer radius of TPC
+
+ static const Double_t inthick = tpcParams.getDoubleVal("tpcInnerWallThickness") ; // thickness of inner shell
+ static const Double_t outthick = tpcParams.getDoubleVal("tpcOuterWallThickness") ; // thickness of outer shell
+
+ MaterialDataBase::Instance().registerForService(gearMgr);
+ TMaterial & air = *MaterialDataBase::Instance().getMaterial("air");
+ TMaterial & tpcgas = *MaterialDataBase::Instance().getMaterial("tpcgas");
+ // TMaterial & aluminium = *MaterialDataBase::Instance().getMaterial("aluminium");
+ TMaterial & tpcinnerfieldcage = *MaterialDataBase::Instance().getMaterial("tpcinnerfieldcage");
+ TMaterial & tpcouterfieldcage = *MaterialDataBase::Instance().getMaterial("tpcouterfieldcage");
+
+ Bool_t active = true;
+ Bool_t dummy = false;
+
+ std::string name = "TPC";
+
+ const double x0 = 0.0;
+ const double y0 = 0.0;
+ const double z0 = 0.0;
+
+
+ // add inner field cage
+ Add( new ILDCylinderMeasLayer(air, tpcinnerfieldcage , rtub, lhalf, x0, y0, z0, bz, dummy,-1,"TPCInnerFCInr" ) );
+ // streamlog_out( DEBUG0 ) << " *** adding " << name << " Measurement layer using CellID: [ inner field cage ] at R = " << rtub
+ // << " X0_in = " << air.GetRadLength() << " X0_out = " << tpcinnerfieldcage.GetRadLength()
+ // << std::endl ;
+
+ Add( new ILDCylinderMeasLayer(tpcinnerfieldcage , tpcgas, rtub+inthick, lhalf, x0, y0, z0, bz, dummy,-1,"TPCInnerFCOtr" ) );
+ // streamlog_out( DEBUG0 ) << " *** adding " << name << " Measurement layer using CellID: [ inner field cage ] at R = " << rtub+inthick
+ // << " X0_in = " << tpcinnerfieldcage.GetRadLength() << " X0_out = " << tpcgas.GetRadLength()
+ // << std::endl ;
+
+
+ // streamlog_out( DEBUG0 ) << " *** Inner Field Cage = " << int( (inthick/(tpcinnerfieldcage.GetRadLength()*10.0) /*cm*/ )*1000) / 10.0 << "% of a radiation length " << std::endl ;
+
+ // create measurement layers
+ Double_t r = rmin;
+
+ UTIL::BitField64 encoder( lcio::ILDCellID0::encoder_string ) ;
+
+ for (Int_t layer = 0; layer < nlayers; layer++) {
+
+ encoder.reset() ; // reset to 0
+
+ encoder[lcio::ILDCellID0::subdet] = lcio::ILDDetID::TPC ;
+ encoder[lcio::ILDCellID0::layer] = layer ;
+
+ int CellID = encoder.lowWord() ;
+
+ ILDCylinderMeasLayer* tpcL = new ILDCylinderMeasLayer(tpcgas, tpcgas, r, lhalf, x0, y0, z0, bz, active, CellID, "TPCMeasLayer") ;
+
+ Add( tpcL ) ;
+
+ int nth_layers(10) ;
+
+ if( layer % nth_layers == 0 ){
+
+ // streamlog_out( DEBUG0 ) << " *** for TPC Gas printing only every " << nth_layers << "th layer" << std::endl ;
+ // streamlog_out( DEBUG0 ) << " *** adding " << name << " Measurement layer using CellID: [" << CellID << "] at R = " << r
+ // << " X0_in = " << tpcgas.GetRadLength() << " X0_out = " << tpcgas.GetRadLength()
+ // << std::endl ;
+ }
+
+ r += rstep;
+
+ }
+
+ // add outer field cage
+ Add( new ILDCylinderMeasLayer(tpcgas, tpcouterfieldcage, outerr-outthick, lhalf, x0, y0, z0, bz, dummy,-1,"TPCOuterFCInr") ) ;
+
+ // streamlog_out( DEBUG0 ) << " *** adding " << name << " Measurement layer using CellID: [ outer field cage ] at R = " << outerr-outthick
+ // << " X0_in = " << tpcgas.GetRadLength() << " X0_out = " << tpcouterfieldcage.GetRadLength()
+ // << std::endl ;
+
+ Add( new ILDCylinderMeasLayer(tpcouterfieldcage, air, outerr, lhalf, x0, y0, z0, bz, dummy,-1,"TPCOuterFCOtr") ) ;
+
+ // streamlog_out( DEBUG0 ) << " *** adding " << name << " Measurement layer using CellID: [ outer field cage ] at R = " << outerr
+ // << " X0_in = " << tpcouterfieldcage.GetRadLength() << " X0_out = " << air.GetRadLength()
+ // << std::endl ;
+
+ // streamlog_out( DEBUG0 ) << " *** Outer Field Cage = " << int( (outthick/(tpcouterfieldcage.GetRadLength()*10.0) /*cm*/ )*1000) / 10.0 << "% of a radiation length " << std::endl ;
+
+
+ SetOwner();
+}
+
+
diff --git a/Utilities/KalDet/src/ild/tpc/ILDTPCKalDetector.cc.remove b/Utilities/KalDet/src/ild/tpc/ILDTPCKalDetector.cc.remove
new file mode 100644
index 0000000000000000000000000000000000000000..dc6101e5ee7acee641647a3563dd5c5c1ba5e016
--- /dev/null
+++ b/Utilities/KalDet/src/ild/tpc/ILDTPCKalDetector.cc.remove
@@ -0,0 +1,139 @@
+
+#include "ILDTPCKalDetector.h"
+#include "ILDCylinderMeasLayer.h"
+#include "ILDCylinderHit.h"
+
+#include "TMath.h"
+#include "TTUBE.h"
+
+#include "MaterialDataBase.h"
+
+#include <sstream>
+
+#include "gear/GEAR.h"
+#include "gear/BField.h"
+#include "gear/TPCParameters.h"
+#include "gear/PadRowLayout2D.h"
+#include "gearimpl/Util.h"
+
+#include <UTIL/BitField64.h>
+#include <UTIL/ILDConf.h>
+
+#include "streamlog/streamlog.h"
+
+namespace kaldet{
+
+ILDTPCKalDetector::ILDTPCKalDetector( const gear::GearMgr& gearMgr ) :
+TVKalDetector(250) // SJA:FIXME initial size, 250 looks reasonable for ILD, though this would be better stored as a const somewhere
+{
+
+ streamlog_out(DEBUG1) << "ILDTPCKalDetector building TPC detector using GEAR " << std::endl ;
+
+ const gear::TPCParameters& tpcParams = gearMgr.getTPCParameters();
+
+ const gear::PadRowLayout2D& pL = tpcParams.getPadLayout() ;
+
+ streamlog_out(DEBUG1) << "ILDTPCKalDetector - got padlayout with nLayers = " << pL.getNRows() << std::endl ;
+
+ const Double_t bz = gearMgr.getBField().at( gear::Vector3D( 0.,0.,0.) ).z() ;
+
+ static const Int_t nlayers = pL.getNRows() ; // n rows
+ static const Double_t lhalf = tpcParams.getMaxDriftLength() ; // half length
+
+ static const Double_t rstep = pL.getRowHeight(0) ; // step length of radius
+
+ // assuming that this is the radius of the first measurment layer ....
+ static const Double_t rmin = tpcParams.getPlaneExtent()[0] + rstep/2. ; // minimum radius
+
+ streamlog_out( DEBUG0 ) << tpcParams << std::endl ;
+
+ static const Double_t rtub = tpcParams.getDoubleVal("tpcInnerRadius") ; // inner r of support tube
+ static const Double_t outerr = tpcParams.getDoubleVal("tpcOuterRadius") ; // outer radius of TPC
+
+ static const Double_t inthick = tpcParams.getDoubleVal("tpcInnerWallThickness") ; // thickness of inner shell
+ static const Double_t outthick = tpcParams.getDoubleVal("tpcOuterWallThickness") ; // thickness of outer shell
+
+ MaterialDataBase::Instance().registerForService(gearMgr);
+ TMaterial & air = *MaterialDataBase::Instance().getMaterial("air");
+ TMaterial & tpcgas = *MaterialDataBase::Instance().getMaterial("tpcgas");
+ // TMaterial & aluminium = *MaterialDataBase::Instance().getMaterial("aluminium");
+ TMaterial & tpcinnerfieldcage = *MaterialDataBase::Instance().getMaterial("tpcinnerfieldcage");
+ TMaterial & tpcouterfieldcage = *MaterialDataBase::Instance().getMaterial("tpcouterfieldcage");
+
+ Bool_t active = true;
+ Bool_t dummy = false;
+
+ std::string name = "TPC";
+
+ const double x0 = 0.0;
+ const double y0 = 0.0;
+ const double z0 = 0.0;
+
+
+ // add inner field cage
+ Add( new ILDCylinderMeasLayer(air, tpcinnerfieldcage , rtub, lhalf, x0, y0, z0, bz, dummy,-1,"TPCInnerFCInr" ) );
+ streamlog_out( DEBUG0 ) << " *** adding " << name << " Measurement layer using CellID: [ inner field cage ] at R = " << rtub
+ << " X0_in = " << air.GetRadLength() << " X0_out = " << tpcinnerfieldcage.GetRadLength()
+ << std::endl ;
+
+ Add( new ILDCylinderMeasLayer(tpcinnerfieldcage , tpcgas, rtub+inthick, lhalf, x0, y0, z0, bz, dummy,-1,"TPCInnerFCOtr" ) );
+ streamlog_out( DEBUG0 ) << " *** adding " << name << " Measurement layer using CellID: [ inner field cage ] at R = " << rtub+inthick
+ << " X0_in = " << tpcinnerfieldcage.GetRadLength() << " X0_out = " << tpcgas.GetRadLength()
+ << std::endl ;
+
+
+ streamlog_out( DEBUG0 ) << " *** Inner Field Cage = " << int( (inthick/(tpcinnerfieldcage.GetRadLength()*10.0) /*cm*/ )*1000) / 10.0 << "% of a radiation length " << std::endl ;
+
+ // create measurement layers
+ Double_t r = rmin;
+
+ UTIL::BitField64 encoder( lcio::ILDCellID0::encoder_string ) ;
+
+ for (Int_t layer = 0; layer < nlayers; layer++) {
+
+ encoder.reset() ; // reset to 0
+
+ encoder[lcio::ILDCellID0::subdet] = lcio::ILDDetID::TPC ;
+ encoder[lcio::ILDCellID0::layer] = layer ;
+
+ int CellID = encoder.lowWord() ;
+
+ ILDCylinderMeasLayer* tpcL = new ILDCylinderMeasLayer(tpcgas, tpcgas, r, lhalf, x0, y0, z0, bz, active, CellID, "TPCMeasLayer") ;
+
+ Add( tpcL ) ;
+
+ int nth_layers(10) ;
+
+ if( layer % nth_layers == 0 ){
+
+ streamlog_out( DEBUG0 ) << " *** for TPC Gas printing only every " << nth_layers << "th layer" << std::endl ;
+ streamlog_out( DEBUG0 ) << " *** adding " << name << " Measurement layer using CellID: [" << CellID << "] at R = " << r
+ << " X0_in = " << tpcgas.GetRadLength() << " X0_out = " << tpcgas.GetRadLength()
+ << std::endl ;
+ }
+
+ r += rstep;
+
+ }
+
+ // add outer field cage
+ Add( new ILDCylinderMeasLayer(tpcgas, tpcouterfieldcage, outerr-outthick, lhalf, x0, y0, z0, bz, dummy,-1,"TPCOuterFCInr") ) ;
+
+ streamlog_out( DEBUG0 ) << " *** adding " << name << " Measurement layer using CellID: [ outer field cage ] at R = " << outerr-outthick
+ << " X0_in = " << tpcgas.GetRadLength() << " X0_out = " << tpcouterfieldcage.GetRadLength()
+ << std::endl ;
+
+ Add( new ILDCylinderMeasLayer(tpcouterfieldcage, air, outerr, lhalf, x0, y0, z0, bz, dummy,-1,"TPCOuterFCOtr") ) ;
+
+ streamlog_out( DEBUG0 ) << " *** adding " << name << " Measurement layer using CellID: [ outer field cage ] at R = " << outerr
+ << " X0_in = " << tpcouterfieldcage.GetRadLength() << " X0_out = " << air.GetRadLength()
+ << std::endl ;
+
+ streamlog_out( DEBUG0 ) << " *** Outer Field Cage = " << int( (outthick/(tpcouterfieldcage.GetRadLength()*10.0) /*cm*/ )*1000) / 10.0 << "% of a radiation length " << std::endl ;
+
+
+ SetOwner();
+}
+
+
+}
diff --git a/Utilities/KalDet/src/ild/tpc/ILDTPCKalDetector.h b/Utilities/KalDet/src/ild/tpc/ILDTPCKalDetector.h
new file mode 100644
index 0000000000000000000000000000000000000000..e5ab8db97c723357f2fbd8e964ab319ec7102ca6
--- /dev/null
+++ b/Utilities/KalDet/src/ild/tpc/ILDTPCKalDetector.h
@@ -0,0 +1,29 @@
+#ifndef __ILDTPCDETECTOR__
+#define __ILDTPCDETECTOR__
+
+/** TPC to be used for ILD DBD studies
+ *
+ * @author S.Aplin DESY
+ */
+
+#include "kaltest/TVKalDetector.h"
+
+class TNode;
+
+namespace gear{
+ class GearMgr ;
+}
+
+
+class ILDTPCKalDetector : public TVKalDetector {
+public:
+
+ /** Initialize the TPC from GEAR */
+ ILDTPCKalDetector( const gear::GearMgr& gearMgr );
+
+
+private:
+
+};
+
+#endif
diff --git a/Utilities/KalDet/src/ild/vxd/ILDVXDKalDetector.cc b/Utilities/KalDet/src/ild/vxd/ILDVXDKalDetector.cc
new file mode 100644
index 0000000000000000000000000000000000000000..a820db54985ae8936acecc432c08577a3f9324de
--- /dev/null
+++ b/Utilities/KalDet/src/ild/vxd/ILDVXDKalDetector.cc
@@ -0,0 +1,406 @@
+
+#include "ILDVXDKalDetector.h"
+
+#include "MaterialDataBase.h"
+
+#include "ILDParallelPlanarMeasLayer.h"
+#include "ILDCylinderMeasLayer.h"
+#include "ILDDiscMeasLayer.h"
+
+#include <UTIL/BitField64.h>
+#include <UTIL/ILDConf.h>
+
+#include <gear/GEAR.h>
+#include "gear/BField.h"
+#include <gearimpl/ZPlanarParametersImpl.h>
+#include <gear/VXDParameters.h>
+#include <gear/VXDLayerLayout.h>
+#include "gearimpl/Util.h"
+#include "DetInterface/IGeoSvc.h"
+
+#include "TMath.h"
+
+#include "math.h"
+#include <sstream>
+
+// #include "streamlog/streamlog.h"
+
+ILDVXDKalDetector::ILDVXDKalDetector( const gear::GearMgr& gearMgr, IGeoSvc* geoSvc )
+: TVKalDetector(300) // SJA:FIXME initial size, 300 looks reasonable for ILD, though this would be better stored as a const somewhere
+{
+
+ // streamlog_out(DEBUG1) << "ILDVXDKalDetector building VXD detector using GEAR " << std::endl ;
+
+ MaterialDataBase::Instance().registerForService(gearMgr, geoSvc);
+
+ TMaterial & air = *MaterialDataBase::Instance().getMaterial("air");
+ TMaterial & silicon = *MaterialDataBase::Instance().getMaterial("silicon");
+ TMaterial & carbon = *MaterialDataBase::Instance().getMaterial("VXDSupportMaterial");
+ TMaterial & beryllium = *MaterialDataBase::Instance().getMaterial("beryllium");
+
+ // needed for cryostat
+
+ TMaterial & aluminium = *MaterialDataBase::Instance().getMaterial("aluminium");
+
+ _vxd_Cryostat.exists = false;
+
+ this->setupGearGeom(gearMgr, geoSvc) ;
+
+ //--The Ladder structure (realistic ladder)--
+ int nLadders;
+
+ Bool_t active = true;
+ Bool_t dummy = false;
+
+ static const double eps = 1e-6;
+
+ UTIL::BitField64 encoder( lcio::ILDCellID0::encoder_string ) ;
+
+ for (int layer=0; layer<_nLayers; ++layer) {
+
+ nLadders = _VXDgeo[layer].nLadders ;
+
+ double phi0 = _VXDgeo[layer].phi0 ;
+
+ double ladder_distance = _VXDgeo[layer].supRMin ;
+ double ladder_thickness = _VXDgeo[layer].supThickness ;
+
+ double sensitive_distance = _VXDgeo[layer].senRMin ;
+ double sensitive_thickness = _VXDgeo[layer].senThickness ;
+
+ double width = _VXDgeo[layer].width ;
+ double length = _VXDgeo[layer].length;
+ double offset = _VXDgeo[layer].offset;
+
+ double pos_xi_nonoverlap_width = (2.0 * (( width / 2.0 ) - fabs(offset)));
+
+ double currPhi;
+ double dphi = _VXDgeo[layer].dphi ;
+
+ static const double z_offset = 0.0; // all VXD planes are centred at zero
+
+ for (int ladder=0; ladder<nLadders; ++ladder) {
+
+ currPhi = phi0 + (dphi * ladder);
+
+ encoder.reset() ; // reset to 0
+
+ encoder[lcio::ILDCellID0::subdet] = lcio::ILDDetID::VXD ;
+ encoder[lcio::ILDCellID0::side] = 0 ;
+ encoder[lcio::ILDCellID0::layer] = layer ;
+ encoder[lcio::ILDCellID0::module] = ladder ;
+ encoder[lcio::ILDCellID0::sensor] = 0 ;
+
+ int CellID = encoder.lowWord() ;
+
+ // even layers have the senstive side facing the IP
+ if(layer%2 == 0 ){ // overlap section of ladder0 is defined after the last ladder,
+
+
+ double sen_front_sorting_policy = sensitive_distance + (4 * ladder+0) * eps ;
+ double measurement_plane_sorting_policy = sensitive_distance + (4 * ladder+1) * eps ;
+ double sen_back_sorting_policy = sensitive_distance + (4 * ladder+2) * eps ;
+ double sup_back_sorting_policy = sensitive_distance + (4 * ladder+3) * eps ;
+
+
+ if(ladder==0){ // bacause overlap section of ladder0 is further outer than the last ladder.
+
+ // streamlog_out(DEBUG0) << "ILDVXDKalDetector add surface with CellID = "
+ // << CellID
+ // << std::endl ;
+
+ // non overlapping region
+ // air - sensitive boundary
+ Add(new ILDParallelPlanarMeasLayer(air, silicon, sensitive_distance, currPhi, _bZ, sen_front_sorting_policy, pos_xi_nonoverlap_width, length, 0.0, z_offset, offset, dummy,-1,"VXDSenFront_non_overlap_even" )) ;
+
+ // measurement plane defined as the middle of the sensitive volume - unless "relative_position_of_measurement_surface" parameter given in GEAR
+ Add(new ILDParallelPlanarMeasLayer(silicon, silicon, sensitive_distance+sensitive_thickness*_relative_position_of_measurement_surface, currPhi, _bZ, measurement_plane_sorting_policy, pos_xi_nonoverlap_width, length, 0.0, z_offset, offset, active, CellID, "VXDMeasLayer_non_overlap_even" )) ;
+
+ // sensitive - support boundary
+ Add(new ILDParallelPlanarMeasLayer(silicon, carbon, sensitive_distance+sensitive_thickness, currPhi, _bZ, sen_back_sorting_policy, pos_xi_nonoverlap_width, length, 0.0, z_offset, offset, dummy,-1,"VXDSenSuppportIntf_non_overlap_even" )) ;
+
+ // support - air boundary
+ Add(new ILDParallelPlanarMeasLayer(carbon, air, ladder_distance+ladder_thickness, currPhi, _bZ, sup_back_sorting_policy, pos_xi_nonoverlap_width, length, 0.0, z_offset, offset, dummy,-1,"VXDSupRear_non_overlap_even" )) ;
+
+
+ // overlapping region
+ double overlap_region_width = width - pos_xi_nonoverlap_width ;
+ double overlap_region_offset = -(overlap_region_width/2.0) - (pos_xi_nonoverlap_width)/2.0 ;
+
+
+ // overlap sorting policy uses nLadders as the overlapping "ladder" is the order i.e. there will now be nLadders+1
+ double overlap_front_sorting_policy = sensitive_distance + (4* nLadders+0) * eps;
+ double overlap_measurement_plane_sorting_policy = sensitive_distance + (4* nLadders+1) * eps;
+ double overlap_back_sorting_policy = sensitive_distance + (4* nLadders+2) * eps;
+ double overlap_sup_back_sorting_policy = sensitive_distance + (4* nLadders+3) * eps;
+
+ // streamlog_out(DEBUG0) << "ILDVXDKalDetector add surface with CellID = "
+ // << CellID
+ // << std::endl ;
+
+ // air - sensitive boundary
+ Add(new ILDParallelPlanarMeasLayer(air, silicon, sensitive_distance, currPhi, _bZ, overlap_front_sorting_policy, overlap_region_width, length, overlap_region_offset, z_offset, offset, dummy,-1,"VXDSenFront_overlap_even")) ;
+
+ // measurement plane defined as the middle of the sensitive volume - unless "relative_position_of_measurement_surface" parameter given in GEAR
+ Add(new ILDParallelPlanarMeasLayer(silicon, silicon, sensitive_distance+sensitive_thickness*_relative_position_of_measurement_surface, currPhi, _bZ, overlap_measurement_plane_sorting_policy, overlap_region_width, length, overlap_region_offset, z_offset, offset, active, CellID, "VXDMeasLayer_overlap_even" )) ;
+
+
+ // sensitive - support boundary
+ Add(new ILDParallelPlanarMeasLayer(silicon, carbon, sensitive_distance+sensitive_thickness, currPhi, _bZ, overlap_back_sorting_policy, overlap_region_width, length, overlap_region_offset, z_offset, offset, dummy,-1,"VXDSenSuppportIntf_overlap_even")) ;
+
+ // support - air boundary
+ Add(new ILDParallelPlanarMeasLayer(carbon, air, ladder_distance+ladder_thickness, currPhi, _bZ, overlap_sup_back_sorting_policy, overlap_region_width, length, overlap_region_offset, z_offset, offset, dummy,-1,"VXDSupRear_overlap_even")) ;
+
+ }
+ else{
+
+ // streamlog_out(DEBUG0) << "ILDVXDKalDetector (ILDParallelPlanarMeasLayer) add surface with CellID = "
+ // << CellID
+ // << std::endl ;
+
+
+ // air - sensitive boundary
+ Add(new ILDParallelPlanarMeasLayer(air, silicon, sensitive_distance, currPhi, _bZ, sen_front_sorting_policy, width, length, offset, z_offset, offset, dummy,-1, "VXDSenFront_even")) ;
+
+
+ // measurement plane defined as the middle of the sensitive volume - unless "relative_position_of_measurement_surface" parameter given in GEAR - even layers face outwards !
+ Add(new ILDParallelPlanarMeasLayer(silicon, silicon, sensitive_distance+sensitive_thickness*( 1.-_relative_position_of_measurement_surface ), currPhi, _bZ, measurement_plane_sorting_policy, width, length, offset, z_offset, offset, active, CellID, "VXDMeaslayer_even" )) ;
+
+ // sensitive - support boundary
+ Add(new ILDParallelPlanarMeasLayer(silicon, carbon, sensitive_distance+sensitive_thickness, currPhi, _bZ, sen_back_sorting_policy, width, length, offset, z_offset, offset, dummy,-1,"VXDSenSuppportIntf_even" )) ;
+
+ // support - air boundary
+ Add(new ILDParallelPlanarMeasLayer(carbon, air, ladder_distance+ladder_thickness, currPhi, _bZ, sup_back_sorting_policy, width, length, offset, z_offset, offset, dummy,-1,"VXDSupRear_even" )) ;
+
+ }
+ }
+ else{ // counting from 0, odd numbered layers are placed with the support closer to the IP than the sensitive
+
+
+
+ double sup_forward_sorting_policy = ladder_distance + (4 * ladder+0) * eps ;
+ double sup_back_sorting_policy = ladder_distance + (4 * ladder+1) * eps ;
+ double measurement_plane_sorting_policy = ladder_distance + (4 * ladder+2) * eps ;
+ double sen_back_sorting_policy = ladder_distance + (4 * ladder+3) * eps ;
+
+ // streamlog_out(DEBUG0) << "ILDVXDKalDetector (ILDPlanarMeasLayer) add surface with CellID = "
+ // << CellID
+ // << std::endl ;
+
+ // air - support boundary
+ Add(new ILDParallelPlanarMeasLayer(air, carbon, ladder_distance, currPhi, _bZ, sup_forward_sorting_policy, width, length, offset, z_offset, offset, dummy,-1,"VXDSupFront_odd" )) ;
+
+ // support - sensitive boundary
+ Add(new ILDParallelPlanarMeasLayer(carbon, silicon, (ladder_distance+ladder_thickness), currPhi, _bZ, sup_back_sorting_policy, width, length, offset, z_offset, offset, dummy,-1,"VXDSenSuppportIntf_odd")) ;
+
+ // measurement plane defined as the middle of the sensitive volume
+ Add(new ILDParallelPlanarMeasLayer(silicon, silicon, (sensitive_distance+sensitive_thickness*0.5), currPhi, _bZ, measurement_plane_sorting_policy, width, length, offset, z_offset, offset, active, CellID, "VXDMeaslayer_odd")) ;
+
+ // sensitive air - sensitive boundary
+ Add(new ILDParallelPlanarMeasLayer(silicon, air, (sensitive_distance+sensitive_thickness), currPhi, _bZ, sen_back_sorting_policy, width, length, offset, z_offset, offset, dummy,-1,"VXDSenRear_odd")) ;
+
+
+ }
+ }
+ }
+
+ if (_vxd_Cryostat.exists) {
+ // build Cryostat according to mokka driver vxd04.cc
+
+ // beryllium shell
+
+ double rtub = _vxd_Cryostat.shellInnerR;
+ double halfz = _vxd_Cryostat.shelllHalfZ;
+
+ const double x0 = 0.0;
+ const double y0 = 0.0;
+ const double z0 = 0.0;
+
+
+ // beryllium cylinder inner wall
+ Add( new ILDCylinderMeasLayer(air, beryllium , rtub, halfz, x0, y0, z0, _bZ, dummy,-1,"VXDShellInnerWall" ) );
+
+ // streamlog_out( DEBUG0 ) << " *** adding " << "VXDShellInnerWall" << " Measurement layer using CellID: [ VXDShellInnerWall ] at R = " << rtub
+ // << " X0_in = " << air.GetRadLength() << " X0_out = " << beryllium.GetRadLength()
+ // << std::endl;
+
+
+ rtub += _vxd_Cryostat.shellThickness;
+
+ // beryllium cylinder outer wall
+ Add( new ILDCylinderMeasLayer(beryllium, air , rtub, halfz, x0, y0, z0, _bZ, dummy,-1,"VXDShellOuterWall" ) );
+
+ // streamlog_out( DEBUG0 ) << " *** adding " << "VXDShellOuterWall" << " Measurement layer using CellID: [ VXDShellOuterWall ] at R = " << rtub
+ // << " X0_in = " << beryllium.GetRadLength() << " X0_out = " << air.GetRadLength()
+ // << std::endl;
+
+
+ rtub = _vxd_Cryostat.alRadius;
+ halfz = _vxd_Cryostat.alHalfZ;
+
+
+ // aluminum cylinder inner wall
+ Add( new ILDCylinderMeasLayer(air, aluminium , _vxd_Cryostat.alRadius, halfz, x0, y0, z0, _bZ, dummy,-1,"VXDCryoAlInnerWall" ) );
+
+
+ // streamlog_out( DEBUG0 ) << " *** adding " << "VXDCryoAlInnerWall" << " Measurement layer using CellID: [ VXDCryoAlInnerWall ] at R = " << rtub
+ // << " X0_in = " << air.GetRadLength() << " X0_out = " << aluminium.GetRadLength()
+ // << std::endl;
+
+ rtub += 1.1 * _vxd_Cryostat.alThickness; // SJA:FIXME: increase the thickness as we don't have the information on the foam in the GEAR file.
+
+ // aluminum cylinder outer wall
+ Add( new ILDCylinderMeasLayer(aluminium, air , rtub, halfz, x0, y0, z0, _bZ, dummy,-1,"VXDCryoAlOuterWall" ) );
+
+
+ // streamlog_out( DEBUG0 ) << " *** adding " << "VXDCryoAlOuterWall" << " Measurement layer using CellID: [ VXDCryoAlOuterWall ] at R = " << rtub
+ // << " X0_in = " << aluminium.GetRadLength() << " X0_out = " << air.GetRadLength()
+ // << std::endl;
+
+
+ // aluminum endcaps
+
+
+ const double z_front_face = _vxd_Cryostat.alZEndCap;
+ const double z_rear_face = z_front_face + _vxd_Cryostat.alThickness;
+
+ double rOuter = _vxd_Cryostat.alRadius - 0.1 ; // make sure we don't collide with the aluminium cryostat cylinder
+ double rInner = _vxd_Cryostat.alInnerR ;
+
+
+ double eps_face = 1.0e-06 ; // offset for forwards and backwards
+ double eps_side = 1.0e-08 ; // offset for forwards and backwards
+
+ double sort_policy = rOuter ;
+
+
+ TVector3 xc_fwd(0.0, 0.0, z_front_face) ;
+ TVector3 normal_fwd(xc_fwd) ;
+ normal_fwd.SetMag(1.0) ;
+
+ // streamlog_out(DEBUG) << "VXDCryoAleEndCap created disk at " << xc_fwd.z() << " sort_policy = " << sort_policy << std::endl;
+
+ Add(new ILDDiscMeasLayer( air, aluminium, xc_fwd, normal_fwd, _bZ, sort_policy,
+ rInner, rOuter, dummy,-1, "VXDCryoAleEndCapDiscFrontFwd" ) );
+
+ sort_policy += eps_face;
+ xc_fwd.SetZ(z_rear_face);
+
+ Add(new ILDDiscMeasLayer( aluminium, air, xc_fwd, normal_fwd, _bZ, sort_policy,
+ rInner, rOuter, dummy,-1, "VXDCryoAleEndCapDiscBackFwd" ) );
+
+
+ TVector3 xc_bwd(0.0, 0.0, -z_front_face) ;
+ TVector3 normal_bwd(xc_bwd) ;
+ normal_bwd.SetMag(1.0) ;
+
+ // offset needed for rear disks
+ sort_policy = rOuter + eps_side ;
+
+ // streamlog_out(DEBUG) << "VXDCryoAleEndCap created disk at " << xc_bwd.z() << " sort_policy = " << sort_policy << std::endl;
+
+ Add(new ILDDiscMeasLayer( air, aluminium, xc_bwd, normal_bwd, _bZ, sort_policy,
+ rInner, rOuter, dummy,-1, "VXDCryoAleEndCapDiscFrontBwd" ) );
+
+ sort_policy += eps_face;
+ xc_fwd.SetZ(-z_rear_face);
+
+ Add(new ILDDiscMeasLayer( aluminium, air, xc_bwd, normal_bwd, _bZ, sort_policy,
+ rInner, rOuter, dummy,-1, "VXDCryoAleEndCapDiscFrontBwd" ) );
+
+
+
+ }
+
+ SetOwner();
+}
+
+
+
+
+void ILDVXDKalDetector::setupGearGeom( const gear::GearMgr& gearMgr, IGeoSvc* geoSvc){
+
+ const gear::VXDParameters& pVXDDetMainObject = gearMgr.getVXDParameters();
+ const gear::VXDParameters* pVXDDetMain2 = &pVXDDetMainObject;
+ const gear::ZPlanarParametersImpl* pVXDDetMain = geoSvc->getVXDParameters();
+ const gear::VXDLayerLayout& pVXDLayerLayout = pVXDDetMain->getVXDLayerLayout();
+ const gear::VXDLayerLayout& pVXDLayerLayout2 = pVXDDetMain2->getVXDLayerLayout();
+
+ _bZ = gearMgr.getBField().at( gear::Vector3D( 0.,0.,0.) ).z() ;
+
+ _nLayers = pVXDLayerLayout.getNLayers();
+ _VXDgeo.resize(_nLayers);
+
+ //SJA:FIXME: for now the support is taken as the same size the sensitive
+ // if this is not done then the exposed areas of the support would leave a carbon - air boundary,
+ // which if traversed in the reverse direction to the next boundary then the track will be propagated through carbon
+ // for a significant distance
+
+ for( int layer=0; layer < _nLayers; ++layer){
+ _VXDgeo[layer].nLadders = pVXDLayerLayout.getNLadders(layer);
+ _VXDgeo[layer].phi0 = pVXDLayerLayout.getPhi0(layer);
+ _VXDgeo[layer].dphi = 2*M_PI / _VXDgeo[layer].nLadders;
+ _VXDgeo[layer].senRMin = pVXDLayerLayout.getSensitiveDistance(layer);
+ _VXDgeo[layer].supRMin = pVXDLayerLayout.getLadderDistance(layer);
+ _VXDgeo[layer].length = pVXDLayerLayout.getSensitiveLength(layer) * 2.0 ; // note: gear for historical reasons uses the halflength
+ _VXDgeo[layer].width = pVXDLayerLayout.getSensitiveWidth(layer);
+ _VXDgeo[layer].offset = pVXDLayerLayout.getSensitiveOffset(layer);
+ _VXDgeo[layer].senThickness = pVXDLayerLayout.getSensitiveThickness(layer);
+ _VXDgeo[layer].supThickness = pVXDLayerLayout.getLadderThickness(layer);
+ std::cout << layer << ": " << _VXDgeo[layer].nLadders << " " << _VXDgeo[layer].phi0 << " " << _VXDgeo[layer].dphi << " " << _VXDgeo[layer].senRMin
+ << " " << _VXDgeo[layer].supRMin << " " << _VXDgeo[layer].length << " " << _VXDgeo[layer].width << " " << _VXDgeo[layer].offset
+ << " " << _VXDgeo[layer].senThickness << " " << _VXDgeo[layer].supThickness << std::endl;
+ std::cout << layer << ": " << pVXDLayerLayout2.getNLadders(layer) << " " << pVXDLayerLayout2.getPhi0(layer) << " " << 2*M_PI/pVXDLayerLayout2.getNLadders(layer)
+ << " " << pVXDLayerLayout2.getSensitiveDistance(layer) << " " << pVXDLayerLayout2.getLadderDistance(layer)
+ << " " << pVXDLayerLayout2.getSensitiveLength(layer)*2 << " " << pVXDLayerLayout2.getSensitiveWidth(layer)
+ << " " << pVXDLayerLayout2.getSensitiveOffset(layer) << " " << pVXDLayerLayout2.getSensitiveThickness(layer)
+ << " " << pVXDLayerLayout2.getLadderThickness(layer) << std::endl;
+ }
+ // by default, we put the measurement surface in the middle of the sensitive
+ // layer, this can optionally be changed, e.g. in the case of the FPCCD where the
+ // epitaxial layer is 15 mu thick (in a 50 mu wafer)
+ _relative_position_of_measurement_surface = 0.5 ;
+
+ try {
+
+ _relative_position_of_measurement_surface = pVXDDetMain->getDoubleVal( "relative_position_of_measurement_surface" );
+
+ // streamlog_out(DEBUG) << " ILDVXDKalDetector::setupGearGeom: relative_position_of_measurement_surface parameter is provided : " << _relative_position_of_measurement_surface << std::endl ;
+
+ } catch (gear::UnknownParameterException& e) {}
+
+ // Cryostat
+ try {
+
+ //const gear::GearParameters& pVXDInfraObject = gearMgr.getGearParameters("VXDInfra");
+ //const gear::GearParameters* pVXDInfra = &pVXDInfraObject;
+ //change Gear to GeoSvc
+ //const gear::GearParametersImpl* pVXDInfra = geoSvc->getDetParameters("VXDInfra");
+ //_vxd_Cryostat.alRadius = pVXDInfra->getDoubleVal( "CryostatAlRadius" );
+ //_vxd_Cryostat.alThickness = pVXDInfra->getDoubleVal( "CryostatAlThickness" );
+ //_vxd_Cryostat.alInnerR = pVXDInfra->getDoubleVal( "CryostatAlInnerR" );
+ //_vxd_Cryostat.alZEndCap = pVXDInfra->getDoubleVal( "CryostatAlZEndCap" );
+ //_vxd_Cryostat.alHalfZ = pVXDInfra->getDoubleVal( "CryostatAlHalfZ" );
+ //change GearParametersImpl to get directly
+ //const std::map<std::string,double>& vxdInfra = geoSvc->getDetParameters("VXDInfra");
+ _vxd_Cryostat.alRadius = geoSvc->getDetParameter("VXDInfra","CryostatAlRadius");
+ _vxd_Cryostat.alThickness = geoSvc->getDetParameter("VXDInfra","CryostatAlThickness");
+ _vxd_Cryostat.alInnerR = geoSvc->getDetParameter("VXDInfra","CryostatAlInnerR");
+ _vxd_Cryostat.alZEndCap = geoSvc->getDetParameter("VXDInfra","CryostatAlZEndCap");
+ _vxd_Cryostat.alHalfZ = geoSvc->getDetParameter("VXDInfra","CryostatAlHalfZ");
+
+ _vxd_Cryostat.shellInnerR = pVXDDetMain->getShellInnerRadius();
+ _vxd_Cryostat.shellThickness = pVXDDetMain->getShellOuterRadius() - _vxd_Cryostat.shellInnerR;
+ _vxd_Cryostat.shelllHalfZ = pVXDDetMain->getShellHalfLength();
+
+ _vxd_Cryostat.exists = true;
+ }
+ //catch (gear::UnknownParameterException& e) {
+ catch (std::runtime_error& e) {
+ //streamlog_out( WARNING ) << "ILDVXDKalDetector Cryostat values not found in GEAR file " << std::endl ;
+ std::cout << e.what() << std::endl ;
+ _vxd_Cryostat.exists = false;
+
+ }
+
+}
diff --git a/Utilities/KalDet/src/ild/vxd/ILDVXDKalDetector.h b/Utilities/KalDet/src/ild/vxd/ILDVXDKalDetector.h
new file mode 100644
index 0000000000000000000000000000000000000000..c0205e149f55b4ca2340cdfc7549b17fd020cdbc
--- /dev/null
+++ b/Utilities/KalDet/src/ild/vxd/ILDVXDKalDetector.h
@@ -0,0 +1,73 @@
+#ifndef __ILDVXDKALDETECTOR__
+#define __ILDVXDKALDETECTOR__
+
+/** Ladder based VXD to be used for ILD DBD studies
+ *
+ * @author S.Aplin DESY
+ */
+
+#include "kaltest/TVKalDetector.h"
+
+#include "TMath.h"
+
+class TNode;
+class IGeoSvc;
+
+namespace gear{
+ class GearMgr ;
+}
+
+
+class ILDVXDKalDetector : public TVKalDetector {
+
+public:
+
+ ILDVXDKalDetector( const gear::GearMgr& gearMgr, IGeoSvc* geoSvc);
+
+
+private:
+
+ void setupGearGeom( const gear::GearMgr& gearMgr, IGeoSvc* geoSvc) ;
+
+ int _nLayers ;
+ double _bZ ;
+
+ double _relative_position_of_measurement_surface ;
+
+ struct VXD_Layer {
+ int nLadders;
+ double phi0;
+ double dphi;
+ double senRMin;
+ double supRMin;
+ double length;
+ double width;
+ double offset;
+ double senThickness;
+ double supThickness;
+ };
+ std::vector<VXD_Layer> _VXDgeo;
+
+
+ struct VXD_Cryostat {
+ double alRadius;
+ double alThickness;
+ double alInnerR;
+ double alZEndCap;
+ double alHalfZ;
+ double shellRadius;
+ double shellThickness;
+ double shellInnerR;
+ double shellZEndCap;
+ double shelllHalfZ;
+
+ bool exists;
+ };
+
+ VXD_Cryostat _vxd_Cryostat;
+
+};
+
+
+
+#endif
diff --git a/Utilities/KalDet/src/kern/EXVKalDetector.cxx b/Utilities/KalDet/src/kern/EXVKalDetector.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..d65bb32c2ea32d5fa073e3412e4ed032e6d546ba
--- /dev/null
+++ b/Utilities/KalDet/src/kern/EXVKalDetector.cxx
@@ -0,0 +1,34 @@
+//*************************************************************************
+//* ======================
+//* EXVKalDetector Class
+//* ======================
+//*
+//* (Description)
+//* Abstract detector class for Kalman filter
+//* (Requires)
+//* TVKalDetector
+//* (Provides)
+//* class EXVKalDetector
+//* (Update Recored)
+//* 2009/11/23 K.Ikematsu Derived from KalTest/examples/kaltest/
+//* hybrid/kern/EXVKalDetector.cxx
+//* 2010/11/17 K.Fujii Changed unit system to (mm, nsec, T)
+//* from (cm, nsec, kG)
+//*
+//* $Id: EXVKalDetector.cxx,v 1.1.1.1 2009-11-24 00:13:59 ikematsu Exp $
+//*************************************************************************
+//
+#include "EXVKalDetector.h"
+
+ClassImp(EXVKalDetector)
+
+EXVKalDetector::EXVKalDetector(Double_t bField, Int_t m)
+ : TVKalDetector(m),
+ fIsPowerOn(kTRUE),
+ fBfield(bField)
+{
+}
+
+EXVKalDetector::~EXVKalDetector()
+{
+}
diff --git a/Utilities/KalDet/src/kern/EXVKalDetector.h b/Utilities/KalDet/src/kern/EXVKalDetector.h
new file mode 100644
index 0000000000000000000000000000000000000000..f7a8413a462bf37f1f51da528a521537d815bf34
--- /dev/null
+++ b/Utilities/KalDet/src/kern/EXVKalDetector.h
@@ -0,0 +1,68 @@
+#ifndef EXVKALDETECTOR_H
+#define EXVKALDETECTOR_H
+//*************************************************************************
+//* ======================
+//* EXVKalDetector Class
+//* ======================
+//*
+//* (Description)
+//* Abstract detector class for Kalman filter
+//* (Requires)
+//* TVKalDetector
+//* (Provides)
+//* class EXVKalDetector
+//* (Update Recored)
+//* 2009/11/23 K.Ikematsu Derived from KalTest/examples/kaltest/
+//* hybrid/kern/EXVKalDetector.h
+//*
+//* $Id: EXVKalDetector.h,v 1.1.1.1 2009-11-24 00:13:59 ikematsu Exp $
+//*************************************************************************
+//
+#include <TVector3.h>
+#include <kaltest/TVKalDetector.h>
+#include <kaltest/TAttDrawable.h>
+
+class TNode;
+
+/**
+ * Base class to make a detector drawable, add a magnetic field,
+ * a power switch (whatever the use may be).
+ *
+ * Killenb: I removed the TAttDrawable for the moment. The TNode pointer
+ * stuff and the implementation of Draw belong to the TAttDrawable anyway. So if
+ * the drawability is needed move it to TAttDrawable and just inherit from it.
+ *
+ * \deprecated EXVKalDetector
+ */
+//class EXVKalDetector : public TVKalDetector, public TAttDrawable {
+class EXVKalDetector : public TVKalDetector {
+
+public:
+ EXVKalDetector(Double_t bField, Int_t m = 100);
+ virtual ~EXVKalDetector();
+
+ /// Return whether the power is on. Currently hard coded to true.
+ inline virtual Bool_t IsPowerOn() const { return true; }
+
+ /// Turn the power on. Currently ignored.
+ inline virtual void PowerOn () { fIsPowerOn = kTRUE; }
+
+ /// Turn the power off. Currently ignored.
+ inline virtual void PowerOff () { fIsPowerOn = kFALSE; }
+
+ /// Returns a single double value with a 3D point as an input.
+ /// Completely unphysical interface. Either the magnetic field varies with the position,
+ /// in which case you need a three-dimensional return value, or B can be desrcibed as single
+ /// value, which means it is homogeneous and thus indepenent from the position.
+ /// Currently it does the only reasonable thing: It ignores the argument and returns the
+ /// constant value given in the constructor.
+ virtual Double_t GetBfield (const TVector3 &xx = TVector3(0.,0.,0.)) const
+ { return fBfield; }
+
+protected:
+ Bool_t fIsPowerOn; // power status
+ Double_t fBfield; // magnetic field [T]
+
+ ClassDef(EXVKalDetector, 1) // Abstract measurement layer class
+};
+#endif
diff --git a/Utilities/KalDet/src/kern/EXVMeasLayer.cxx b/Utilities/KalDet/src/kern/EXVMeasLayer.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..3ce17f2d16d4b02833da68da3489b1b585ed492b
--- /dev/null
+++ b/Utilities/KalDet/src/kern/EXVMeasLayer.cxx
@@ -0,0 +1,39 @@
+//*************************************************************************
+//* ====================
+//* EXVMeasLayer Class
+//* ====================
+//*
+//* (Description)
+//* Abstract measurement layer class used by TVTrackHit
+//* (Requires)
+//* TVMeasLayer
+//* (Provides)
+//* class EXVMeasLayer
+//* (Update Recored)
+//* 2009/11/23 K.Ikematsu Derived from KalTest/examples/kaltest/
+//* hybrid/kern/EXVMeasLayer.cxx
+//*
+//* $Id: EXVMeasLayer.cxx,v 1.1.1.1 2009-11-24 00:13:59 ikematsu Exp $
+//*************************************************************************
+//
+#include "EXVMeasLayer.h"
+#include <TNode.h>
+
+Bool_t EXVMeasLayer::kActive = kTRUE;
+Bool_t EXVMeasLayer::kDummy = kFALSE;
+
+ClassImp(EXVMeasLayer)
+
+EXVMeasLayer::EXVMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ Bool_t isactive,
+ const Char_t *name)
+ : TVMeasLayer(min, mout, isactive),
+ fName(name),
+ fNodePtr(0)
+{
+}
+
+EXVMeasLayer::~EXVMeasLayer()
+{
+}
diff --git a/Utilities/KalDet/src/kern/EXVMeasLayer.h b/Utilities/KalDet/src/kern/EXVMeasLayer.h
new file mode 100644
index 0000000000000000000000000000000000000000..db456868c0886921699599834ace276b7d54d426
--- /dev/null
+++ b/Utilities/KalDet/src/kern/EXVMeasLayer.h
@@ -0,0 +1,60 @@
+#ifndef EXVMEASLAYER_H
+#define EXVMEASLAYER_H
+//*************************************************************************
+//* ====================
+//* EXVMeasLayer Class
+//* ====================
+//*
+//* (Description)
+//* Abstract measurement layer class used by TVTrackHit
+//* (Requires)
+//* TVMeasLayer
+//* (Provides)
+//* class EXVMeasLayer
+//* (Update Recored)
+//* 2009/11/23 K.Ikematsu Derived from KalTest/examples/kaltest/
+//* hybrid/kern/EXVMeasLayer.h
+//*
+//* $Id: EXVMeasLayer.h,v 1.1.1.1 2009-11-24 00:13:59 ikematsu Exp $
+//*************************************************************************
+//
+#include <TVector3.h>
+#include <kaltest/TKalMatrix.h>
+#include <kaltest/TCylinder.h>
+#include <kaltest/TVMeasLayer.h>
+#include <kaltest/TAttDrawable.h>
+#include <kaltest/KalTrackDim.h>
+#include <TString.h>
+
+class TVTrackHit;
+#include <TNode.h>
+
+class EXVMeasLayer : public TVMeasLayer, public TAttDrawable {
+
+public:
+ static Bool_t kActive;
+ static Bool_t kDummy;
+
+ // Ctors and Dtor
+
+ EXVMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ Bool_t type = EXVMeasLayer::kActive,
+ const Char_t *name = "MeasL");
+ virtual ~EXVMeasLayer();
+
+ virtual void ProcessHit(const TVector3 &xx,
+ TObjArray &hits) const = 0;
+
+ inline TString GetMLName () const { return fName; }
+ inline TNode *GetNodePtr() const { return fNodePtr; }
+
+ inline void SetNodePtr(TNode *nodep) { fNodePtr = nodep; }
+
+private:
+ TString fName; // layer name
+ TNode *fNodePtr; // node pointer
+
+ ClassDef(EXVMeasLayer, 1) // Abstract measurement layer class
+};
+#endif
diff --git a/Utilities/KalDet/src/kern/LinkDef.h b/Utilities/KalDet/src/kern/LinkDef.h
new file mode 100644
index 0000000000000000000000000000000000000000..e4f3a1c5692a6c07b66ae8a68e810783672a6ea4
--- /dev/null
+++ b/Utilities/KalDet/src/kern/LinkDef.h
@@ -0,0 +1,10 @@
+#ifdef __CINT__
+
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+
+#pragma link C++ class EXVKalDetector+;
+#pragma link C++ class EXVMeasLayer+;
+
+#endif
diff --git a/Utilities/KalDet/src/lctpc/doc/Doxyfile_html b/Utilities/KalDet/src/lctpc/doc/Doxyfile_html
new file mode 100644
index 0000000000000000000000000000000000000000..5d8d0456bda50333081f240ce26fc53a21ce4f55
--- /dev/null
+++ b/Utilities/KalDet/src/lctpc/doc/Doxyfile_html
@@ -0,0 +1,1790 @@
+# Doxyfile 1.7.5.1
+
+# This file describes the settings to be used by the documentation system
+# doxygen (www.doxygen.org) for a project
+#
+# All text after a hash (#) is considered a comment and will be ignored
+# The format is:
+# TAG = value [value, ...]
+# For lists items can also be appended using:
+# TAG += value [value, ...]
+# Values that contain spaces should be placed between quotes (" ")
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+
+# This tag specifies the encoding used for all characters in the config file
+# that follow. The default is UTF-8 which is also the encoding used for all
+# text before the first occurrence of this tag. Doxygen uses libiconv (or the
+# iconv built into libc) for the transcoding. See
+# http://www.gnu.org/software/libiconv for the list of possible encodings.
+
+DOXYFILE_ENCODING = UTF-8
+
+# The PROJECT_NAME tag is a single word (or sequence of words) that should
+# identify the project. Note that if you do not use Doxywizard you need
+# to put quotes around the project name if it contains spaces.
+
+PROJECT_NAME = GearTPC
+
+# The PROJECT_NUMBER tag can be used to enter a project or revision number.
+# This could be handy for archiving the generated documentation or
+# if some version control system is used.
+
+PROJECT_NUMBER =
+
+# Using the PROJECT_BRIEF tag one can provide an optional one line description
+# for a project that appears at the top of each page and should give viewer
+# a quick idea about the purpose of the project. Keep the description short.
+
+PROJECT_BRIEF =
+
+# With the PROJECT_LOGO tag one can specify an logo or icon that is
+# included in the documentation. The maximum height of the logo should not
+# exceed 55 pixels and the maximum width should not exceed 200 pixels.
+# Doxygen will copy the logo to the output directory.
+
+PROJECT_LOGO =
+
+# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
+# base path where the generated documentation will be put.
+# If a relative path is entered, it will be relative to the location
+# where doxygen was started. If left blank the current directory will be used.
+
+OUTPUT_DIRECTORY = .
+
+# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create
+# 4096 sub-directories (in 2 levels) under the output directory of each output
+# format and will distribute the generated files over these directories.
+# Enabling this option can be useful when feeding doxygen a huge amount of
+# source files, where putting all generated files in the same directory would
+# otherwise cause performance problems for the file system.
+
+CREATE_SUBDIRS = NO
+
+# The OUTPUT_LANGUAGE tag is used to specify the language in which all
+# documentation generated by doxygen is written. Doxygen will use this
+# information to generate all constant output in the proper language.
+# The default language is English, other supported languages are:
+# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional,
+# Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German,
+# Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English
+# messages), Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian,
+# Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrillic, Slovak,
+# Slovene, Spanish, Swedish, Ukrainian, and Vietnamese.
+
+OUTPUT_LANGUAGE = English
+
+# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will
+# include brief member descriptions after the members that are listed in
+# the file and class documentation (similar to JavaDoc).
+# Set to NO to disable this.
+
+BRIEF_MEMBER_DESC = YES
+
+# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend
+# the brief description of a member or function before the detailed description.
+# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
+# brief descriptions will be completely suppressed.
+
+REPEAT_BRIEF = YES
+
+# This tag implements a quasi-intelligent brief description abbreviator
+# that is used to form the text in various listings. Each string
+# in this list, if found as the leading text of the brief description, will be
+# stripped from the text and the result after processing the whole list, is
+# used as the annotated text. Otherwise, the brief description is used as-is.
+# If left blank, the following values are used ("$name" is automatically
+# replaced with the name of the entity): "The $name class" "The $name widget"
+# "The $name file" "is" "provides" "specifies" "contains"
+# "represents" "a" "an" "the"
+
+ABBREVIATE_BRIEF = "The $name class" \
+ "The $name widget" \
+ "The $name file" \
+ is \
+ provides \
+ specifies \
+ contains \
+ represents \
+ a \
+ an \
+ the
+
+# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
+# Doxygen will generate a detailed section even if there is only a brief
+# description.
+
+ALWAYS_DETAILED_SEC = NO
+
+# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
+# inherited members of a class in the documentation of that class as if those
+# members were ordinary class members. Constructors, destructors and assignment
+# operators of the base classes will not be shown.
+
+INLINE_INHERITED_MEMB = NO
+
+# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full
+# path before files name in the file list and in the header files. If set
+# to NO the shortest path that makes the file name unique will be used.
+
+FULL_PATH_NAMES = NO
+
+# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag
+# can be used to strip a user-defined part of the path. Stripping is
+# only done if one of the specified strings matches the left-hand part of
+# the path. The tag can be used to show relative paths in the file list.
+# If left blank the directory from which doxygen is run is used as the
+# path to strip.
+
+STRIP_FROM_PATH =
+
+# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of
+# the path mentioned in the documentation of a class, which tells
+# the reader which header file to include in order to use a class.
+# If left blank only the name of the header file containing the class
+# definition is used. Otherwise one should specify the include paths that
+# are normally passed to the compiler using the -I flag.
+
+STRIP_FROM_INC_PATH =
+
+# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter
+# (but less readable) file names. This can be useful if your file system
+# doesn't support long names like on DOS, Mac, or CD-ROM.
+
+SHORT_NAMES = NO
+
+# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen
+# will interpret the first line (until the first dot) of a JavaDoc-style
+# comment as the brief description. If set to NO, the JavaDoc
+# comments will behave just like regular Qt-style comments
+# (thus requiring an explicit @brief command for a brief description.)
+
+JAVADOC_AUTOBRIEF = YES
+
+# If the QT_AUTOBRIEF tag is set to YES then Doxygen will
+# interpret the first line (until the first dot) of a Qt-style
+# comment as the brief description. If set to NO, the comments
+# will behave just like regular Qt-style comments (thus requiring
+# an explicit \brief command for a brief description.)
+
+QT_AUTOBRIEF = YES
+
+# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen
+# treat a multi-line C++ special comment block (i.e. a block of //! or ///
+# comments) as a brief description. This used to be the default behaviour.
+# The new default is to treat a multi-line C++ comment block as a detailed
+# description. Set this tag to YES if you prefer the old behaviour instead.
+
+MULTILINE_CPP_IS_BRIEF = NO
+
+# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented
+# member inherits the documentation from any documented member that it
+# re-implements.
+
+INHERIT_DOCS = YES
+
+# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce
+# a new page for each member. If set to NO, the documentation of a member will
+# be part of the file/class/namespace that contains it.
+
+SEPARATE_MEMBER_PAGES = NO
+
+# The TAB_SIZE tag can be used to set the number of spaces in a tab.
+# Doxygen uses this value to replace tabs by spaces in code fragments.
+
+TAB_SIZE = 8
+
+# This tag can be used to specify a number of aliases that acts
+# as commands in the documentation. An alias has the form "name=value".
+# For example adding "sideeffect=\par Side Effects:\n" will allow you to
+# put the command \sideeffect (or @sideeffect) in the documentation, which
+# will result in a user-defined paragraph with heading "Side Effects:".
+# You can put \n's in the value part of an alias to insert newlines.
+
+ALIASES =
+
+# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C
+# sources only. Doxygen will then generate output that is more tailored for C.
+# For instance, some of the names that are used will be different. The list
+# of all members will be omitted, etc.
+
+OPTIMIZE_OUTPUT_FOR_C = NO
+
+# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java
+# sources only. Doxygen will then generate output that is more tailored for
+# Java. For instance, namespaces will be presented as packages, qualified
+# scopes will look different, etc.
+
+OPTIMIZE_OUTPUT_JAVA = NO
+
+# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
+# sources only. Doxygen will then generate output that is more tailored for
+# Fortran.
+
+OPTIMIZE_FOR_FORTRAN = NO
+
+# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
+# sources. Doxygen will then generate output that is tailored for
+# VHDL.
+
+OPTIMIZE_OUTPUT_VHDL = NO
+
+# Doxygen selects the parser to use depending on the extension of the files it
+# parses. With this tag you can assign which parser to use for a given extension.
+# Doxygen has a built-in mapping, but you can override or extend it using this
+# tag. The format is ext=language, where ext is a file extension, and language
+# is one of the parsers supported by doxygen: IDL, Java, Javascript, CSharp, C,
+# C++, D, PHP, Objective-C, Python, Fortran, VHDL, C, C++. For instance to make
+# doxygen treat .inc files as Fortran files (default is PHP), and .f files as C
+# (default is Fortran), use: inc=Fortran f=C. Note that for custom extensions
+# you also need to set FILE_PATTERNS otherwise the files are not read by doxygen.
+
+EXTENSION_MAPPING =
+
+# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
+# to include (a tag file for) the STL sources as input, then you should
+# set this tag to YES in order to let doxygen match functions declarations and
+# definitions whose arguments contain STL classes (e.g. func(std::string); v.s.
+# func(std::string) {}). This also makes the inheritance and collaboration
+# diagrams that involve STL classes more complete and accurate.
+
+BUILTIN_STL_SUPPORT = NO
+
+# If you use Microsoft's C++/CLI language, you should set this option to YES to
+# enable parsing support.
+
+CPP_CLI_SUPPORT = NO
+
+# Set the SIP_SUPPORT tag to YES if your project consists of sip sources only.
+# Doxygen will parse them like normal C++ but will assume all classes use public
+# instead of private inheritance when no explicit protection keyword is present.
+
+SIP_SUPPORT = NO
+
+# For Microsoft's IDL there are propget and propput attributes to indicate getter
+# and setter methods for a property. Setting this option to YES (the default)
+# will make doxygen replace the get and set methods by a property in the
+# documentation. This will only work if the methods are indeed getting or
+# setting a simple type. If this is not the case, or you want to show the
+# methods anyway, you should set this option to NO.
+
+IDL_PROPERTY_SUPPORT = YES
+
+# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
+# tag is set to YES, then doxygen will reuse the documentation of the first
+# member in the group (if any) for the other members of the group. By default
+# all members of a group must be documented explicitly.
+
+DISTRIBUTE_GROUP_DOC = NO
+
+# Set the SUBGROUPING tag to YES (the default) to allow class member groups of
+# the same type (for instance a group of public functions) to be put as a
+# subgroup of that type (e.g. under the Public Functions section). Set it to
+# NO to prevent subgrouping. Alternatively, this can be done per class using
+# the \nosubgrouping command.
+
+SUBGROUPING = YES
+
+# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and
+# unions are shown inside the group in which they are included (e.g. using
+# @ingroup) instead of on a separate page (for HTML and Man pages) or
+# section (for LaTeX and RTF).
+
+INLINE_GROUPED_CLASSES = NO
+
+# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and
+# unions with only public data fields will be shown inline in the documentation
+# of the scope in which they are defined (i.e. file, namespace, or group
+# documentation), provided this scope is documented. If set to NO (the default),
+# structs, classes, and unions are shown on a separate page (for HTML and Man
+# pages) or section (for LaTeX and RTF).
+
+INLINE_SIMPLE_STRUCTS = NO
+
+# When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum
+# is documented as struct, union, or enum with the name of the typedef. So
+# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
+# with name TypeT. When disabled the typedef will appear as a member of a file,
+# namespace, or class. And the struct will be named TypeS. This can typically
+# be useful for C code in case the coding convention dictates that all compound
+# types are typedef'ed and only the typedef is referenced, never the tag name.
+
+TYPEDEF_HIDES_STRUCT = NO
+
+# The SYMBOL_CACHE_SIZE determines the size of the internal cache use to
+# determine which symbols to keep in memory and which to flush to disk.
+# When the cache is full, less often used symbols will be written to disk.
+# For small to medium size projects (<1000 input files) the default value is
+# probably good enough. For larger projects a too small cache size can cause
+# doxygen to be busy swapping symbols to and from disk most of the time
+# causing a significant performance penalty.
+# If the system has enough physical memory increasing the cache will improve the
+# performance by keeping more symbols in memory. Note that the value works on
+# a logarithmic scale so increasing the size by one will roughly double the
+# memory usage. The cache size is given by this formula:
+# 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0,
+# corresponding to a cache size of 2^16 = 65536 symbols
+
+SYMBOL_CACHE_SIZE = 0
+
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+
+# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
+# documentation are documented, even if no documentation was available.
+# Private class members and static file members will be hidden unless
+# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
+
+EXTRACT_ALL = YES
+
+# If the EXTRACT_PRIVATE tag is set to YES all private members of a class
+# will be included in the documentation.
+
+EXTRACT_PRIVATE = NO
+
+# If the EXTRACT_STATIC tag is set to YES all static members of a file
+# will be included in the documentation.
+
+EXTRACT_STATIC = NO
+
+# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs)
+# defined locally in source files will be included in the documentation.
+# If set to NO only classes defined in header files are included.
+
+EXTRACT_LOCAL_CLASSES = YES
+
+# This flag is only useful for Objective-C code. When set to YES local
+# methods, which are defined in the implementation section but not in
+# the interface are included in the documentation.
+# If set to NO (the default) only methods in the interface are included.
+
+EXTRACT_LOCAL_METHODS = NO
+
+# If this flag is set to YES, the members of anonymous namespaces will be
+# extracted and appear in the documentation as a namespace called
+# 'anonymous_namespace{file}', where file will be replaced with the base
+# name of the file that contains the anonymous namespace. By default
+# anonymous namespaces are hidden.
+
+EXTRACT_ANON_NSPACES = NO
+
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all
+# undocumented members of documented classes, files or namespaces.
+# If set to NO (the default) these members will be included in the
+# various overviews, but no documentation section is generated.
+# This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_MEMBERS = NO
+
+# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all
+# undocumented classes that are normally visible in the class hierarchy.
+# If set to NO (the default) these classes will be included in the various
+# overviews. This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_CLASSES = NO
+
+# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all
+# friend (class|struct|union) declarations.
+# If set to NO (the default) these declarations will be included in the
+# documentation.
+
+HIDE_FRIEND_COMPOUNDS = NO
+
+# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any
+# documentation blocks found inside the body of a function.
+# If set to NO (the default) these blocks will be appended to the
+# function's detailed documentation block.
+
+HIDE_IN_BODY_DOCS = NO
+
+# The INTERNAL_DOCS tag determines if documentation
+# that is typed after a \internal command is included. If the tag is set
+# to NO (the default) then the documentation will be excluded.
+# Set it to YES to include the internal documentation.
+
+INTERNAL_DOCS = NO
+
+# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate
+# file names in lower-case letters. If set to YES upper-case letters are also
+# allowed. This is useful if you have classes or files whose names only differ
+# in case and if your file system supports case sensitive file names. Windows
+# and Mac users are advised to set this option to NO.
+
+CASE_SENSE_NAMES = NO
+
+# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen
+# will show members with their full class and namespace scopes in the
+# documentation. If set to YES the scope will be hidden.
+
+HIDE_SCOPE_NAMES = NO
+
+# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen
+# will put a list of the files that are included by a file in the documentation
+# of that file.
+
+SHOW_INCLUDE_FILES = YES
+
+# If the FORCE_LOCAL_INCLUDES tag is set to YES then Doxygen
+# will list include files with double quotes in the documentation
+# rather than with sharp brackets.
+
+FORCE_LOCAL_INCLUDES = NO
+
+# If the INLINE_INFO tag is set to YES (the default) then a tag [inline]
+# is inserted in the documentation for inline members.
+
+INLINE_INFO = YES
+
+# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen
+# will sort the (detailed) documentation of file and class members
+# alphabetically by member name. If set to NO the members will appear in
+# declaration order.
+
+SORT_MEMBER_DOCS = YES
+
+# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the
+# brief documentation of file, namespace and class members alphabetically
+# by member name. If set to NO (the default) the members will appear in
+# declaration order.
+
+SORT_BRIEF_DOCS = NO
+
+# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen
+# will sort the (brief and detailed) documentation of class members so that
+# constructors and destructors are listed first. If set to NO (the default)
+# the constructors will appear in the respective orders defined by
+# SORT_MEMBER_DOCS and SORT_BRIEF_DOCS.
+# This tag will be ignored for brief docs if SORT_BRIEF_DOCS is set to NO
+# and ignored for detailed docs if SORT_MEMBER_DOCS is set to NO.
+
+SORT_MEMBERS_CTORS_1ST = NO
+
+# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the
+# hierarchy of group names into alphabetical order. If set to NO (the default)
+# the group names will appear in their defined order.
+
+SORT_GROUP_NAMES = NO
+
+# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be
+# sorted by fully-qualified names, including namespaces. If set to
+# NO (the default), the class list will be sorted only by class name,
+# not including the namespace part.
+# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
+# Note: This option applies only to the class list, not to the
+# alphabetical list.
+
+SORT_BY_SCOPE_NAME = NO
+
+# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to
+# do proper type resolution of all parameters of a function it will reject a
+# match between the prototype and the implementation of a member function even
+# if there is only one candidate or it is obvious which candidate to choose
+# by doing a simple string match. By disabling STRICT_PROTO_MATCHING doxygen
+# will still accept a match between prototype and implementation in such cases.
+
+STRICT_PROTO_MATCHING = NO
+
+# The GENERATE_TODOLIST tag can be used to enable (YES) or
+# disable (NO) the todo list. This list is created by putting \todo
+# commands in the documentation.
+
+GENERATE_TODOLIST = YES
+
+# The GENERATE_TESTLIST tag can be used to enable (YES) or
+# disable (NO) the test list. This list is created by putting \test
+# commands in the documentation.
+
+GENERATE_TESTLIST = YES
+
+# The GENERATE_BUGLIST tag can be used to enable (YES) or
+# disable (NO) the bug list. This list is created by putting \bug
+# commands in the documentation.
+
+GENERATE_BUGLIST = YES
+
+# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or
+# disable (NO) the deprecated list. This list is created by putting
+# \deprecated commands in the documentation.
+
+GENERATE_DEPRECATEDLIST= YES
+
+# The ENABLED_SECTIONS tag can be used to enable conditional
+# documentation sections, marked by \if sectionname ... \endif.
+
+ENABLED_SECTIONS =
+
+# The MAX_INITIALIZER_LINES tag determines the maximum number of lines
+# the initial value of a variable or macro consists of for it to appear in
+# the documentation. If the initializer consists of more lines than specified
+# here it will be hidden. Use a value of 0 to hide initializers completely.
+# The appearance of the initializer of individual variables and macros in the
+# documentation can be controlled using \showinitializer or \hideinitializer
+# command in the documentation regardless of this setting.
+
+MAX_INITIALIZER_LINES = 30
+
+# Set the SHOW_USED_FILES tag to NO to disable the list of files generated
+# at the bottom of the documentation of classes and structs. If set to YES the
+# list will mention the files that were used to generate the documentation.
+
+SHOW_USED_FILES = YES
+
+# If the sources in your project are distributed over multiple directories
+# then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy
+# in the documentation. The default is NO.
+
+SHOW_DIRECTORIES = NO
+
+# Set the SHOW_FILES tag to NO to disable the generation of the Files page.
+# This will remove the Files entry from the Quick Index and from the
+# Folder Tree View (if specified). The default is YES.
+
+SHOW_FILES = YES
+
+# Set the SHOW_NAMESPACES tag to NO to disable the generation of the
+# Namespaces page. This will remove the Namespaces entry from the Quick Index
+# and from the Folder Tree View (if specified). The default is YES.
+
+SHOW_NAMESPACES = YES
+
+# The FILE_VERSION_FILTER tag can be used to specify a program or script that
+# doxygen should invoke to get the current version for each file (typically from
+# the version control system). Doxygen will invoke the program by executing (via
+# popen()) the command <command> <input-file>, where <command> is the value of
+# the FILE_VERSION_FILTER tag, and <input-file> is the name of an input file
+# provided by doxygen. Whatever the program writes to standard output
+# is used as the file version. See the manual for examples.
+
+FILE_VERSION_FILTER =
+
+# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
+# by doxygen. The layout file controls the global structure of the generated
+# output files in an output format independent way. The create the layout file
+# that represents doxygen's defaults, run doxygen with the -l option.
+# You can optionally specify a file name after the option, if omitted
+# DoxygenLayout.xml will be used as the name of the layout file.
+
+LAYOUT_FILE =
+
+# The CITE_BIB_FILES tag can be used to specify one or more bib files
+# containing the references data. This must be a list of .bib files. The
+# .bib extension is automatically appended if omitted. Using this command
+# requires the bibtex tool to be installed. See also
+# http://en.wikipedia.org/wiki/BibTeX for more info. For LaTeX the style
+# of the bibliography can be controlled using LATEX_BIB_STYLE.
+
+CITE_BIB_FILES =
+
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+
+# The QUIET tag can be used to turn on/off the messages that are generated
+# by doxygen. Possible values are YES and NO. If left blank NO is used.
+
+QUIET = NO
+
+# The WARNINGS tag can be used to turn on/off the warning messages that are
+# generated by doxygen. Possible values are YES and NO. If left blank
+# NO is used.
+
+WARNINGS = YES
+
+# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings
+# for undocumented members. If EXTRACT_ALL is set to YES then this flag will
+# automatically be disabled.
+
+WARN_IF_UNDOCUMENTED = YES
+
+# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for
+# potential errors in the documentation, such as not documenting some
+# parameters in a documented function, or documenting parameters that
+# don't exist or using markup commands wrongly.
+
+WARN_IF_DOC_ERROR = YES
+
+# The WARN_NO_PARAMDOC option can be enabled to get warnings for
+# functions that are documented, but have no documentation for their parameters
+# or return value. If set to NO (the default) doxygen will only warn about
+# wrong or incomplete parameter documentation, but not about the absence of
+# documentation.
+
+WARN_NO_PARAMDOC = NO
+
+# The WARN_FORMAT tag determines the format of the warning messages that
+# doxygen can produce. The string should contain the $file, $line, and $text
+# tags, which will be replaced by the file and line number from which the
+# warning originated and the warning text. Optionally the format may contain
+# $version, which will be replaced by the version of the file (if it could
+# be obtained via FILE_VERSION_FILTER)
+
+WARN_FORMAT = "$file:$line: $text"
+
+# The WARN_LOGFILE tag can be used to specify a file to which warning
+# and error messages should be written. If left blank the output is written
+# to stderr.
+
+WARN_LOGFILE =
+
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+
+# The INPUT tag can be used to specify the files and/or directories that contain
+# documented source files. You may enter file names like "myfile.cpp" or
+# directories like "/usr/src/myproject". Separate the files or directories
+# with spaces.
+
+INPUT = ../gearTPC \
+ GearTPC_mainpage.h
+
+# This tag can be used to specify the character encoding of the source files
+# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is
+# also the default input encoding. Doxygen uses libiconv (or the iconv built
+# into libc) for the transcoding. See http://www.gnu.org/software/libiconv for
+# the list of possible encodings.
+
+INPUT_ENCODING = UTF-8
+
+# If the value of the INPUT tag contains directories, you can use the
+# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
+# and *.h) to filter out the source-files in the directories. If left
+# blank the following patterns are tested:
+# *.c *.cc *.cxx *.cpp *.c++ *.d *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh
+# *.hxx *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.dox *.py
+# *.f90 *.f *.for *.vhd *.vhdl
+
+FILE_PATTERNS = *.c \
+ *.cc \
+ *.cxx \
+ *.cpp \
+ *.c++ \
+ *.d \
+ *.java \
+ *.ii \
+ *.ixx \
+ *.ipp \
+ *.i++ \
+ *.inl \
+ *.h \
+ *.hh \
+ *.hxx \
+ *.hpp \
+ *.h++ \
+ *.idl \
+ *.odl \
+ *.cs \
+ *.php \
+ *.php3 \
+ *.inc \
+ *.m \
+ *.mm \
+ *.dox \
+ *.py \
+ *.f90 \
+ *.f \
+ *.for \
+ *.vhd \
+ *.vhdl
+
+# The RECURSIVE tag can be used to turn specify whether or not subdirectories
+# should be searched for input files as well. Possible values are YES and NO.
+# If left blank NO is used.
+
+RECURSIVE = YES
+
+# The EXCLUDE tag can be used to specify files and/or directories that should
+# excluded from the INPUT source files. This way you can easily exclude a
+# subdirectory from a directory tree whose root is specified with the INPUT tag.
+# Note that relative paths are relative to directory from which doxygen is run.
+
+EXCLUDE =
+
+# The EXCLUDE_SYMLINKS tag can be used select whether or not files or
+# directories that are symbolic links (a Unix file system feature) are excluded
+# from the input.
+
+EXCLUDE_SYMLINKS = NO
+
+# If the value of the INPUT tag contains directories, you can use the
+# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
+# certain files from those directories. Note that the wildcards are matched
+# against the file with absolute path, so to exclude all test directories
+# for example use the pattern */test/*
+
+EXCLUDE_PATTERNS =
+
+# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
+# (namespaces, classes, functions, etc.) that should be excluded from the
+# output. The symbol name can be a fully qualified name, a word, or if the
+# wildcard * is used, a substring. Examples: ANamespace, AClass,
+# AClass::ANamespace, ANamespace::*Test
+
+EXCLUDE_SYMBOLS =
+
+# The EXAMPLE_PATH tag can be used to specify one or more files or
+# directories that contain example code fragments that are included (see
+# the \include command).
+
+EXAMPLE_PATH =
+
+# If the value of the EXAMPLE_PATH tag contains directories, you can use the
+# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
+# and *.h) to filter out the source-files in the directories. If left
+# blank all files are included.
+
+EXAMPLE_PATTERNS = *
+
+# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
+# searched for input files to be used with the \include or \dontinclude
+# commands irrespective of the value of the RECURSIVE tag.
+# Possible values are YES and NO. If left blank NO is used.
+
+EXAMPLE_RECURSIVE = NO
+
+# The IMAGE_PATH tag can be used to specify one or more files or
+# directories that contain image that are included in the documentation (see
+# the \image command).
+
+IMAGE_PATH =
+
+# The INPUT_FILTER tag can be used to specify a program that doxygen should
+# invoke to filter for each input file. Doxygen will invoke the filter program
+# by executing (via popen()) the command <filter> <input-file>, where <filter>
+# is the value of the INPUT_FILTER tag, and <input-file> is the name of an
+# input file. Doxygen will then use the output that the filter program writes
+# to standard output. If FILTER_PATTERNS is specified, this tag will be
+# ignored.
+
+INPUT_FILTER =
+
+# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
+# basis. Doxygen will compare the file name with each pattern and apply the
+# filter if there is a match. The filters are a list of the form:
+# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further
+# info on how filters are used. If FILTER_PATTERNS is empty or if
+# non of the patterns match the file name, INPUT_FILTER is applied.
+
+FILTER_PATTERNS =
+
+# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
+# INPUT_FILTER) will be used to filter the input files when producing source
+# files to browse (i.e. when SOURCE_BROWSER is set to YES).
+
+FILTER_SOURCE_FILES = NO
+
+# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
+# pattern. A pattern will override the setting for FILTER_PATTERN (if any)
+# and it is also possible to disable source filtering for a specific pattern
+# using *.ext= (so without naming a filter). This option only has effect when
+# FILTER_SOURCE_FILES is enabled.
+
+FILTER_SOURCE_PATTERNS =
+
+#---------------------------------------------------------------------------
+# configuration options related to source browsing
+#---------------------------------------------------------------------------
+
+# If the SOURCE_BROWSER tag is set to YES then a list of source files will
+# be generated. Documented entities will be cross-referenced with these sources.
+# Note: To get rid of all source code in the generated output, make sure also
+# VERBATIM_HEADERS is set to NO.
+
+SOURCE_BROWSER = YES
+
+# Setting the INLINE_SOURCES tag to YES will include the body
+# of functions and classes directly in the documentation.
+
+INLINE_SOURCES = NO
+
+# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct
+# doxygen to hide any special comment blocks from generated source code
+# fragments. Normal C and C++ comments will always remain visible.
+
+STRIP_CODE_COMMENTS = YES
+
+# If the REFERENCED_BY_RELATION tag is set to YES
+# then for each documented function all documented
+# functions referencing it will be listed.
+
+REFERENCED_BY_RELATION = NO
+
+# If the REFERENCES_RELATION tag is set to YES
+# then for each documented function all documented entities
+# called/used by that function will be listed.
+
+REFERENCES_RELATION = NO
+
+# If the REFERENCES_LINK_SOURCE tag is set to YES (the default)
+# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from
+# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will
+# link to the source code. Otherwise they will link to the documentation.
+
+REFERENCES_LINK_SOURCE = YES
+
+# If the USE_HTAGS tag is set to YES then the references to source code
+# will point to the HTML generated by the htags(1) tool instead of doxygen
+# built-in source browser. The htags tool is part of GNU's global source
+# tagging system (see http://www.gnu.org/software/global/global.html). You
+# will need version 4.8.6 or higher.
+
+USE_HTAGS = NO
+
+# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen
+# will generate a verbatim copy of the header file for each class for
+# which an include is specified. Set to NO to disable this.
+
+VERBATIM_HEADERS = YES
+
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+
+# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index
+# of all compounds will be generated. Enable this if the project
+# contains a lot of classes, structs, unions or interfaces.
+
+ALPHABETICAL_INDEX = YES
+
+# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then
+# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns
+# in which this list will be split (can be a number in the range [1..20])
+
+COLS_IN_ALPHA_INDEX = 5
+
+# In case all classes in a project start with a common prefix, all
+# classes will be put under the same header in the alphabetical index.
+# The IGNORE_PREFIX tag can be used to specify one or more prefixes that
+# should be ignored while generating the index headers.
+
+IGNORE_PREFIX =
+
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_HTML tag is set to YES (the default) Doxygen will
+# generate HTML output.
+
+GENERATE_HTML = YES
+
+# The HTML_OUTPUT tag is used to specify where the HTML docs will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `html' will be used as the default path.
+
+HTML_OUTPUT = html
+
+# The HTML_FILE_EXTENSION tag can be used to specify the file extension for
+# each generated HTML page (for example: .htm,.php,.asp). If it is left blank
+# doxygen will generate files with .html extension.
+
+HTML_FILE_EXTENSION = .html
+
+# The HTML_HEADER tag can be used to specify a personal HTML header for
+# each generated HTML page. If it is left blank doxygen will generate a
+# standard header. Note that when using a custom header you are responsible
+# for the proper inclusion of any scripts and style sheets that doxygen
+# needs, which is dependent on the configuration options used.
+# It is adviced to generate a default header using "doxygen -w html
+# header.html footer.html stylesheet.css YourConfigFile" and then modify
+# that header. Note that the header is subject to change so you typically
+# have to redo this when upgrading to a newer version of doxygen or when
+# changing the value of configuration settings such as GENERATE_TREEVIEW!
+
+HTML_HEADER =
+
+# The HTML_FOOTER tag can be used to specify a personal HTML footer for
+# each generated HTML page. If it is left blank doxygen will generate a
+# standard footer.
+
+HTML_FOOTER =
+
+# The HTML_STYLESHEET tag can be used to specify a user-defined cascading
+# style sheet that is used by each HTML page. It can be used to
+# fine-tune the look of the HTML output. If the tag is left blank doxygen
+# will generate a default style sheet. Note that doxygen will try to copy
+# the style sheet file to the HTML output directory, so don't put your own
+# stylesheet in the HTML output directory as well, or it will be erased!
+
+HTML_STYLESHEET =
+
+# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
+# other source files which should be copied to the HTML output directory. Note
+# that these files will be copied to the base HTML output directory. Use the
+# $relpath$ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
+# files. In the HTML_STYLESHEET file, use the file name only. Also note that
+# the files will be copied as-is; there are no commands or markers available.
+
+HTML_EXTRA_FILES =
+
+# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output.
+# Doxygen will adjust the colors in the stylesheet and background images
+# according to this color. Hue is specified as an angle on a colorwheel,
+# see http://en.wikipedia.org/wiki/Hue for more information.
+# For instance the value 0 represents red, 60 is yellow, 120 is green,
+# 180 is cyan, 240 is blue, 300 purple, and 360 is red again.
+# The allowed range is 0 to 359.
+
+HTML_COLORSTYLE_HUE = 220
+
+# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of
+# the colors in the HTML output. For a value of 0 the output will use
+# grayscales only. A value of 255 will produce the most vivid colors.
+
+HTML_COLORSTYLE_SAT = 100
+
+# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to
+# the luminance component of the colors in the HTML output. Values below
+# 100 gradually make the output lighter, whereas values above 100 make
+# the output darker. The value divided by 100 is the actual gamma applied,
+# so 80 represents a gamma of 0.8, The value 220 represents a gamma of 2.2,
+# and 100 does not change the gamma.
+
+HTML_COLORSTYLE_GAMMA = 80
+
+# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
+# page will contain the date and time when the page was generated. Setting
+# this to NO can help when comparing the output of multiple runs.
+
+HTML_TIMESTAMP = YES
+
+# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes,
+# files or namespaces will be aligned in HTML using tables. If set to
+# NO a bullet list will be used.
+
+HTML_ALIGN_MEMBERS = YES
+
+# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
+# documentation will contain sections that can be hidden and shown after the
+# page has loaded. For this to work a browser that supports
+# JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox
+# Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari).
+
+HTML_DYNAMIC_SECTIONS = NO
+
+# If the GENERATE_DOCSET tag is set to YES, additional index files
+# will be generated that can be used as input for Apple's Xcode 3
+# integrated development environment, introduced with OSX 10.5 (Leopard).
+# To create a documentation set, doxygen will generate a Makefile in the
+# HTML output directory. Running make will produce the docset in that
+# directory and running "make install" will install the docset in
+# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find
+# it at startup.
+# See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
+# for more information.
+
+GENERATE_DOCSET = NO
+
+# When GENERATE_DOCSET tag is set to YES, this tag determines the name of the
+# feed. A documentation feed provides an umbrella under which multiple
+# documentation sets from a single provider (such as a company or product suite)
+# can be grouped.
+
+DOCSET_FEEDNAME = "Doxygen generated docs"
+
+# When GENERATE_DOCSET tag is set to YES, this tag specifies a string that
+# should uniquely identify the documentation set bundle. This should be a
+# reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen
+# will append .docset to the name.
+
+DOCSET_BUNDLE_ID = org.doxygen.Project
+
+# When GENERATE_PUBLISHER_ID tag specifies a string that should uniquely identify
+# the documentation publisher. This should be a reverse domain-name style
+# string, e.g. com.mycompany.MyDocSet.documentation.
+
+DOCSET_PUBLISHER_ID = org.doxygen.Publisher
+
+# The GENERATE_PUBLISHER_NAME tag identifies the documentation publisher.
+
+DOCSET_PUBLISHER_NAME = Publisher
+
+# If the GENERATE_HTMLHELP tag is set to YES, additional index files
+# will be generated that can be used as input for tools like the
+# Microsoft HTML help workshop to generate a compiled HTML help file (.chm)
+# of the generated HTML documentation.
+
+GENERATE_HTMLHELP = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can
+# be used to specify the file name of the resulting .chm file. You
+# can add a path in front of the file if the result should not be
+# written to the html output directory.
+
+CHM_FILE =
+
+# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can
+# be used to specify the location (absolute path including file name) of
+# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run
+# the HTML help compiler on the generated index.hhp.
+
+HHC_LOCATION =
+
+# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag
+# controls if a separate .chi index file is generated (YES) or that
+# it should be included in the master .chm file (NO).
+
+GENERATE_CHI = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING
+# is used to encode HtmlHelp index (hhk), content (hhc) and project file
+# content.
+
+CHM_INDEX_ENCODING =
+
+# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag
+# controls whether a binary table of contents is generated (YES) or a
+# normal table of contents (NO) in the .chm file.
+
+BINARY_TOC = NO
+
+# The TOC_EXPAND flag can be set to YES to add extra items for group members
+# to the contents of the HTML help documentation and to the tree view.
+
+TOC_EXPAND = NO
+
+# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
+# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated
+# that can be used as input for Qt's qhelpgenerator to generate a
+# Qt Compressed Help (.qch) of the generated HTML documentation.
+
+GENERATE_QHP = NO
+
+# If the QHG_LOCATION tag is specified, the QCH_FILE tag can
+# be used to specify the file name of the resulting .qch file.
+# The path specified is relative to the HTML output folder.
+
+QCH_FILE =
+
+# The QHP_NAMESPACE tag specifies the namespace to use when generating
+# Qt Help Project output. For more information please see
+# http://doc.trolltech.com/qthelpproject.html#namespace
+
+QHP_NAMESPACE = org.doxygen.Project
+
+# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating
+# Qt Help Project output. For more information please see
+# http://doc.trolltech.com/qthelpproject.html#virtual-folders
+
+QHP_VIRTUAL_FOLDER = doc
+
+# If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to
+# add. For more information please see
+# http://doc.trolltech.com/qthelpproject.html#custom-filters
+
+QHP_CUST_FILTER_NAME =
+
+# The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the
+# custom filter to add. For more information please see
+# <a href="http://doc.trolltech.com/qthelpproject.html#custom-filters">
+# Qt Help Project / Custom Filters</a>.
+
+QHP_CUST_FILTER_ATTRS =
+
+# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
+# project's
+# filter section matches.
+# <a href="http://doc.trolltech.com/qthelpproject.html#filter-attributes">
+# Qt Help Project / Filter Attributes</a>.
+
+QHP_SECT_FILTER_ATTRS =
+
+# If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can
+# be used to specify the location of Qt's qhelpgenerator.
+# If non-empty doxygen will try to run qhelpgenerator on the generated
+# .qhp file.
+
+QHG_LOCATION =
+
+# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files
+# will be generated, which together with the HTML files, form an Eclipse help
+# plugin. To install this plugin and make it available under the help contents
+# menu in Eclipse, the contents of the directory containing the HTML and XML
+# files needs to be copied into the plugins directory of eclipse. The name of
+# the directory within the plugins directory should be the same as
+# the ECLIPSE_DOC_ID value. After copying Eclipse needs to be restarted before
+# the help appears.
+
+GENERATE_ECLIPSEHELP = NO
+
+# A unique identifier for the eclipse help plugin. When installing the plugin
+# the directory name containing the HTML and XML files should also have
+# this name.
+
+ECLIPSE_DOC_ID = org.doxygen.Project
+
+# The DISABLE_INDEX tag can be used to turn on/off the condensed index at
+# top of each HTML page. The value NO (the default) enables the index and
+# the value YES disables it.
+
+DISABLE_INDEX = NO
+
+# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values
+# (range [0,1..20]) that doxygen will group on one line in the generated HTML
+# documentation. Note that a value of 0 will completely suppress the enum
+# values from appearing in the overview section.
+
+ENUM_VALUES_PER_LINE = 4
+
+# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
+# structure should be generated to display hierarchical information.
+# If the tag value is set to YES, a side panel will be generated
+# containing a tree-like index structure (just like the one that
+# is generated for HTML Help). For this to work a browser that supports
+# JavaScript, DHTML, CSS and frames is required (i.e. any modern browser).
+# Windows users are probably better off using the HTML help feature.
+
+GENERATE_TREEVIEW = NO
+
+# By enabling USE_INLINE_TREES, doxygen will generate the Groups, Directories,
+# and Class Hierarchy pages using a tree view instead of an ordered list.
+
+USE_INLINE_TREES = NO
+
+# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be
+# used to set the initial width (in pixels) of the frame in which the tree
+# is shown.
+
+TREEVIEW_WIDTH = 250
+
+# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open
+# links to external symbols imported via tag files in a separate window.
+
+EXT_LINKS_IN_WINDOW = NO
+
+# Use this tag to change the font size of Latex formulas included
+# as images in the HTML documentation. The default is 10. Note that
+# when you change the font size after a successful doxygen run you need
+# to manually remove any form_*.png images from the HTML output directory
+# to force them to be regenerated.
+
+FORMULA_FONTSIZE = 10
+
+# Use the FORMULA_TRANPARENT tag to determine whether or not the images
+# generated for formulas are transparent PNGs. Transparent PNGs are
+# not supported properly for IE 6.0, but are supported on all modern browsers.
+# Note that when changing this option you need to delete any form_*.png files
+# in the HTML output before the changes have effect.
+
+FORMULA_TRANSPARENT = YES
+
+# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax
+# (see http://www.mathjax.org) which uses client side Javascript for the
+# rendering instead of using prerendered bitmaps. Use this if you do not
+# have LaTeX installed or if you want to formulas look prettier in the HTML
+# output. When enabled you also need to install MathJax separately and
+# configure the path to it using the MATHJAX_RELPATH option.
+
+USE_MATHJAX = NO
+
+# When MathJax is enabled you need to specify the location relative to the
+# HTML output directory using the MATHJAX_RELPATH option. The destination
+# directory should contain the MathJax.js script. For instance, if the mathjax
+# directory is located at the same level as the HTML output directory, then
+# MATHJAX_RELPATH should be ../mathjax. The default value points to the
+# mathjax.org site, so you can quickly see the result without installing
+# MathJax, but it is strongly recommended to install a local copy of MathJax
+# before deployment.
+
+MATHJAX_RELPATH = http://www.mathjax.org/mathjax
+
+# The MATHJAX_EXTENSIONS tag can be used to specify one or MathJax extension
+# names that should be enabled during MathJax rendering.
+
+MATHJAX_EXTENSIONS =
+
+# When the SEARCHENGINE tag is enabled doxygen will generate a search box
+# for the HTML output. The underlying search engine uses javascript
+# and DHTML and should work on any modern browser. Note that when using
+# HTML help (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets
+# (GENERATE_DOCSET) there is already a search function so this one should
+# typically be disabled. For large projects the javascript based search engine
+# can be slow, then enabling SERVER_BASED_SEARCH may provide a better solution.
+
+SEARCHENGINE = YES
+
+# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
+# implemented using a PHP enabled web server instead of at the web client
+# using Javascript. Doxygen will generate the search PHP script and index
+# file to put on the web server. The advantage of the server
+# based approach is that it scales better to large projects and allows
+# full text search. The disadvantages are that it is more difficult to setup
+# and does not have live searching capabilities.
+
+SERVER_BASED_SEARCH = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will
+# generate Latex output.
+
+GENERATE_LATEX = NO
+
+# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `latex' will be used as the default path.
+
+LATEX_OUTPUT = latex
+
+# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
+# invoked. If left blank `latex' will be used as the default command name.
+# Note that when enabling USE_PDFLATEX this option is only used for
+# generating bitmaps for formulas in the HTML output, but not in the
+# Makefile that is written to the output directory.
+
+LATEX_CMD_NAME = latex
+
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to
+# generate index for LaTeX. If left blank `makeindex' will be used as the
+# default command name.
+
+MAKEINDEX_CMD_NAME = makeindex
+
+# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact
+# LaTeX documents. This may be useful for small projects and may help to
+# save some trees in general.
+
+COMPACT_LATEX = NO
+
+# The PAPER_TYPE tag can be used to set the paper type that is used
+# by the printer. Possible values are: a4, letter, legal and
+# executive. If left blank a4wide will be used.
+
+PAPER_TYPE = a4
+
+# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX
+# packages that should be included in the LaTeX output.
+
+EXTRA_PACKAGES =
+
+# The LATEX_HEADER tag can be used to specify a personal LaTeX header for
+# the generated latex document. The header should contain everything until
+# the first chapter. If it is left blank doxygen will generate a
+# standard header. Notice: only use this tag if you know what you are doing!
+
+LATEX_HEADER =
+
+# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for
+# the generated latex document. The footer should contain everything after
+# the last chapter. If it is left blank doxygen will generate a
+# standard footer. Notice: only use this tag if you know what you are doing!
+
+LATEX_FOOTER =
+
+# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated
+# is prepared for conversion to pdf (using ps2pdf). The pdf file will
+# contain links (just like the HTML output) instead of page references
+# This makes the output suitable for online browsing using a pdf viewer.
+
+PDF_HYPERLINKS = YES
+
+# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of
+# plain latex in the generated Makefile. Set this option to YES to get a
+# higher quality PDF documentation.
+
+USE_PDFLATEX = YES
+
+# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode.
+# command to the generated LaTeX files. This will instruct LaTeX to keep
+# running if errors occur, instead of asking the user for help.
+# This option is also used when generating formulas in HTML.
+
+LATEX_BATCHMODE = NO
+
+# If LATEX_HIDE_INDICES is set to YES then doxygen will not
+# include the index chapters (such as File Index, Compound Index, etc.)
+# in the output.
+
+LATEX_HIDE_INDICES = NO
+
+# If LATEX_SOURCE_CODE is set to YES then doxygen will include
+# source code with syntax highlighting in the LaTeX output.
+# Note that which sources are shown also depends on other settings
+# such as SOURCE_BROWSER.
+
+LATEX_SOURCE_CODE = NO
+
+# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
+# bibliography, e.g. plainnat, or ieeetr. The default style is "plain". See
+# http://en.wikipedia.org/wiki/BibTeX for more info.
+
+LATEX_BIB_STYLE = plain
+
+#---------------------------------------------------------------------------
+# configuration options related to the RTF output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output
+# The RTF output is optimized for Word 97 and may not look very pretty with
+# other RTF readers or editors.
+
+GENERATE_RTF = NO
+
+# The RTF_OUTPUT tag is used to specify where the RTF docs will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `rtf' will be used as the default path.
+
+RTF_OUTPUT = rtf
+
+# If the COMPACT_RTF tag is set to YES Doxygen generates more compact
+# RTF documents. This may be useful for small projects and may help to
+# save some trees in general.
+
+COMPACT_RTF = NO
+
+# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated
+# will contain hyperlink fields. The RTF file will
+# contain links (just like the HTML output) instead of page references.
+# This makes the output suitable for online browsing using WORD or other
+# programs which support those fields.
+# Note: wordpad (write) and others do not support links.
+
+RTF_HYPERLINKS = NO
+
+# Load stylesheet definitions from file. Syntax is similar to doxygen's
+# config file, i.e. a series of assignments. You only have to provide
+# replacements, missing definitions are set to their default value.
+
+RTF_STYLESHEET_FILE =
+
+# Set optional variables used in the generation of an rtf document.
+# Syntax is similar to doxygen's config file.
+
+RTF_EXTENSIONS_FILE =
+
+#---------------------------------------------------------------------------
+# configuration options related to the man page output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_MAN tag is set to YES (the default) Doxygen will
+# generate man pages
+
+GENERATE_MAN = NO
+
+# The MAN_OUTPUT tag is used to specify where the man pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `man' will be used as the default path.
+
+MAN_OUTPUT = man
+
+# The MAN_EXTENSION tag determines the extension that is added to
+# the generated man pages (default is the subroutine's section .3)
+
+MAN_EXTENSION = .3
+
+# If the MAN_LINKS tag is set to YES and Doxygen generates man output,
+# then it will generate one additional man file for each entity
+# documented in the real man page(s). These additional files
+# only source the real man page, but without them the man command
+# would be unable to find the correct page. The default is NO.
+
+MAN_LINKS = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the XML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_XML tag is set to YES Doxygen will
+# generate an XML file that captures the structure of
+# the code including all documentation.
+
+GENERATE_XML = NO
+
+# The XML_OUTPUT tag is used to specify where the XML pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `xml' will be used as the default path.
+
+XML_OUTPUT = xml
+
+# The XML_SCHEMA tag can be used to specify an XML schema,
+# which can be used by a validating XML parser to check the
+# syntax of the XML files.
+
+XML_SCHEMA =
+
+# The XML_DTD tag can be used to specify an XML DTD,
+# which can be used by a validating XML parser to check the
+# syntax of the XML files.
+
+XML_DTD =
+
+# If the XML_PROGRAMLISTING tag is set to YES Doxygen will
+# dump the program listings (including syntax highlighting
+# and cross-referencing information) to the XML output. Note that
+# enabling this will significantly increase the size of the XML output.
+
+XML_PROGRAMLISTING = YES
+
+#---------------------------------------------------------------------------
+# configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will
+# generate an AutoGen Definitions (see autogen.sf.net) file
+# that captures the structure of the code including all
+# documentation. Note that this feature is still experimental
+# and incomplete at the moment.
+
+GENERATE_AUTOGEN_DEF = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_PERLMOD tag is set to YES Doxygen will
+# generate a Perl module file that captures the structure of
+# the code including all documentation. Note that this
+# feature is still experimental and incomplete at the
+# moment.
+
+GENERATE_PERLMOD = NO
+
+# If the PERLMOD_LATEX tag is set to YES Doxygen will generate
+# the necessary Makefile rules, Perl scripts and LaTeX code to be able
+# to generate PDF and DVI output from the Perl module output.
+
+PERLMOD_LATEX = NO
+
+# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be
+# nicely formatted so it can be parsed by a human reader. This is useful
+# if you want to understand what is going on. On the other hand, if this
+# tag is set to NO the size of the Perl module output will be much smaller
+# and Perl will parse it just the same.
+
+PERLMOD_PRETTY = YES
+
+# The names of the make variables in the generated doxyrules.make file
+# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX.
+# This is useful so different doxyrules.make files included by the same
+# Makefile don't overwrite each other's variables.
+
+PERLMOD_MAKEVAR_PREFIX =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor
+#---------------------------------------------------------------------------
+
+# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will
+# evaluate all C-preprocessor directives found in the sources and include
+# files.
+
+ENABLE_PREPROCESSING = YES
+
+# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro
+# names in the source code. If set to NO (the default) only conditional
+# compilation will be performed. Macro expansion can be done in a controlled
+# way by setting EXPAND_ONLY_PREDEF to YES.
+
+MACRO_EXPANSION = NO
+
+# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES
+# then the macro expansion is limited to the macros specified with the
+# PREDEFINED and EXPAND_AS_DEFINED tags.
+
+EXPAND_ONLY_PREDEF = NO
+
+# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files
+# pointed to by INCLUDE_PATH will be searched when a #include is found.
+
+SEARCH_INCLUDES = YES
+
+# The INCLUDE_PATH tag can be used to specify one or more directories that
+# contain include files that are not input files but should be processed by
+# the preprocessor.
+
+INCLUDE_PATH =
+
+# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
+# patterns (like *.h and *.hpp) to filter out the header-files in the
+# directories. If left blank, the patterns specified with FILE_PATTERNS will
+# be used.
+
+INCLUDE_FILE_PATTERNS =
+
+# The PREDEFINED tag can be used to specify one or more macro names that
+# are defined before the preprocessor is started (similar to the -D option of
+# gcc). The argument of the tag is a list of macros of the form: name
+# or name=definition (no spaces). If the definition and the = are
+# omitted =1 is assumed. To prevent a macro definition from being
+# undefined via #undef or recursively expanded use the := operator
+# instead of the = operator.
+
+PREDEFINED =
+
+# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
+# this tag can be used to specify a list of macro names that should be expanded.
+# The macro definition that is found in the sources will be used.
+# Use the PREDEFINED tag if you want to use a different macro definition that
+# overrules the definition found in the source code.
+
+EXPAND_AS_DEFINED =
+
+# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then
+# doxygen's preprocessor will remove all references to function-like macros
+# that are alone on a line, have an all uppercase name, and do not end with a
+# semicolon, because these will confuse the parser if not removed.
+
+SKIP_FUNCTION_MACROS = YES
+
+#---------------------------------------------------------------------------
+# Configuration::additions related to external references
+#---------------------------------------------------------------------------
+
+# The TAGFILES option can be used to specify one or more tagfiles.
+# Optionally an initial location of the external documentation
+# can be added for each tagfile. The format of a tag file without
+# this location is as follows:
+# TAGFILES = file1 file2 ...
+# Adding location for the tag files is done as follows:
+# TAGFILES = file1=loc1 "file2 = loc2" ...
+# where "loc1" and "loc2" can be relative or absolute paths or
+# URLs. If a location is present for each tag, the installdox tool
+# does not have to be run to correct the links.
+# Note that each tag file must have a unique name
+# (where the name does NOT include the path)
+# If a tag file is not located in the directory in which doxygen
+# is run, you must also specify the path to the tagfile here.
+
+TAGFILES =
+
+# When a file name is specified after GENERATE_TAGFILE, doxygen will create
+# a tag file that is based on the input files it reads.
+
+GENERATE_TAGFILE =
+
+# If the ALLEXTERNALS tag is set to YES all external classes will be listed
+# in the class index. If set to NO only the inherited external classes
+# will be listed.
+
+ALLEXTERNALS = NO
+
+# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed
+# in the modules index. If set to NO, only the current project's groups will
+# be listed.
+
+EXTERNAL_GROUPS = YES
+
+# The PERL_PATH should be the absolute path and name of the perl script
+# interpreter (i.e. the result of `which perl').
+
+PERL_PATH = /usr/bin/perl
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+
+# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will
+# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base
+# or super classes. Setting the tag to NO turns the diagrams off. Note that
+# this option also works with HAVE_DOT disabled, but it is recommended to
+# install and use dot, since it yields more powerful graphs.
+
+CLASS_DIAGRAMS = YES
+
+# You can define message sequence charts within doxygen comments using the \msc
+# command. Doxygen will then run the mscgen tool (see
+# http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the
+# documentation. The MSCGEN_PATH tag allows you to specify the directory where
+# the mscgen tool resides. If left empty the tool is assumed to be found in the
+# default search path.
+
+MSCGEN_PATH =
+
+# If set to YES, the inheritance and collaboration graphs will hide
+# inheritance and usage relations if the target is undocumented
+# or is not a class.
+
+HIDE_UNDOC_RELATIONS = YES
+
+# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
+# available from the path. This tool is part of Graphviz, a graph visualization
+# toolkit from AT&T and Lucent Bell Labs. The other options in this section
+# have no effect if this option is set to NO (the default)
+
+HAVE_DOT = NO
+
+# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is
+# allowed to run in parallel. When set to 0 (the default) doxygen will
+# base this on the number of processors available in the system. You can set it
+# explicitly to a value larger than 0 to get control over the balance
+# between CPU load and processing speed.
+
+DOT_NUM_THREADS = 0
+
+# By default doxygen will use the Helvetica font for all dot files that
+# doxygen generates. When you want a differently looking font you can specify
+# the font name using DOT_FONTNAME. You need to make sure dot is able to find
+# the font, which can be done by putting it in a standard location or by setting
+# the DOTFONTPATH environment variable or by setting DOT_FONTPATH to the
+# directory containing the font.
+
+DOT_FONTNAME = Helvetica
+
+# The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs.
+# The default size is 10pt.
+
+DOT_FONTSIZE = 10
+
+# By default doxygen will tell dot to use the Helvetica font.
+# If you specify a different font using DOT_FONTNAME you can use DOT_FONTPATH to
+# set the path where dot can find it.
+
+DOT_FONTPATH =
+
+# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen
+# will generate a graph for each documented class showing the direct and
+# indirect inheritance relations. Setting this tag to YES will force the
+# the CLASS_DIAGRAMS tag to NO.
+
+CLASS_GRAPH = YES
+
+# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen
+# will generate a graph for each documented class showing the direct and
+# indirect implementation dependencies (inheritance, containment, and
+# class references variables) of the class with other documented classes.
+
+COLLABORATION_GRAPH = YES
+
+# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen
+# will generate a graph for groups, showing the direct groups dependencies
+
+GROUP_GRAPHS = YES
+
+# If the UML_LOOK tag is set to YES doxygen will generate inheritance and
+# collaboration diagrams in a style similar to the OMG's Unified Modeling
+# Language.
+
+UML_LOOK = NO
+
+# If set to YES, the inheritance and collaboration graphs will show the
+# relations between templates and their instances.
+
+TEMPLATE_RELATIONS = NO
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT
+# tags are set to YES then doxygen will generate a graph for each documented
+# file showing the direct and indirect include dependencies of the file with
+# other documented files.
+
+INCLUDE_GRAPH = YES
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and
+# HAVE_DOT tags are set to YES then doxygen will generate a graph for each
+# documented header file showing the documented files that directly or
+# indirectly include this file.
+
+INCLUDED_BY_GRAPH = YES
+
+# If the CALL_GRAPH and HAVE_DOT options are set to YES then
+# doxygen will generate a call dependency graph for every global function
+# or class method. Note that enabling this option will significantly increase
+# the time of a run. So in most cases it will be better to enable call graphs
+# for selected functions only using the \callgraph command.
+
+CALL_GRAPH = NO
+
+# If the CALLER_GRAPH and HAVE_DOT tags are set to YES then
+# doxygen will generate a caller dependency graph for every global function
+# or class method. Note that enabling this option will significantly increase
+# the time of a run. So in most cases it will be better to enable caller
+# graphs for selected functions only using the \callergraph command.
+
+CALLER_GRAPH = NO
+
+# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen
+# will generate a graphical hierarchy of all classes instead of a textual one.
+
+GRAPHICAL_HIERARCHY = YES
+
+# If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES
+# then doxygen will show the dependencies a directory has on other directories
+# in a graphical way. The dependency relations are determined by the #include
+# relations between the files in the directories.
+
+DIRECTORY_GRAPH = YES
+
+# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
+# generated by dot. Possible values are svg, png, jpg, or gif.
+# If left blank png will be used. If you choose svg you need to set
+# HTML_FILE_EXTENSION to xhtml in order to make the SVG files
+# visible in IE 9+ (other browsers do not have this requirement).
+
+DOT_IMAGE_FORMAT = png
+
+# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
+# enable generation of interactive SVG images that allow zooming and panning.
+# Note that this requires a modern browser other than Internet Explorer.
+# Tested and working are Firefox, Chrome, Safari, and Opera. For IE 9+ you
+# need to set HTML_FILE_EXTENSION to xhtml in order to make the SVG files
+# visible. Older versions of IE do not have SVG support.
+
+INTERACTIVE_SVG = NO
+
+# The tag DOT_PATH can be used to specify the path where the dot tool can be
+# found. If left blank, it is assumed the dot tool can be found in the path.
+
+DOT_PATH =
+
+# The DOTFILE_DIRS tag can be used to specify one or more directories that
+# contain dot files that are included in the documentation (see the
+# \dotfile command).
+
+DOTFILE_DIRS =
+
+# The MSCFILE_DIRS tag can be used to specify one or more directories that
+# contain msc files that are included in the documentation (see the
+# \mscfile command).
+
+MSCFILE_DIRS =
+
+# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of
+# nodes that will be shown in the graph. If the number of nodes in a graph
+# becomes larger than this value, doxygen will truncate the graph, which is
+# visualized by representing a node as a red box. Note that doxygen if the
+# number of direct children of the root node in a graph is already larger than
+# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note
+# that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
+
+DOT_GRAPH_MAX_NODES = 50
+
+# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the
+# graphs generated by dot. A depth value of 3 means that only nodes reachable
+# from the root by following a path via at most 3 edges will be shown. Nodes
+# that lay further from the root node will be omitted. Note that setting this
+# option to 1 or 2 may greatly reduce the computation time needed for large
+# code bases. Also note that the size of a graph can be further restricted by
+# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
+
+MAX_DOT_GRAPH_DEPTH = 0
+
+# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
+# background. This is disabled by default, because dot on Windows does not
+# seem to support this out of the box. Warning: Depending on the platform used,
+# enabling this option may lead to badly anti-aliased labels on the edges of
+# a graph (i.e. they become hard to read).
+
+DOT_TRANSPARENT = NO
+
+# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
+# files in one run (i.e. multiple -o and -T options on the command line). This
+# makes dot run faster, but since only newer versions of dot (>1.8.10)
+# support this, this feature is disabled by default.
+
+DOT_MULTI_TARGETS = NO
+
+# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will
+# generate a legend page explaining the meaning of the various boxes and
+# arrows in the dot generated graphs.
+
+GENERATE_LEGEND = YES
+
+# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will
+# remove the intermediate dot files that are used to generate
+# the various graphs.
+
+DOT_CLEANUP = YES
diff --git a/Utilities/KalDet/src/lctpc/doc/Doxyfile_latex b/Utilities/KalDet/src/lctpc/doc/Doxyfile_latex
new file mode 100644
index 0000000000000000000000000000000000000000..26eb34dc728b9001365f38c4cdfe4db230b05e60
--- /dev/null
+++ b/Utilities/KalDet/src/lctpc/doc/Doxyfile_latex
@@ -0,0 +1,1790 @@
+# Doxyfile 1.7.5.1
+
+# This file describes the settings to be used by the documentation system
+# doxygen (www.doxygen.org) for a project
+#
+# All text after a hash (#) is considered a comment and will be ignored
+# The format is:
+# TAG = value [value, ...]
+# For lists items can also be appended using:
+# TAG += value [value, ...]
+# Values that contain spaces should be placed between quotes (" ")
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+
+# This tag specifies the encoding used for all characters in the config file
+# that follow. The default is UTF-8 which is also the encoding used for all
+# text before the first occurrence of this tag. Doxygen uses libiconv (or the
+# iconv built into libc) for the transcoding. See
+# http://www.gnu.org/software/libiconv for the list of possible encodings.
+
+DOXYFILE_ENCODING = UTF-8
+
+# The PROJECT_NAME tag is a single word (or sequence of words) that should
+# identify the project. Note that if you do not use Doxywizard you need
+# to put quotes around the project name if it contains spaces.
+
+PROJECT_NAME = GearTPC
+
+# The PROJECT_NUMBER tag can be used to enter a project or revision number.
+# This could be handy for archiving the generated documentation or
+# if some version control system is used.
+
+PROJECT_NUMBER =
+
+# Using the PROJECT_BRIEF tag one can provide an optional one line description
+# for a project that appears at the top of each page and should give viewer
+# a quick idea about the purpose of the project. Keep the description short.
+
+PROJECT_BRIEF =
+
+# With the PROJECT_LOGO tag one can specify an logo or icon that is
+# included in the documentation. The maximum height of the logo should not
+# exceed 55 pixels and the maximum width should not exceed 200 pixels.
+# Doxygen will copy the logo to the output directory.
+
+PROJECT_LOGO =
+
+# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
+# base path where the generated documentation will be put.
+# If a relative path is entered, it will be relative to the location
+# where doxygen was started. If left blank the current directory will be used.
+
+OUTPUT_DIRECTORY = .
+
+# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create
+# 4096 sub-directories (in 2 levels) under the output directory of each output
+# format and will distribute the generated files over these directories.
+# Enabling this option can be useful when feeding doxygen a huge amount of
+# source files, where putting all generated files in the same directory would
+# otherwise cause performance problems for the file system.
+
+CREATE_SUBDIRS = NO
+
+# The OUTPUT_LANGUAGE tag is used to specify the language in which all
+# documentation generated by doxygen is written. Doxygen will use this
+# information to generate all constant output in the proper language.
+# The default language is English, other supported languages are:
+# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional,
+# Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German,
+# Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English
+# messages), Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian,
+# Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrillic, Slovak,
+# Slovene, Spanish, Swedish, Ukrainian, and Vietnamese.
+
+OUTPUT_LANGUAGE = English
+
+# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will
+# include brief member descriptions after the members that are listed in
+# the file and class documentation (similar to JavaDoc).
+# Set to NO to disable this.
+
+BRIEF_MEMBER_DESC = YES
+
+# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend
+# the brief description of a member or function before the detailed description.
+# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
+# brief descriptions will be completely suppressed.
+
+REPEAT_BRIEF = YES
+
+# This tag implements a quasi-intelligent brief description abbreviator
+# that is used to form the text in various listings. Each string
+# in this list, if found as the leading text of the brief description, will be
+# stripped from the text and the result after processing the whole list, is
+# used as the annotated text. Otherwise, the brief description is used as-is.
+# If left blank, the following values are used ("$name" is automatically
+# replaced with the name of the entity): "The $name class" "The $name widget"
+# "The $name file" "is" "provides" "specifies" "contains"
+# "represents" "a" "an" "the"
+
+ABBREVIATE_BRIEF = "The $name class" \
+ "The $name widget" \
+ "The $name file" \
+ is \
+ provides \
+ specifies \
+ contains \
+ represents \
+ a \
+ an \
+ the
+
+# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
+# Doxygen will generate a detailed section even if there is only a brief
+# description.
+
+ALWAYS_DETAILED_SEC = NO
+
+# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
+# inherited members of a class in the documentation of that class as if those
+# members were ordinary class members. Constructors, destructors and assignment
+# operators of the base classes will not be shown.
+
+INLINE_INHERITED_MEMB = NO
+
+# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full
+# path before files name in the file list and in the header files. If set
+# to NO the shortest path that makes the file name unique will be used.
+
+FULL_PATH_NAMES = YES
+
+# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag
+# can be used to strip a user-defined part of the path. Stripping is
+# only done if one of the specified strings matches the left-hand part of
+# the path. The tag can be used to show relative paths in the file list.
+# If left blank the directory from which doxygen is run is used as the
+# path to strip.
+
+STRIP_FROM_PATH =
+
+# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of
+# the path mentioned in the documentation of a class, which tells
+# the reader which header file to include in order to use a class.
+# If left blank only the name of the header file containing the class
+# definition is used. Otherwise one should specify the include paths that
+# are normally passed to the compiler using the -I flag.
+
+STRIP_FROM_INC_PATH =
+
+# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter
+# (but less readable) file names. This can be useful if your file system
+# doesn't support long names like on DOS, Mac, or CD-ROM.
+
+SHORT_NAMES = NO
+
+# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen
+# will interpret the first line (until the first dot) of a JavaDoc-style
+# comment as the brief description. If set to NO, the JavaDoc
+# comments will behave just like regular Qt-style comments
+# (thus requiring an explicit @brief command for a brief description.)
+
+JAVADOC_AUTOBRIEF = YES
+
+# If the QT_AUTOBRIEF tag is set to YES then Doxygen will
+# interpret the first line (until the first dot) of a Qt-style
+# comment as the brief description. If set to NO, the comments
+# will behave just like regular Qt-style comments (thus requiring
+# an explicit \brief command for a brief description.)
+
+QT_AUTOBRIEF = YES
+
+# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen
+# treat a multi-line C++ special comment block (i.e. a block of //! or ///
+# comments) as a brief description. This used to be the default behaviour.
+# The new default is to treat a multi-line C++ comment block as a detailed
+# description. Set this tag to YES if you prefer the old behaviour instead.
+
+MULTILINE_CPP_IS_BRIEF = NO
+
+# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented
+# member inherits the documentation from any documented member that it
+# re-implements.
+
+INHERIT_DOCS = YES
+
+# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce
+# a new page for each member. If set to NO, the documentation of a member will
+# be part of the file/class/namespace that contains it.
+
+SEPARATE_MEMBER_PAGES = NO
+
+# The TAB_SIZE tag can be used to set the number of spaces in a tab.
+# Doxygen uses this value to replace tabs by spaces in code fragments.
+
+TAB_SIZE = 8
+
+# This tag can be used to specify a number of aliases that acts
+# as commands in the documentation. An alias has the form "name=value".
+# For example adding "sideeffect=\par Side Effects:\n" will allow you to
+# put the command \sideeffect (or @sideeffect) in the documentation, which
+# will result in a user-defined paragraph with heading "Side Effects:".
+# You can put \n's in the value part of an alias to insert newlines.
+
+ALIASES =
+
+# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C
+# sources only. Doxygen will then generate output that is more tailored for C.
+# For instance, some of the names that are used will be different. The list
+# of all members will be omitted, etc.
+
+OPTIMIZE_OUTPUT_FOR_C = NO
+
+# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java
+# sources only. Doxygen will then generate output that is more tailored for
+# Java. For instance, namespaces will be presented as packages, qualified
+# scopes will look different, etc.
+
+OPTIMIZE_OUTPUT_JAVA = NO
+
+# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
+# sources only. Doxygen will then generate output that is more tailored for
+# Fortran.
+
+OPTIMIZE_FOR_FORTRAN = NO
+
+# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
+# sources. Doxygen will then generate output that is tailored for
+# VHDL.
+
+OPTIMIZE_OUTPUT_VHDL = NO
+
+# Doxygen selects the parser to use depending on the extension of the files it
+# parses. With this tag you can assign which parser to use for a given extension.
+# Doxygen has a built-in mapping, but you can override or extend it using this
+# tag. The format is ext=language, where ext is a file extension, and language
+# is one of the parsers supported by doxygen: IDL, Java, Javascript, CSharp, C,
+# C++, D, PHP, Objective-C, Python, Fortran, VHDL, C, C++. For instance to make
+# doxygen treat .inc files as Fortran files (default is PHP), and .f files as C
+# (default is Fortran), use: inc=Fortran f=C. Note that for custom extensions
+# you also need to set FILE_PATTERNS otherwise the files are not read by doxygen.
+
+EXTENSION_MAPPING =
+
+# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
+# to include (a tag file for) the STL sources as input, then you should
+# set this tag to YES in order to let doxygen match functions declarations and
+# definitions whose arguments contain STL classes (e.g. func(std::string); v.s.
+# func(std::string) {}). This also makes the inheritance and collaboration
+# diagrams that involve STL classes more complete and accurate.
+
+BUILTIN_STL_SUPPORT = NO
+
+# If you use Microsoft's C++/CLI language, you should set this option to YES to
+# enable parsing support.
+
+CPP_CLI_SUPPORT = NO
+
+# Set the SIP_SUPPORT tag to YES if your project consists of sip sources only.
+# Doxygen will parse them like normal C++ but will assume all classes use public
+# instead of private inheritance when no explicit protection keyword is present.
+
+SIP_SUPPORT = NO
+
+# For Microsoft's IDL there are propget and propput attributes to indicate getter
+# and setter methods for a property. Setting this option to YES (the default)
+# will make doxygen replace the get and set methods by a property in the
+# documentation. This will only work if the methods are indeed getting or
+# setting a simple type. If this is not the case, or you want to show the
+# methods anyway, you should set this option to NO.
+
+IDL_PROPERTY_SUPPORT = YES
+
+# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
+# tag is set to YES, then doxygen will reuse the documentation of the first
+# member in the group (if any) for the other members of the group. By default
+# all members of a group must be documented explicitly.
+
+DISTRIBUTE_GROUP_DOC = NO
+
+# Set the SUBGROUPING tag to YES (the default) to allow class member groups of
+# the same type (for instance a group of public functions) to be put as a
+# subgroup of that type (e.g. under the Public Functions section). Set it to
+# NO to prevent subgrouping. Alternatively, this can be done per class using
+# the \nosubgrouping command.
+
+SUBGROUPING = YES
+
+# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and
+# unions are shown inside the group in which they are included (e.g. using
+# @ingroup) instead of on a separate page (for HTML and Man pages) or
+# section (for LaTeX and RTF).
+
+INLINE_GROUPED_CLASSES = NO
+
+# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and
+# unions with only public data fields will be shown inline in the documentation
+# of the scope in which they are defined (i.e. file, namespace, or group
+# documentation), provided this scope is documented. If set to NO (the default),
+# structs, classes, and unions are shown on a separate page (for HTML and Man
+# pages) or section (for LaTeX and RTF).
+
+INLINE_SIMPLE_STRUCTS = NO
+
+# When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum
+# is documented as struct, union, or enum with the name of the typedef. So
+# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
+# with name TypeT. When disabled the typedef will appear as a member of a file,
+# namespace, or class. And the struct will be named TypeS. This can typically
+# be useful for C code in case the coding convention dictates that all compound
+# types are typedef'ed and only the typedef is referenced, never the tag name.
+
+TYPEDEF_HIDES_STRUCT = NO
+
+# The SYMBOL_CACHE_SIZE determines the size of the internal cache use to
+# determine which symbols to keep in memory and which to flush to disk.
+# When the cache is full, less often used symbols will be written to disk.
+# For small to medium size projects (<1000 input files) the default value is
+# probably good enough. For larger projects a too small cache size can cause
+# doxygen to be busy swapping symbols to and from disk most of the time
+# causing a significant performance penalty.
+# If the system has enough physical memory increasing the cache will improve the
+# performance by keeping more symbols in memory. Note that the value works on
+# a logarithmic scale so increasing the size by one will roughly double the
+# memory usage. The cache size is given by this formula:
+# 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0,
+# corresponding to a cache size of 2^16 = 65536 symbols
+
+SYMBOL_CACHE_SIZE = 0
+
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+
+# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
+# documentation are documented, even if no documentation was available.
+# Private class members and static file members will be hidden unless
+# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
+
+EXTRACT_ALL = YES
+
+# If the EXTRACT_PRIVATE tag is set to YES all private members of a class
+# will be included in the documentation.
+
+EXTRACT_PRIVATE = NO
+
+# If the EXTRACT_STATIC tag is set to YES all static members of a file
+# will be included in the documentation.
+
+EXTRACT_STATIC = NO
+
+# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs)
+# defined locally in source files will be included in the documentation.
+# If set to NO only classes defined in header files are included.
+
+EXTRACT_LOCAL_CLASSES = YES
+
+# This flag is only useful for Objective-C code. When set to YES local
+# methods, which are defined in the implementation section but not in
+# the interface are included in the documentation.
+# If set to NO (the default) only methods in the interface are included.
+
+EXTRACT_LOCAL_METHODS = NO
+
+# If this flag is set to YES, the members of anonymous namespaces will be
+# extracted and appear in the documentation as a namespace called
+# 'anonymous_namespace{file}', where file will be replaced with the base
+# name of the file that contains the anonymous namespace. By default
+# anonymous namespaces are hidden.
+
+EXTRACT_ANON_NSPACES = NO
+
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all
+# undocumented members of documented classes, files or namespaces.
+# If set to NO (the default) these members will be included in the
+# various overviews, but no documentation section is generated.
+# This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_MEMBERS = NO
+
+# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all
+# undocumented classes that are normally visible in the class hierarchy.
+# If set to NO (the default) these classes will be included in the various
+# overviews. This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_CLASSES = NO
+
+# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all
+# friend (class|struct|union) declarations.
+# If set to NO (the default) these declarations will be included in the
+# documentation.
+
+HIDE_FRIEND_COMPOUNDS = NO
+
+# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any
+# documentation blocks found inside the body of a function.
+# If set to NO (the default) these blocks will be appended to the
+# function's detailed documentation block.
+
+HIDE_IN_BODY_DOCS = NO
+
+# The INTERNAL_DOCS tag determines if documentation
+# that is typed after a \internal command is included. If the tag is set
+# to NO (the default) then the documentation will be excluded.
+# Set it to YES to include the internal documentation.
+
+INTERNAL_DOCS = NO
+
+# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate
+# file names in lower-case letters. If set to YES upper-case letters are also
+# allowed. This is useful if you have classes or files whose names only differ
+# in case and if your file system supports case sensitive file names. Windows
+# and Mac users are advised to set this option to NO.
+
+CASE_SENSE_NAMES = NO
+
+# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen
+# will show members with their full class and namespace scopes in the
+# documentation. If set to YES the scope will be hidden.
+
+HIDE_SCOPE_NAMES = NO
+
+# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen
+# will put a list of the files that are included by a file in the documentation
+# of that file.
+
+SHOW_INCLUDE_FILES = YES
+
+# If the FORCE_LOCAL_INCLUDES tag is set to YES then Doxygen
+# will list include files with double quotes in the documentation
+# rather than with sharp brackets.
+
+FORCE_LOCAL_INCLUDES = NO
+
+# If the INLINE_INFO tag is set to YES (the default) then a tag [inline]
+# is inserted in the documentation for inline members.
+
+INLINE_INFO = YES
+
+# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen
+# will sort the (detailed) documentation of file and class members
+# alphabetically by member name. If set to NO the members will appear in
+# declaration order.
+
+SORT_MEMBER_DOCS = YES
+
+# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the
+# brief documentation of file, namespace and class members alphabetically
+# by member name. If set to NO (the default) the members will appear in
+# declaration order.
+
+SORT_BRIEF_DOCS = NO
+
+# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen
+# will sort the (brief and detailed) documentation of class members so that
+# constructors and destructors are listed first. If set to NO (the default)
+# the constructors will appear in the respective orders defined by
+# SORT_MEMBER_DOCS and SORT_BRIEF_DOCS.
+# This tag will be ignored for brief docs if SORT_BRIEF_DOCS is set to NO
+# and ignored for detailed docs if SORT_MEMBER_DOCS is set to NO.
+
+SORT_MEMBERS_CTORS_1ST = NO
+
+# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the
+# hierarchy of group names into alphabetical order. If set to NO (the default)
+# the group names will appear in their defined order.
+
+SORT_GROUP_NAMES = NO
+
+# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be
+# sorted by fully-qualified names, including namespaces. If set to
+# NO (the default), the class list will be sorted only by class name,
+# not including the namespace part.
+# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
+# Note: This option applies only to the class list, not to the
+# alphabetical list.
+
+SORT_BY_SCOPE_NAME = NO
+
+# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to
+# do proper type resolution of all parameters of a function it will reject a
+# match between the prototype and the implementation of a member function even
+# if there is only one candidate or it is obvious which candidate to choose
+# by doing a simple string match. By disabling STRICT_PROTO_MATCHING doxygen
+# will still accept a match between prototype and implementation in such cases.
+
+STRICT_PROTO_MATCHING = NO
+
+# The GENERATE_TODOLIST tag can be used to enable (YES) or
+# disable (NO) the todo list. This list is created by putting \todo
+# commands in the documentation.
+
+GENERATE_TODOLIST = YES
+
+# The GENERATE_TESTLIST tag can be used to enable (YES) or
+# disable (NO) the test list. This list is created by putting \test
+# commands in the documentation.
+
+GENERATE_TESTLIST = YES
+
+# The GENERATE_BUGLIST tag can be used to enable (YES) or
+# disable (NO) the bug list. This list is created by putting \bug
+# commands in the documentation.
+
+GENERATE_BUGLIST = YES
+
+# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or
+# disable (NO) the deprecated list. This list is created by putting
+# \deprecated commands in the documentation.
+
+GENERATE_DEPRECATEDLIST= YES
+
+# The ENABLED_SECTIONS tag can be used to enable conditional
+# documentation sections, marked by \if sectionname ... \endif.
+
+ENABLED_SECTIONS =
+
+# The MAX_INITIALIZER_LINES tag determines the maximum number of lines
+# the initial value of a variable or macro consists of for it to appear in
+# the documentation. If the initializer consists of more lines than specified
+# here it will be hidden. Use a value of 0 to hide initializers completely.
+# The appearance of the initializer of individual variables and macros in the
+# documentation can be controlled using \showinitializer or \hideinitializer
+# command in the documentation regardless of this setting.
+
+MAX_INITIALIZER_LINES = 30
+
+# Set the SHOW_USED_FILES tag to NO to disable the list of files generated
+# at the bottom of the documentation of classes and structs. If set to YES the
+# list will mention the files that were used to generate the documentation.
+
+SHOW_USED_FILES = NO
+
+# If the sources in your project are distributed over multiple directories
+# then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy
+# in the documentation. The default is NO.
+
+SHOW_DIRECTORIES = NO
+
+# Set the SHOW_FILES tag to NO to disable the generation of the Files page.
+# This will remove the Files entry from the Quick Index and from the
+# Folder Tree View (if specified). The default is YES.
+
+SHOW_FILES = NO
+
+# Set the SHOW_NAMESPACES tag to NO to disable the generation of the
+# Namespaces page. This will remove the Namespaces entry from the Quick Index
+# and from the Folder Tree View (if specified). The default is YES.
+
+SHOW_NAMESPACES = NO
+
+# The FILE_VERSION_FILTER tag can be used to specify a program or script that
+# doxygen should invoke to get the current version for each file (typically from
+# the version control system). Doxygen will invoke the program by executing (via
+# popen()) the command <command> <input-file>, where <command> is the value of
+# the FILE_VERSION_FILTER tag, and <input-file> is the name of an input file
+# provided by doxygen. Whatever the program writes to standard output
+# is used as the file version. See the manual for examples.
+
+FILE_VERSION_FILTER =
+
+# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
+# by doxygen. The layout file controls the global structure of the generated
+# output files in an output format independent way. The create the layout file
+# that represents doxygen's defaults, run doxygen with the -l option.
+# You can optionally specify a file name after the option, if omitted
+# DoxygenLayout.xml will be used as the name of the layout file.
+
+LAYOUT_FILE =
+
+# The CITE_BIB_FILES tag can be used to specify one or more bib files
+# containing the references data. This must be a list of .bib files. The
+# .bib extension is automatically appended if omitted. Using this command
+# requires the bibtex tool to be installed. See also
+# http://en.wikipedia.org/wiki/BibTeX for more info. For LaTeX the style
+# of the bibliography can be controlled using LATEX_BIB_STYLE.
+
+CITE_BIB_FILES =
+
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+
+# The QUIET tag can be used to turn on/off the messages that are generated
+# by doxygen. Possible values are YES and NO. If left blank NO is used.
+
+QUIET = NO
+
+# The WARNINGS tag can be used to turn on/off the warning messages that are
+# generated by doxygen. Possible values are YES and NO. If left blank
+# NO is used.
+
+WARNINGS = YES
+
+# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings
+# for undocumented members. If EXTRACT_ALL is set to YES then this flag will
+# automatically be disabled.
+
+WARN_IF_UNDOCUMENTED = YES
+
+# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for
+# potential errors in the documentation, such as not documenting some
+# parameters in a documented function, or documenting parameters that
+# don't exist or using markup commands wrongly.
+
+WARN_IF_DOC_ERROR = YES
+
+# The WARN_NO_PARAMDOC option can be enabled to get warnings for
+# functions that are documented, but have no documentation for their parameters
+# or return value. If set to NO (the default) doxygen will only warn about
+# wrong or incomplete parameter documentation, but not about the absence of
+# documentation.
+
+WARN_NO_PARAMDOC = NO
+
+# The WARN_FORMAT tag determines the format of the warning messages that
+# doxygen can produce. The string should contain the $file, $line, and $text
+# tags, which will be replaced by the file and line number from which the
+# warning originated and the warning text. Optionally the format may contain
+# $version, which will be replaced by the version of the file (if it could
+# be obtained via FILE_VERSION_FILTER)
+
+WARN_FORMAT = "$file:$line: $text"
+
+# The WARN_LOGFILE tag can be used to specify a file to which warning
+# and error messages should be written. If left blank the output is written
+# to stderr.
+
+WARN_LOGFILE =
+
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+
+# The INPUT tag can be used to specify the files and/or directories that contain
+# documented source files. You may enter file names like "myfile.cpp" or
+# directories like "/usr/src/myproject". Separate the files or directories
+# with spaces.
+
+INPUT = ../gearTPC \
+ GearTPC_mainpage.h
+
+# This tag can be used to specify the character encoding of the source files
+# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is
+# also the default input encoding. Doxygen uses libiconv (or the iconv built
+# into libc) for the transcoding. See http://www.gnu.org/software/libiconv for
+# the list of possible encodings.
+
+INPUT_ENCODING = UTF-8
+
+# If the value of the INPUT tag contains directories, you can use the
+# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
+# and *.h) to filter out the source-files in the directories. If left
+# blank the following patterns are tested:
+# *.c *.cc *.cxx *.cpp *.c++ *.d *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh
+# *.hxx *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.dox *.py
+# *.f90 *.f *.for *.vhd *.vhdl
+
+FILE_PATTERNS = *.c \
+ *.cc \
+ *.cxx \
+ *.cpp \
+ *.c++ \
+ *.d \
+ *.java \
+ *.ii \
+ *.ixx \
+ *.ipp \
+ *.i++ \
+ *.inl \
+ *.h \
+ *.hh \
+ *.hxx \
+ *.hpp \
+ *.h++ \
+ *.idl \
+ *.odl \
+ *.cs \
+ *.php \
+ *.php3 \
+ *.inc \
+ *.m \
+ *.mm \
+ *.dox \
+ *.py \
+ *.f90 \
+ *.f \
+ *.for \
+ *.vhd \
+ *.vhdl
+
+# The RECURSIVE tag can be used to turn specify whether or not subdirectories
+# should be searched for input files as well. Possible values are YES and NO.
+# If left blank NO is used.
+
+RECURSIVE = YES
+
+# The EXCLUDE tag can be used to specify files and/or directories that should
+# excluded from the INPUT source files. This way you can easily exclude a
+# subdirectory from a directory tree whose root is specified with the INPUT tag.
+# Note that relative paths are relative to directory from which doxygen is run.
+
+EXCLUDE =
+
+# The EXCLUDE_SYMLINKS tag can be used select whether or not files or
+# directories that are symbolic links (a Unix file system feature) are excluded
+# from the input.
+
+EXCLUDE_SYMLINKS = NO
+
+# If the value of the INPUT tag contains directories, you can use the
+# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
+# certain files from those directories. Note that the wildcards are matched
+# against the file with absolute path, so to exclude all test directories
+# for example use the pattern */test/*
+
+EXCLUDE_PATTERNS =
+
+# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
+# (namespaces, classes, functions, etc.) that should be excluded from the
+# output. The symbol name can be a fully qualified name, a word, or if the
+# wildcard * is used, a substring. Examples: ANamespace, AClass,
+# AClass::ANamespace, ANamespace::*Test
+
+EXCLUDE_SYMBOLS =
+
+# The EXAMPLE_PATH tag can be used to specify one or more files or
+# directories that contain example code fragments that are included (see
+# the \include command).
+
+EXAMPLE_PATH =
+
+# If the value of the EXAMPLE_PATH tag contains directories, you can use the
+# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
+# and *.h) to filter out the source-files in the directories. If left
+# blank all files are included.
+
+EXAMPLE_PATTERNS = *
+
+# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
+# searched for input files to be used with the \include or \dontinclude
+# commands irrespective of the value of the RECURSIVE tag.
+# Possible values are YES and NO. If left blank NO is used.
+
+EXAMPLE_RECURSIVE = NO
+
+# The IMAGE_PATH tag can be used to specify one or more files or
+# directories that contain image that are included in the documentation (see
+# the \image command).
+
+IMAGE_PATH =
+
+# The INPUT_FILTER tag can be used to specify a program that doxygen should
+# invoke to filter for each input file. Doxygen will invoke the filter program
+# by executing (via popen()) the command <filter> <input-file>, where <filter>
+# is the value of the INPUT_FILTER tag, and <input-file> is the name of an
+# input file. Doxygen will then use the output that the filter program writes
+# to standard output. If FILTER_PATTERNS is specified, this tag will be
+# ignored.
+
+INPUT_FILTER =
+
+# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
+# basis. Doxygen will compare the file name with each pattern and apply the
+# filter if there is a match. The filters are a list of the form:
+# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further
+# info on how filters are used. If FILTER_PATTERNS is empty or if
+# non of the patterns match the file name, INPUT_FILTER is applied.
+
+FILTER_PATTERNS =
+
+# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
+# INPUT_FILTER) will be used to filter the input files when producing source
+# files to browse (i.e. when SOURCE_BROWSER is set to YES).
+
+FILTER_SOURCE_FILES = NO
+
+# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
+# pattern. A pattern will override the setting for FILTER_PATTERN (if any)
+# and it is also possible to disable source filtering for a specific pattern
+# using *.ext= (so without naming a filter). This option only has effect when
+# FILTER_SOURCE_FILES is enabled.
+
+FILTER_SOURCE_PATTERNS =
+
+#---------------------------------------------------------------------------
+# configuration options related to source browsing
+#---------------------------------------------------------------------------
+
+# If the SOURCE_BROWSER tag is set to YES then a list of source files will
+# be generated. Documented entities will be cross-referenced with these sources.
+# Note: To get rid of all source code in the generated output, make sure also
+# VERBATIM_HEADERS is set to NO.
+
+SOURCE_BROWSER = NO
+
+# Setting the INLINE_SOURCES tag to YES will include the body
+# of functions and classes directly in the documentation.
+
+INLINE_SOURCES = NO
+
+# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct
+# doxygen to hide any special comment blocks from generated source code
+# fragments. Normal C and C++ comments will always remain visible.
+
+STRIP_CODE_COMMENTS = YES
+
+# If the REFERENCED_BY_RELATION tag is set to YES
+# then for each documented function all documented
+# functions referencing it will be listed.
+
+REFERENCED_BY_RELATION = NO
+
+# If the REFERENCES_RELATION tag is set to YES
+# then for each documented function all documented entities
+# called/used by that function will be listed.
+
+REFERENCES_RELATION = NO
+
+# If the REFERENCES_LINK_SOURCE tag is set to YES (the default)
+# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from
+# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will
+# link to the source code. Otherwise they will link to the documentation.
+
+REFERENCES_LINK_SOURCE = YES
+
+# If the USE_HTAGS tag is set to YES then the references to source code
+# will point to the HTML generated by the htags(1) tool instead of doxygen
+# built-in source browser. The htags tool is part of GNU's global source
+# tagging system (see http://www.gnu.org/software/global/global.html). You
+# will need version 4.8.6 or higher.
+
+USE_HTAGS = NO
+
+# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen
+# will generate a verbatim copy of the header file for each class for
+# which an include is specified. Set to NO to disable this.
+
+VERBATIM_HEADERS = YES
+
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+
+# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index
+# of all compounds will be generated. Enable this if the project
+# contains a lot of classes, structs, unions or interfaces.
+
+ALPHABETICAL_INDEX = YES
+
+# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then
+# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns
+# in which this list will be split (can be a number in the range [1..20])
+
+COLS_IN_ALPHA_INDEX = 5
+
+# In case all classes in a project start with a common prefix, all
+# classes will be put under the same header in the alphabetical index.
+# The IGNORE_PREFIX tag can be used to specify one or more prefixes that
+# should be ignored while generating the index headers.
+
+IGNORE_PREFIX =
+
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_HTML tag is set to YES (the default) Doxygen will
+# generate HTML output.
+
+GENERATE_HTML = NO
+
+# The HTML_OUTPUT tag is used to specify where the HTML docs will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `html' will be used as the default path.
+
+HTML_OUTPUT = html
+
+# The HTML_FILE_EXTENSION tag can be used to specify the file extension for
+# each generated HTML page (for example: .htm,.php,.asp). If it is left blank
+# doxygen will generate files with .html extension.
+
+HTML_FILE_EXTENSION = .html
+
+# The HTML_HEADER tag can be used to specify a personal HTML header for
+# each generated HTML page. If it is left blank doxygen will generate a
+# standard header. Note that when using a custom header you are responsible
+# for the proper inclusion of any scripts and style sheets that doxygen
+# needs, which is dependent on the configuration options used.
+# It is adviced to generate a default header using "doxygen -w html
+# header.html footer.html stylesheet.css YourConfigFile" and then modify
+# that header. Note that the header is subject to change so you typically
+# have to redo this when upgrading to a newer version of doxygen or when
+# changing the value of configuration settings such as GENERATE_TREEVIEW!
+
+HTML_HEADER =
+
+# The HTML_FOOTER tag can be used to specify a personal HTML footer for
+# each generated HTML page. If it is left blank doxygen will generate a
+# standard footer.
+
+HTML_FOOTER =
+
+# The HTML_STYLESHEET tag can be used to specify a user-defined cascading
+# style sheet that is used by each HTML page. It can be used to
+# fine-tune the look of the HTML output. If the tag is left blank doxygen
+# will generate a default style sheet. Note that doxygen will try to copy
+# the style sheet file to the HTML output directory, so don't put your own
+# stylesheet in the HTML output directory as well, or it will be erased!
+
+HTML_STYLESHEET =
+
+# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
+# other source files which should be copied to the HTML output directory. Note
+# that these files will be copied to the base HTML output directory. Use the
+# $relpath$ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
+# files. In the HTML_STYLESHEET file, use the file name only. Also note that
+# the files will be copied as-is; there are no commands or markers available.
+
+HTML_EXTRA_FILES =
+
+# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output.
+# Doxygen will adjust the colors in the stylesheet and background images
+# according to this color. Hue is specified as an angle on a colorwheel,
+# see http://en.wikipedia.org/wiki/Hue for more information.
+# For instance the value 0 represents red, 60 is yellow, 120 is green,
+# 180 is cyan, 240 is blue, 300 purple, and 360 is red again.
+# The allowed range is 0 to 359.
+
+HTML_COLORSTYLE_HUE = 220
+
+# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of
+# the colors in the HTML output. For a value of 0 the output will use
+# grayscales only. A value of 255 will produce the most vivid colors.
+
+HTML_COLORSTYLE_SAT = 100
+
+# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to
+# the luminance component of the colors in the HTML output. Values below
+# 100 gradually make the output lighter, whereas values above 100 make
+# the output darker. The value divided by 100 is the actual gamma applied,
+# so 80 represents a gamma of 0.8, The value 220 represents a gamma of 2.2,
+# and 100 does not change the gamma.
+
+HTML_COLORSTYLE_GAMMA = 80
+
+# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
+# page will contain the date and time when the page was generated. Setting
+# this to NO can help when comparing the output of multiple runs.
+
+HTML_TIMESTAMP = YES
+
+# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes,
+# files or namespaces will be aligned in HTML using tables. If set to
+# NO a bullet list will be used.
+
+HTML_ALIGN_MEMBERS = YES
+
+# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
+# documentation will contain sections that can be hidden and shown after the
+# page has loaded. For this to work a browser that supports
+# JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox
+# Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari).
+
+HTML_DYNAMIC_SECTIONS = NO
+
+# If the GENERATE_DOCSET tag is set to YES, additional index files
+# will be generated that can be used as input for Apple's Xcode 3
+# integrated development environment, introduced with OSX 10.5 (Leopard).
+# To create a documentation set, doxygen will generate a Makefile in the
+# HTML output directory. Running make will produce the docset in that
+# directory and running "make install" will install the docset in
+# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find
+# it at startup.
+# See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
+# for more information.
+
+GENERATE_DOCSET = NO
+
+# When GENERATE_DOCSET tag is set to YES, this tag determines the name of the
+# feed. A documentation feed provides an umbrella under which multiple
+# documentation sets from a single provider (such as a company or product suite)
+# can be grouped.
+
+DOCSET_FEEDNAME = "Doxygen generated docs"
+
+# When GENERATE_DOCSET tag is set to YES, this tag specifies a string that
+# should uniquely identify the documentation set bundle. This should be a
+# reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen
+# will append .docset to the name.
+
+DOCSET_BUNDLE_ID = org.doxygen.Project
+
+# When GENERATE_PUBLISHER_ID tag specifies a string that should uniquely identify
+# the documentation publisher. This should be a reverse domain-name style
+# string, e.g. com.mycompany.MyDocSet.documentation.
+
+DOCSET_PUBLISHER_ID = org.doxygen.Publisher
+
+# The GENERATE_PUBLISHER_NAME tag identifies the documentation publisher.
+
+DOCSET_PUBLISHER_NAME = Publisher
+
+# If the GENERATE_HTMLHELP tag is set to YES, additional index files
+# will be generated that can be used as input for tools like the
+# Microsoft HTML help workshop to generate a compiled HTML help file (.chm)
+# of the generated HTML documentation.
+
+GENERATE_HTMLHELP = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can
+# be used to specify the file name of the resulting .chm file. You
+# can add a path in front of the file if the result should not be
+# written to the html output directory.
+
+CHM_FILE =
+
+# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can
+# be used to specify the location (absolute path including file name) of
+# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run
+# the HTML help compiler on the generated index.hhp.
+
+HHC_LOCATION =
+
+# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag
+# controls if a separate .chi index file is generated (YES) or that
+# it should be included in the master .chm file (NO).
+
+GENERATE_CHI = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING
+# is used to encode HtmlHelp index (hhk), content (hhc) and project file
+# content.
+
+CHM_INDEX_ENCODING =
+
+# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag
+# controls whether a binary table of contents is generated (YES) or a
+# normal table of contents (NO) in the .chm file.
+
+BINARY_TOC = NO
+
+# The TOC_EXPAND flag can be set to YES to add extra items for group members
+# to the contents of the HTML help documentation and to the tree view.
+
+TOC_EXPAND = NO
+
+# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
+# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated
+# that can be used as input for Qt's qhelpgenerator to generate a
+# Qt Compressed Help (.qch) of the generated HTML documentation.
+
+GENERATE_QHP = NO
+
+# If the QHG_LOCATION tag is specified, the QCH_FILE tag can
+# be used to specify the file name of the resulting .qch file.
+# The path specified is relative to the HTML output folder.
+
+QCH_FILE =
+
+# The QHP_NAMESPACE tag specifies the namespace to use when generating
+# Qt Help Project output. For more information please see
+# http://doc.trolltech.com/qthelpproject.html#namespace
+
+QHP_NAMESPACE = org.doxygen.Project
+
+# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating
+# Qt Help Project output. For more information please see
+# http://doc.trolltech.com/qthelpproject.html#virtual-folders
+
+QHP_VIRTUAL_FOLDER = doc
+
+# If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to
+# add. For more information please see
+# http://doc.trolltech.com/qthelpproject.html#custom-filters
+
+QHP_CUST_FILTER_NAME =
+
+# The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the
+# custom filter to add. For more information please see
+# <a href="http://doc.trolltech.com/qthelpproject.html#custom-filters">
+# Qt Help Project / Custom Filters</a>.
+
+QHP_CUST_FILTER_ATTRS =
+
+# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
+# project's
+# filter section matches.
+# <a href="http://doc.trolltech.com/qthelpproject.html#filter-attributes">
+# Qt Help Project / Filter Attributes</a>.
+
+QHP_SECT_FILTER_ATTRS =
+
+# If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can
+# be used to specify the location of Qt's qhelpgenerator.
+# If non-empty doxygen will try to run qhelpgenerator on the generated
+# .qhp file.
+
+QHG_LOCATION =
+
+# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files
+# will be generated, which together with the HTML files, form an Eclipse help
+# plugin. To install this plugin and make it available under the help contents
+# menu in Eclipse, the contents of the directory containing the HTML and XML
+# files needs to be copied into the plugins directory of eclipse. The name of
+# the directory within the plugins directory should be the same as
+# the ECLIPSE_DOC_ID value. After copying Eclipse needs to be restarted before
+# the help appears.
+
+GENERATE_ECLIPSEHELP = NO
+
+# A unique identifier for the eclipse help plugin. When installing the plugin
+# the directory name containing the HTML and XML files should also have
+# this name.
+
+ECLIPSE_DOC_ID = org.doxygen.Project
+
+# The DISABLE_INDEX tag can be used to turn on/off the condensed index at
+# top of each HTML page. The value NO (the default) enables the index and
+# the value YES disables it.
+
+DISABLE_INDEX = NO
+
+# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values
+# (range [0,1..20]) that doxygen will group on one line in the generated HTML
+# documentation. Note that a value of 0 will completely suppress the enum
+# values from appearing in the overview section.
+
+ENUM_VALUES_PER_LINE = 4
+
+# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
+# structure should be generated to display hierarchical information.
+# If the tag value is set to YES, a side panel will be generated
+# containing a tree-like index structure (just like the one that
+# is generated for HTML Help). For this to work a browser that supports
+# JavaScript, DHTML, CSS and frames is required (i.e. any modern browser).
+# Windows users are probably better off using the HTML help feature.
+
+GENERATE_TREEVIEW = NO
+
+# By enabling USE_INLINE_TREES, doxygen will generate the Groups, Directories,
+# and Class Hierarchy pages using a tree view instead of an ordered list.
+
+USE_INLINE_TREES = NO
+
+# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be
+# used to set the initial width (in pixels) of the frame in which the tree
+# is shown.
+
+TREEVIEW_WIDTH = 250
+
+# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open
+# links to external symbols imported via tag files in a separate window.
+
+EXT_LINKS_IN_WINDOW = NO
+
+# Use this tag to change the font size of Latex formulas included
+# as images in the HTML documentation. The default is 10. Note that
+# when you change the font size after a successful doxygen run you need
+# to manually remove any form_*.png images from the HTML output directory
+# to force them to be regenerated.
+
+FORMULA_FONTSIZE = 10
+
+# Use the FORMULA_TRANPARENT tag to determine whether or not the images
+# generated for formulas are transparent PNGs. Transparent PNGs are
+# not supported properly for IE 6.0, but are supported on all modern browsers.
+# Note that when changing this option you need to delete any form_*.png files
+# in the HTML output before the changes have effect.
+
+FORMULA_TRANSPARENT = YES
+
+# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax
+# (see http://www.mathjax.org) which uses client side Javascript for the
+# rendering instead of using prerendered bitmaps. Use this if you do not
+# have LaTeX installed or if you want to formulas look prettier in the HTML
+# output. When enabled you also need to install MathJax separately and
+# configure the path to it using the MATHJAX_RELPATH option.
+
+USE_MATHJAX = NO
+
+# When MathJax is enabled you need to specify the location relative to the
+# HTML output directory using the MATHJAX_RELPATH option. The destination
+# directory should contain the MathJax.js script. For instance, if the mathjax
+# directory is located at the same level as the HTML output directory, then
+# MATHJAX_RELPATH should be ../mathjax. The default value points to the
+# mathjax.org site, so you can quickly see the result without installing
+# MathJax, but it is strongly recommended to install a local copy of MathJax
+# before deployment.
+
+MATHJAX_RELPATH = http://www.mathjax.org/mathjax
+
+# The MATHJAX_EXTENSIONS tag can be used to specify one or MathJax extension
+# names that should be enabled during MathJax rendering.
+
+MATHJAX_EXTENSIONS =
+
+# When the SEARCHENGINE tag is enabled doxygen will generate a search box
+# for the HTML output. The underlying search engine uses javascript
+# and DHTML and should work on any modern browser. Note that when using
+# HTML help (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets
+# (GENERATE_DOCSET) there is already a search function so this one should
+# typically be disabled. For large projects the javascript based search engine
+# can be slow, then enabling SERVER_BASED_SEARCH may provide a better solution.
+
+SEARCHENGINE = YES
+
+# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
+# implemented using a PHP enabled web server instead of at the web client
+# using Javascript. Doxygen will generate the search PHP script and index
+# file to put on the web server. The advantage of the server
+# based approach is that it scales better to large projects and allows
+# full text search. The disadvantages are that it is more difficult to setup
+# and does not have live searching capabilities.
+
+SERVER_BASED_SEARCH = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will
+# generate Latex output.
+
+GENERATE_LATEX = YES
+
+# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `latex' will be used as the default path.
+
+LATEX_OUTPUT = latex
+
+# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
+# invoked. If left blank `latex' will be used as the default command name.
+# Note that when enabling USE_PDFLATEX this option is only used for
+# generating bitmaps for formulas in the HTML output, but not in the
+# Makefile that is written to the output directory.
+
+LATEX_CMD_NAME = latex
+
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to
+# generate index for LaTeX. If left blank `makeindex' will be used as the
+# default command name.
+
+MAKEINDEX_CMD_NAME = makeindex
+
+# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact
+# LaTeX documents. This may be useful for small projects and may help to
+# save some trees in general.
+
+COMPACT_LATEX = NO
+
+# The PAPER_TYPE tag can be used to set the paper type that is used
+# by the printer. Possible values are: a4, letter, legal and
+# executive. If left blank a4wide will be used.
+
+PAPER_TYPE = a4
+
+# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX
+# packages that should be included in the LaTeX output.
+
+EXTRA_PACKAGES =
+
+# The LATEX_HEADER tag can be used to specify a personal LaTeX header for
+# the generated latex document. The header should contain everything until
+# the first chapter. If it is left blank doxygen will generate a
+# standard header. Notice: only use this tag if you know what you are doing!
+
+LATEX_HEADER =
+
+# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for
+# the generated latex document. The footer should contain everything after
+# the last chapter. If it is left blank doxygen will generate a
+# standard footer. Notice: only use this tag if you know what you are doing!
+
+LATEX_FOOTER =
+
+# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated
+# is prepared for conversion to pdf (using ps2pdf). The pdf file will
+# contain links (just like the HTML output) instead of page references
+# This makes the output suitable for online browsing using a pdf viewer.
+
+PDF_HYPERLINKS = YES
+
+# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of
+# plain latex in the generated Makefile. Set this option to YES to get a
+# higher quality PDF documentation.
+
+USE_PDFLATEX = YES
+
+# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode.
+# command to the generated LaTeX files. This will instruct LaTeX to keep
+# running if errors occur, instead of asking the user for help.
+# This option is also used when generating formulas in HTML.
+
+LATEX_BATCHMODE = NO
+
+# If LATEX_HIDE_INDICES is set to YES then doxygen will not
+# include the index chapters (such as File Index, Compound Index, etc.)
+# in the output.
+
+LATEX_HIDE_INDICES = NO
+
+# If LATEX_SOURCE_CODE is set to YES then doxygen will include
+# source code with syntax highlighting in the LaTeX output.
+# Note that which sources are shown also depends on other settings
+# such as SOURCE_BROWSER.
+
+LATEX_SOURCE_CODE = NO
+
+# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
+# bibliography, e.g. plainnat, or ieeetr. The default style is "plain". See
+# http://en.wikipedia.org/wiki/BibTeX for more info.
+
+LATEX_BIB_STYLE = plain
+
+#---------------------------------------------------------------------------
+# configuration options related to the RTF output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output
+# The RTF output is optimized for Word 97 and may not look very pretty with
+# other RTF readers or editors.
+
+GENERATE_RTF = NO
+
+# The RTF_OUTPUT tag is used to specify where the RTF docs will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `rtf' will be used as the default path.
+
+RTF_OUTPUT = rtf
+
+# If the COMPACT_RTF tag is set to YES Doxygen generates more compact
+# RTF documents. This may be useful for small projects and may help to
+# save some trees in general.
+
+COMPACT_RTF = NO
+
+# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated
+# will contain hyperlink fields. The RTF file will
+# contain links (just like the HTML output) instead of page references.
+# This makes the output suitable for online browsing using WORD or other
+# programs which support those fields.
+# Note: wordpad (write) and others do not support links.
+
+RTF_HYPERLINKS = NO
+
+# Load stylesheet definitions from file. Syntax is similar to doxygen's
+# config file, i.e. a series of assignments. You only have to provide
+# replacements, missing definitions are set to their default value.
+
+RTF_STYLESHEET_FILE =
+
+# Set optional variables used in the generation of an rtf document.
+# Syntax is similar to doxygen's config file.
+
+RTF_EXTENSIONS_FILE =
+
+#---------------------------------------------------------------------------
+# configuration options related to the man page output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_MAN tag is set to YES (the default) Doxygen will
+# generate man pages
+
+GENERATE_MAN = NO
+
+# The MAN_OUTPUT tag is used to specify where the man pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `man' will be used as the default path.
+
+MAN_OUTPUT = man
+
+# The MAN_EXTENSION tag determines the extension that is added to
+# the generated man pages (default is the subroutine's section .3)
+
+MAN_EXTENSION = .3
+
+# If the MAN_LINKS tag is set to YES and Doxygen generates man output,
+# then it will generate one additional man file for each entity
+# documented in the real man page(s). These additional files
+# only source the real man page, but without them the man command
+# would be unable to find the correct page. The default is NO.
+
+MAN_LINKS = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the XML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_XML tag is set to YES Doxygen will
+# generate an XML file that captures the structure of
+# the code including all documentation.
+
+GENERATE_XML = NO
+
+# The XML_OUTPUT tag is used to specify where the XML pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `xml' will be used as the default path.
+
+XML_OUTPUT = xml
+
+# The XML_SCHEMA tag can be used to specify an XML schema,
+# which can be used by a validating XML parser to check the
+# syntax of the XML files.
+
+XML_SCHEMA =
+
+# The XML_DTD tag can be used to specify an XML DTD,
+# which can be used by a validating XML parser to check the
+# syntax of the XML files.
+
+XML_DTD =
+
+# If the XML_PROGRAMLISTING tag is set to YES Doxygen will
+# dump the program listings (including syntax highlighting
+# and cross-referencing information) to the XML output. Note that
+# enabling this will significantly increase the size of the XML output.
+
+XML_PROGRAMLISTING = YES
+
+#---------------------------------------------------------------------------
+# configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will
+# generate an AutoGen Definitions (see autogen.sf.net) file
+# that captures the structure of the code including all
+# documentation. Note that this feature is still experimental
+# and incomplete at the moment.
+
+GENERATE_AUTOGEN_DEF = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_PERLMOD tag is set to YES Doxygen will
+# generate a Perl module file that captures the structure of
+# the code including all documentation. Note that this
+# feature is still experimental and incomplete at the
+# moment.
+
+GENERATE_PERLMOD = NO
+
+# If the PERLMOD_LATEX tag is set to YES Doxygen will generate
+# the necessary Makefile rules, Perl scripts and LaTeX code to be able
+# to generate PDF and DVI output from the Perl module output.
+
+PERLMOD_LATEX = NO
+
+# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be
+# nicely formatted so it can be parsed by a human reader. This is useful
+# if you want to understand what is going on. On the other hand, if this
+# tag is set to NO the size of the Perl module output will be much smaller
+# and Perl will parse it just the same.
+
+PERLMOD_PRETTY = YES
+
+# The names of the make variables in the generated doxyrules.make file
+# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX.
+# This is useful so different doxyrules.make files included by the same
+# Makefile don't overwrite each other's variables.
+
+PERLMOD_MAKEVAR_PREFIX =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor
+#---------------------------------------------------------------------------
+
+# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will
+# evaluate all C-preprocessor directives found in the sources and include
+# files.
+
+ENABLE_PREPROCESSING = YES
+
+# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro
+# names in the source code. If set to NO (the default) only conditional
+# compilation will be performed. Macro expansion can be done in a controlled
+# way by setting EXPAND_ONLY_PREDEF to YES.
+
+MACRO_EXPANSION = NO
+
+# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES
+# then the macro expansion is limited to the macros specified with the
+# PREDEFINED and EXPAND_AS_DEFINED tags.
+
+EXPAND_ONLY_PREDEF = NO
+
+# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files
+# pointed to by INCLUDE_PATH will be searched when a #include is found.
+
+SEARCH_INCLUDES = YES
+
+# The INCLUDE_PATH tag can be used to specify one or more directories that
+# contain include files that are not input files but should be processed by
+# the preprocessor.
+
+INCLUDE_PATH =
+
+# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
+# patterns (like *.h and *.hpp) to filter out the header-files in the
+# directories. If left blank, the patterns specified with FILE_PATTERNS will
+# be used.
+
+INCLUDE_FILE_PATTERNS =
+
+# The PREDEFINED tag can be used to specify one or more macro names that
+# are defined before the preprocessor is started (similar to the -D option of
+# gcc). The argument of the tag is a list of macros of the form: name
+# or name=definition (no spaces). If the definition and the = are
+# omitted =1 is assumed. To prevent a macro definition from being
+# undefined via #undef or recursively expanded use the := operator
+# instead of the = operator.
+
+PREDEFINED =
+
+# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
+# this tag can be used to specify a list of macro names that should be expanded.
+# The macro definition that is found in the sources will be used.
+# Use the PREDEFINED tag if you want to use a different macro definition that
+# overrules the definition found in the source code.
+
+EXPAND_AS_DEFINED =
+
+# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then
+# doxygen's preprocessor will remove all references to function-like macros
+# that are alone on a line, have an all uppercase name, and do not end with a
+# semicolon, because these will confuse the parser if not removed.
+
+SKIP_FUNCTION_MACROS = YES
+
+#---------------------------------------------------------------------------
+# Configuration::additions related to external references
+#---------------------------------------------------------------------------
+
+# The TAGFILES option can be used to specify one or more tagfiles.
+# Optionally an initial location of the external documentation
+# can be added for each tagfile. The format of a tag file without
+# this location is as follows:
+# TAGFILES = file1 file2 ...
+# Adding location for the tag files is done as follows:
+# TAGFILES = file1=loc1 "file2 = loc2" ...
+# where "loc1" and "loc2" can be relative or absolute paths or
+# URLs. If a location is present for each tag, the installdox tool
+# does not have to be run to correct the links.
+# Note that each tag file must have a unique name
+# (where the name does NOT include the path)
+# If a tag file is not located in the directory in which doxygen
+# is run, you must also specify the path to the tagfile here.
+
+TAGFILES =
+
+# When a file name is specified after GENERATE_TAGFILE, doxygen will create
+# a tag file that is based on the input files it reads.
+
+GENERATE_TAGFILE =
+
+# If the ALLEXTERNALS tag is set to YES all external classes will be listed
+# in the class index. If set to NO only the inherited external classes
+# will be listed.
+
+ALLEXTERNALS = NO
+
+# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed
+# in the modules index. If set to NO, only the current project's groups will
+# be listed.
+
+EXTERNAL_GROUPS = YES
+
+# The PERL_PATH should be the absolute path and name of the perl script
+# interpreter (i.e. the result of `which perl').
+
+PERL_PATH = /usr/bin/perl
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+
+# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will
+# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base
+# or super classes. Setting the tag to NO turns the diagrams off. Note that
+# this option also works with HAVE_DOT disabled, but it is recommended to
+# install and use dot, since it yields more powerful graphs.
+
+CLASS_DIAGRAMS = YES
+
+# You can define message sequence charts within doxygen comments using the \msc
+# command. Doxygen will then run the mscgen tool (see
+# http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the
+# documentation. The MSCGEN_PATH tag allows you to specify the directory where
+# the mscgen tool resides. If left empty the tool is assumed to be found in the
+# default search path.
+
+MSCGEN_PATH =
+
+# If set to YES, the inheritance and collaboration graphs will hide
+# inheritance and usage relations if the target is undocumented
+# or is not a class.
+
+HIDE_UNDOC_RELATIONS = YES
+
+# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
+# available from the path. This tool is part of Graphviz, a graph visualization
+# toolkit from AT&T and Lucent Bell Labs. The other options in this section
+# have no effect if this option is set to NO (the default)
+
+HAVE_DOT = NO
+
+# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is
+# allowed to run in parallel. When set to 0 (the default) doxygen will
+# base this on the number of processors available in the system. You can set it
+# explicitly to a value larger than 0 to get control over the balance
+# between CPU load and processing speed.
+
+DOT_NUM_THREADS = 0
+
+# By default doxygen will use the Helvetica font for all dot files that
+# doxygen generates. When you want a differently looking font you can specify
+# the font name using DOT_FONTNAME. You need to make sure dot is able to find
+# the font, which can be done by putting it in a standard location or by setting
+# the DOTFONTPATH environment variable or by setting DOT_FONTPATH to the
+# directory containing the font.
+
+DOT_FONTNAME = Helvetica
+
+# The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs.
+# The default size is 10pt.
+
+DOT_FONTSIZE = 10
+
+# By default doxygen will tell dot to use the Helvetica font.
+# If you specify a different font using DOT_FONTNAME you can use DOT_FONTPATH to
+# set the path where dot can find it.
+
+DOT_FONTPATH =
+
+# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen
+# will generate a graph for each documented class showing the direct and
+# indirect inheritance relations. Setting this tag to YES will force the
+# the CLASS_DIAGRAMS tag to NO.
+
+CLASS_GRAPH = YES
+
+# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen
+# will generate a graph for each documented class showing the direct and
+# indirect implementation dependencies (inheritance, containment, and
+# class references variables) of the class with other documented classes.
+
+COLLABORATION_GRAPH = YES
+
+# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen
+# will generate a graph for groups, showing the direct groups dependencies
+
+GROUP_GRAPHS = YES
+
+# If the UML_LOOK tag is set to YES doxygen will generate inheritance and
+# collaboration diagrams in a style similar to the OMG's Unified Modeling
+# Language.
+
+UML_LOOK = NO
+
+# If set to YES, the inheritance and collaboration graphs will show the
+# relations between templates and their instances.
+
+TEMPLATE_RELATIONS = NO
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT
+# tags are set to YES then doxygen will generate a graph for each documented
+# file showing the direct and indirect include dependencies of the file with
+# other documented files.
+
+INCLUDE_GRAPH = YES
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and
+# HAVE_DOT tags are set to YES then doxygen will generate a graph for each
+# documented header file showing the documented files that directly or
+# indirectly include this file.
+
+INCLUDED_BY_GRAPH = YES
+
+# If the CALL_GRAPH and HAVE_DOT options are set to YES then
+# doxygen will generate a call dependency graph for every global function
+# or class method. Note that enabling this option will significantly increase
+# the time of a run. So in most cases it will be better to enable call graphs
+# for selected functions only using the \callgraph command.
+
+CALL_GRAPH = NO
+
+# If the CALLER_GRAPH and HAVE_DOT tags are set to YES then
+# doxygen will generate a caller dependency graph for every global function
+# or class method. Note that enabling this option will significantly increase
+# the time of a run. So in most cases it will be better to enable caller
+# graphs for selected functions only using the \callergraph command.
+
+CALLER_GRAPH = NO
+
+# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen
+# will generate a graphical hierarchy of all classes instead of a textual one.
+
+GRAPHICAL_HIERARCHY = YES
+
+# If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES
+# then doxygen will show the dependencies a directory has on other directories
+# in a graphical way. The dependency relations are determined by the #include
+# relations between the files in the directories.
+
+DIRECTORY_GRAPH = YES
+
+# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
+# generated by dot. Possible values are svg, png, jpg, or gif.
+# If left blank png will be used. If you choose svg you need to set
+# HTML_FILE_EXTENSION to xhtml in order to make the SVG files
+# visible in IE 9+ (other browsers do not have this requirement).
+
+DOT_IMAGE_FORMAT = png
+
+# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
+# enable generation of interactive SVG images that allow zooming and panning.
+# Note that this requires a modern browser other than Internet Explorer.
+# Tested and working are Firefox, Chrome, Safari, and Opera. For IE 9+ you
+# need to set HTML_FILE_EXTENSION to xhtml in order to make the SVG files
+# visible. Older versions of IE do not have SVG support.
+
+INTERACTIVE_SVG = NO
+
+# The tag DOT_PATH can be used to specify the path where the dot tool can be
+# found. If left blank, it is assumed the dot tool can be found in the path.
+
+DOT_PATH =
+
+# The DOTFILE_DIRS tag can be used to specify one or more directories that
+# contain dot files that are included in the documentation (see the
+# \dotfile command).
+
+DOTFILE_DIRS =
+
+# The MSCFILE_DIRS tag can be used to specify one or more directories that
+# contain msc files that are included in the documentation (see the
+# \mscfile command).
+
+MSCFILE_DIRS =
+
+# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of
+# nodes that will be shown in the graph. If the number of nodes in a graph
+# becomes larger than this value, doxygen will truncate the graph, which is
+# visualized by representing a node as a red box. Note that doxygen if the
+# number of direct children of the root node in a graph is already larger than
+# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note
+# that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
+
+DOT_GRAPH_MAX_NODES = 50
+
+# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the
+# graphs generated by dot. A depth value of 3 means that only nodes reachable
+# from the root by following a path via at most 3 edges will be shown. Nodes
+# that lay further from the root node will be omitted. Note that setting this
+# option to 1 or 2 may greatly reduce the computation time needed for large
+# code bases. Also note that the size of a graph can be further restricted by
+# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
+
+MAX_DOT_GRAPH_DEPTH = 0
+
+# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
+# background. This is disabled by default, because dot on Windows does not
+# seem to support this out of the box. Warning: Depending on the platform used,
+# enabling this option may lead to badly anti-aliased labels on the edges of
+# a graph (i.e. they become hard to read).
+
+DOT_TRANSPARENT = NO
+
+# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
+# files in one run (i.e. multiple -o and -T options on the command line). This
+# makes dot run faster, but since only newer versions of dot (>1.8.10)
+# support this, this feature is disabled by default.
+
+DOT_MULTI_TARGETS = NO
+
+# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will
+# generate a legend page explaining the meaning of the various boxes and
+# arrows in the dot generated graphs.
+
+GENERATE_LEGEND = YES
+
+# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will
+# remove the intermediate dot files that are used to generate
+# the various graphs.
+
+DOT_CLEANUP = YES
diff --git a/Utilities/KalDet/src/lctpc/doc/GearTPC_mainpage.h b/Utilities/KalDet/src/lctpc/doc/GearTPC_mainpage.h
new file mode 100644
index 0000000000000000000000000000000000000000..b6793715ca22da768de1841a8cf5170372b0b009
--- /dev/null
+++ b/Utilities/KalDet/src/lctpc/doc/GearTPC_mainpage.h
@@ -0,0 +1,15 @@
+/**
+@mainpage
+
+GearTPCKalDetector is a KalDet implementation for the LCTPC collaboration
+which is flexible enough to handle multiple detector geometries
+without having to adapt the code. It instantiates the full KalDet geometry only from information from the Gear file.
+The design is flexible enough that any geometry which can be described with gear
+can also be treated by the Kalman detector. Currently not all parts are
+implemented, for instance straight pad rows / Kalman layers. In this
+case an error message is printed and a gear::NotImplementedException is thrown.
+
+For backward compatibility the EXTPC interface has been reimplemented using
+the GearTPC classes. Once all dependencies on EXTPC have been removed from
+MarlinTPC these compatibility classes will be removed from KalDet.
+ */
diff --git a/Utilities/KalDet/src/lctpc/doc/Readme b/Utilities/KalDet/src/lctpc/doc/Readme
new file mode 100644
index 0000000000000000000000000000000000000000..bfb7eb61b1155634b636efa6a360315d793083ff
--- /dev/null
+++ b/Utilities/KalDet/src/lctpc/doc/Readme
@@ -0,0 +1,4 @@
+There are two different doxy-files for html and latex. For the latex version
+the sourcecode brower, namespace and file lists are truned of in order not to
+overload the document with information that is not very useful when
+printed. In the html version you want these features.
diff --git a/Utilities/KalDet/src/lctpc/gearTPC/EXTPCHit.cxx b/Utilities/KalDet/src/lctpc/gearTPC/EXTPCHit.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..91aa0898cfc369fecb55f2eb75b6bbb77f77cd7c
--- /dev/null
+++ b/Utilities/KalDet/src/lctpc/gearTPC/EXTPCHit.cxx
@@ -0,0 +1,27 @@
+#include "EXTPCHit.h"
+
+EXTPCHit::EXTPCHit(Int_t m) : kaldet::GearTPCCylinderHit(m) , fSide(0) {}
+
+EXTPCHit::EXTPCHit(const TVMeasLayer &ms,
+ Double_t *x,
+ Double_t *dx,
+ Int_t side,
+ Double_t v,
+ const TVector3 &xx,
+ Double_t b,
+ Int_t m)
+ : kaldet::GearTPCCylinderHit(ms, x, dx, xx, b, v, m), fSide(side) {}
+
+EXTPCHit::EXTPCHit(const TVMeasLayer &ms,
+ Double_t *x,
+ Double_t *dx,
+ Int_t side,
+ Double_t v,
+ const void *hitp,
+ Double_t b,
+ Int_t m)
+ : kaldet::GearTPCCylinderHit(ms, x, dx, hitp, b, v, m), fSide(side) {}
+
+EXTPCHit::~EXTPCHit()
+{}
+
diff --git a/Utilities/KalDet/src/lctpc/gearTPC/EXTPCHit.h b/Utilities/KalDet/src/lctpc/gearTPC/EXTPCHit.h
new file mode 100644
index 0000000000000000000000000000000000000000..8d604c36f5b3120156e030626f293e312aa3dac6
--- /dev/null
+++ b/Utilities/KalDet/src/lctpc/gearTPC/EXTPCHit.h
@@ -0,0 +1,54 @@
+#ifndef LCTPC_EXTPCHIT_H
+#define LCTPC_EXTPCHIT_H
+
+#include "GearTPCCylinderHit.h"
+#include <kaltest/TVMeasLayer.h>
+
+/**
+ * A backward compatibility class for GearTPCCylinderHit.
+ * Do not use this in new code, but use GearTPCCylinderHit directly.
+ * This class extends the GearTPCCylinderHit by a side, which is never used anywhere.
+ *
+ * \deprecated EXTPCHit
+ */
+
+class EXTPCHit : public kaldet::GearTPCCylinderHit
+{
+ public:
+ /// The default constructor.
+ EXTPCHit(Int_t m = kMdim);
+
+ /// Constructor initialising the original hit as 3D coordinates.
+ EXTPCHit(const TVMeasLayer &ms,
+ Double_t *x,
+ Double_t *dx,
+ Int_t side,
+ Double_t v,
+ const TVector3 &xx,
+ Double_t b,
+ Int_t m = kMdim);
+
+ /// Constructor initialising the original hit with a reference pointer.
+ EXTPCHit(const TVMeasLayer &ms,
+ Double_t *x,
+ Double_t *dx,
+ Int_t side,
+ Double_t v,
+ const void *hitp,
+ Double_t b,
+ Int_t m = kMdim);
+
+ /// The destructor.
+ virtual ~EXTPCHit();
+
+ /// Get the side value which has been set in the constructor.
+ inline Int_t GetSide () const { return fSide; }
+
+ private:
+ Int_t fSide; /// (-1, +1) = (-z side, +z side)
+
+ // ClassDef(EXTPCHit, 1) // EXTPC hit class
+
+};
+
+#endif // LCTPC_EXTPCHIT_H
diff --git a/Utilities/KalDet/src/lctpc/gearTPC/EXTPCKalDetector.cxx b/Utilities/KalDet/src/lctpc/gearTPC/EXTPCKalDetector.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..913398a456ce561ef8a97cbe7ae3f46cd1ea5bdc
--- /dev/null
+++ b/Utilities/KalDet/src/lctpc/gearTPC/EXTPCKalDetector.cxx
@@ -0,0 +1,76 @@
+#include "EXTPCKalDetector.h"
+#include <kaltest/TKalDetCradle.h>
+#include <gear/GearMgr.h>
+#include <gear/BField.h>
+// #include <streamlog/streamlog.h>
+#include <stdlib.h>
+// global constants from Marlin, used for the global pointer to the GearMgr
+// KILLENB: Worst style I have ever seen. Unfortunately needed to implement
+// the static (stupid!!) GetInstance function. I will kick this out as soon
+// as I have the comparison with the old code.
+//#include <marlin/Global.h>
+
+
+Double_t EXTPCKalDetector::fgVdrift = 76.e-3; // [mm/nsec]
+EXTPCKalDetector * EXTPCKalDetector::fgInstance=0;
+
+//ClassImp(EXTPCKalDetector)
+
+EXTPCKalDetector::EXTPCKalDetector(const gear::GearMgr& gearMgr)
+ : kaldet::GearTPCKalDetector(gearMgr)
+{
+ gear::BField const & bField = gearMgr.getBField();
+ // get the BField at 0,0,0. Check that there are no transverse components
+ // FIXME: Event though there are no transverse components at 0, 0, 0 does not mean
+ // there are no transverse components somewhere else.
+ gear::Vector3D bFieldVector = bField.at(gear::Vector3D(0., 0., 0.));
+ if (bFieldVector[0]!=0 || bFieldVector[1]!=0)
+ {
+ // streamlog_out(ERROR) << "B-field has transverse components."
+ // << " EXTPCKalDetector only works with homogeneous B-field"
+ // << " in z direction" << std::endl;
+ throw gear::Exception("Magnetic field not in z direction.");
+ }
+
+ fBField = bFieldVector[2];
+}
+
+EXTPCKalDetector::~EXTPCKalDetector()
+{}
+
+EXTPCKalDetector * EXTPCKalDetector::GetInstance()
+{
+ //gear::GearMgr const * gearMgr = marlin::Global::GEAR;
+
+ if (!fgInstance) {
+ //fgInstance = new EXTPCKalDetector(*gearMgr);
+ std::cout << "need to fix, no gearMgr...." << std::endl;
+ exit(1);
+ // Let's leak some memory. This cradle can never be deleted because we loose the pointer.
+ // But it cannot be deleted anyway because the Layers in the KalDetector have the cradle as
+ // parent, so deleting the cradle voids the detector.
+ // But you also cannot delete the KalDetector, because there are layers pointed to by the cradle.
+ // Stupid design.
+ TKalDetCradle * lp1tpc = new TKalDetCradle;
+ lp1tpc->Install(*fgInstance);
+ lp1tpc->Close();
+ lp1tpc->Sort();
+
+ //std::cout << "# of layers: " << lp1tpc.GetEntries() << std::endl;
+ }
+ return fgInstance;
+
+}
+
+ Double_t EXTPCKalDetector::GetBfield()
+ {
+ if (fgInstance)
+ return fgInstance->fBField;
+ else
+ {
+ // streamlog_out(ERROR) << " EXTPCKalDetector::GetBField() called without instantiating the object"
+ // << std::endl;
+ throw std::exception();
+ return 0;
+ }
+ }
diff --git a/Utilities/KalDet/src/lctpc/gearTPC/EXTPCKalDetector.h b/Utilities/KalDet/src/lctpc/gearTPC/EXTPCKalDetector.h
new file mode 100644
index 0000000000000000000000000000000000000000..96025f38d7ac92b6ac795935ca71b793a2b25799
--- /dev/null
+++ b/Utilities/KalDet/src/lctpc/gearTPC/EXTPCKalDetector.h
@@ -0,0 +1,45 @@
+#ifndef LCTPC_EXTPCKALDETECTOR_H
+#define LCTPC_EXTPCKALDETECTOR_H
+
+#include "GearTPCKalDetector.h"
+
+/**
+ * A backward compatibility class for GearTPCKalDetector.
+ * It basically provides a static instance of the detector which can be
+ * accessed via the GetInstance() method.
+ * In addition it provides the static GetVDrift() and GetBField(), which are used
+ * in the old code. The use of this class is highly depreciated.
+ *
+ * \deprecated EXTPCKalDetector
+ */
+
+class EXTPCKalDetector: public kaldet::GearTPCKalDetector
+{
+ private:
+ /// As this this a singleton class the constructor is private.
+ EXTPCKalDetector(const gear::GearMgr& gearMgr);
+
+public:
+ /// The destructor.
+ virtual ~EXTPCKalDetector();
+
+ /// Static access function to the singleton instance.
+ static EXTPCKalDetector * GetInstance();
+
+ /// Returns the hard coded drift velocity of 76.e-3 mm/ns.
+ static Double_t GetVdrift() { return fgVdrift; }
+
+ /// Static function to access the magnetic field.
+ static Double_t GetBfield();
+
+ private:
+ static Double_t fgVdrift; //< The drift velocity.
+ static EXTPCKalDetector * fgInstance; //< The singleton pointer.
+
+ Double_t fBField; //< The magnetic field
+
+ // ClassDef(EXTPCKalDetector, 1) // User defined detector class
+
+};
+
+#endif // LCTPC_EXTPCKALDETECTOR_H
diff --git a/Utilities/KalDet/src/lctpc/gearTPC/EXTPCMeasLayer.cxx b/Utilities/KalDet/src/lctpc/gearTPC/EXTPCMeasLayer.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..55f30ba5ae15f9387d1078b5b8c1e4f0e61f7a7b
--- /dev/null
+++ b/Utilities/KalDet/src/lctpc/gearTPC/EXTPCMeasLayer.cxx
@@ -0,0 +1,85 @@
+#include "EXTPCMeasLayer.h"
+#include "EXTPCKalDetector.h"
+#include "EXTPCHit.h"
+
+#include <TRandom.h>
+// #include <streamlog/streamlog.h>
+
+//ClassImp(EXTPCMeasLayer)
+
+EXTPCMeasLayer::EXTPCMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ Int_t module,
+ Int_t row,
+ Double_t r0,
+ Double_t lhalf,
+ TVector3 xc,
+ Bool_t isPerfect,
+ Bool_t isActive,
+ Double_t sigmaX0,
+ Double_t sigmaX1,
+ Double_t sigmaZ0,
+ Double_t sigmaZ1)
+ : kaldet::GearTPCMeasLayer(min, mout, module, row, isPerfect, isActive,
+ sigmaX0, sigmaX1, sigmaZ0, sigmaZ1),
+ TCylinder(r0, lhalf, xc.X(), xc.Y(), xc.Z())
+
+{
+}
+
+EXTPCMeasLayer::~EXTPCMeasLayer(){}
+
+Int_t EXTPCMeasLayer::GetModuleID() const
+{
+ return fModuleRows.begin()->first;
+}
+
+Int_t EXTPCMeasLayer::GetLayerID() const
+{
+ return fModuleRows.begin()->second;
+}
+
+TKalMatrix EXTPCMeasLayer::XvToMv(const TVector3 &xv, Int_t side) const
+{
+ return XvToMv(xv);
+}
+
+void EXTPCMeasLayer::ProcessHit(const TVector3 &xx,
+ TObjArray &hits) const
+{
+ TKalMatrix h = XvToMv(xx);
+ Double_t rphi = h(0, 0);
+ Double_t d = h(1, 0);
+
+ Double_t dx = GetSigmaX(d);
+ Double_t dz = GetSigmaZ(d);
+ rphi += gRandom->Gaus(0., dx); // smearing rphi
+ d += gRandom->Gaus(0., dz); // smearing drift distance
+
+ Double_t meas [2];
+ Double_t dmeas[2];
+ meas [0] = rphi;
+ meas [1] = d;
+ dmeas[0] = dx;
+ dmeas[1] = dz;
+
+ Double_t b;
+ Double_t vDrift;
+ try{
+ EXTPCKalDetector const & detector = dynamic_cast<EXTPCKalDetector const &>(GetParent(false));
+ b = detector.GetBfield();
+ vDrift = detector.GetVdrift();
+ }
+ catch( std::bad_cast & )
+ {
+ // streamlog_out(ERROR) << "EXTPCMeasLayer::ProcessHit: Error: Parent is not an EXTPCKalDetector."
+ // << std::endl;
+ // streamlog_out(ERROR) << "This function is for backward compatibility only."
+ // <<" Please do not use it when directly instantiating a GearTPCKalDetector."
+ // << std::endl;
+ throw;
+ }
+
+ hits.Add(new EXTPCHit(*this, meas, dmeas, 1 /*side, not functional anyway*/,
+ vDrift, xx, b ));
+}
diff --git a/Utilities/KalDet/src/lctpc/gearTPC/EXTPCMeasLayer.h b/Utilities/KalDet/src/lctpc/gearTPC/EXTPCMeasLayer.h
new file mode 100644
index 0000000000000000000000000000000000000000..3557ae56f0f3b46757fc53446cb2707d918b327d
--- /dev/null
+++ b/Utilities/KalDet/src/lctpc/gearTPC/EXTPCMeasLayer.h
@@ -0,0 +1,83 @@
+#ifndef LCTPC_EXTPCMEASLAYER_H
+#define LCTPC_EXTPCMEASLAYER_H
+
+#include "GearTPCMeasLayer.h"
+#include <kaltest/TCylinder.h>
+
+/**
+ * A backward compatibility class for GearTPCCylinderMeasLayer.
+ * It introduces one module and one row, which are associated to the layer.
+ * This is deprecated, the GearTPCCylinderMeasLayer provides an assiciation of several
+ * module-row pairs to the layer.
+
+ * This class is an intermediate inheritance class so a GearTPCCylinderMeasLayer can be
+ * instantiated (as should be in the current code) and the old code can cast the
+ * TObject pointer, which is delivered by the detector cradle, to an EXTPCMeasLayer.
+ *
+ * \attention Do not use any of these function in new code. All new code should still run
+ * after this class has been removed from the ineritance chain.
+ *
+ * \deprecated EXTPCMeasLayer
+ */
+class EXTPCMeasLayer : public kaldet::GearTPCMeasLayer, public TCylinder
+{
+
+public:
+ /// Minimal constructor for this (partially) virtual class.
+ EXTPCMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ Int_t module,
+ Int_t row,
+ Double_t r0,
+ Double_t lhalf,
+ TVector3 xc,
+ Bool_t isPerfect,
+ Bool_t isActive,
+ Double_t sigmaX0 = 0., //< the constant part of sigmaX
+ Double_t sigmaX1 = 0., //< the z-dependent part of sigmaX
+ Double_t sigmaZ0 = 0., //< the constant part of sigmaZ
+ Double_t sigmaZ1 = 0.); //< the z-dependent part of sigmaZ
+
+ /// The destructor.
+ virtual ~EXTPCMeasLayer();
+
+ /**
+ * Get the module associated with this layer (deprecated).
+ * \attention Do not programme against this when using the GearTPC interface.
+ * This is for backward compatibility only!!!
+ */
+ Int_t GetModuleID() const;
+
+ /**
+ * Get the layer ID (i.\ e.\ row in the module) associated with this Kalman layer (deprecated).
+ *
+ * \attention Do not programme against this when using the GearTPC interface.
+ * This is for backward compatibility only!!!
+ */
+ Int_t GetLayerID () const;
+
+ /** Deprecated XvToMv which in addition to the position takes a side.
+ * Side is ignored and XvToMv without the side is called.
+ * \attention Do not programme against this when using the GearTPC interface.
+ * This is for backward compatibility only!!!
+ */
+ TKalMatrix XvToMv(const TVector3 &xv, Int_t side) const;
+
+ /** The fully virtual declaration of XvToMv. It is called within the version which also takes
+ * the side argument, but is implemented in GearTPCCylinderMeasLayer.
+ */
+ virtual TKalMatrix XvToMv(const TVector3 &xv) const = 0;
+
+ /** Smear the incoming hit in the layes measurement surface and place the result into the TObjArray
+ * which is given as argument.
+ * From a design point of view this function should not be in the detector class but in a
+ * simulation extension. It is only put in for compatibility reasons.
+ * \attention Do not programme against this when using the GearTPC interface.
+ * This is for backward compatibility only!!!
+ */
+ virtual void ProcessHit(const TVector3 &xx, TObjArray &hits) const;
+
+ //ClassDef(EXTPCMeasLayer, 1) // User defined measurement layer class
+};
+
+#endif // LCTPC_EXTPCMEASLAYER_H
diff --git a/Utilities/KalDet/src/lctpc/gearTPC/GearTPCCylinderHit.cxx b/Utilities/KalDet/src/lctpc/gearTPC/GearTPCCylinderHit.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..d5441b0d8e5ab8f2da205a18692a850f3380773d
--- /dev/null
+++ b/Utilities/KalDet/src/lctpc/gearTPC/GearTPCCylinderHit.cxx
@@ -0,0 +1,111 @@
+#include "GearTPCCylinderHit.h"
+#include "GearTPCCylinderMeasLayer.h"
+#include <TMath.h>
+
+#include <iostream>
+#include <iomanip>
+// #include <streamlog/streamlog.h>
+
+using namespace std;
+
+namespace kaldet{
+
+//_________________________________________________________________________
+// --------------
+// Ctors and Dtor
+// --------------
+//
+GearTPCCylinderHit::GearTPCCylinderHit(Int_t m)
+ : GearTPCHit(m)
+{
+}
+
+GearTPCCylinderHit::GearTPCCylinderHit(const TVMeasLayer &ms,
+ Double_t *x,
+ Double_t *dx,
+ const TVector3 &xx,
+ Double_t b,
+ Double_t v,
+ Int_t m)
+ : GearTPCHit(ms, x, dx, xx, b, v, m)
+{
+}
+
+GearTPCCylinderHit::GearTPCCylinderHit(const TVMeasLayer &ms,
+ Double_t *x,
+ Double_t *dx,
+ const void *hitp,
+ Double_t b,
+ Double_t v,
+ Int_t m)
+ : GearTPCHit(ms, x, dx, hitp, b, v, m)
+{
+}
+
+GearTPCCylinderHit::~GearTPCCylinderHit()
+{
+}
+
+//_________________________________________________________________________
+// --------------------------------
+// Implementation of public methods
+// --------------------------------
+//
+TKalMatrix GearTPCCylinderHit::XvToMv(const TVector3 &xv, Double_t t0) const
+{
+ // KILLENB What does this do? The ild version just returns measLayer->XvToMv()
+
+ TKalMatrix h(GetDimension());
+ Double_t r;
+ try{
+ const GearTPCCylinderMeasLayer &ms
+ = dynamic_cast<const GearTPCCylinderMeasLayer &>(GetMeasLayer());
+ h = ms.XvToMv(xv);
+ r = ms.GetR();
+ }
+ catch(std::bad_cast &)
+ {
+ // streamlog_out(ERROR) << "GearTPCHit::XvToMv: Measurement layer is not a GearTPCCylinderMeasLayer\n"
+ // << " The current implementation only works for cylindrical layer, sorry."
+ // << std::endl;
+ throw;
+ }
+
+
+ Double_t phih = h(0, 0) / r;
+ Double_t phim = (*this)(0, 0) / r;
+ Double_t dphi = phih - phim;
+
+ static const Double_t kPi = TMath::Pi();
+ static const Double_t kTwoPi = 2 * kPi;
+
+ while (dphi < -kPi) dphi += kTwoPi;
+ while (dphi > kPi) dphi -= kTwoPi;
+
+ h(0, 0) = r * (phim + dphi);
+ h(1, 0) += fVDrift * t0;
+
+ return h;
+}
+
+void GearTPCCylinderHit::DebugPrint(Option_t *) const
+{
+ cerr << "------------------- Site Info -------------------------" << endl;
+
+ for (Int_t i = 0; i < GetDimension(); i++) {
+ Double_t x = (*this)(i, 0);
+ Double_t dx = (*this)(i, 1);
+ cerr << " x[" << i << "] = " << setw(8) << setprecision(5) << x
+ << " "
+ << "dx[" << i << "] = " << setw(6) << setprecision(2) << dx
+ << setprecision(7)
+ << resetiosflags(ios::showpoint)
+ << endl;
+ }
+ cerr << " r = " << setw(8)
+ << dynamic_cast<const GearTPCCylinderMeasLayer &>(GetMeasLayer()).GetR() << endl;
+ cerr << "-------------------------------------------------------" << endl;
+}
+
+
+}//namespace kaldet
diff --git a/Utilities/KalDet/src/lctpc/gearTPC/GearTPCCylinderHit.h b/Utilities/KalDet/src/lctpc/gearTPC/GearTPCCylinderHit.h
new file mode 100644
index 0000000000000000000000000000000000000000..db9763a5b4a691e22bf61c46b78e6e5aceb7ddc0
--- /dev/null
+++ b/Utilities/KalDet/src/lctpc/gearTPC/GearTPCCylinderHit.h
@@ -0,0 +1,55 @@
+#ifndef GEARTPCCYLINDERHIT_H
+#define GEARTPCCYLINDERHIT_H
+
+#include <kaltest/KalTrackDim.h>
+#include "GearTPCHit.h"
+#include <kaltest/TVMeasLayer.h>
+
+namespace kaldet{
+
+/** The cylindrical implementation of the GearTPCHit.
+ */
+class GearTPCCylinderHit : public GearTPCHit {
+
+public:
+ /// KILLENB What does this constructor do? Best throw it out, it does not
+ /// properly initialise the class at all, does it?
+ GearTPCCylinderHit(Int_t m = kMdim);
+
+ /** Constructor to initialise the GearTPCHit using space point coordinates (TVector3) as original hit.
+ */
+ GearTPCCylinderHit(const TVMeasLayer &ms,
+ Double_t *x,
+ Double_t *dx,
+ const TVector3 &xx,
+ Double_t b,
+ Double_t v,
+ Int_t m = kMdim);
+
+ /** Constructor using a pointer to the original hit as reference.
+ */
+ GearTPCCylinderHit(const TVMeasLayer &ms,
+ Double_t *x,
+ Double_t *dx,
+ const void *hitp,
+ Double_t b,
+ Double_t v,
+ Int_t m = kMdim);
+
+ /** The dectructor.
+ */
+ virtual ~GearTPCCylinderHit();
+
+ /** Implementation of the space vector (xv) to measurement vector (mv) calculation
+ * for a cylindrical hit.
+ */
+ virtual TKalMatrix XvToMv(const TVector3 &xv, Double_t t0) const;
+
+ /** Print some debug output to std err.
+ */
+ virtual void DebugPrint(Option_t *opt = "") const;
+};
+
+}//namespace kaldet
+
+#endif //GEARTPCCYLINDERHIT_H
diff --git a/Utilities/KalDet/src/lctpc/gearTPC/GearTPCCylinderMeasLayer.cxx b/Utilities/KalDet/src/lctpc/gearTPC/GearTPCCylinderMeasLayer.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..050549e12ec5f0a8ac1cf8124b869fdef933f38c
--- /dev/null
+++ b/Utilities/KalDet/src/lctpc/gearTPC/GearTPCCylinderMeasLayer.cxx
@@ -0,0 +1,218 @@
+#include "GearTPCCylinderMeasLayer.h"
+#include "GearTPCHit.h"
+#include "GearTPCKalDetector.h"
+#include "GearTPCCylinderHit.h"
+
+#include <TMath.h>
+
+#include <iostream>
+// #include <streamlog/streamlog.h>
+
+#include <gear/GEAR.h>
+
+namespace kaldet
+{
+
+
+GearTPCCylinderMeasLayer::GearTPCCylinderMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ Int_t module,
+ Int_t row,
+ Double_t r0,
+ Double_t lhalf,
+ TVector3 xc,
+ Bool_t isPerfect,
+ Bool_t isActive,
+ Double_t sigmaX0,
+ Double_t sigmaX1,
+ Double_t sigmaZ0,
+ Double_t sigmaZ1,
+ Double_t phimin,
+ Double_t phimax)
+ : EXTPCMeasLayer(min, mout, module, row, r0, lhalf, xc ,isPerfect,
+ isActive, sigmaX0, sigmaX1, sigmaZ0, sigmaZ1),
+ /* this is the original code which should be reactivated once the EXTPCMeasLayer is phased out:
+ : GearTPCMeasLayer(min, mout, module, isPerfect, isActive,
+ sigmaX0, sigmaX1, sigmaZ0, sigmaZ1),
+ TCylinder(r0, lhalf, xc.X(), xc.Y(), xc.Z()),
+ */
+ fPhiMin(phimin),
+ fPhiMax(phimax)
+{
+ //FIXME: As the handling of cylinder segments is not defined yet we force the layer to be
+ //a perfect cylinder
+ fIsPerfect = true;
+
+ // for a full cylinder phi min and max do not make sense. Give a warning if they are used.
+ if (fIsPerfect)
+ {
+ if (phimin!=-TMath::Pi())
+ {
+ // streamlog_out(WARNING) << "GearTPCCylinderMeasLayer: Ignoring input parameter phimin."
+ // << " The current implementation is a full cylinder." << std::endl;
+ phimin=-TMath::Pi();
+ }
+ if (phimax!=TMath::Pi())
+ {
+ // streamlog_out(WARNING) << "GearTPCCylinderMeasLayer: Ignoring input parameter phimax."
+ // << " The current implementation is a full cylinder." << std::endl;
+ phimax=TMath::Pi();
+ }
+ }
+}
+
+GearTPCCylinderMeasLayer::~GearTPCCylinderMeasLayer()
+{
+}
+
+TKalMatrix GearTPCCylinderMeasLayer::XvToMv(const TVector3 &xv) const
+{
+ TVector3 xxv = xv - GetXc();
+
+ Double_t phi = TMath::ATan2(xxv.Y(), xxv.X());// - fPhiMin;
+
+ static Double_t kPi = TMath::Pi();
+ static Double_t kTwoPi = 2 * kPi;
+ while (phi < -kPi) phi += kTwoPi;
+ while (phi > kPi) phi -= kTwoPi;
+
+ // Calculate hit coordinate information:
+ // mv(0, 0) = r * phi
+ // (1, 0) = drift distance
+
+ TKalMatrix mv(kMdim, 1);
+ mv(0, 0) = GetR() * phi;
+
+ mv(1, 0) = xxv.Z();
+
+ return mv;
+}
+
+TKalMatrix GearTPCCylinderMeasLayer::XvToMv(const TVTrackHit &vhit,
+ const TVector3 &xv) const
+{
+ return XvToMv(xv);
+}
+
+TVector3 GearTPCCylinderMeasLayer::HitToXv(const TVTrackHit &vhit) const
+{
+ // const EXTPCHit &hit = dynamic_cast<const EXTPCHit &>(vhit);
+
+
+ Double_t phi = vhit(0, 0) / GetR();// + fPhiMin;
+
+ Double_t z = vhit(1, 0);
+
+ Double_t x = GetR() * TMath::Cos(phi) + GetXc().X();
+ Double_t y = GetR() * TMath::Sin(phi) + GetXc().Y();
+
+ return TVector3(x, y, z);
+}
+
+void GearTPCCylinderMeasLayer::CalcDhDa(const TVTrackHit & vhit,
+ const TVector3 &xxv,
+ const TKalMatrix &dxphiada,
+ TKalMatrix &H) const
+{
+ double vDrift;
+ try{
+ const GearTPCHit &hit = dynamic_cast<const GearTPCHit &>(vhit);
+ vDrift = hit.GetVdrift();
+ }
+ catch(std::bad_cast &)
+ {
+ // streamlog_out(ERROR) << "GearTPCCylinderMeasLayer::CalcDhDa :"
+ // << "Cannot cast incoming TVTrackHit to GearTPCHit!"<< std::endl;
+ throw;
+ }
+
+ // Calculate
+ // H = (@h/@a) = (@phi/@a, @z/@a)^t
+ // where
+ // h(a) = (phi, z)^t: expected meas vector
+ // a = (drho, phi0, kappa, dz, tanl, t0)
+ //
+
+ Int_t sdim = H.GetNcols();
+ Int_t hdim = TMath::Max(5, sdim - 1);
+
+ TVector3 xxvc = xxv - GetXc();
+ Double_t xv = xxvc.X();
+ Double_t yv = xxvc.Y();
+ Double_t xxyy = xv * xv + yv * yv;
+
+ // Set H = (@h/@a) = (@d/@a, @z/@a)^t
+
+ for (Int_t i = 0; i < hdim; i++) {
+ H(0, i) = - (yv / xxyy) * dxphiada(0, i)
+ + (xv / xxyy) * dxphiada(1, i);
+ H(0, i) *= GetR();
+
+ H(1, i) = dxphiada(2, i);
+ }
+
+ if (sdim == 6) {
+ H(0, sdim - 1) = 0.;
+
+ // KILLENB I don't understand what this does, but I removed vDrift, so I set this to 0.
+ H(1, sdim - 1) = - vDrift;
+ }
+}
+
+Double_t GearTPCCylinderMeasLayer::GetSortingPolicy() const
+{
+ // The sorting policy (copied from the header file):
+ // The layers are first sorted by radius + offset. This offset is only
+ // useful for segments of a cylinder, like the LP1.
+ // As offsets in this case can be positive or negative, but only make sense in one
+ // direction (you need a continuous number), we only allow offsets in X.
+ // This should not be too much of a problem, you should be able to rotate your coordinates
+ // so the offset is in X. If not you have to extend the sorting policy. (Please thake
+ // care not to reduce versatility when doing so. You might want to implement your own class?)
+ //
+ // For equal radii + offset the layers are sorted by moduleID. As we have to squeeze this
+ // information into only one number, we multiply the radius + offset by 1e9 and add the moduleID.
+ // A double has a precision of 53 bits, which is 15.9 digits. So the radius can be up to 1e6.9 mm
+ // without causing the last digit of the the ModuleID to be cut, and for up to 1000 modules the
+ // layers can be distinguished down to 1 nm without the two numbers mixing, or down to 1 micron
+ // with up to 1.000.000 modules.
+
+ // The additional sorting by module is intended for cylinder segments. Here only one module/row
+ // per layer is allowed, so we just take the first entry in the set. In case of a perfect layer
+ // it does not matter because there should only be one layer at this radius, so the sort order
+ // should not be affected by adding an arbitrary module ID (as long as the module ID is < 1e6, as
+ // described above).
+
+ // check that the offset is onyl in X
+ if ( (GetXc().Y()!=0) || (GetXc().Z()!=0) )
+ {
+ throw gear::NotImplementedException("Offset is only allowed in X in the current implementation");
+ }
+
+ int moduleID = fModuleRows.begin()->first;
+ // give a warning in case of very large module IDs. The sorting policy might have to be adapted
+ if( moduleID > 1e6 )
+ {
+ // streamlog_out(WARNING) << "GearTPCCylinderMeasLayer::GetSortingPolicy(): "
+ // << "Very large module ID " << moduleID << " found. "
+ // << "This might compromise the sorting policy."
+ // << std::endl;
+ }
+
+ // FIXME: Do we have to check for a max r-offsetX?
+ return (GetR() + GetXc().X())*1e9 + moduleID;
+}
+
+GearTPCHit * GearTPCCylinderMeasLayer::createHit(Double_t * meas,
+ Double_t * dmeas,
+ void * hitPointer,
+ Double_t bField,
+ Double_t vDrift,
+ Int_t m) const
+{
+ return new GearTPCCylinderHit(*this, meas, dmeas, hitPointer,
+ bField, vDrift, m);
+}
+
+
+}//namespace kaldet
diff --git a/Utilities/KalDet/src/lctpc/gearTPC/GearTPCCylinderMeasLayer.h b/Utilities/KalDet/src/lctpc/gearTPC/GearTPCCylinderMeasLayer.h
new file mode 100644
index 0000000000000000000000000000000000000000..e20af5be813e99e3875837d844a58ccb2096d0fc
--- /dev/null
+++ b/Utilities/KalDet/src/lctpc/gearTPC/GearTPCCylinderMeasLayer.h
@@ -0,0 +1,131 @@
+#ifndef GEARTPCCYLINDERMEASLAYER_H
+#define GEARTPCCYLINDERMEASLAYER_H
+#include <TVector3.h>
+#include <kaltest/TKalMatrix.h>
+#include <kaltest/TCylinder.h>
+#include <kaldet/EXTPCMeasLayer.h>
+//#include <KalTrackDim.h>
+
+#include <TMath.h>
+
+#include <set>
+
+class TVTrackHit;
+
+namespace kaldet
+{
+
+ /**
+ * A cylindrical measurement layer.
+ */
+ class GearTPCCylinderMeasLayer
+ : public EXTPCMeasLayer
+ /* this is the original code which should be reactivated once the EXTPCMeasLayer is phased out:
+ : public GearTPCMeasLayer, public TCylinder
+ */
+ {
+
+ public:
+ /** The constructor.
+ * If the layer is perfect it is always a full circle. The constructor forces
+ * phiMin and phiMax to +-TMath::Pi(). Differing values will be ignored and a warning is
+ * printed.
+ *
+ * Note: The current implementation forces the layer to be perfect. Segmented layers are
+ * not supported yet.
+ *
+ * Note: for backward compatibility this is derrived from EXTPCMeasLayer.
+ * After the change to the GearTPC interface this should be changed to GearTPCMeasLayer and
+ * TCylinder, as EXTPCMeasLayer is inherrited now.
+ * The current version ensures compatibility for the transition phase.
+ */
+ GearTPCCylinderMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ Int_t module,
+ Int_t row,
+ Double_t r0,
+ Double_t lhalf,
+ TVector3 xc = TVector3(),
+ Bool_t isPerfect = true,
+ Bool_t isActive = true,
+ Double_t sigmaX0 = 0.,
+ Double_t sigmaX1 = 0.,
+ Double_t sigmaZ0 = 0.,
+ Double_t sigmaZ1 = 0.,
+ Double_t phiMin = -TMath::Pi(),
+ Double_t phiMax = TMath::Pi());
+
+ /**
+ * The desctructor.
+ */
+ virtual ~GearTPCCylinderMeasLayer();
+
+ // Parent's pure virtuals that must be implemented
+
+ /** Implements kaltest::TVMeasLayer's XvToMv. I have no idea why there are two arguments.
+ * It ignores ht and just calls XvToMv(xv).
+ */
+ virtual TKalMatrix XvToMv (const TVTrackHit &ht,
+ const TVector3 &xv) const;
+
+ /** Implements the coordinate transformation from the space vector xv to the
+ * measurement vector (Kalman matrix).
+ */
+ virtual TKalMatrix XvToMv (const TVector3 &xv) const;
+
+ /** Implements the conversion from a Kalman hit (measurement vector) to
+ * a 3D space point.
+ */
+ virtual TVector3 HitToXv (const TVTrackHit &ht) const;
+
+ /**
+ * Implements CalcDhDa, whatever that is.
+ */
+ virtual void CalcDhDa (const TVTrackHit &ht,
+ const TVector3 &xv,
+ const TKalMatrix &dxphiada,
+ TKalMatrix &H) const;
+ /** Implements the sorting policy.
+ * The layers are first sorted by radius + offset. This offset is only
+ * useful for segments of a cylinder, like the LP1.
+ * As offsets in this case can be positive or negative, but only make sense in one
+ * direction (you need a continuous number), we only allow offsets in x.
+ * This should not be too much of a problem, you should be able to rotate your coordinates
+ * so the offset is in x. If not you have to extend the sorting policy. (Please thake
+ * care not to reduce versatility when doing so. You might want to implement your own class?)
+ *
+ * For equal radii + offset the layers are sorted by moduleID. As we have to squeeze this
+ * information into only one number, we multiply the radius + offset by 1e9 and add the moduleID.
+ * A double has a precision of 53 bits, which is 15.9 digits. So the radius can be up to 1e6.9 mm
+ * without causing the last digit of the the ModuleID to be cut, and for up to 1000 modules the
+ * layers can be distinguished down to 1 nm without the two numbers mixing, or down to 1 micron
+ * with up to 1.000.000 modules.
+ *
+ * The additional sorting by module is intended for cylinder segments. Here only one module/row
+ * per layer is allowed, so we just take the first entry in the set. In case of a perfect layer
+ * it does not matter because there should only be one layer at this radius, so the sort order
+ * should not be affected by adding an arbitrary module ID (as long as the module ID is < 1e6, as
+ * described above).
+ */
+ virtual Double_t GetSortingPolicy() const;
+
+ /**
+ * Creates a GearTPCCylinderHit and hands over the ownership.
+ */
+ virtual GearTPCHit * createHit(Double_t * meas,
+ Double_t * dmeas,
+ void * hitPointer,
+ Double_t bField,
+ Double_t vDrift,
+ Int_t m = kMdim) const;
+
+
+
+protected:
+ Double_t fPhiMin; //< Minimum phi.
+ Double_t fPhiMax; //< Maximum phi.
+
+};
+
+}//namespace kaldet
+#endif
diff --git a/Utilities/KalDet/src/lctpc/gearTPC/GearTPCHit.cxx b/Utilities/KalDet/src/lctpc/gearTPC/GearTPCHit.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..8215cb661408538e184ab9025a10a3fc8ca83a44
--- /dev/null
+++ b/Utilities/KalDet/src/lctpc/gearTPC/GearTPCHit.cxx
@@ -0,0 +1,81 @@
+#include "GearTPCHit.h"
+
+#include <iomanip>
+// #include <streamlog/streamlog.h>
+
+namespace kaldet{
+
+//_________________________________________________________________________
+// --------------
+// Ctors and Dtor
+// --------------
+//
+GearTPCHit::GearTPCHit(Int_t m)
+ : TVTrackHit(m),
+ fXXPtr(0),
+ fHitPtr(0),
+ fVDrift(0)
+{
+}
+
+GearTPCHit::GearTPCHit(const TVMeasLayer &ms,
+ Double_t *x,
+ Double_t *dx,
+ const TVector3 &xx,
+ Double_t b,
+ Double_t v,
+ Int_t m)
+ : TVTrackHit(ms, x, dx, b, m),
+ fXXPtr(&xx),
+ fHitPtr(0),
+ fVDrift(v)
+{
+}
+
+GearTPCHit::GearTPCHit(const TVMeasLayer &ms,
+ Double_t *x,
+ Double_t *dx,
+ const void *hitp,
+ Double_t b,
+ Double_t v,
+ Int_t m)
+ : TVTrackHit(ms, x, dx, b, m),
+ fXXPtr(0),
+ fHitPtr(hitp),
+ fVDrift(v)
+{
+}
+
+GearTPCHit::~GearTPCHit()
+{
+}
+
+//_________________________________________________________________________
+// ----------------
+// Compare two Hits
+// ----------------
+//
+Int_t GearTPCHit::Compare(const TObject *obj) const
+{
+ Double_t me = GetSortingPolicy();
+ Double_t you = dynamic_cast<const GearTPCHit *>(obj)->GetSortingPolicy();
+ if (you == 0)
+ {
+ // streamlog_out(ERROR) << "Cannot compare GearTPCHit to something which is not a"
+ // << " GearTPCHit" << std::endl;
+ throw std::bad_cast();
+ }
+ return me < you ? -1 : (me > you ? +1 : 0);
+}
+
+Double_t GearTPCHit::GetSortingPolicy() const
+{
+ return GetMeasLayer().HitToXv(*this).Mag();
+}
+
+Bool_t GearTPCHit::IsSortable() const
+{
+ return kTRUE;
+}
+
+}//namespace kaldet
diff --git a/Utilities/KalDet/src/lctpc/gearTPC/GearTPCHit.h b/Utilities/KalDet/src/lctpc/gearTPC/GearTPCHit.h
new file mode 100644
index 0000000000000000000000000000000000000000..de947f6ec04fcb97bc33ef3c369177708d25672c
--- /dev/null
+++ b/Utilities/KalDet/src/lctpc/gearTPC/GearTPCHit.h
@@ -0,0 +1,94 @@
+#ifndef GEARTPCHIT_H
+#define GEARTPCHIT_H
+
+#include <kaltest/KalTrackDim.h>
+#include <kaltest/TVTrackHit.h>
+#include <kaltest/TVMeasLayer.h>
+
+namespace kaldet{
+
+/** Base class of a hit for GearTPCKalDetector. It extends the TVTrackHit with the functionality to
+ * store a space point or a pointer to the original hit for reference. In addition it stores
+ * the local drift velocity and allows sorting of the hits (according to the distance to the
+ * origin).
+ *
+ * It does not implement the purely virtual functions of the TVTrackHit, which happens in the
+ * specialisations for cylindrical and planar measurement layers.
+ */
+class GearTPCHit : public TVTrackHit {
+
+public:
+ /// KILLENB What does this constructor do? Best throw it out, it does not
+ /// properly initialise the class at all, does it?
+ GearTPCHit(Int_t m = kMdim);
+
+ /** Constructor to initialise the GearTPCHit using space point coordinates (TVector3) as original hit.
+ */
+ GearTPCHit(const TVMeasLayer &ms,
+ Double_t *x,
+ Double_t *dx,
+ const TVector3 &xx,
+ Double_t b,
+ Double_t v,
+ Int_t m = kMdim);
+
+ /** Constructor using a pointer to the original hit as reference.
+ */
+ GearTPCHit(const TVMeasLayer &ms,
+ Double_t *x,
+ Double_t *dx,
+ const void *hitp,
+ Double_t b,
+ Double_t v,
+ Int_t m = kMdim);
+
+ /** The dectructor.
+ */
+ virtual ~GearTPCHit();
+
+ /**
+ * The sorting policy of hits is implemented as the distance to the origin.
+ *
+ * Note: The sorting of hits does not necessarily correspond to the sort order of
+ * the corresponding Kalman layer!
+ */
+ virtual Double_t GetSortingPolicy() const;
+
+ /**
+ * Compare two hits according to their sorting policy.
+ * Returns
+ * \li -1 if this hits sorting policy is smaller
+ * \li 0 if both soting policies are equal
+ * \li 1 if this hits hits sortin policy is larger
+ *
+ * Killenb: n.b. Who comes up with this wierd stuff? Ever head of anything like a
+ * `less than operator` or `comparison operator`?
+ */
+ virtual Int_t Compare(const TObject *obj) const;
+
+ /**
+ * Returns true.
+ */
+ virtual Bool_t IsSortable() const;
+
+ /// Get the pointer to the reference hit. 0 if the TVector3 has been used for initialisation.
+ inline const void *GetHitPtr() const { return fHitPtr; }
+
+ /// Get the referece position. (0, 0, 0) if the reference pointer has been used for initialisation.
+ inline TVector3 GetExactX() const { return *fXXPtr; }
+
+ /// Get the local drift velocity set in the constructor.
+ inline Double_t GetVdrift() const { return fVDrift; }
+
+protected:
+ const TVector3 *fXXPtr; //< pointer to exact hit
+ const void *fHitPtr; //< pointer to raw Hit object
+
+ Double_t fVDrift; //< the local drift veclocity at this point
+
+
+};
+
+}//namespace kaldet
+
+#endif
diff --git a/Utilities/KalDet/src/lctpc/gearTPC/GearTPCKalDetector.cxx b/Utilities/KalDet/src/lctpc/gearTPC/GearTPCKalDetector.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..a851e9b83173b665cf70af0c4413b59dced0c082
--- /dev/null
+++ b/Utilities/KalDet/src/lctpc/gearTPC/GearTPCKalDetector.cxx
@@ -0,0 +1,312 @@
+// STL
+#include <vector>
+
+// GEAR
+#include <gear/GEAR.h>
+#include <gear/TPCParameters.h>
+#include <gear/PadRowLayout2D.h>
+#include <gear/BField.h>
+#include <gearimpl/TPCModuleImpl.h>
+#include <gearxml/GearXML.h>
+
+// #include <streamlog/streamlog.h>
+
+#include "GearTPCKalDetector.h"
+#include "GearTPCCylinderMeasLayer.h"
+//#include "GearTPCHit.h"
+#include <kaltest/TKalDetCradle.h>
+#include <TRandom.h>
+#include <TMath.h>
+
+//#include "TTUBE.h"
+//#include "TNode.h"
+//#include "TVirtualPad.h"
+
+namespace kaldet
+{
+
+GearTPCKalDetector::GearTPCKalDetector(const gear::GearMgr& gearMgr)
+ : TVKalDetector(210)
+{
+ gear::TPCParameters const & tpcParameters = gearMgr.getTPCParameters();
+
+ // Try to read the material properties from the GEAR file.
+ // If it cannot be found use an Argon based mixture instead.
+ Double_t A, Z, density, radlen;
+
+ try{
+ // One try/catch block for all.
+ // It does not make sense to only replace part of the parameters,
+ // they all have to be there.
+ A = tpcParameters.getDoubleVal("TPCGas_A");
+ Z = tpcParameters.getDoubleVal("TPCGas_Z");
+ density = tpcParameters.getDoubleVal("TPCGas_density");
+ radlen = tpcParameters.getDoubleVal("TPCGas_radlen");
+ }
+ catch( gear::UnknownParameterException & )
+ {
+ // streamlog_out(MESSAGE) << "GearTPCKalDetector: No TPCGas parameters found in the gear file."
+ // << " Using Ar/CH4 90/10." << std::endl;
+
+ // Is this supposed to be Ar/CH4 90/10?
+ // I think it's wrong. A CH4 module does not consist of 0.2 carbon
+ // and 0.8 hydrogen atoms, but 1 C and 4 H, so it should be
+ // A = 39.948 * 0.9 + (12.011 + 1.00794 * 4) * 0.1;
+ A = 39.948 * 0.9 + (12.011 * 0.2 + 1.00794 * 0.8) * 0.1;
+ Z = 16.4; // now how does this calculate?
+ density = 0.749e-3; // in which units?
+ radlen = 1.196e4 * 2; // in which units?
+ }
+
+ TMaterial &gas = *new TMaterial("TPCGas", "", A, Z, density, radlen, 0.);
+
+ // FIXME: what about the cathode tickness. Sensitivity gap in the middle?
+ // And what about the LP? There it's not the half length...
+ Double_t lhalf
+ = tpcParameters.getMaxDriftLength(); // half length
+
+// gear::BField const & bField = gearMgr.getBField();
+// // get the BField at 0,0,0. Check that there are no transverse components
+// // FIXME: Event though there are no transverse components at 0, 0, 0 does not mean
+// // there are no transverse components somewhere else.
+// gear::Vector3D bFieldVector = bField.at(gear::Vector3D(0., 0., 0.));
+// if (bFieldVector[0]!=0 || bFieldVector[1]!=0)
+// {
+// streamlog_out(ERROR) << "B-field has transverse components."
+// << " GearTPCKalDetector only works with homogeneous B-field"
+// << " in z direction" << std::endl;
+// throw gear::Exception("Magnetic field not homogeneous");
+// }
+
+ // set the protected member variable of EXVKalDetector
+ // fBfield = bFieldVector[2];
+
+ // FIXME: Just don't put dummy modules into the gear file?
+ // No, we might need the radiation length
+ // Damn it, the description in GEAR is not complete, grrrr.
+ // Bool_t active = GearTPCMeasLayer::kActive;
+ // Bool_t dummy = GearTPCMeasLayer::kDummy;
+
+ // The index where in the TObjectArray the next element will be stored. Unfortunately we have to
+ // do the bookkeeping manually :-(
+ Int_t arrayIndex = 0;
+
+ // A map to store if a layer, which is a full cylinder, already exists. If it has the same
+ // offset and the same radius, this is the case. Then to not add a Kalman layer but add the module
+ // to the layer.
+ std::map< std::pair<double, double> , Int_t > uniqueLayerMap;// <offset, r>, LayerIndex
+
+ for (std::vector<gear::TPCModule *>::const_iterator moduleIter = tpcParameters.getModules().begin();
+ moduleIter < tpcParameters.getModules().end(); ++moduleIter)
+ {
+ gear::TPCModule *module = *moduleIter;
+
+ // The resolution parameters can vary from module to module.
+ // In case they are not there use the jgem values
+ Double_t sigmax0, sigmax1, sigmaz0, sigmaz1;
+ try{
+ sigmax0 = module->getDoubleVal("sigmax0");
+ sigmax1 = module->getDoubleVal("sigmax1");
+ sigmaz0 = module->getDoubleVal("sigmaz0");
+ sigmaz1 = module->getDoubleVal("sigmaz1");
+ }
+ catch( gear::UnknownParameterException & )
+ {
+ // streamlog_out(MESSAGE) << "No resolution parameters found for module "
+ // << module->getModuleID()<<"."
+ // << " Using jgem settings." << std::endl;
+
+ // FIXME: n_eff of argon per distance, adapt to pad length. Or read from GEAR file?
+ Double_t neff = 22.7;
+
+ // FIXME : I think the sqrt(10) is a leftover from the old cm units....
+ sigmax0 = 38.3e-3;
+ sigmax1 = 101.5e-3 / TMath::Sqrt(10.) / TMath::Sqrt(neff);
+ sigmaz0 = 500.e-3 ;
+ sigmaz1 = 154.e-3 / TMath::Sqrt(10.) / TMath::Sqrt(neff);
+ }
+
+ // FIXME: Implementation for RectangularPadRowLayout missing
+ switch (module->getLocalPadLayout().getCoordinateType())
+ {
+ case gear::PadRowLayout2D::POLAR :
+ {
+ //Unfortunately cylinder segments are not implemented in KalDet yet.
+ //Perhaps in a future implementation...
+ // Get the phi min and phi max of the module, plus the right rotation
+ // in the global coordinate system. This is not the global angle because it is
+ // relative to the origin of the module, which has a shift in global coordinates.
+ //Double_t phimin = module->getLocalModuleExtent()[2] + module->getAngle();
+ //Double_t phimax = module->getLocalModuleExtent()[3] + module->getAngle();
+
+ // the offset is either in r/phi or in x/y, depending on the global coordinate system
+ double xOffset, yOffset;
+ switch (module->getCoordinateType())
+ {
+ case gear::PadRowLayout2D::POLAR :
+ xOffset=module->getOffset()[0]*cos(module->getOffset()[1]);
+ yOffset=module->getOffset()[0]*sin(module->getOffset()[1]);
+ break;
+ case gear::PadRowLayout2D::CARTESIAN :
+ xOffset=module->getOffset()[0];
+ yOffset=module->getOffset()[1];
+ break;
+ default:
+ throw gear::UnknownParameterException("Unknown global coordinate system in GearTPCKalDet");
+
+ }
+
+ if (yOffset!=0)
+ {
+ // streamlog_out(ERROR) << "yOffset not 0. The current implementation of GearTPCKalDetector"
+ // << "only allows an offset in x direction." << std::endl;
+ throw gear::UnknownParameterException("Offset in y is not 0.");
+ }
+
+ TVector3 cylinderCentre(xOffset,
+ yOffset,
+ 0.); // FIXME: cathode thickness
+
+ // Loop the pad rows and place one cylinder segement each
+ for (int row = 0; row < module->getNRows(); ++row)
+ {
+ // To get the radius we have to ask for the centre of one one the pads,
+ // just take pad 0 in this row.
+ int padIndex = module->getPadIndex(row, 0);
+
+ // The radius only makes sense in local module coordinates.
+ // So we have to ask the local pad layout. The module always answers in global coordinates.
+ Double_t r = module->getLocalPadLayout().getPadCenter(padIndex)[0];
+
+ std::map< std::pair<double, double> , Int_t >::iterator uniqueLayerIterator=
+ uniqueLayerMap.find( std::pair<double, double>(xOffset, r) );
+
+ if ( uniqueLayerIterator==uniqueLayerMap.end() )
+ {
+ // streamlog_out(DEBUG2) << "adding new layer "<<arrayIndex<< " (xOffset="<<xOffset
+ // <<", r="<<r
+ // <<") with module "<< module->getModuleID()
+ // <<" and row "<<row << std::endl;
+ // add the measurement layer to this object, and remember where we put it
+ Add(new GearTPCCylinderMeasLayer(gas, gas,
+ module->getModuleID(), row,
+ r, lhalf,
+ cylinderCentre,
+ true, true, // perfect and active
+ sigmax0, sigmax1, sigmaz0, sigmaz1));
+ // add the moduleRow to the map with the array indices
+ moduleRowToMeasurementLayerMap[ std::pair<int, int>(module->getModuleID(), row) ]
+ = arrayIndex;
+
+ // add the layer to the uniqueLayerMap
+ uniqueLayerMap[std::pair<double, double>(xOffset, r)] = arrayIndex;
+
+ // count up the array index
+ ++arrayIndex;
+ }
+ else // layer already exists
+ {
+ Int_t existingIndex = uniqueLayerIterator->second;
+ // streamlog_out(DEBUG2) << "adding module "<< module->getModuleID()
+ // <<", row "<<row <<" to existing layer " << existingIndex
+ // << " (xOffset="<<xOffset<<", row="<<row<<")"
+ // << std::endl;
+
+ GearTPCCylinderMeasLayer * measLayer =
+ dynamic_cast<GearTPCCylinderMeasLayer *>( At(existingIndex));
+
+ // If the cast fails something went terribly wrong. This layer should be a
+ // GearTPCCylinderMeasLayers, otherwise we cannot add a cylindrical module
+ if (measLayer==0)
+ {
+ // streamlog_out(ERROR) << "Something went terribly wrong. Could not cast a member of "
+ // << " GerTPCKalDetector to GearTPCCylinderMeasLayer" << std::endl;
+ throw std::bad_cast();
+ }
+
+ measLayer->AddModuleRow( module->getModuleID(), row );
+
+ moduleRowToMeasurementLayerMap[ std::pair<int, int>(module->getModuleID(), row) ]
+ = existingIndex;
+
+ }
+
+ }// loop rows in module
+ }
+ break;
+ case gear::PadRowLayout2D::CARTESIAN :
+ throw gear::NotImplementedException("Cartesian local coordinates not yet supported by GearTPCKalDetector");
+ default:
+ throw gear::UnknownParameterException("Unknown local coordinate system in GearTPCKalDet");
+ }//switch coordinate type
+
+ }
+
+ SetOwner();// make the KalDetector (TObjectArry) owner of the measurement layers so they are
+ // deleted when the detector is deleted
+
+}
+
+GearTPCKalDetector::~GearTPCKalDetector()
+{
+}
+
+
+GearTPCMeasLayer const * GearTPCKalDetector::GetMeasLayer(int moduleID, int row) const
+{
+ std::map< std::pair<int, int >, Int_t >::const_iterator indexIter =
+ moduleRowToMeasurementLayerMap.find( std::pair<int, int>(moduleID, row) );
+
+ if (indexIter==moduleRowToMeasurementLayerMap.end())
+ {
+ // streamlog_out(ERROR) << "GearTPCKalDetector::getMeasLayer: "
+ // << "layer with moduleID=" << moduleID
+ // << " and row=" << row << " not defined." << std::endl;
+ throw gear::Exception("Unknown row on moduleID");
+ }
+
+ // second is the key of the iterator (the arrow dereferencing the iterator to a key-value pair)
+ GearTPCMeasLayer const * measurementLayer =
+ dynamic_cast<GearTPCMeasLayer const * >( At(indexIter->second) );
+ if (measurementLayer==0)
+ {
+ // streamlog_out(ERROR) << "GearTPCKalDetector::getMeasLayer: "
+ // << " cannot cast object this->At(" << indexIter->second
+ // << ") to GearTPCMeasLayer const * " << std::endl;
+ }
+ return measurementLayer;
+}
+
+//_________________________________________________________________________
+// --------------
+// Utility Method
+// --------------
+//_________________________________________________________________________
+// --------------------------------------
+// Draw: Drawing method for event display
+// --------------------------------------
+//
+//void GearTPCKalDetector::Draw(Int_t color, const Char_t *opt)
+//{
+// if (! gPad) return;
+// TNode *nodep = GetNodePtr();
+// nodep->cd();
+//
+// if (! fNodePtr) {
+// GearTPCMeasLayer *inp = static_cast<GearTPCMeasLayer *>(First());
+// GearTPCMeasLayer *outp = static_cast<GearTPCMeasLayer *>(Last());
+// Double_t rin = inp->GetR();
+// Double_t rout = outp->GetR();
+// Double_t hlen = outp->GetZmax();
+// const Char_t *name = "TPC";
+// const Char_t *nname = "TPCNode";
+// TTUBE *tubep = new TTUBE(name, name, "void", rin, rout, hlen);
+// tubep->SetBit(kCanDelete);
+// fNodePtr = new TNode(nname, nname, name);
+// fNodePtr->SetLineColor(color);
+// fNodePtr->SetLineWidth(1); // line width given in number of pixels
+// }
+// EXVKalDetector::Draw(color, opt);
+//}
+
+}//namespace kaldet
diff --git a/Utilities/KalDet/src/lctpc/gearTPC/GearTPCKalDetector.h b/Utilities/KalDet/src/lctpc/gearTPC/GearTPCKalDetector.h
new file mode 100644
index 0000000000000000000000000000000000000000..800934a5dce925b27ac6460cec8ad011494a662c
--- /dev/null
+++ b/Utilities/KalDet/src/lctpc/gearTPC/GearTPCKalDetector.h
@@ -0,0 +1,77 @@
+#ifndef GEARTPCKALDETECTOR_H
+#define GEARTPCKALDETECTOR_H
+
+#include "kaltest/TVKalDetector.h"
+
+#include "GearTPCMeasLayer.h"
+
+#include <map>
+
+namespace gear{
+ class GearMgr ;
+}
+
+namespace kaldet{
+
+ /**
+ * The LCTPC implementation for a TPC which is completely instantiated from GEAR.
+ *
+ */
+class GearTPCKalDetector : public TVKalDetector {
+
+public:
+ /**
+ * The constructor. All information to initialise the TPC is taken from GEAR.
+ *
+ * As a pragmatic approach to avoid dealing with conditions data and material databases,
+ * the information about the material budget and the resolution of the layers
+ * is taken from the GEAR file as user parameters. If the parameters are not found in the
+ * file the previously hard coded parameters are used as default, which ensures backward
+ * compatibility.
+ *
+ * The gas properties for the matrial budget can be given as user parameters
+ * for the TPCParameters:
+ * \param TPCGas_A The mean atomic mass (default 36.2740552)
+ * \param TPCGas_Z The mean number of protons (default 16.4)
+ * \param TPCGas_density The density (default 0.749e-3 in which units?)
+ * \param TPCGas_radlen The radiation length (default 2.392e4 in which units?)
+ *
+ * The default gas parameters (are supposed to) correspond to Ar/CH4 90/10.
+ * N.B.: KILLENB: I think there is a bug in the calculation, the mean A should be
+ * 37.6 instead of 36.3 (see source code).
+ * In addition the description as a single TMaterial is not good.
+ * Using TMixture would be better.
+ *
+ * The reslution is calculated as \f$\sigma_x = \sqrt{x_0^2 + x_1^2 \cdot z}\f$.
+ * This requires z to be proportional to the drift distance, i.\ e. z=0 is at the readout.
+
+ * The resolution of the layers can be given as user parameters in each TPCModule
+ * section of the GEAR xml file.
+ * \param sigmax0 The constant part of the x resolution (default 38.3e-3 mm)
+ * \param sigmax1 The drift distance dependent part of the x resolution
+ * (default 6.74e-3 mm/sqrt(mm) )
+ * \param sigmaz0 The constant part of the z resolution (default 0.5 mm)
+ * \param sigmaz1 The drift distance dependent part the z resolution
+ * (default 10.2e-3 mm/sqrt(mm) )
+ */
+ GearTPCKalDetector(const gear::GearMgr& gearMgr);
+
+ /// The destructor.
+ virtual ~GearTPCKalDetector();
+
+ /**
+ * Get access to the measurement layers using moduleID and row.
+ * Do not directly access the measurement layers using At()
+ * because the order depends on the order in the gear file.
+ * Throws a gear::Exception if the row on the module is not defined.
+ */
+ virtual GearTPCMeasLayer const * GetMeasLayer(int moduleID, int row) const;
+
+protected:
+ /// Map which contains the information which measurement layer is stored
+ /// at which position in the array.
+ std::map< std::pair<int, int >, Int_t > moduleRowToMeasurementLayerMap;
+};
+
+}// namespace kaldet
+#endif //GEARTPCKALDETECTOR_H
diff --git a/Utilities/KalDet/src/lctpc/gearTPC/GearTPCMeasLayer.cxx b/Utilities/KalDet/src/lctpc/gearTPC/GearTPCMeasLayer.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..44069288f86887f7fe43c2bd987654fe54ce2537
--- /dev/null
+++ b/Utilities/KalDet/src/lctpc/gearTPC/GearTPCMeasLayer.cxx
@@ -0,0 +1,72 @@
+#include "GearTPCMeasLayer.h"
+
+#include <TMath.h>
+
+#include <iostream>
+// #include <streamlog/streamlog.h>
+
+#include <gear/GEAR.h>
+
+namespace kaldet
+{
+
+
+GearTPCMeasLayer::GearTPCMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ Int_t module,
+ Int_t row,
+ Bool_t isPerfect,
+ Bool_t isActive,
+ Double_t sigmax0,
+ Double_t sigmax1,
+ Double_t sigmaz0,
+ Double_t sigmaz1)
+ : TVMeasLayer(min, mout, isActive),
+ fSigmaX0(sigmax0),
+ fSigmaX1(sigmax1),
+ fSigmaZ0(sigmaz0),
+ fSigmaZ1(sigmaz1),
+ fIsPerfect(isPerfect)
+{
+ fModuleRows.insert( std::pair<int, int>(module, row) );
+}
+
+GearTPCMeasLayer::~GearTPCMeasLayer()
+{
+}
+
+Bool_t GearTPCMeasLayer::IsPerfect() const
+{
+ return fIsPerfect;
+}
+
+std::set< std::pair <int, int> > const & GearTPCMeasLayer::GetModuleRows() const
+{
+ return fModuleRows;
+}
+
+
+void GearTPCMeasLayer::AddModuleRow(int module, int row)
+{
+ if (fIsPerfect)
+ {
+ fModuleRows.insert( std::pair<int, int>(module, row) );
+ }
+ else
+ {
+ // streamlog_out(ERROR) << "You can only add additional modules to perfect layers." <<std::endl;
+ throw gear::Exception("GearTPCMeasLayer is not declared perfect.");
+ }
+}
+
+Double_t GearTPCMeasLayer::GetSigmaX(Double_t zdrift) const
+{
+ return TMath::Sqrt(fSigmaX0 * fSigmaX0 + fSigmaX1 * fSigmaX1 * zdrift);
+}
+
+Double_t GearTPCMeasLayer::GetSigmaZ(Double_t zdrift) const
+{
+ return TMath::Sqrt(fSigmaZ0 * fSigmaZ0 + fSigmaZ1 * fSigmaZ1 * zdrift);
+}
+
+}//namespace kaldet
diff --git a/Utilities/KalDet/src/lctpc/gearTPC/GearTPCMeasLayer.h b/Utilities/KalDet/src/lctpc/gearTPC/GearTPCMeasLayer.h
new file mode 100644
index 0000000000000000000000000000000000000000..3c27effab1d15c742ca80af9d1d31954429e2aef
--- /dev/null
+++ b/Utilities/KalDet/src/lctpc/gearTPC/GearTPCMeasLayer.h
@@ -0,0 +1,123 @@
+#ifndef GEARTPC_MEASLAYER_H
+#define GEARTPC_MEASLAYER_H
+
+#include <kaltest/TVMeasLayer.h>
+#include <set>
+
+namespace kaldet
+{
+
+ class GearTPCHit;
+
+ /**
+ * The GearTPCMeasLayer class introduces the z-dependent resolutions sigmaX and sigmaZ
+ * as well as Gear modules and rows which correspond to this layer.
+ *
+ * If the layer is defined as a perfect layer this means all modules are perfectly alligned
+ * and more than one module/row can be assigned to this layer. You can add them using AddModuleRow.
+ * The perfect layer should contain all the moduleRows on it, so it is guaranteed that the
+ * user can access all neighbouring modules this way.
+ *
+ * If the layer is not defined as perfect (default) there can only be one module on this layer.
+ * Calling AddModuleRow will throw an exception. This is the default behaviour because Gear does
+ * not guarantee that the modules are alligned. Displaced modules do not make up a perfect
+ * cylinder / plane and have to be treated as separate segments. Finding a neighbouring module/row
+ * is not trivial and has to be left to the user or a future Gear version.
+ */
+
+ class GearTPCMeasLayer
+ : public TVMeasLayer
+ {
+
+ public:
+ /** The constructor.
+ * The materials and the type (active or passive) are passed on to the
+ * TVMeasLayer. sigmaX0 [mm] is the constant part of sigmaX, sigmaX1 [mm/sqrt(mm)]
+ * the z-dependent part, accordingly for sigmaZ.
+ *
+ * Module and row have to be specified. They will be added as the first
+ * module/row pair of this measurement layer.
+ * For a perfect layer modules can be added with AddModuleRow.
+ *
+ * Note: This class cannot be instantiated because the parent's geometry dependent
+ * purely virtual
+ * functions like XvToMv are not implemented. This will happen in the cylindrical or planar
+ * implementations.
+ *
+ * For inactive layers you will usually leave the sigmas at 0, they have no useful meaning in
+ * this case.
+ */
+ GearTPCMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ Int_t module,
+ Int_t row,
+ Bool_t isPerfect,
+ Bool_t isActive,
+ Double_t sigmaX0 = 0., //< the constant part of sigmaX
+ Double_t sigmaX1 = 0., //< the z-dependent part of sigmaX
+ Double_t sigmaZ0 = 0. , //< the constant part of sigmaZ
+ Double_t sigmaZ1 = 0.); //< the z-dependent part of sigmaZ
+
+ /// The destructor
+ virtual ~GearTPCMeasLayer();
+
+ /**
+ * A perfect measurement layer contains all the modules with rows (row segments)
+ * that make up the layer.
+ */
+ virtual std::set< std::pair <int, int> > const & GetModuleRows() const;
+
+ /**
+ * Add another row on another module which lies on the same cylinder.
+ */
+ virtual void AddModuleRow(int module, int row);
+
+ /**
+ * Get the measurement vector (mv) for this layer from a space point (xv)
+ */
+ virtual TKalMatrix XvToMv (const TVector3 &xv) const = 0;
+
+ /**
+ * Get the z-depenent resolution in the readout plane
+ * (usually x or r\f$\phi\f$).
+ */
+ virtual Double_t GetSigmaX(Double_t z) const;
+
+ /**
+ * Get the z-depenent resolution in z (drift direction).
+ */
+ virtual Double_t GetSigmaZ(Double_t z) const;
+
+
+ /**
+ * Get the flag whether the layer is declared as perfect.
+ */
+ virtual Bool_t IsPerfect() const;
+
+ /**
+ * A virtual function to create the appropriate hit. Depending on the implementation
+ * (cylindrical or straight measurement layer) you get the appropriate implementation
+ * of GearTPCHit.
+ * It creates a new hit on the heap and hands over the ownership.
+ */
+ virtual GearTPCHit * createHit(Double_t * meas,
+ Double_t * dmeas,
+ void * hitPointer,
+ Double_t bField,
+ Double_t vDrift,
+ Int_t m = kMdim) const = 0;
+
+ protected:
+ Double_t fSigmaX0; // xy resolution
+ Double_t fSigmaX1; // xy resolution
+ Double_t fSigmaZ0; // z resolution
+ Double_t fSigmaZ1; // z resolution
+
+ /// A set to hold all the module/row combinations associated to this layer
+ std::set< std::pair<int, int> > fModuleRows;
+
+ Bool_t fIsPerfect;
+ };
+
+}// namespace kaldet
+#endif // GEARTPC_MEASLAYER_H
diff --git a/Utilities/KalDet/src/lctpc/gearTPC/LinkDef.h b/Utilities/KalDet/src/lctpc/gearTPC/LinkDef.h
new file mode 100644
index 0000000000000000000000000000000000000000..87a9fa8fe94d444b2575d334d8346d11ea013a83
--- /dev/null
+++ b/Utilities/KalDet/src/lctpc/gearTPC/LinkDef.h
@@ -0,0 +1,8 @@
+#ifdef __CINT__
+
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+
+
+#endif
diff --git a/Utilities/KalDet/src/othertpc/toytpc/EXTPCHit.cxx b/Utilities/KalDet/src/othertpc/toytpc/EXTPCHit.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..ab697842e8ba76b7d21985b554697fac718b68a4
--- /dev/null
+++ b/Utilities/KalDet/src/othertpc/toytpc/EXTPCHit.cxx
@@ -0,0 +1,135 @@
+//*************************************************************************
+//* ================
+//* EXTPCHit Class
+//* ================
+//*
+//* (Description)
+//* User defined hit class
+//* provides coordinate vector as defined by the MeasLayer
+//* (Requires)
+//* TVTrackHit
+//* (Provides)
+//* class EXTPCHit
+//* (Update Recored)
+//* 2009/11/23 K.Ikematsu Derived from KalTest/examples/kaltest/
+//* hybrid/tpc/EXTPCHit.cxx
+//* 2009/11/23 K.Ikematsu Added GetSortingPolicy() method
+//* 2009/11/23 K.Ikematsu Added data member *fHitPtr
+//* as a pointer to raw Hit object
+//*
+//* $Id: EXTPCHit.cxx,v 1.1 2010-03-11 15:07:01 fujiik Exp $
+//*************************************************************************
+//
+#include "EXTPCHit.h"
+#include "EXTPCMeasLayer.h"
+#include "TMath.h"
+
+#include <iostream>
+#include <iomanip>
+
+using namespace std;
+
+ClassImp(EXTPCHit)
+
+//_________________________________________________________________________
+// --------------
+// Ctors and Dtor
+// --------------
+//
+EXTPCHit::EXTPCHit(Int_t m)
+ : TVTrackHit(m),
+ fSide(0),
+ fVdrift(0)
+{
+}
+
+EXTPCHit::EXTPCHit(const EXTPCMeasLayer &ms,
+ Double_t *x,
+ Double_t *dx,
+ Int_t side,
+ Double_t v,
+ const TVector3 &xx,
+ Double_t b,
+ Int_t m)
+ : TVTrackHit(ms, x, dx, b, m),
+ fSide(side),
+ fVdrift(v),
+ fXXPtr(&xx)
+{
+}
+
+EXTPCHit::EXTPCHit(const EXTPCMeasLayer &ms,
+ Double_t *x,
+ Double_t *dx,
+ Int_t side,
+ Double_t v,
+ const void *hitp,
+ Double_t b,
+ Int_t m)
+ : TVTrackHit(ms, x, dx, b, m),
+ fSide(side),
+ fVdrift(v),
+ fHitPtr(hitp)
+{
+}
+
+EXTPCHit::~EXTPCHit()
+{
+}
+
+//_________________________________________________________________________
+// --------------------------------
+// Implementation of public methods
+// --------------------------------
+//
+TKalMatrix EXTPCHit::XvToMv(const TVector3 &xv, Double_t t0) const
+{
+ const EXTPCMeasLayer &ms
+ = dynamic_cast<const EXTPCMeasLayer &>(GetMeasLayer());
+ TKalMatrix h = ms.XvToMv(xv, GetSide());
+ h(0,0) = xv.X();
+ h(1,0) += fVdrift * t0;
+ return h;
+}
+
+void EXTPCHit::DebugPrint(Option_t *) const
+{
+ cerr << "------------------- Site Info -------------------------" << endl;
+
+ for (Int_t i = 0; i < GetDimension(); i++) {
+ Double_t x = (*this)(i, 0);
+ Double_t dx = (*this)(i, 1);
+ cerr << " x[" << i << "] = " << setw(8) << setprecision(5) << x
+ << " "
+ << "dx[" << i << "] = " << setw(6) << setprecision(2) << dx
+ << setprecision(7)
+ << resetiosflags(ios::showpoint)
+ << endl;
+ }
+ cerr << " r = " << setw(8)
+ << static_cast<const EXTPCMeasLayer&>(GetMeasLayer()).GetXc().Y() << endl;
+ cerr << "-------------------------------------------------------" << endl;
+}
+
+//_________________________________________________________________________
+// ----------------
+// Compare two Hits
+// ----------------
+//
+Int_t EXTPCHit::Compare(const TObject *obj) const
+{
+ Double_t me = GetSortingPolicy();
+ Double_t you = dynamic_cast<const EXTPCHit *>(obj)->GetSortingPolicy();
+ return me < you ? -1 : (me > you ? +1 : 0);
+}
+
+Double_t EXTPCHit::GetSortingPolicy() const
+{
+ // Calculate "r" (Caution!! vaild only for GEAR coordinate system)
+ return GetMeasLayer().HitToXv(*this).Mag();
+}
+
+Bool_t EXTPCHit::IsSortable() const
+{
+ return kTRUE;
+}
diff --git a/Utilities/KalDet/src/othertpc/toytpc/EXTPCHit.h b/Utilities/KalDet/src/othertpc/toytpc/EXTPCHit.h
new file mode 100644
index 0000000000000000000000000000000000000000..a151b88bd1cd060634c14378b1acd61eb98b4f8f
--- /dev/null
+++ b/Utilities/KalDet/src/othertpc/toytpc/EXTPCHit.h
@@ -0,0 +1,73 @@
+#ifndef EXTPCHIT_H
+#define EXTPCHIT_H
+//*************************************************************************
+//* ================
+//* EXTPCHit Class
+//* ================
+//*
+//* (Description)
+//* User defined hit class
+//* provides coordinate vector as defined by the MeasLayer
+//* (Requires)
+//* TVTrackHit
+//* (Provides)
+//* class EXTPCHit
+//* (Update Recored)
+//* 2009/11/23 K.Ikematsu Derived from KalTest/examples/kaltest/
+//* hybrid/tpc/EXTPCHit.h
+//* 2009/11/23 K.Ikematsu Added GetSortingPolicy() method
+//* 2009/11/23 K.Ikematsu Added data member *fHitPtr
+//* as a pointer to raw Hit object
+//*
+//* $Id: EXTPCHit.h,v 1.1 2010-03-11 15:07:01 fujiik Exp $
+//*************************************************************************
+//
+#include "kaltest/KalTrackDim.h"
+#include "kaltest/TVTrackHit.h"
+#include "EXTPCMeasLayer.h"
+
+class EXTPCHit : public TVTrackHit {
+
+public:
+ EXTPCHit(Int_t m = kMdim);
+
+ EXTPCHit(const EXTPCMeasLayer &ms,
+ Double_t *x,
+ Double_t *dx,
+ Int_t side,
+ Double_t v,
+ const TVector3 &xx,
+ Double_t b,
+ Int_t m = kMdim);
+
+ EXTPCHit(const EXTPCMeasLayer &ms,
+ Double_t *x,
+ Double_t *dx,
+ Int_t side,
+ Double_t v,
+ const void *hitp,
+ Double_t b,
+ Int_t m = kMdim);
+
+ virtual ~EXTPCHit();
+
+ virtual TKalMatrix XvToMv(const TVector3 &xv, Double_t t0) const;
+ virtual void DebugPrint(Option_t *opt = "") const;
+ virtual Double_t GetSortingPolicy() const;
+ virtual Int_t Compare(const TObject *obj) const;
+ virtual Bool_t IsSortable() const;
+
+ inline Int_t GetSide () const { return fSide; }
+ inline Double_t GetVdrift() const { return fVdrift; }
+ inline const void *GetHitPtr() const { return fHitPtr; }
+ inline const TVector3 GetExactX() const { return *fXXPtr; }
+
+private:
+ Int_t fSide; // (-1, +1) = (-z side, +z side)
+ Double_t fVdrift; // drift veclocity
+ const TVector3 *fXXPtr; // pointer to exact hit
+ const void *fHitPtr; // pointer to raw Hit object
+
+ ClassDef(EXTPCHit, 1) // EXTPC hit class
+};
+#endif
diff --git a/Utilities/KalDet/src/othertpc/toytpc/EXTPCKalDetector.cxx b/Utilities/KalDet/src/othertpc/toytpc/EXTPCKalDetector.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..279cd9cde882373a07d2b2e3479d57fdec16c8f3
--- /dev/null
+++ b/Utilities/KalDet/src/othertpc/toytpc/EXTPCKalDetector.cxx
@@ -0,0 +1,147 @@
+//*************************************************************************
+//* ========================
+//* EXTPCKalDetector Class
+//* ========================
+//*
+//* (Description)
+//* User defined detector class
+//* (Requires)
+//* EXVKalDetector
+//* (Provides)
+//* class EXTPCKalDetector
+//* (Update Recored)
+//* 2009/11/23 K.Ikematsu Derived from KalTest/examples/kaltest/
+//* hybrid/tpc/EXTPCKalDetector.cxx
+//*
+//* $Id: EXTPCKalDetector.cxx,v 1.1 2010-03-11 15:07:01 fujiik Exp $
+//*************************************************************************
+//
+// STL
+#include <vector>
+
+// GEAR
+#include "gear/GEAR.h"
+#include "gear/TPCParameters.h"
+#include "gear/PadRowLayout2D.h"
+#include "gearimpl/TPCModuleImpl.h"
+#include "gearxml/GearXML.h"
+
+// global constants from Marlin, used for the global pointer to the GearMgr
+//#include <marlin/Global.h>
+
+#include "EXTPCKalDetector.h"
+#include "EXTPCMeasLayer.h"
+#include "EXTPCHit.h"
+#include "kaltest/TKalDetCradle.h"
+
+// ROOT
+#include "TRandom.h"
+#include "TMath.h"
+#include "TTUBE.h"
+#include "TNode.h"
+#include "TVirtualPad.h"
+
+EXTPCKalDetector * EXTPCKalDetector::fgInstance = 0;
+Double_t EXTPCKalDetector::fgVdrift = 7.6e-3;
+
+
+ClassImp(EXTPCKalDetector)
+
+// definition of gas parameters for mixture of Ar + CF4 + C4H10
+Double_t Ar = 0.95; // fraction of Argon in chamber gas
+Double_t CF = 0.043; // fraction of CF4 in chamber gas
+Double_t CH = 0.007; // fraction of C4H10 in chamber gas
+
+EXTPCKalDetector::EXTPCKalDetector(Int_t m)
+ : EXVKalDetector(m),
+ fNodePtr(0)
+{
+ Double_t A, Z, density, radlen;
+
+ A = 39.948 * Ar + 17.601 * CF + 4.152 * CH;
+ Z = 18 * Ar + 8.4 * CF + 2.4 * CH;
+ density = (1.784 * Ar + 3.692 * CF + 2.65 * CH)/1000;
+ radlen = 1.196e4*2; // has to be checked, copied from 0.9 Ar, 0.1 C4H10 lines
+ TMaterial &gas = *new TMaterial("TPCGas", "", A, Z, density, radlen, 0.);
+#if 1
+ static const Int_t nlayers = 24; // number of layer
+ static const Double_t kmm2cm = 0.1;
+ static const Double_t lhalf = 600. * kmm2cm; //length
+ // diffusion coefficients transversal (x) and longitudinal (z) to magnetic field
+ static const Double_t neff = 22.7;
+#if 0
+ static const Double_t sigmax0 = 38.3e-4;
+ static const Double_t sigmax1 = 101.5e-4 /TMath::Sqrt(10.)/TMath::Sqrt(neff);
+ static const Double_t sigmaz0 = 500.e-4;
+ static const Double_t sigmaz1 = 154.e-4/TMath::Sqrt(10.)/TMath::Sqrt(neff);
+#else
+ static const Double_t sigmax0 = 50e-4;
+ static const Double_t sigmax1 = 0.;
+ static const Double_t sigmaz0 = 500.e-4;
+ static const Double_t sigmaz1 = 0.;
+#endif
+ fgVdrift = 50.e-3 * kmm2cm;
+#else
+
+ gear::TPCParameters const &theTPCParameters
+ = marlin::Global::GEAR->getTPCParameters();
+
+ Int_t nmodules = theTPCParameters.getNModules();
+
+ std::vector<const gear::TPCModule *> modules;
+
+ for (Int_t i = 0; i < nmodules; i++) {
+ modules.push_back(&theTPCParameters.getModule(i));
+ }
+
+ static const Double_t kmm2cm = 0.1;
+
+ static const Double_t lhalf
+ = theTPCParameters.getMaxDriftLength() * kmm2cm; // half length
+ static const Int_t nrows = modules[0]->getNRows(); // # of pad rows
+ ///// FIXME: temporary treatment /////////////////////////
+ static const Int_t nlayers = nrows * 3; // # of layers
+ //////////////////////////////////////////////////////////
+ static const Double_t neff = 22.7;
+ static const Double_t sigmax0 = 38.3e-4;
+ static const Double_t sigmax1 = 101.5e-4 / TMath::Sqrt(10.) / TMath::Sqrt(neff);
+ static const Double_t sigmaz0 = 500.e-4;
+ static const Double_t sigmaz1 = 154.e-4 / TMath::Sqrt(10.) / TMath::Sqrt(neff);
+#endif
+ Bool_t active = EXTPCMeasLayer::kActive;
+
+ // create measurement layers
+ Int_t module = 1;
+ for (Int_t layer = 0; layer < nlayers; layer++) {
+ Double_t XMin = -32. * kmm2cm;
+ Double_t XMax = 32. * kmm2cm;
+ Double_t y0 = (4.*layer-46.) * kmm2cm;
+ Add(new EXTPCMeasLayer(gas, gas, y0, XMin, XMax, lhalf, sigmax0, sigmax1, sigmaz0, sigmaz1, active, layer, module));
+ }
+ SetOwner();
+}
+
+EXTPCKalDetector::~EXTPCKalDetector()
+{
+}
+
+EXTPCKalDetector * EXTPCKalDetector::GetInstance()
+{
+ if (!fgInstance) {
+ fgInstance = new EXTPCKalDetector;
+ TKalDetCradle & toydet = * new TKalDetCradle;
+ toydet.Install(*fgInstance);
+ toydet.Close();
+ toydet.Sort();
+ }
+ return fgInstance;
+}
+
+void EXTPCKalDetector::Draw(Int_t color, const Char_t *opt)
+{
+ if (! gPad) return;
+ TNode *nodep = GetNodePtr();
+ nodep->cd();
+ //EXVKalDetector::Draw(color, opt);
+ TAttDrawable::Draw(color, opt);
+}
diff --git a/Utilities/KalDet/src/othertpc/toytpc/EXTPCKalDetector.h b/Utilities/KalDet/src/othertpc/toytpc/EXTPCKalDetector.h
new file mode 100644
index 0000000000000000000000000000000000000000..63fa7576c72ce51ca619aea4eee4f44faea4f091
--- /dev/null
+++ b/Utilities/KalDet/src/othertpc/toytpc/EXTPCKalDetector.h
@@ -0,0 +1,45 @@
+#ifndef EXTPCDETECTOR_H
+#define EXTPCDETECTOR_H
+//*************************************************************************
+//* ========================
+//* EXTPCKalDetector Class
+//* ========================
+//*
+//* (Description)
+//* User defined detector class
+//* (Requires)
+//* EXVKalDetector
+//* (Provides)
+//* class EXTPCKalDetector
+//* (Update Recored)
+//* 2009/11/23 K.Ikematsu Derived from KalTest/examples/kaltest/
+//* hybrid/tpc/EXTPCKalDetector.h
+//*
+//* $Id: EXTPCKalDetector.h,v 1.1 2010-03-11 15:07:01 fujiik Exp $
+//*************************************************************************
+//
+#include "kaldet/EXVKalDetector.h"
+
+class TNode;
+
+class EXTPCKalDetector : public EXVKalDetector {
+private:
+ EXTPCKalDetector(Int_t m = 100);
+
+public:
+ ~EXTPCKalDetector();
+ static EXTPCKalDetector * GetInstance();
+
+ static Double_t GetVdrift() { return fgVdrift; }
+
+ //using EXVKalDetector::Draw;
+ void Draw(Int_t color, const Char_t *opt = "");
+
+private:
+ TNode * fNodePtr; // node pointer
+ static Double_t fgVdrift; // drift velocity
+ static EXTPCKalDetector * fgInstance; //! singleton pointer
+
+ ClassDef(EXTPCKalDetector, 1) // User defined detector class
+};
+#endif
diff --git a/Utilities/KalDet/src/othertpc/toytpc/EXTPCMeasLayer.cxx b/Utilities/KalDet/src/othertpc/toytpc/EXTPCMeasLayer.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..d7a4c9c5f2e1c21b92b5640a658e2134ea33032d
--- /dev/null
+++ b/Utilities/KalDet/src/othertpc/toytpc/EXTPCMeasLayer.cxx
@@ -0,0 +1,202 @@
+//*************************************************************************
+//* ===================
+//* EXTPCMeasLayer Class
+//* ===================
+//*
+//* (Description)
+//* Sample measurement layer class used by EXTPCHit.
+//* (Requires)
+//* (Provides)
+//* class EXTPCMeasLayer
+//* (Update Recored)
+//* 2003/09/30 Y.Nakashima Original version.
+//*
+//*************************************************************************
+//
+
+#include "EXTPCMeasLayer.h"
+#include "EXTPCHit.h"
+#include "EXTPCKalDetector.h"
+#include "TRandom.h"
+#include "TMath.h"
+
+
+ClassImp(EXTPCMeasLayer)
+
+EXTPCMeasLayer::EXTPCMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ Double_t y0,
+ Double_t lhalf,
+ Double_t sigmax0,
+ Double_t sigmax1,
+ Double_t sigmaz0,
+ Double_t sigmaz1,
+ Bool_t type)
+ : EXVMeasLayer(min, mout, type),
+ TPlane(TVector3(0.,y0,lhalf), TVector3(0.,1.,0.)),
+ fSigmaX0(sigmax0),
+ fSigmaX1(sigmax1),
+ fSigmaZ0(sigmaz0),
+ fSigmaZ1(sigmaz1),
+ fLayer(-1)
+{
+}
+
+EXTPCMeasLayer::EXTPCMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ Double_t y0,
+ Double_t XMin,
+ Double_t XMax,
+ Double_t lhalf,
+ Double_t sigmax0,
+ Double_t sigmax1,
+ Double_t sigmaz0,
+ Double_t sigmaz1,
+ Bool_t type,
+ Int_t layer,
+ Int_t module)
+ : EXVMeasLayer(min, mout, type),
+ TPlane(TVector3(0.,y0,lhalf), TVector3(0.,1.,0.)),
+ fXMin(XMin),
+ fXMax(XMax),
+ fSigmaX0(sigmax0),
+ fSigmaX1(sigmax1),
+ fSigmaZ0(sigmaz0),
+ fSigmaZ1(sigmaz1),
+ fModule(module),
+ fLayer(layer)
+{
+}
+
+EXTPCMeasLayer::~EXTPCMeasLayer()
+{
+}
+
+TKalMatrix EXTPCMeasLayer::XvToMv(const TVector3 &xv,
+ Int_t side) const
+{
+ TKalMatrix mv(kMdim,1);
+ mv(0,0) =xv.X();
+ mv(1,0) =xv.Z();
+ return mv;
+}
+
+TKalMatrix EXTPCMeasLayer::XvToMv(const TVTrackHit &vht,
+ const TVector3 &xv) const
+{
+ return XvToMv(xv, dynamic_cast<const EXTPCHit &>(vht).GetSide());
+}
+
+TVector3 EXTPCMeasLayer::HitToXv(const TVTrackHit &vht) const
+{
+ const EXTPCHit &ht = dynamic_cast<const EXTPCHit &>(vht);
+ Double_t x = ht(0,0);
+ Double_t y = GetXc().Y();
+ Double_t z = ht(1,0);
+ return TVector3(x,y,z);
+}
+
+void EXTPCMeasLayer::CalcDhDa(const TVTrackHit &vht,
+ const TVector3 &xxv,
+ const TKalMatrix &dxphiada,
+ TKalMatrix &H) const
+{
+ Int_t sdim = H.GetNcols();
+ Int_t hdim = TMath::Max(5,sdim-1);
+
+ for (Int_t i=0;i<hdim;i++){
+ H(0,i) = dxphiada(0,i);
+ H(1,i) = dxphiada(2,i);
+ }
+}
+
+/*
+ void EXTPCMeasLayer::CalcDhDa(const TVTrackHit &vht,
+ const TVector3 &xxv,
+ const TKalMatrix &dxphiada,
+ TKalMatrix &H) const
+ {
+ const EXTPCHit &ht = dynamic_cast<const EXTPCHit &>(vht);
+
+ // Calculate
+ // H = (@h/@a) = (@phi/@a, @z/@a)^t
+ // where
+ // h(a) = (phi, z)^t: expected meas vector
+ // a = (drho, phi0, kappa, dz, tanl, t0)
+
+
+ Int_t sdim = H.GetNcols();
+ Int_t hdim = TMath::Max(5,sdim-1);
+
+ TVector3 xxvc = xxv - GetXc();
+ Double_t xv = xxvc.X();
+ Double_t yv = xxvc.Y();
+ Double_t xxyy = xv * xv + yv * yv;
+
+ // Set H = (@h/@a) = (@d/@a, @z/@a)^t
+
+ for (Int_t i=0; i<hdim; i++) {
+ H(0,i) = - (yv / xxyy) * dxphiada(0,i)
+ + (xv / xxyy) * dxphiada(1,i);
+ H(0,i) *= 0;//GetR();
+#if 0
+ H(1,i) = - ht.GetSide() * dxphiada(2,i);
+#else
+ H(1,i) = dxphiada(2,i);
+#endif
+ }
+ if (sdim == 6) {
+ H(0,sdim-1) = 0.;
+#if 0
+ H(1,sdim-1) = ht.GetVdrift();
+#else
+ H(1,sdim-1) = - ht.GetVdrift();
+#endif
+ }
+}
+*/
+
+Double_t EXTPCMeasLayer::GetSigmaX(Double_t zdrift) const
+{
+ return TMath::Sqrt(fSigmaX0 * fSigmaX0 + fSigmaX1 * fSigmaX1 * zdrift);
+}
+
+Double_t EXTPCMeasLayer::GetSigmaZ(Double_t zdrift) const
+{
+ return TMath::Sqrt(fSigmaZ0 * fSigmaZ0 + fSigmaZ1 * fSigmaZ1 * zdrift);
+}
+
+Double_t EXTPCMeasLayer::GetSortingPolicy() const
+{
+ return GetXc().Y();
+}
+
+
+void EXTPCMeasLayer::ProcessHit(const TVector3 &xx,
+ TObjArray &hits)
+{
+ Int_t side = (xx.Z() < 0. ? -1 : 1);
+ TKalMatrix h = XvToMv(xx, side);
+ Double_t rphi = h(0, 0);
+ Double_t d = h(1, 0);
+
+ Double_t dx = GetSigmaX(d);
+ Double_t dz = GetSigmaZ(d);
+ rphi += gRandom->Gaus(0., dx); // smearing rphi
+ d += gRandom->Gaus(0., dz); // smearing drift distance
+
+ Double_t v = EXTPCKalDetector::GetVdrift();
+#if 0
+ d += v * EXEventGen::GetT0(); // T0 shift
+#endif
+
+ Double_t meas [2];
+ Double_t dmeas[2];
+ meas [0] = rphi;
+ meas [1] = d;
+ dmeas[0] = dx;
+ dmeas[1] = dz;
+
+ Double_t b = EXTPCKalDetector::GetBfield();
+ hits.Add(new EXTPCHit(*this, meas, dmeas, side, v, xx, b));
+}
diff --git a/Utilities/KalDet/src/othertpc/toytpc/EXTPCMeasLayer.h b/Utilities/KalDet/src/othertpc/toytpc/EXTPCMeasLayer.h
new file mode 100644
index 0000000000000000000000000000000000000000..c9dc038828bc4709a15e3822463684cde2f2aa56
--- /dev/null
+++ b/Utilities/KalDet/src/othertpc/toytpc/EXTPCMeasLayer.h
@@ -0,0 +1,91 @@
+#ifndef EXTPCMEASLAYER_H
+#define EXTPCMEASLAYER_H
+//*************************************************************************
+//* ===================
+//* EXTPCMeasLayer Class
+//* ===================
+//*
+//* (Description)
+//* Sample measurement layer class used by EXTPCHit.
+//* (Requires)
+//* (Provides)
+//* class EXTPCMeasLayer
+//* (Update Recored)
+//* 2003/09/30 Y.Nakashima Original version.
+//*
+//*************************************************************************
+//
+#include "TVector3.h"
+#include "kaltest/TKalMatrix.h"
+#include "kaltest/TPlane.h"
+#include "kaltest/KalTrackDim.h"
+#include "kaldet/EXVMeasLayer.h"
+
+class TVTrackHit;
+
+class EXTPCMeasLayer : public EXVMeasLayer, public TPlane {
+public:
+ // Ctors and Dtor
+
+ EXTPCMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ Double_t y0,
+ Double_t lhalf,
+ Double_t sigmax0,
+ Double_t sigmax1,
+ Double_t sigmaz0,
+ Double_t sigmaz1,
+ Bool_t type = EXVMeasLayer::kActive);
+ EXTPCMeasLayer(TMaterial &min,
+ TMaterial &mout,
+ Double_t y0,
+ Double_t xmin,
+ Double_t ymax,
+ Double_t lhalf,
+ Double_t sigmax0,
+ Double_t sigmax1,
+ Double_t sigmaz0,
+ Double_t sigmaz1,
+ Bool_t type = EXVMeasLayer::kDummy,
+ Int_t layer = -1,
+ Int_t module = 0);
+ virtual ~EXTPCMeasLayer();
+
+ // Getters and Setters
+
+ inline Int_t GetModuleID() const { return fModule; }
+ inline Int_t GetLayerID () const { return fLayer; }
+
+ // Parrent's pure virtuals that must be implemented
+
+ virtual TKalMatrix XvToMv (const TVTrackHit &ht,
+ const TVector3 &xv) const;
+ virtual TKalMatrix XvToMv (const TVector3 &xv,
+ Int_t side) const;
+ virtual TVector3 HitToXv (const TVTrackHit &ht) const;
+ virtual void CalcDhDa (const TVTrackHit &ht,
+ const TVector3 &xv,
+ const TKalMatrix &dxphiada,
+ TKalMatrix &H) const;
+ virtual void ProcessHit(const TVector3 &xx,
+ TObjArray &hits);
+
+ virtual Double_t GetSortingPolicy () const;
+
+ Double_t GetSigmaX(Double_t z) const;
+ Double_t GetSigmaZ(Double_t z) const;
+
+private:
+ Double_t fXMin; // minimum phi
+ Double_t fXMax; // maximum phi
+ Double_t fSigmaX0; // xy resolution
+ Double_t fSigmaX1; // xy resolution
+ Double_t fSigmaZ0; // z resolution
+ Double_t fSigmaZ1; // z resolution
+ Int_t fModule; // module number
+ Int_t fLayer; // layer number
+
+ ClassDef(EXTPCMeasLayer,1) // Sample measurement layer class
+};
+
+#endif
diff --git a/Utilities/KalDet/src/othertpc/toytpc/Imakefile b/Utilities/KalDet/src/othertpc/toytpc/Imakefile
new file mode 100644
index 0000000000000000000000000000000000000000..559ab42540f563a1a806443e53f4f7b949b11f6e
--- /dev/null
+++ b/Utilities/KalDet/src/othertpc/toytpc/Imakefile
@@ -0,0 +1,62 @@
+#include "../../conf/makejsf.tmpl"
+
+INSTALLDIR = ../..
+PACKAGENAME = KalDetToyTpc
+SOREV = 2009.01
+SRCS = EXTPCKalDetector.$(SrcSuf) \
+ EXTPCMeasLayer.$(SrcSuf) \
+ EXTPCHit.$(SrcSuf)
+
+OBJS = $(subst .$(SrcSuf),.$(ObjSuf),$(SRCS)) \
+ $(PACKAGENAME)Dict.$(ObjSuf)
+
+HDRS = $(subst .$(SrcSuf),.h,$(SRCS))
+
+DICTNAME = $(PACKAGENAME)Dict
+
+LIBNAME = $(PACKAGENAME)
+
+SONAME = lib$(LIBNAME).$(DllSuf).$(SOREV)
+
+LIBINSTALLDIR = $(INSTALLDIR)/lib
+INCINSTALLDIR = $(INSTALLDIR)/include
+INCPATH = -I. -I$(KALTESTROOT)/include -I$(INCINSTALLDIR)
+INCPATH += -I$(MARLIN)/include -I$(GEAR)/include
+CXXFLAGS += $(INCPATH) -O -g
+CXXFLAGS += -DUSE_GEAR
+SHLIBLDFLAGS = $(DYLIBFLAGS)
+
+all:: $(SONAME)
+
+SharedLibraryTarget($(LIBNAME),$(SOREV),$(OBJS),.,.)
+
+#if defined(DarwinArchitecture)
+$(SONAME): $(OBJS)
+ $(LD) $(SOFLAGS) -o $(SONAME) $(OBJS) $(LDFLAGS)
+
+install:: $(SONAME)
+ $(MKDIRHIER) $(DESTDIR)$(LIBINSTALLDIR)
+ $(INSTALL) $(INSTALLFLAGS) $(SONAME) $(LIBINSTALLDIR)
+ $(RM) $(LIBINSTALLDIR)/lib$(LIBNAME).$(DllSuf)
+ $(LN) $(SONAME) $(LIBINSTALLDIR)/lib$(LIBNAME).$(DllSuf)
+#endif
+
+InstallSharedLibrary($(LIBNAME),$(SOREV),$(LIBINSTALLDIR))
+
+InstallMultipleFlags($(HDRS),$(INCINSTALLDIR),-m 644 -C)
+
+clean::
+ @rm -f $(OBJS) core *.$(DllSuf) $(DICTNAME).$(SrcSuf) $(DICTNAME).h
+
+depend:: $(SRCS) $(HDRS)
+ for i in $(SRCS); do \
+ rmkdepend -a -- $(DEPENDFILES) -- $$i; done
+
+distclean:: clean
+ @rm -f $(OBJS) core *.$(DllSuf) $(DICTNAME).$(SrcSuf) $(DICTNAME).h *~
+ @rm -f *.root Makefile
+
+$(DICTNAME).$(SrcSuf): $(HDRS) LinkDef.h
+ @echo "Generating dictionary ..."
+ rootcint -f $(DICTNAME).$(SrcSuf) \
+ -c $(INCPATH) $(HDRS) LinkDef.h
diff --git a/Utilities/KalDet/src/othertpc/toytpc/LinkDef.h b/Utilities/KalDet/src/othertpc/toytpc/LinkDef.h
new file mode 100644
index 0000000000000000000000000000000000000000..c5932dc1edf594d424364e14af5a236cb1e2f4fe
--- /dev/null
+++ b/Utilities/KalDet/src/othertpc/toytpc/LinkDef.h
@@ -0,0 +1,11 @@
+#ifdef __CINT__
+
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+
+#pragma link C++ class EXTPCKalDetector+;
+#pragma link C++ class EXTPCHit+;
+#pragma link C++ class EXTPCMeasLayer+;
+
+#endif