cmake_minimum_required(VERSION 2.6.2)
project(CA)
set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")

find_package(Vc REQUIRED)
include_directories(${VC_INCLUDE_DIR})

find_package(SSE)
#find_package(TBB REQUIRED)
#include_directories(${TBB_INCLUDE_DIRS})

if(NOT CMAKE_BUILD_TYPE)
   set(CMAKE_BUILD_TYPE Release CACHE STRING
      "Choose the type of build, options are: None Debug Release RelWithDebug RelWithDebInfo MinSizeRel."
      FORCE)
endif(NOT CMAKE_BUILD_TYPE)

find_package(TBB)
include_directories(${TBB_INCLUDE_DIRS})
set(TBB_REALY_FOUND = ${TBB_FOUND})

 set(ENABLE_ROOT TRUE CACHE BOOL "Enable usage of ROOT if it is found.")
 if(ENABLE_ROOT)
    find_package(Root)
 else(ENABLE_ROOT)
    set(ROOT_FOUND FALSE)
 endif(ENABLE_ROOT)

if(NUM_THREADS)
   add_definitions(-DNUM_THREADS=${NUM_THREADS})
endif(NUM_THREADS)
#if(VC_NO_GATHER_TRICKS)
#   add_definitions(-DVC_NO_GATHER_TRICKS)
#endif(VC_NO_GATHER_TRICKS)

macro(add_target_property _target _prop _value)
   get_target_property(_oldprop "${_target}" ${_prop})
   if(NOT _oldprop)
      set_target_properties("${_target}" PROPERTIES ${_prop} "${_value}")
   else(NOT _oldprop)
      set_target_properties("${_target}" PROPERTIES ${_prop} "${_oldprop} ${_value}")
   endif(NOT _oldprop)
endmacro(add_target_property)

#for KF Particle
add_definitions(-DUSE_TIMERS -DKFParticleStandalone -DNonhomogeneousField -DDO_TPCCATRACKER_EFF_PERFORMANCE -DCBM -DUSE_RL_TABLE)

if(CMAKE_COMPILER_IS_GNUCXX)
   ##################################################################################################
   #                                              GCC                                               #
   ##################################################################################################
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -W -Wall -Wswitch -Wformat -Wchar-subscripts -Wno-parentheses -Wmultichar -Wtrigraphs -Wpointer-arith -Wcast-align -Wreturn-type -Wno-unused-function -Wno-unused-local-typedefs -Wno-parentheses -ansi -pedantic -Wno-long-long -Wno-variadic-macros -msse -msse2 -Wshadow -fno-threadsafe-statics  -DHAVE_SSE -Iopenlab_mod -DTBB2 -lpthread -fopenmp -qsmp ")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -W -Wall -Wswitch -Wformat -Wchar-subscripts -Wno-parentheses -Wmultichar -Wtrigraphs -Wpointer-arith -Wcast-align -Wreturn-type -Wno-unused-function -Wno-unused-local-typedefs -Wno-parentheses -ansi -pedantic -Wno-long-long -Wno-variadic-macros -msse -msse2 -Wshadow -fno-threadsafe-statics -DHAVE_SSE -Iopenlab_mod -DTBB2 -lpthread -fopenmp")
   if(TBB_FOUND)
      set(CMAKE_CXX_FLAGS_DEBUG          "${CMAKE_CXX_FLAGS_DEBUG} -DTBB_DO_ASSERT=1")
   endif(TBB_FOUND)
   set(CMAKE_CXX_FLAGS_MINSIZEREL     "${CMAKE_CXX_FLAGS_MINSIZEREL}")
   set(CMAKE_CXX_FLAGS_RELEASE        "${CMAKE_CXX_FLAGS_RELEASE} -O3")
   set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -O3")
   if(TBB_FOUND)
      set(CMAKE_C_FLAGS_DEBUG          "${CMAKE_C_FLAGS_DEBUG} -DTBB_DO_ASSERT=1")
   endif(TBB_FOUND)
   set(CMAKE_C_FLAGS_MINSIZEREL     "${CMAKE_C_FLAGS_MINSIZEREL}")
   set(CMAKE_C_FLAGS_RELEASE        "${CMAKE_C_FLAGS_RELEASE} -O3")
   set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} -O3")
   
#  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -lrt")

   if(CMAKE_BUILD_TYPE STREQUAL "Debug")
      add_definitions(-DNO_OPTIMIZATION)
   elseif(CMAKE_BUILD_TYPE STREQUAL "" AND NOT CMAKE_CXX_FLAGS MATCHES "-O[123]")
      add_definitions(-DNO_OPTIMIZATION)
   endif(CMAKE_BUILD_TYPE STREQUAL "Debug")
   if(CMAKE_BUILD_TYPE STREQUAL "Release" OR CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")
      set(ENABLE_STRICT_ALIASING true CACHE BOOL "Enables strict aliasing rules for more aggressive optimizations")
      if(NOT ENABLE_STRICT_ALIASING)
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-strict-aliasing")
         set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fno-strict-aliasing")
      endif(NOT ENABLE_STRICT_ALIASING)
      set(DISABLE_DEBUG true CACHE BOOL "Disables debugging code, like assertions")
      if(DISABLE_DEBUG)
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DNDEBUG -DNODEBUG")
         set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DNDEBUG -DNODEBUG")
      endif(DISABLE_DEBUG)
   endif(CMAKE_BUILD_TYPE STREQUAL "Release" OR CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")

   set(USE_SSSE3 ${SSSE3_FOUND} CACHE BOOL "Use SSE3 and SSSE3. If (S)SSE3 instructions are not enabled they will be emulated.")
   set(USE_SSE4_1 ${SSE4_1_FOUND} CACHE BOOL "Use SSE4.1. If SSE4.1 instructions are not enabled they will be emulated.")
   if(USE_SSSE3)
      set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -msse3 -mssse3")
      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -msse3 -mssse3")
   endif(USE_SSSE3)
   if(USE_SSE4_1)
      set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -msse4.1")
      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -msse4.1")
   endif(USE_SSE4_1)
elseif(CMAKE_CXX_COMPILER MATCHES "/(icpc|icc)$")
   ##################################################################################################
   #                                          Intel Compiler                                        #
   ##################################################################################################


   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wformat -Wparentheses -Wmultichar -Wtrigraphs -Wpointer-arith -Wreturn-type -Wno-unused-function -ansi -msse -msse2 -Wshadow -DHAVE_SSE -Iopenlab_mod -DTBB2 -lpthread -openmp") # -DUSE_TIMERS")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wformat -Wparentheses -Wmultichar -Wtrigraphs -Wpointer-arith -Wreturn-type -Wno-unused-function -ansi -msse -msse2 -Wshadow -DHAVE_SSE -Iopenlab_mod -DTBB2 -lpthread -openmp")

   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x -lrt")# -D_MSC_VER=1200")
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c++0x -lrt")# -D_MSC_VER=1200")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -shared-libgcc")
#   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -no-cxxlib")

   set(CMAKE_CXX_FLAGS_RELEASE        "${CMAKE_CXX_FLAGS_RELEASE} -O3")
   set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -DNDEBUG -DNODEBUG -O3 -g")
   set(CMAKE_C_FLAGS_RELEASE          "${CMAKE_C_FLAGS_RELEASE} -O3")
   set(CMAKE_C_FLAGS_RELWITHDEBINFO   "${CMAKE_C_FLAGS_RELWITHDEBINFO} -DNDEBUG -DNODEBUG -O3 -g")

   set(ALIAS_FLAGS "-no-ansi-alias")
   if(CMAKE_BUILD_TYPE STREQUAL "Release" OR CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")
      set(ENABLE_STRICT_ALIASING true CACHE BOOL "Enables strict aliasing rules for more aggressive optimizations")
      if(ENABLE_STRICT_ALIASING)
         set(ALIAS_FLAGS "-ansi-alias")
      endif(ENABLE_STRICT_ALIASING)
   endif(CMAKE_BUILD_TYPE STREQUAL "Release" OR CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")

   # per default icc is not IEEE compliant, but we need that for verification
   set(CMAKE_C_FLAGS   "${CMAKE_C_FLAGS}   ${ALIAS_FLAGS} -w1 -fp-model precise")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${ALIAS_FLAGS} -w1 -fp-model precise")

   if(CMAKE_BUILD_TYPE STREQUAL "Debug")
      add_definitions(-DNO_OPTIMIZATION)
   elseif(CMAKE_BUILD_TYPE STREQUAL "" AND NOT CMAKE_CXX_FLAGS MATCHES "-O[123]")
      add_definitions(-DNO_OPTIMIZATION)
   endif(CMAKE_BUILD_TYPE STREQUAL "Debug")
endif(CMAKE_COMPILER_IS_GNUCXX)

if(CMAKE_BUILD_TYPE STREQUAL "" AND NOT CMAKE_CXX_FLAGS MATCHES "-O[123]")
   message(STATUS "WARNING! It seems you are compiling without optimization. Please set CMAKE_BUILD_TYPE.")
endif(CMAKE_BUILD_TYPE STREQUAL "" AND NOT CMAKE_CXX_FLAGS MATCHES "-O[123]")

set(FAST_MATH FALSE CACHE BOOL "Use floating point math shortcuts. Might not be IEEE compliant!")
if(FAST_MATH)
   if(CMAKE_COMPILER_IS_GNUCXX)
      set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -ffast-math")
      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ffast-math")
   elseif(CMAKE_CXX_COMPILER MATCHES "/(icpc|icc)$")
      set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fp-model fast=2")
      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fp-model fast=2")
   elseif(MSVC)
   endif(CMAKE_COMPILER_IS_GNUCXX)
endif(FAST_MATH)

include_directories(${CMAKE_CURRENT_SOURCE_DIR}/code
                    ${CMAKE_CURRENT_SOURCE_DIR}
                    ${CMAKE_CURRENT_SOURCE_DIR}/code/Common
		    ${CMAKE_CURRENT_SOURCE_DIR}/code/Parallelization
                    ${CMAKE_CURRENT_SOURCE_DIR}/code/Performance
                    ${CMAKE_CURRENT_SOURCE_DIR}/code/Performance/KFParticlePerformance
                    ${CMAKE_CURRENT_SOURCE_DIR}/code/L1InputData
		    ${CMAKE_CURRENT_SOURCE_DIR}/code/L1Algo
                    ${CMAKE_CURRENT_SOURCE_DIR}/code/KFParticle
                    ${CMAKE_CURRENT_SOURCE_DIR}/code/KFParticle/KFParticle
                    ${CMAKE_CURRENT_SOURCE_DIR}/code/vectors
		    ${CMAKE_CURRENT_SOURCE_DIR}/code/utils
		    )
		    
set(CommonCode
    code/Common/TDHelper.cxx
    code/TaskManager.cxx
   )
set(AlgoCode
    code/L1InputData/L1AlgoInputSettings.cxx
    code/L1InputData/L1AlgoInputData.cxx
    code/L1Algo/L1Algo.cxx 
    code/L1Algo/L1Grid.cxx
    code/L1Algo/L1TrackExtender.cxx
    code/L1Algo/L1CAMergeClones.cxx
    code/L1Algo/L1TrackFitter.cxx
    code/L1Algo/L1CATrackFinder.cxx
    code/L1Algo/L1HitsSortHelper.cxx
    code/L1Algo/L1Event.cxx
    code/L1Algo/L1MCEvent.cxx
    code/L1Algo/L1EventMatch.cxx
    code/L1Algo/L1TrackParFit.cxx
   )
set(KFParticleCode
    code/KFParticle/CbmKFTrackFitter.cxx
    code/KFParticle/KFParticle/KFParticleDatabase.cxx
    code/KFParticle/KFParticle/KFPTrack.cxx
    code/KFParticle/KFParticle/KFPTrackVector.cxx
    code/KFParticle/KFParticle/KFPVertex.cxx
    code/KFParticle/KFParticle/KFParticleBase.cxx
    code/KFParticle/KFParticle/KFParticleBaseSIMD.cxx
    code/KFParticle/KFParticle/KFParticle.cxx
    code/KFParticle/KFParticle/KFVertex.cxx 
    code/KFParticle/KFParticle/KFParticleSIMD.cxx
    code/KFParticle/KFParticle/KFParticlePVReconstructor.cxx
    code/KFParticle/KFParticle/KFParticleFinder.cxx
    code/KFParticle/KFParticle/KFParticleTopoReconstructor.cxx
   )
set(PerformanceCode
    code/Performance/CbmL1MCTrack.cxx
    code/Performance/L1AlgoInputMCData.cxx
    code/Performance/Performance.cxx
    code/Performance/KFParticlePerformance/KFPartEfficiencies.cxx
    code/Performance/KFParticlePerformance/KFMCParticle.cxx
    code/Performance/KFParticlePerformance/KFMCVertex.cxx
    code/Performance/KFParticlePerformance/KFParticlePerformanceBase.cxx
    code/Performance/KFParticlePerformance/KFTopoPerformance.cxx
   )

set(VALGRIND_ENABLED FALSE CACHE BOOL "Enable valgrind client calls")
if(NOT VALGRIND_ENABLED)
   add_definitions(-DNVALGRIND)
endif(NOT VALGRIND_ENABLED)

set(TESTS_ENABLED FALSE CACHE BOOL "Enable build of unit tests")
if(TESTS_ENABLED)
   add_subdirectory(tests)
   enable_testing()
endif(TESTS_ENABLED)

set(DEBUG_MESSAGES "0" CACHE STRING "Enable debug messages (1: Seeding, 2: Fitting, 4: Kalman Filter, 8: TrackletSelector, 16: Tracker::WriteOutput)")
if(DEBUG_MESSAGES)
   add_definitions(-DDEBUG_MESSAGES=${DEBUG_MESSAGES})
endif(DEBUG_MESSAGES)

add_definitions(-DENABLE_VECTORIZATION)

set(ENABLE_ARRAY_BOUNDS_CHECKING FALSE CACHE BOOL "Enable Array bounds checking. Slow!")
if(ENABLE_ARRAY_BOUNDS_CHECKING)
   add_definitions(-DENABLE_ARRAY_BOUNDS_CHECKING)
endif(ENABLE_ARRAY_BOUNDS_CHECKING)

set(USE_SSE TRUE CACHE BOOL "When compiling on x86 use SSE Vector class instead of Simple implementation")
#if(USE_SSE)
#   add_definitions(-DVC_IMPL=SSE)
#else(USE_SSE)
#   add_definitions(-DVC_IMPL=Scalar)
#endif(USE_SSE)
#set(CommonCode ${CommonCode} code/AliHLTTPCCASliceDataVector.cxx)

set(DUMP_LINKS FALSE CACHE BOOL "dump links into Links directory after NeighboursFinder")
if(DUMP_LINKS)
   add_definitions(-DDUMP_LINKS)
endif(DUMP_LINKS)
set(DUMP_TRACKLETCONSTRUCTION FALSE CACHE BOOL "dump Tracklet Construction states into TrackletConstruction directory")
if(DUMP_TRACKLETCONSTRUCTION)
   add_definitions(-DDUMP_TRACKLETCONSTRUCTION)
endif(DUMP_TRACKLETCONSTRUCTION)
set(DUMP_TC_OUTPUT FALSE CACHE BOOL "dump Tracklet Construction output to stdout")
if(DUMP_TC_OUTPUT)
   add_definitions(-DDUMP_TC_OUTPUT)
endif(DUMP_TC_OUTPUT)

#########################################################################################

#add_executable(convertToBinary convertToBinary.cpp code/AliHLTTPCCAMCTrack.cxx)
#target_link_libraries(convertToBinary ${ROOT_LIBS} ${VC_LIBRARIES})

#add_executable(benchmark benchmark.cpp)

set(CA_SRCS            ${CommonCode} )
set(CA_SRCS ${CA_SRCS} ${AlgoCode} )
set(CA_SRCS ${CA_SRCS} ${KFParticleCode} )
set(CA_SRCS ${CA_SRCS} ${PerformanceCode})

#add_executable(CA CA.cpp ${CA_SRCS})
#if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
#   add_target_property(CA COMPILE_FLAGS "-DR__UNIX")
#endif(CMAKE_SYSTEM_NAME STREQUAL "Linux")

  add_executable(CA CA.cpp ${CA_SRCS})
  add_executable(CA-draw CA.cpp ${CA_SRCS})
  add_executable(convert convert.cpp ${CA_SRCS})

if(TBB_REALY_FOUND)
  message("-- TBB will be used for CA_parallel")

#  set(CMAKE_CXX_FLAGS_DEBUG        "${CMAKE_CXX_FLAGS_DEBUG} -DTBB_DO_ASSERT=1")
#  set(CMAKE_C_FLAGS_DEBUG          "${CMAKE_C_FLAGS_DEBUG} -DTBB_DO_ASSERT=1")

  add_executable(CA_parallel CA_parallel.cpp ${CA_SRCS})  #	TODO parallel
  target_link_libraries(CA_parallel ${TBB_RELEASE_LIBRARIES} ${VC_LIBRARIES})

  add_executable(CA_parallel_OMP CA_parallel_OpenMP.cpp ${CA_SRCS})
endif(TBB_REALY_FOUND)

if(ROOT_FOUND)    

  include_directories(${ROOT_INCLUDE_DIR})
  target_link_libraries(CA ${ROOT_LIBS} ${VC_LIBRARIES})
  target_link_libraries(CA-draw ${ROOT_LIBS} ${VC_LIBRARIES})
  target_link_libraries(CA_parallel ${ROOT_LIBS} ${VC_LIBRARIES})
  target_link_libraries(CA_parallel_OMP ${ROOT_LIBS} ${VC_LIBRARIES})
  target_link_libraries(convert ${ROOT_LIBS} ${VC_LIBRARIES})

  add_definitions( -DROOT_IS_USED )
  add_target_property(CA-draw COMPILE_FLAGS "-DDRAW")

endif(ROOT_FOUND)

# install dir is not interesting for now
mark_as_advanced(CMAKE_INSTALL_PREFIX)