[u/mrichter/AliRoot.git] / HLT / configure.ac

dnl -*- mode: autoconf -*- 
dnl
dnl $Id$
dnl template for the configuration script for the Alice HLT 
dnl framework and components
dnl 
dnl ------------------------------------------------------------------

dnl Take either the AliRoot tag as version id or the current revision
AC_INIT([Alice High Level Trigger] , 
	m4_esyscmd([url=`svn info 2> /dev/null | grep "URL:" | cut -d: -f3 | sed -e 's|[/]*HLT[/]*$||' | sed -e 's|^[/]*||g' | cut -d '/' -f 4`; \
	            revision=`svn info 2> /dev/null | grep "Revision:" | cut -d ' ' -f 2 | cut -d '/' -f 4`; \
	            if test "x$url" != "x"; then echo -n $url; \
		    elif test "x$revision" != "x"; then echo -n $revision ; \
		    elif test -e .revision && test x`cat .revision` != x; then \
		       cat .revision; \
		    else \
		       echo -n invalid-version; \
		    fi]),
	[Matthias.Richter@ift.uib.no], 
	[alice-hlt])

dnl ------------------------------------------------------------------
dnl the package from CVS contains the old Makefiles as well. In order to
dnl prevent them from becoming overwritten, we require a separate build
dnl directory
if test "`dirname $0`" = "." ; then
   AC_ERROR([please run the script from a separate build directory])
fi

dnl ------------------------------------------------------------------
AC_CANONICAL_SYSTEM
AC_PREFIX_DEFAULT(${PWD})
AC_CONFIG_SRCDIR(BASE/AliHLTComponent.cxx)
AM_INIT_AUTOMAKE
AC_PROG_CC
AC_PROG_CXX
AC_PROG_LIBTOOL

AC_DEBUG
AC_OPTIMIZATION
AM_CONDITIONAL(STANDALONE_SAMPLELIB, test 0 )

dnl ------------------------------------------------------------------
dnl A warning posted into the auto-generated files
dnl Does NOT concern this file ;-)
AUTOGENERATED_WARNING="!!!!!!!    DO NOT EDIT THIS FILE !!!!!!"
AC_SUBST([AUTOGENERATED_WARNING])

dnl ------------------------------------------------------------------
dnl
dnl Check for ROOT
dnl
ROOT_PATH(, [have_root=1], [AC_ERROR([Stop! The HLT package needs ROOT.])])
AM_CONDITIONAL(HAVE_ROOT, test "x$have_root" = "x1" )
AC_SUBST([ROOTSYS])
ROOTBINDIR=`dirname $ROOTEXEC`
AC_SUBST([ROOTBINDIR])

dnl test for additional required root libraries and headers
LIBS='-ldl'
if test "x$have_root" = "x1"; then
  AC_LANG_PUSH(C++)
  save_CPPFLAGS=$CPPFLAGS
  save_LDFLAGS=$LDFLAGS
  save_LIBS=$LIBS
  CPPFLAGS=`echo $save_CPPFLAGS; for i in ${ROOTINCDIR}; do echo -n "-I$i " ; done`
  
  # we check for the libSTEER library which is linked to
  # - the ROOT libs libGeom libMinuit libVMC libEG
  # - the AliRoot libESD libRAWData (libRAWDatarec from v4-04-Rev-07)
  # - ROOT libCint needs also libdl
  # - from Nov 1 2006 TTreeFormula is needed by AliTagAnalysis and requires
  #   libTreePlayer.so
  # - from Jan 07 libESD also depends on libXMLIO
  # - libSTEER depends on libProofPlayer since Oct 2007 (after v4-07-Release)
  # - libCDB.so depends on libXMLParser since Mar 11 2009 r 31411
  ROOT_CHECKLIBS='Geom Minuit EG VMC TreePlayer XMLIO Thread Proof ProofPlayer XMLParser'
  for CHECKLIB in $ROOT_CHECKLIBS ; do
    LDFLAGS="$save_LDFLAGS -L${ROOTLIBDIR}"
    LIBS="$save_LIBS $ROOTLIBS $ADD_ROOTLIBS"
    AC_CHECK_LIB([$CHECKLIB],[_init], [ADD_ROOTLIBS="$ADD_ROOTLIBS -l$CHECKLIB"])
  done

  # TBuffer.h has been made pure virtual in root v5-15-02 and one
  # has to derive from TBufferFile.h (needed for BASE/AliHLTMessage.h)
  AC_CHECK_HEADER([TBufferFile.h], [], [HAVE_NOT_TBUFFERFILE])

  # TView.h has been made pure virtual right after root v5-15-02 and one
  # has to derive from TView3D.h (needed for TPCLib/OnlineDisplay/AliHLTTPCDisplay3D)
  AC_CHECK_HEADER([TView3D.h], [], [HAVE_NOT_TVIEW3D])

  CPPFLAGS=$save_CPPFLAGS
  LDFLAGS=$save_LDFLAGS
  LIBS=$save_LIBS
  AC_LANG_POP(C++)
fi

dnl ------------------------------------------------------------------
# TODO: make this configurable through arguments
#Define whether you want to run with ALIROOT or only ROOT
AH_TEMPLATE([ALIHLT_USEPACKAGE],[running environment])
ALIHLT_USEPACKAGE=ALIROOT
#ALIHLT_USEPACKAGE=ROOT
#ALIHLT_USEPACKAGE=STANDALONE
AC_DEFINE(use_aliroot)
AC_DEFINE(use_root)
CPPFLAGS="$CPPFLAGS ${ROOTCFLAGS}"
save_CPPFLAGS=$CPPFLAGS
save_LDFLAGS=$LDFLAGS
save_LIBS=$LIBS

dnl ------------------------------------------------------------------
dnl check for AliRoot features
AC_LANG_PUSH(C++)
have_aliroot=no
AC_ARG_WITH(aliroot,[  --with-aliroot	top of the AliRoot installation],
		    [test -d $with_aliroot && ALICE_ROOT=$with_aliroot],
		    [])

if test "x$ALICE_ROOT" != "x" && test -d $ALICE_ROOT ; then
  dnl ------------------------------------------------------------------
  dnl Try to estimate the system architecture
  case $host_os:$host_cpu in
  linux*:x86_64*)	alice_target='linuxx8664gcc'		;;
  linux*)		alice_target='linux'			;;
  *)			alice_target='unknown'			;;
  esac
  if test "x$alice_target" = "xunknown" ; then
    if test -z $ALICE_TARGET ; then
    AC_MSG_ERROR([Can not estimate system architecture.
    To avoid the problem, set the ALICE_TARGET variable appropriately.
    Please send the following information to Matthias.Richter@ift.uib.no:
	${PACKAGE}: no AliRoot target definition for os=$host_os and cpu=$host_cpu ])
    else
    AC_MSG_NOTICE([Unknown system architecture.
    Please send the following information to Matthias.Richter@ift.uib.no:
	${PACKAGE}: no AliRoot target definition for os=$host_os and cpu=$host_cpu ])  
    fi
  else
    if test "x$ALICE_TARGET" != "x" && test "x$ALICE_TARGET" != "x$alice_target" ; then
    AC_MSG_WARN([The ALICE_TARGET variable does not match your current system
    overriding $ALICE_TARGET by $alice_target])
    fi
    ALICE_TARGET=$alice_target
  fi
  ALIROOTBINDIR=${ALICE_ROOT}/bin/tgt_${ALICE_TARGET}
  ALIROOTLIBDIR=${ALICE_ROOT}/lib/tgt_${ALICE_TARGET}
  ALIROOTINCDIR=${ALICE_ROOT}/include
  test -d ${ALIROOTBINDIR} || AC_MSG_WARN([can not find AliRoot binary directory $ALIROOTBINDIR])
  test -d ${ALIROOTLIBDIR} || AC_MSG_WARN([can not find AliRoot library directory $ALIROOTLIBDIR])
  test -d ${ALIROOTINCDIR} || AC_MSG_WARN([can not find AliRoot include directory $ALIROOTINCDIR])
fi

AC_MSG_CHECKING([for AliRoot])
if test "x$ALICE_ROOT" != "x" \
   && test -d ${ALIROOTBINDIR} \
   && test -d ${ALIROOTLIBDIR} \
   && test -d ${ALIROOTINCDIR}; then
  have_aliroot=$ALICE_ROOT
else
  ALIROOTBINDIR=
  ALIROOTLIBDIR=
  ALIROOTINCDIR=
fi
AC_MSG_RESULT([$have_aliroot])

if test ! "x$have_aliroot" = "xno" ; then
  ALIROOT_CPPFLAGS="-I${ALIROOTINCDIR} -I${ALICE_ROOT}/RAW"
  ALIROOT_LDFLAGS="-L${ALIROOTLIBDIR}"
  ALIROOT_LIBS="$ADD_ROOTLIBS"
  save_CPPFLAGS=$CPPFLAGS
  save_LDFLAGS=$LDFLAGS
  save_LIBS=$LIBS
  CPPFLAGS="$save_CPPFLAGS $ALIROOT_CPPFLAGS"
  LDFLAGS="$save_LDFLAGS -L${ROOTLIBDIR} $ALIROOT_LDFLAGS"
  
  # check for certain AliRoot libraries/files/features
  # libSTEERBase present since Aug 7 2007
  # ###########################################
  # temporary workaround for circular dependency libSTEERbase libSTEER 	 
  # https://savannah.cern.ch/bugs/index.php?49914
  # disable the sequence of checks and load libraries in parallel
  ALIROOT_LIBS="$ALIROOT_LIBS -lAOD -lCDB -lRAWDatabase -lRAWDatarec -lESD -lSTEER"
  LIBS="$save_LIBS $ROOTLIBS $ALIROOT_LIBS"
  CHECKLIB=STEERBase
  AC_CHECK_LIB([$CHECKLIB],[_init],[ALIROOT_LIBS="$ALIROOT_LIBS -l$CHECKLIB"])

  LIBS="$save_LIBS $ROOTLIBS $ALIROOT_LIBS"
  CHECKLIB=AOD
  AC_CHECK_LIB([$CHECKLIB],[_init],[ALIROOT_LIBS="$ALIROOT_LIBS -l$CHECKLIB"])

  # CBD library is present since AliRoot version v4-05-00 (02.06.2006)
  LIBS="$save_LIBS $ROOTLIBS $ALIROOT_LIBS"
  CHECKLIB=CDB
  AC_CHECK_LIB([$CHECKLIB],[_init],[ALIROOT_LIBS="$ALIROOT_LIBS -l$CHECKLIB"])

  # splitted RAW libraries since AliRoot version v4-04-Rev-07 (09.08.2006)
  have_alirawdata=no
  LIBS="$save_LIBS $ROOTLIBS $ALIROOT_LIBS"
  CHECKLIB=RAWDatabase
  AC_CHECK_LIB([$CHECKLIB],[_init],
	[ALIROOT_LIBS="$ALIROOT_LIBS -l$CHECKLIB"
	 LIBS="$save_LIBS $ROOTLIBS $ALIROOT_LIBS -lESD -lSTEER"
	 CHECKLIB=RAWDatarec
	 AC_CHECK_LIB([$CHECKLIB],[_init],
               [ALIROOT_LIBS="$ALIROOT_LIBS -l$CHECKLIB"
	        have_alirawdata=$CHECKLIB])],
	[# second pass with -RAWData
	 CHECKLIB="-lRAWData"
	 LIBS="$save_LIBS $ROOTLIBS $ALIROOT_LIBS $CHECKLIB -lSTEER"
	 AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <AliRawReaderMemory.h>
 				       #include <AliRawReaderFile.h>
 				       #include <AliRawReaderDate.h>
 				       #include <AliRawReaderRoot.h>], 
                                     [AliRawReaderMemory mreader;
 				       AliRawReaderFile freader;
 				       AliRawReaderDate dreader(NULL,0);
 				       AliRawReaderRoot rreader(NULL,0);])],
                                     [ALIROOT_LIBS="$ALIROOT_LIBS $CHECKLIB"
 				       have_alirawdata=$CHECKLIB], 
 				      [have_alirawdata=no])
	]) dnl AC_CHECK_LIB RAWDatabase
  AC_MSG_CHECKING([for AliRawReader classes in RAWData libraries])
  AC_MSG_RESULT([$have_alirawdata])

  LIBS="$save_LIBS $ROOTLIBS $ALIROOT_LIBS -lSTEER"
  CHECKLIB=ESD
  AC_CHECK_LIB([$CHECKLIB],[_init],[ALIROOT_LIBS="$ALIROOT_LIBS -l$CHECKLIB"])

  LIBS="$save_LIBS $ROOTLIBS $ALIROOT_LIBS"
  CHECKLIB=STEER
  AC_CHECK_LIB([$CHECKLIB],[_init],[ALIROOT_LIBS="$ALIROOT_LIBS -l$CHECKLIB"],[have_aliroot=no])

  dnl
  dnl check whether AliLog supports notification callback
  dnl
  LIBS="$save_LIBS $ROOTLIBS $ALIROOT_LIBS"
  have_alilog_notification=no
  if test ! "x$have_aliroot" = "xno" ; then
  AC_MSG_CHECKING([whether AliLog supports notification callback])
  AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <AliLog.h>], 
		                  [AliLog::AliLogNotification fct])],
                                  [have_alilog_notification=yes], 
				  [AC_DEFINE(NO_ALILOG_NOTIFICATION)])
  AC_MSG_RESULT([$have_alilog_notification])
  fi

  if test "x$have_aliroot" = "xno" ; then
    # 2007-08-18 dont reset ALIROOT_CPPFLAGS in order to allow compilation
    # but library dependencies might not be resolved completely
    #ALIROOT_CPPFLAGS=
    AC_MSG_WARN([some of the AliRoot library dependencies are not resolved.
    This can happen from time to time due to development in AliRoot. You can
    force compilation of detector libs by --enable-<detector>, but be aware
    of unresolved references at runtime.])
    AC_MSG_WARN([       ------------------------------------------ ])
    AC_MSG_WARN([       Report this to $PACKAGE_BUGREPORT ])
    AC_MSG_WARN([       please include config.log                  ])
    AC_MSG_WARN([       ------------------------------------------ ])
    ALIROOT_LDFLAGS=
    ALIROOT_LIBS=
  fi

  dnl
  dnl ESD supports non-std content
  dnl
  have_esd_nonstd=no
  AC_RUN_IFELSE([AC_LANG_PROGRAM([#include <AliESDEvent.h>
				   #include <AliExternalTrackParam.h>
				   #include <TTree.h>
				   #include <TClonesArray.h>],
				  [AliESDEvent esd;
				   esd.CreateStdContent();
				   TTree* tree=new TTree("esdTree", "Tree with HLT ESD objects");
				   TClonesArray* a=new TClonesArray("AliExternalTrackParam");
				   a->SetName("SomeObject");
				   esd.AddObject(a);
				   esd.WriteToTree(tree);
				   if (!tree->FindBranch("SomeObject")) return 1;
				   return 0;])],
                 [have_esd_nonstd=yes], 
  		 [AC_DEFINE(HAVE_NOT_ESD_NONSTD)])
  AC_MSG_CHECKING(whether ESD supports non standard content)
  AC_MSG_RESULT([$have_esd_nonstd])

  dnl
  dnl ESD copy function added May 9 2008 rev 25667
  dnl
  if test "x$have_esd_nonstd" != "xyes"; then
  have_esd_copy=no
  AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <AliESDEvent.h>],
				  [AliESDEvent esd1;
				   AliESDEvent esd2;
				   esd2=esd1;])],
                 [have_esd_copy=yes], 
  		 [AC_DEFINE(HAVE_NOT_ESD_COPY)])
  AC_MSG_CHECKING(for ESD assignment operator)
  AC_MSG_RESULT([$have_esd_copy])
  fi

  dnl
  dnl AliRawReaderMemory support for multiple buffers added
  dnl revision 26829 Jun 2008
  dnl
  CPPFLAGS="$save_CPPFLAGS $ALIROOT_CPPFLAGS -I${ALICE_ROOT}/RAW"
  have_rawreadermemory_multbuffers=no
  AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <AliRawReaderMemory.h>],
				  [AliRawReaderMemory rr;
				   rr.AddBuffer(NULL, 0, 0);])],
                 [have_rawreadermemory_multbuffers=yes], 
  		 [AC_DEFINE(HAVE_NOT_ALIRAWREADERMEMORY_ADDBUFFER)])
  AC_MSG_CHECKING(AliRawReaderMemory support for multiple buffers)
  AC_MSG_RESULT([$have_rawreadermemory_multbuffers])

  dnl
  dnl required header files and libraries for modules
  dnl

  dnl
  dnl Check for the interface of AliExternalTrackParam which has been changed
  dnl in revision 1.17 of AliExternalTrackParam.h (AliRoot version v4-05-04
  dnl or higher)
  externaltrackparam_version=1
  AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <AliExternalTrackParam.h>], 
                                  [AliExternalTrackParam trackparam;
				   Double_t param[[5]]; Double_t covar[[15]];
 				   trackparam.Set(0., 0., param, covar);])],
                                  [externaltrackparam_version=2],
 				  [AC_DEFINE(EXTERNALTRACKPARAM_V1)])
  AC_MSG_CHECKING(for version of AliExternalTrackParam)
  AC_MSG_RESULT($externaltrackparam_version)

  dnl The AliShuttleInterface was changed in rev 29388. Some return types
  dnl had been const, now changed according to gcc 4.3 warnings 
  AC_MSG_CHECKING(for version of AliShuttleInterface.h)
    CPPFLAGS="$save_CPPFLAGS $ALIROOT_CPPFLAGS -I${ALICE_ROOT}/"
    LDFLAGS="$save_LDFLAGS -L${ROOTLIBDIR} $ALIROOT_LDFLAGS"
    LIBS="$save_LIBS $ROOTLIBS $ALIROOT_LIBS $ALITPC_LIBS"
    AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <AliShuttleInterface.h>],
                                    [class dummy : public AliShuttleInterface {
				     public:
				       const UInt_t GetStartTimeDCSQuery() {;}
                                     };])],
                                    [AC_DEFINE(SHUTTLE_PRE_REV29388_INTERFACE)
				     alishuttleinterface_version=pre.rev.29388],
  				    [alishuttleinterface_version=up.to.date])
  AC_MSG_RESULT([$alishuttleinterface_version])

  CPPFLAGS=$save_CPPFLAGS
  LDFLAGS=$save_LDFLAGS
  LIBS=$save_LIBS
fi # if test ! "x$have_aliroot" = "xno"

AC_LANG_POP(C++)
AC_SUBST([ALICE_ROOT])
AC_SUBST([ALIROOT_CPPFLAGS])
AC_SUBST([ALIROOT_LDFLAGS])
AC_SUBST([ALIROOTBINDIR])
AC_SUBST([ALIROOTLIBDIR])
AC_SUBST([ALIROOT_LIBS])
AM_CONDITIONAL(USE_TPC_MAPPING, test x$have_tpc_mapping = xyes)

HLTBASE_CPPFLAGS='-I${top_srcdir}/BASE'
HLTBASE_LDFLAGS=
AC_SUBST([HLTBASE_CPPFLAGS])
AC_SUBST([HLTBASE_LDFLAGS])

dnl ------------------------------------------------------------------
dnl check for the HLT PubSub Framework
dnl namely for the existence of the HOMER library
dnl from Sep 2007, the HOMER lib has been incorporated into the alice-hlt
dnl package. It os though possible to choose an external. library
dnl In order to make the origni of the HOMER lib clear, the one in AliRoot
dnl got the name libAliHLTHOMER
AC_MSG_CHECKING([for HLT PubSub Framework])
AC_ARG_WITH(pubsub, [installation path of the HLT PubSub framework],
		    [],
		    [ test -n $ALIHLT_DC_DIR && with_pubsub=$ALIHLT_DC_DIR ])
if test -z $with_pubsub || ! test -d $with_pubsub ; then
  with_pubsub=no
fi
AC_MSG_RESULT([$with_pubsub])
HOMER_VERSION=2
HOMER_LIBS=

AH_TEMPLATE([HAVE_HOMERREADER],[the HLT PubSub Homer Reader interface])
if test "x$with_pubsub" != "xno" ; then
  save_CPPFLAGS=$CPPFLAGS
  save_LDFLAGS=$LDFLAGS
  save_LIBS=$LIBS
  # currently the different versions of the HLT PubSub framework have a different
  # directory layout
  if test -d ${with_pubsub}/include/HOMER ; then
    # the 'early' location of the include files with separated HOMER sub dirs
    HOMER_INCDIRS="${with_pubsub}/include/HOMER ${with_pubsub}/include/HOMER/reader"
  elif test -d ${with_pubsub}/include/Util/HOMER ; then
    # location for HLT Framework versions after Sep 2006
    HOMER_INCDIRS="${with_pubsub}/include/Util/HOMER"
  elif test -d ${with_pubsub}/src/Util/HOMER/include ; then
    # fall back if include files were not installed (versions after Sep 06)
    HOMER_INCDIRS="${with_pubsub}/src/Util/HOMER/include"
  else
    # fall back if include files were not installed (versions before Sep 06)
    HOMER_INCDIRS="${with_pubsub}/src/Util/HOMER/reader/include ${with_pubsub}/src/Util/HOMER/data/include"
  fi
  HOMER_CPPFLAGS=`for i in ${HOMER_INCDIRS}; do echo -n "-I$i " ; done`

  AC_ARG_ENABLE(pubsub-debug,
    [AC_HELP_STRING([--disable-pubsub-debug],
        [force the production version of the PubSub framework])],
    [],[enable_pubsub_debug=yes])
  homer_type="none"
  HOMER_TARGET="`uname -s`-`uname -m`"
  AC_MSG_CHECKING([for HLT PubSub Framework release type])
  if test -d "${with_pubsub}/lib/${HOMER_TARGET}-release" ; then
    homer_type="production"
    HOMER_TARGET="${HOMER_TARGET}-release"
  elif test "x$enable_pubsub_debug" = "xyes" && test -d "${with_pubsub}/lib/${HOMER_TARGET}-debug" ; then
    homer_type="debug"
    HOMER_TARGET="${HOMER_TARGET}-debug"
  fi
  AC_MSG_RESULT([${homer_type}])
  HOMERREADER_HEADER=HOMERReader.h
  HOMER_BINDIR="${with_pubsub}/bin/${HOMER_TARGET}"
  HOMER_LIBDIR="${with_pubsub}/lib/${HOMER_TARGET}"
  HOMER_LDFLAGS="-L${HOMER_LIBDIR}"
  CPPFLAGS="$save_CPPFLAGS $HOMER_CPPFLAGS"
  LDFLAGS="$save_LDFLAGS $HOMER_LDFLAGS"
  LIBS="$save_LIBS "
  with_homer=no
  AC_LANG_PUSH(C++)
  AC_CHECK_HEADER([$HOMERREADER_HEADER],
    [ AC_CHECK_LIB([HOMER],[_init],
      [with_homer=yes
       HOMER_LIBS="-lHOMER"],
      [ AC_CHECK_LIB([HOMERReader],[_init],
                     [with_homer=yes
		      HOMER_LIBS="-lHOMERReader"])])
      LIBS="$LIBS $HOMER_LIBS"
      AC_MSG_CHECKING([version of HOMER library])
      dnl The Homer library has no versioning, so we do our own
      dnl version           description
      dnl ----------------------------------------------------------------------
      dnl   1          inintial version
      dnl   2          GetBlockStatusFlags added to the interface
      AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <HOMERReader.h>],
                                      [HOMERReader reader("dummy", 0);
 				       reader.GetBlockStatusFlags(0);])],
                                      [],
 				      [HOMER_VERSION=1])
      AC_MSG_RESULT([$HOMER_VERSION])
  ],
  [HOMERREADER_HEADER=]) #AC_CHECK_HEADER([$HOMERREADER_HEADER])
  AC_LANG_POP(C++)
  HOMER_INBUILT_LIB=
else
dnl no pubsub version defined, check if the HOMER lib is available in AliRoot
  topdir=`dirname $0`
  HOMER_CPPFLAGS="-I`(cd $topdir; pwd)`/BASE/HOMER"
  HOMERREADER_HEADER=AliHLTHOMERReader.h
  HOMER_INBUILT_LIB=`pwd`/BASE/HOMER/libAliHLTHOMER.la
  HOMER_BINDIR=
  HOMER_LIBDIR=
  HOMER_LDFLAGS=
fi

  if test "x$with_homer" = "xno" ; then
    HOMER_CPPFLAGS=
    HOMER_LDFLAGS=
    HOMER_LIBS=
  else
    HOMER_CPPFLAGS="$HOMER_CPPFLAGS -DHOMER_VERSION=$HOMER_VERSION"
    AC_DEFINE(HAVE_HOMERREADER)
  fi
  CPPFLAGS="$save_CPPFLAGS"
  LDFLAGS="$save_LDFLAGS"
  LIBS="$save_LIBS"  

AC_SUBST([HOMERREADER_HEADER])
AC_SUBST([HOMER_INBUILT_LIB])
AC_SUBST([HOMER_CPPFLAGS])
AC_SUBST([HOMER_LDFLAGS])
AC_SUBST([HOMER_LIBDIR])
AC_SUBST([HOMER_BINDIR])
AC_SUBST([HOMER_LIBS])

dnl ------------------------------------------------------------------
AC_ARG_ENABLE(all,
  [AC_HELP_STRING([--disable-all],
      [disable all detector modules, individual modules can be switched on by --enable-det])],
  [disable_all=yes],[])

dnl ------------------------------------------------------------------
AC_MSG_CHECKING([whether to impose strict coding conventions])
AC_ARG_ENABLE(strict,
  [AC_HELP_STRING([--disable-strict],
      [disable coding convention checks ])],
  [],[enable_strict=yes])
if test "x$enable_strict" = "xyes" ; then
   CPPFLAGS="$CPPFLAGS -W -Weffc++ -Wall -Wshadow"
fi
AC_MSG_RESULT([$enable_strict])

dnl ------------------------------------------------------------------
AC_MSG_CHECKING([whether to enable component statistics])
AC_ARG_ENABLE(component-stat,
  [AC_HELP_STRING([--enable-component-stat],
      [enable component statistics ])],
  [],[enable_component_stat=no])
if test "x$enable_component_stat" = "xyes" ; then
   AC_DEFINE(HLT_COMPONENT_STATISTICS)
fi
AC_MSG_RESULT([$enable_component_stat])

dnl ------------------------------------------------------------------
dnl ----  module checks
dnl ------------------------------------------------------------------
save_CPPFLAGS=$CPPFLAGS
save_LDFLAGS=$LDFLAGS
save_LIBS=$LIBS

dnl ------------------------------------------------------------------
AC_MSG_CHECKING([whether to compile sample library])
AH_TEMPLATE([HLT_SAMPLE],[hlt sample library])
AC_ARG_ENABLE(sample,
  [AC_HELP_STRING([--disable-sample],
      [compile the sample library ])],
  [],
  [if test "x$have_aliroot" = "xno" ; then
     enable_sample="no...requires.AliRoot"
   else
     enable_sample=yes
   fi
  ])

if test "x$enable_sample" = "xyes" ; then 
  AC_DEFINE(HLT_SAMPLE)
fi
AM_CONDITIONAL(EN_HLT_SAMPLE, test x$enable_sample = xyes)
AC_MSG_RESULT([$enable_sample])

dnl ------------------------------------------------------------------
AC_MSG_CHECKING([whether to compile util library])
AH_TEMPLATE([HLT_UTIL],[HLT utility library])
AC_ARG_ENABLE(util,
  [AC_HELP_STRING([--disable-util],
      [compile the util library ])],
  [],
  [if test "x$have_aliroot" = "xno" ; then
     enable_util="no...requires.AliRoot"
   else
     enable_util=yes
   fi
  ])

if test "x$enable_util" = "xyes" ; then 
  AC_DEFINE(HLT_UTIL)
fi
AM_CONDITIONAL(EN_HLT_UTIL, test x$enable_util = xyes)
AC_MSG_RESULT([$enable_util])

dnl ------------------------------------------------------------------
AH_TEMPLATE([HLT_TPC],[hlt tpc library])

ALITPC_LIBS=
CHECK_HLTMODULE([tpc],
		[AliTPCRawStream.h], 
		[$ALIROOT_CPPFLAGS -I$ALICE_ROOT/TPC],
		[Gui ANALYSIS STAT], [-L$ROOTLIBDIR $ALIROOT_LDFLAGS], [$ROOTLIBS $ADD_ROOTLIBS $ALIROOT_LIBS],
		[TPCbase TPCrec TPCcalib], [-L$ROOTLIBDIR $ALIROOT_LDFLAGS], 
		[$ROOTLIBS $ADD_ROOTLIBS $ALIROOT_LIBS])

if test "x$enable_module" = "xmissheader"; then
  enable_module="no...missing.headers"
  enable_tpc=$enable_module
elif test "x$enable_module" = "xforce"; then
  enable_tpc="yes"
else
  enable_tpc=$enable_module
fi

if test "x$enable_tpc" = "xyes" ; then 
  AC_LANG_PUSH(C++)
  AC_DEFINE(HLT_TPC)
  ALITPC_LIBS=$ALIHLTMODULE_LIBS
  dnl
  dnl Check for functionality in the TPC reconstruction required for online
  dnl processing
  dnl 
  have_tpc_hltoffline_rec=no
  AC_MSG_CHECKING(for on-line features of TPC offline reconstruction)
    CPPFLAGS="$save_CPPFLAGS $ALIROOT_CPPFLAGS -I${ALICE_ROOT}/TPC"
    LDFLAGS="$save_LDFLAGS -L${ROOTLIBDIR} $ALIROOT_LDFLAGS"
    LIBS="$save_LIBS $ROOTLIBS $ALIROOT_LIBS $ALITPC_LIBS"
    AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <AliTPCtrackerMI.h>
  				       #include <AliTPCclustererMI.h>	
  				       #include <TObjArray.h>], 
                                    [AliTPCtrackerMI tracker;
  				       TObjArray* array=NULL;
  				       tracker.LoadClusters(array);
  				       AliTPCclustererMI cl(NULL, NULL);
  				       cl.GetOutputClonesArray();])],
                                    [have_tpc_hltoffline_rec=yes], 
  				      [AC_DEFINE(HAVE_NOT_TPCOFFLINE_REC)])
    LIBS=$save_LIBS
  AC_MSG_RESULT([$have_tpc_hltoffline_rec])

  AC_CHECK_HEADER([AliTPCCalibPulser.h], [], [AC_DEFINE(HAVE_NOT_ALITPCCALIBPULSER)])
  AC_CHECK_HEADER([AliTPCCalibPedestal.h], [], [AC_DEFINE(HAVE_NOT_ALITPCCALIBPEDESTAL)])

  have_tpc_mapping=no
  if test ! "x$have_aliroot" = "xno" ; then
    # the TPCLib/AliHLTTPCRawReader needs the actual Pad layout of the TPC 
    # which is stored in the TPC/mapping/Patchx.data files from
    # AliRoot version v4-04-Release (May 2006)
    AH_TEMPLATE([HAVE_TPC_MAPPING],[TPC pad mapping available])
    TPC_PAD_MAPPING_PATH=$have_aliroot/TPC/mapping
    AC_CHECK_FILE( [$TPC_PAD_MAPPING_PATH/Patch0.data], 
		   [have_tpc_mapping=yes
		    AC_SUBST(TPC_PAD_MAPPING_PATH)
		    AC_DEFINE(HAVE_TPC_MAPPING)],
		   [])
    
  fi
  AC_MSG_CHECKING([for TPC mapping layout])
  AC_MSG_RESULT([$have_tpc_mapping])
  AC_LANG_POP(C++)

else
  enable_module=$enable_tpc
fi
AM_CONDITIONAL(EN_HLT_TPC, test x$enable_tpc = xyes)
AC_MSG_CHECKING([whether to compile TPC library])
AC_MSG_RESULT([$enable_module])
AC_SUBST([ALITPC_LIBS])

dnl ------------------------------------------------------------------
AH_TEMPLATE([HLT_RCU],[hlt rcu library])

CHECK_HLTMODULE([rcu],
		[AliAltroDecoder.h], 
		[$ALIROOT_CPPFLAGS -I$ALICE_ROOT/RAW],
		[], [-L$ROOTLIBDIR], [$ROOTLIBS $ADD_ROOTLIBS],
		[], [-L$ROOTLIBDIR $ALIROOT_LDFLAGS], 
		[$ROOTLIBS $ADD_ROOTLIBS $ALIROOT_LIBS])

if test "x$enable_module" = "xmissheader"; then
  enable_module="no...missing.headers"
  enable_rcu=$enable_module
elif test "x$enable_module" = "xforce"; then
  enable_rcu="yes"
else
  AC_LANG_PUSH(C++)
  CPPFLAGS="$save_CPPFLAGS $ALIROOT_CPPFLAGS"
  LDFLAGS="$save_LDFLAGS -L${ROOTLIBDIR} $ALIROOT_LDFLAGS"
  LIBS="$save_LIBS $ROOTLIBS $ALIROOT_LIBS"
  AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <AliAltroDecoder.h>], 
                                  [AliAltroDecoder decoder;
				  decoder.CopyBackward(NULL, 0);])],
                                  [enable_rcu=$enable_module], 
				  [enable_module="no...requires.AliRoot>v4-10-Release"
				   enable_rcu="no...requires.AliRoot>v4-10-Release"])
  CPPFLAGS=$save_CPPFLAGS
  LDFLAGS=$save_LDFLAGS
  LIBS=$save_LIBS
  AC_LANG_POP(C++)
fi

if test "x$enable_rcu" = "xyes" ; then 
  AC_DEFINE(HLT_RCU)
else
  enable_module=$enable_rcu
fi
AM_CONDITIONAL(EN_HLT_RCU, test x$enable_rcu = xyes)
AC_MSG_CHECKING([whether to compile RCU library])
AC_MSG_RESULT([$enable_module])
AC_SUBST([ALIRCU_LIBS])

dnl ------------------------------------------------------------------
AH_TEMPLATE([HLT_PHOS],[hlt phos library])
  
ALIPHOS_LIBS=
CHECK_HLTMODULE([phos],
		[], [$ALIROOT_CPPFLAGS],
		[RAWDatasim], [-L$ROOTLIBDIR $ALIROOT_LDFLAGS], [$ROOTLIBS $ADD_ROOTLIBS $ALIROOT_LIBS],
		[PHOSUtils PHOSbase PHOSrec PHOSsim PHOSshuttle], [-L$ROOTLIBDIR $ALIROOT_LDFLAGS], 
		[$ROOTLIBS $ADD_ROOTLIBS $ALIROOT_LIBS])

if test "x$enable_module" = "xmissheader"; then
  enable_module="no...requires.AliRoot>v4-05-07"
  enable_phos=$enable_module
elif test "x$enable_module" = "xforce"; then
  enable_phos="yes"
else
  have_alicalorawstream=no
  if test ! "x$have_aliroot" = "xno" ; then
    AC_LANG_PUSH(C++)
    save_CPPFLAGS="$CPPFLAGS"
    # this can not be used as AliCaloRawStream.h indirectly depends on TString.h
    #AC_CHECK_HEADERS([AliCaloRawStream.h], [have_alicalorawstream=yes])
    CPPFLAGS="$save_CPPFLAGS $ALIROOT_CPPFLAGS -I$ALICE_ROOT/PHOS"
    AC_MSG_CHECKING([for AliCaloRawStream.h usability])
    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <TString.h>
  				        #include <AliCaloRawStream.h>], 
                                       [int i])],
                                       [AC_DEFINE(HAVE_ALICALORAWSTREAM)
				        have_alicalorawstream=yes], 
  				       [])
    AC_MSG_RESULT([$have_aliphosrecoparam])
    AC_MSG_CHECKING([for required EMC functionality in AliPHOSRecoParam.h ])
    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <AliPHOSRecoParam.h>], 
                                       [AliPHOSRecoParam param;
				        param.GetEMCClusteringThreshold()])],
                                       [have_aliphosrecoparam=yes], 
  				       [AC_DEFINE(HAVE_NOT_PHOSRECOPARAMEMC)])
    AC_MSG_RESULT([$have_alicalorawstream])
    AC_LANG_POP(C++)
    CPPFLAGS="$save_CPPFLAGS"
  fi
  if test "x$have_alicalorawstream" != "xyes"; then
    enable_phos="no...requires.AliRoot>v4-05-07"
  else
    enable_phos=$enable_module
  fi
fi

if test "x$enable_phos" = "xyes" ; then 
  AC_DEFINE(HLT_PHOS)
  ALIPHOS_LIBS=$ALIHLTMODULE_LIBS
else
  enable_module=$enable_phos
fi
AM_CONDITIONAL(EN_HLT_PHOS, test x$enable_phos = xyes)
AC_MSG_CHECKING([whether to compile PHOS library])
AC_MSG_RESULT([$enable_module])
AC_SUBST([ALIPHOS_LIBS])

dnl ------------------------------------------------------------------
AH_TEMPLATE([HLT_TRD],[hlt trd library])
  
ALITRD_LIBS=
CHECK_HLTMODULE([trd],
		[], [],
		[MLP XMLParser], [-L$ROOTLIBDIR], [$ROOTLIBS $ADD_ROOTLIBS],
		[TRDbase TRDrec TRDsim], [-L$ROOTLIBDIR $ALIROOT_LDFLAGS], 
		[$ROOTLIBS $ADD_ROOTLIBS $ALIROOT_LIBS])

if test "x$enable_module" = "xmissheader"; then
  enable_module="no...requires.AliRoot>v4-07-Release"
  enable_trd=$enable_module
elif test "x$enable_module" = "xforce"; then
  enable_trd="yes"
else
  enable_trd=$enable_module
  if test "x$enable_trd" = "xyes" ; then
    AC_LANG_PUSH(C++)
    save_CPPFLAGS="$CPPFLAGS"
    CPPFLAGS="$save_CPPFLAGS $ALIROOT_CPPFLAGS -I$ALICE_ROOT/TRD"
    # AliTRDclusterizer::SetRawVersion() requires >v4-07-Release
    # changed to AliTRDrecoParam::SetSeedingOn() due to revision 26327, Mon Jun 2 2008
    # changed to AliTRDReconstructor::SetStreamLevel() due to revision 27797, Tue Aug 5 2008
    # changed to AliTRDReconstructor::SetClusters() according to revision 28069, Mon Aug 18 2008
    # changed to AliTRDCluster according to revision 30461, Thu Dec 18 2008
    AC_MSG_CHECKING([for required functions in AliTRDCluster])
    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <AliTRDcluster.h>], 
                                       [AliTRDcluster c;
				       c.SetDetector(0)])],
                                       [], 
  				       [enable_trd="no...requires.AliRoot>v4-16-Release"])
    AC_MSG_RESULT([$enable_trd])       
    AC_LANG_POP(C++)
    CPPFLAGS="$save_CPPFLAGS"
  fi
fi

if test "x$enable_trd" = "xyes" ; then 
  AC_DEFINE(HLT_TRD)
  ALITRD_LIBS=$ALIHLTMODULE_LIBS
else
  enable_module=$enable_trd
fi
AM_CONDITIONAL(EN_HLT_TRD, test x$enable_trd = xyes)
AC_MSG_CHECKING([whether to compile TRD library])
AC_MSG_RESULT([$enable_module])
AC_SUBST([ALITRD_LIBS])

dnl ------------------------------------------------------------------
AH_TEMPLATE([HLT_FMD],[hlt fmd library])

ALIFMD_LIBS=$ALIHLTMODULE_LIBS
CHECK_HLTMODULE([fmd],
		[], [],
		[], [-L$ROOTLIBDIR], [$ROOTLIBS $ADD_ROOTLIBS],
		[FMDbase FMDrec], [-L$ROOTLIBDIR $ALIROOT_LDFLAGS],
		[$ROOTLIBS $ADD_ROOTLIBS $ALIROOT_LIBS])

if test "x$enable_module" = "xmissheader"; then
  enable_module="no...missing.headers"
  enable_fmd=$enable_module
elif test "x$enable_module" = "xforce"; then
  enable_fmd="yes"
else
  enable_fmd=$enable_module
fi

if test "x$enable_fmd" = "xyes" ; then
  AC_DEFINE(HLT_FMD)
  ALIFMD_LIBS=$ALIHLTMODULE_LIBS
else
  enable_module=$enable_fmd
fi
AM_CONDITIONAL(EN_HLT_FMD, test x$enable_fmd = xyes)
AC_MSG_CHECKING([whether to compile FMD library])
AC_MSG_RESULT([$enable_module])
AC_SUBST([ALIFMD_LIBS])

dnl ------------------------------------------------------------------
AH_TEMPLATE([HLT_MUON],[hlt dimuon library])

ALIMUON_LIBS=
CHECK_HLTMODULE([dimuon],
		[AliMpExMap.h AliMUONTriggerIO.h], 
		[$ALIROOT_CPPFLAGS -I$ALICE_ROOT/MUON -I$ALICE_ROOT/MUON/mapping],
		[Gui RAWDatasim], [-L$ROOTLIBDIR], [$ROOTLIBS $ADD_ROOTLIBS],
		[MUONcore MUONraw MUONbase MUONgeometry MUONmapping MUONcalib MUONsim MUONtrigger MUONevaluation MUONrec], [-L$ROOTLIBDIR $ALIROOT_LDFLAGS], 
		[$ROOTLIBS $ADD_ROOTLIBS $ALIROOT_LIBS])

if test "x$enable_module" = "xmissheader"; then
  enable_module="no...requires.AliRoot>=v4-08-Release"
  enable_muon=$enable_module
elif test "x$enable_module" = "xforce"; then
  enable_muon="yes"
else
  enable_muon=$enable_module
fi

if test "x$enable_muon" = "xyes" ; then 
  AC_DEFINE(HLT_MUON)
  ALIMUON_LIBS=$ALIHLTMODULE_LIBS
  AC_LANG_PUSH(C++)
  save_CPPFLAGS="$CPPFLAGS"

  dnl
  dnl Check for functionality GetRawStream AliMUONDigitMaker.h
  dnl 
  have_muon_digitmaker_getrawstream=no
  AC_MSG_CHECKING(for GetRawStream methods of AliMUONDigitMaker)
    CPPFLAGS="$save_CPPFLAGS $ALIROOT_CPPFLAGS -I${ALICE_ROOT}/MUON"
    LDFLAGS="$save_LDFLAGS -L${ROOTLIBDIR} $ALIROOT_LDFLAGS"
    LIBS="$save_LIBS $ROOTLIBS $ALIROOT_LIBS $ALIMUON_LIBS"
    AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <AliMUONDigitMaker.h>], 
                                    [AliMUONDigitMaker dm;
  				       dm.GetRawStreamTracker();])],
                                    [have_muon_digitmaker_getrawstream=yes], 
  				      [AC_DEFINE(HAVE_NOT_MUON_DIGITMAKER_GETRAWSTREAM)])
    LIBS=$save_LIBS
  AC_MSG_RESULT([$have_muon_digitmaker_getrawstream])
  CPPFLAGS="$save_CPPFLAGS"

  AC_LANG_POP(C++)
else
  enable_module=$enable_muon
fi
AM_CONDITIONAL(EN_HLT_MUON, test x$enable_muon = xyes)
AC_MSG_CHECKING([whether to compile MUON library])
AC_MSG_RESULT([$enable_module])
AC_SUBST([ALIMUON_LIBS])

dnl ------------------------------------------------------------------
AH_TEMPLATE([HLT_TRIGGER],[hlt trigger library])

ALITRIGGER_LIBS=
CHECK_HLTMODULE([trigger],
		[], [$ALIROOT_CPPFLAGS],
		[], [-L$ROOTLIBDIR], [$ROOTLIBS $ADD_ROOTLIBS],
		[], [-L$ROOTLIBDIR $ALIROOT_LDFLAGS], 
		[$ROOTLIBS $ADD_ROOTLIBS $ALIROOT_LIBS])

if test "x$enable_module" = "xmissheader"; then
  enable_module="no...header.missing"
  enable_trigger=$enable_module
elif test "x$enable_module" = "xforce"; then
  enable_trigger="yes"
else
  enable_trigger=$enable_module
fi

if test "x$enable_trigger" = "xyes" ; then 
  AC_DEFINE(HLT_TRIGGER)
  ALITRIGGER_LIBS=$ALIHLTMODULE_LIBS
else
  enable_module=$enable_trigger
fi
AM_CONDITIONAL(EN_HLT_TRIGGER, test x$enable_trigger = xyes)
AC_MSG_CHECKING([whether to compile Trigger library])
AC_MSG_RESULT([$enable_module])
AC_SUBST([ALITRIGGER_LIBS])

dnl ------------------------------------------------------------------
AH_TEMPLATE([HLT_GLOBAL],[hlt global library])

ALIGLOBAL_LIBS=
CHECK_HLTMODULE([global],
		[], [$ALIROOT_CPPFLAGS],
		[], [-L$ROOTLIBDIR], [$ROOTLIBS $ADD_ROOTLIBS],
		[], [-L$ROOTLIBDIR $ALIROOT_LDFLAGS], 
		[$ROOTLIBS $ADD_ROOTLIBS $ALIROOT_LIBS])

if test "x$enable_module" = "xmissheader"; then
  enable_module="no...header.missing"
  enable_global=$enable_module
elif test "x$enable_module" = "xforce"; then
  enable_global="yes"
else
  enable_global=$enable_module
  if test "x$enable_global" = "xyes" ; then
    AC_LANG_PUSH(C++)
    save_CPPFLAGS="$CPPFLAGS"
    CPPFLAGS="$save_CPPFLAGS $ALIROOT_CPPFLAGS"
    AC_MSG_CHECKING([for required functions in AliESDtrack])
    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <AliESDtrack.h>], 
                                       [AliESDtrack t;
				       t.SetGlobalChi2(0)])],
                                       [], 
  				       [enable_global="no...requires.AliRoot>v4-17-Release"])
    AC_MSG_RESULT([$enable_global])       
    AC_LANG_POP(C++)
    CPPFLAGS="$save_CPPFLAGS"
  fi
fi

if test "x$enable_global" = "xyes" ; then 
  AC_DEFINE(HLT_GLOBAL)
  ALIGLOBAL_LIBS=$ALIHLTMODULE_LIBS
else
  enable_module=$enable_global
fi
AM_CONDITIONAL(EN_HLT_GLOBAL, test x$enable_global = xyes)
AC_MSG_CHECKING([whether to compile Global library])
AC_MSG_RESULT([$enable_module])
AC_SUBST([ALIGLOBAL_LIBS])

dnl ------------------------------------------------------------------
AH_TEMPLATE([HLT_JET],[hlt jet library])

ALIFASTJET_HEADER=
ALIFASTJET_INCFLAGS=
ALIFASTJET_LIBS=
ALIFASTJET_LDFLAGS=
AC_ARG_WITH(fastjet, [installation path of the FASTJET package],
		     [ test "x$with_fastjet" != "xno" && export FASTJET=$with_fastjet],
		     [ test -n $FASTJET && with_fastjet=$FASTJET ])

if test "x$with_fastjet" != "x" && test "x$with_fastjet" != "xno" ; then
  ALIFASTJET_INCFLAGS="-I${with_fastjet}/include"
  ALIFASTJET_HEADER="PseudoJet.hh"
  ALIFASTJET_LDFLAGS="-L${with_fastjet}/lib"
  ALIFASTJET_LIBS="CGAL fastjet"
else
  with_fastjet=no
fi

CHECK_HLTMODULE([jet],
	[$ALIFASTJET_HEADER], [$ALIROOT_CPPFLAGS -I$ALICE_ROOT/JETAN $ALIFASTJET_INCFLAGS],
	[$ALIFASTJET_LIBS], [-L$ROOTLIBDIR $ALIFASTJET_LDFLAGS], [$ROOTLIBS $ADD_ROOTLIBS],
	[AOD ESD ANALYSIS ANALYSISalice JETAN JETANMC], 
	[-L$ROOTLIBDIR $ALIROOT_LDFLAGS -L$ALICE_ROOT/lib/tgt_$ALICE_TARGET],
	[$ROOTLIBS $ADD_ROOTLIBS $ALIROOT_LIBS])

if test "x$enable_module" = "xmissheader"; then
  enable_module="no...header.missing"
  enable_jet=$enable_module
elif test "x$enable_module" = "xforce"; then
  enable_jet="yes"
else
  enable_jet=$enable_module
fi

if test "x$enable_jet" = "xyes" ; then
  AC_DEFINE(HLT_JET)
  ALIJET_LIBS="$ALIHLTMODULE_LIBS"
  
  if test "x$with_fastjet" != "xno"; then
     AC_DEFINE(HAVE_FASTJET)
     AC_DEFINE(WITHFASTJET)
     ALIJET_LIBS="$ALIJET_LIBS -L$FASTJET_LDFLAGS"
  fi
  AC_MSG_CHECKING([compilation with FASTJET package])
  AC_MSG_RESULT($with_fastjet)

else
  enable_module=$enable_jet
fi

AM_CONDITIONAL(EN_HLT_JET, test x$enable_jet = xyes)
AC_MSG_CHECKING([whether to compile Jet library])
AC_MSG_RESULT([$enable_module])
AC_SUBST([ALIJET_LIBS])

dnl ------------------------------------------------------------------
AH_TEMPLATE([HLT_ITS],[hlt its library])

ALIITS_LIBS=
CHECK_HLTMODULE([its],
		[AliITSCompressRawDataSDD.h], [$ALIROOT_CPPFLAGS -I$ALICE_ROOT/ITS],
		[Gui RAWDatasim], [-L$ROOTLIBDIR], [$ROOTLIBS $ADD_ROOTLIBS],
		[ITSbase ITSrec], [-L$ROOTLIBDIR $ALIROOT_LDFLAGS], 
		[$ROOTLIBS $ADD_ROOTLIBS $ALIROOT_LIBS])

if test "x$enable_module" = "xmissheader"; then
  enable_module="no...header.missing"
  enable_its=$enable_module
elif test "x$enable_module" = "xforce"; then
  enable_its="yes"
else
  enable_its=$enable_module
  if test "x$enable_its" = "xyes" ; then
    AC_LANG_PUSH(C++)
    save_CPPFLAGS="$CPPFLAGS"
    CPPFLAGS="$save_CPPFLAGS $ALIROOT_CPPFLAGS -I$ALICE_ROOT/ITS"
    # changes in the AliVertexer base class revision 26414, Thu Jun 5 15:36:18 2008
    # require AliVertexer::GetNominalPos()
    AC_MSG_CHECKING([for required functions in AliITSVertexer])
    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <AliITSVertexerZ.h>], 
                                       [AliITSVertexerZ v;
				       v.GetNominalPos()])],
                                       [], 
  				       [enable_its="no...requires.AliRoot>v4-13-Release"])
    AC_MSG_RESULT([$enable_its])       
    AC_LANG_POP(C++)
    CPPFLAGS="$save_CPPFLAGS"
  fi
fi

if test "x$enable_its" = "xyes" ; then 
  AC_DEFINE(HLT_ITS)
  ALIITS_LIBS=$ALIHLTMODULE_LIBS
else
  enable_module=$enable_its
fi
AM_CONDITIONAL(EN_HLT_ITS, test x$enable_its = xyes)
AC_MSG_CHECKING([whether to compile ITS library])
AC_MSG_RESULT([$enable_module])
AC_SUBST([ALIITS_LIBS])

dnl ------------------------------------------------------------------
AH_TEMPLATE([HLT_EMCAL],[hlt emcal library])

ALIEMCAL_LIBS=
CHECK_HLTMODULE([emcal],
		[], [$ALIROOT_CPPFLAGS -I$ALICE_ROOT/EMCAL],
		[RAWDatasim], [-L$ROOTLIBDIR], [$ROOTLIBS $ADD_ROOTLIBS],
		[EMCALrec EMCALsim EMCALbase], [-L$ROOTLIBDIR $ALIROOT_LDFLAGS], 
		[$ROOTLIBS $ADD_ROOTLIBS $ALIROOT_LIBS])

if test "x$enable_module" = "xmissheader"; then
  enable_module="no...header.missing"
  enable_emcal=$enable_module
elif test "x$enable_module" = "xforce"; then
  enable_emcal="yes"
else
  enable_emcal=$enable_module
fi

if test "x$enable_emcal" = "xyes" ; then 
  AC_DEFINE(HLT_EMCAL)
  ALIEMCAL_LIBS=$ALIHLTMODULE_LIBS
else
  enable_module=$enable_emcal
fi
AM_CONDITIONAL(EN_HLT_EMCAL, test x$enable_emcal = xyes)
AC_MSG_CHECKING([whether to compile EMCAL library])
AC_MSG_RESULT([$enable_module])
AC_SUBST([ALIEMCAL_LIBS])

dnl ------------------------------------------------------------------
AH_TEMPLATE([HLT_COMP],[hlt comp library])

ALICOMP_LIBS=
CHECK_HLTMODULE([comp],
		[], [$ALIROOT_CPPFLAGS],
		[], [-L$ROOTLIBDIR], [$ROOTLIBS $ADD_ROOTLIBS],
		[], [-L$ROOTLIBDIR $ALIROOT_LDFLAGS], 
		[$ROOTLIBS $ADD_ROOTLIBS $ALIROOT_LIBS])

if test "x$enable_module" = "xmissheader"; then
  enable_module="no...header.missing"
  enable_comp=$enable_module
elif test "x$enable_module" = "xforce"; then
  enable_comp="yes"
else
  enable_comp=$enable_module
fi

if test "x$enable_comp" = "xyes" ; then 
  AC_DEFINE(HLT_COMP)
  ALICOMP_LIBS=$ALIHLTMODULE_LIBS
else
  enable_module=$enable_comp
fi
AM_CONDITIONAL(EN_HLT_COMP, test x$enable_comp = xyes)
AC_MSG_CHECKING([whether to compile comp library])
AC_MSG_RESULT([$enable_module])
AC_SUBST([ALICOMP_LIBS])

dnl ------------------------------------------------------------------
AC_MSG_CHECKING([whether to disable AliRoot logging])
AH_TEMPLATE([NOALIROOT_LOGGING],[disable AliRoot logging])
AC_ARG_ENABLE(aliroot-logging,
  [AC_HELP_STRING([--disable-aliroot-logging],
      [disable logging through AliRoot logging methods])],
  [],[enable_aliroot_logging=no])
if test "x$have_aliroot" = "xno" ; then
  enable_aliroot_logging=yes # this means 'disable'
fi
if test "x$enable_aliroot_logging" != "xno" ; then 
  AC_DEFINE(NOALIROOT_LOGGING)
fi
AM_CONDITIONAL(NOALIROOT_LOGGING, test x$enable_aliroot_logging != no)
AC_MSG_RESULT([$enable_aliroot_logging])

dnl ------------------------------------------------------------------
AC_MSG_CHECKING([whether to enable saving MC data through the chain])
AH_TEMPLATE([DOMC],[MC saving])
AC_ARG_ENABLE(mc-saving,
  [AC_HELP_STRING([--enable-mc-saving],
      [enable saving MC data through the chain])],
  [],[enable_mc_saving=no])
if test "x$enable_mc_saving" = "xyes" ; then 
  AC_DEFINE(DOMC)
fi
AC_MSG_RESULT([$enable_mc_saving])

dnl ------------------------------------------------------------------
dnl certainly something old, but we keep the define
AC_MSG_CHECKING([whether to use ROWHOUGH])
AH_TEMPLATE([USEROWHOUGH],[HLT ROWHOUGH])
AC_ARG_ENABLE(rowhough,
  [AC_HELP_STRING([--enable-rowhough],
      [use ROWHOUGH ])],
  [],[enable_rowhough=no])
if test "x$enable_rowhough" = "xyes" ; then 
  AC_DEFINE(USEROWHOUGH)
fi
AC_MSG_RESULT([$enable_rowhough])

dnl ------------------------------------------------------------------
dnl The ROOTVERSION and ALIROOTVERSION defines were used by the old
dnl stand-alone build system. This is most likely something old we can
dnl get rid off later, or do something more reasonable. Since the define
dnl needs the quotes they have to be  escaped. This works well for the
dnl Makefile but not for the configure script. So we have to add the
dnl defines after all the other checks.
CPPFLAGS="$CPPFLAGS -DROOTVERSION=\\\"`${ROOTCONF} --version`\\\""
if test ! "x$have_aliroot" = "xno" ; then
  CPPFLAGS="$CPPFLAGS -DALIROOTVERSION=\\\"Unknown\\\""
fi

dnl ------------------------------------------------------------------
dnl
dnl Documentation
dnl
AC_ARG_VAR(DOXYGEN, The Documentation Generator)
AC_PATH_PROG(PERL, perl)
AC_PATH_PROG(DOXYGEN, doxygen)
AC_ARG_ENABLE(dot,
  [AC_HELP_STRING([--enable-dot],
      [enable dot documentation generator])],
  [],[enable_dot=no])
HAVE_DOT=NO
DOT_PATH=
AC_PATH_PROG(DOT, dot)
if test "x$DOT" != "x" && test "x$enable_dot" = "xyes" ; then
   HAVE_DOT=YES
   DOT_PATH=`dirname $DOT`
fi

AC_MSG_CHECKING([for documentation mode])
AC_ARG_ENABLE(doc,
  [AC_HELP_STRING([--disable-doc],
      [disable documentation build; monolithic build --enable-doc=mono ])],
  [],[enable_doc=modules])

if test "x$DOXYGEN" = "x" ; then
   enable_doc=no.doxygen
elif test "x$enable_doc" = "xyes" ; then
   enable_doc=yes
elif test ! "x$enable_doc" = "xmono" && \
     test ! "x$enable_doc" = "xmodules"  && \
     test ! "x$enable_doc" = "xno"; then
   enable_doc=no
   AC_MSG_WARN([unknown option])
fi
if test "x$enable_doc" = "xno" ; then
   enable_doc=off
   DOXYGEN=
fi

AC_MSG_RESULT([$enable_doc])
AM_CONDITIONAL(MONOLITHIC_DOC, test "x$enable_doc" = "xmono")
AM_CONDITIONAL(HAVE_DOXYGEN, test ! "x$DOXYGEN" = "x")
AC_SUBST([HAVE_DOT])
AC_SUBST([DOT_PATH])

dnl HAVE_SRC_SUBDIR=${abs_top_srcdir}/src
dnl echo $HAVE_SRC_SUBDIR
dnl if ! test -d $HAVE_SRC_SUBDIR; then
dnl   HAVE_SRC_SUBDIR=
dnl fi
dnl AC_SUBST([HAVE_SRC_SUBDIR])

dnl ------------------------------------------------------------------
AC_MSG_NOTICE([---------------------------------------------- ])
AC_MSG_NOTICE([                build summary                  ])
AC_MSG_NOTICE([---------------------------------------------- ])

AC_CONFIG_FILES([Makefile 
		 BASE/Makefile
		 BASE/setenv.sh
		 BASE/setenv.csh
		 BASE/HOMER/Makefile
		 BASE/util/Makefile
		 BASE/util/test/Makefile
		 BASE/interface/Makefile
		 BASE/test/Makefile
		 BASE/interface/test/Makefile
		 doc/Makefile
		 doc/doxygen.conf
		 doc/doxymodule.conf])

dnl AliRoot and installation directory for libraries
dnl 
AC_MSG_NOTICE([AliRoot: $have_aliroot])
AM_CONDITIONAL(HAVE_ALIROOT, test "x$have_aliroot" != "xno" )
if test "x$have_aliroot" != "xno"; then 
  AC_CONFIG_FILES([sim/Makefile	 
		   rec/Makefile	 
		   rec/test/Makefile	 
		   rec/startAliEVE-barrel-tracks.sh
		   shuttle/Makefile
		   pendolino/Makefile
		   benchmark/Makefile
		   ])
fi
if test "x$prefix" != "xNONE" && test $ALICE_ROOT = $prefix ; then
libdir=\${exec_prefix}/lib/tgt_$ALICE_TARGET
AC_MSG_NOTICE([libdir set to $libdir])
fi

AC_MSG_NOTICE([compile sample library: $enable_sample])
if test "x$enable_sample" = "xyes"; then 
  AC_CONFIG_FILES([SampleLib/Makefile])
fi

AC_MSG_NOTICE([compile RCU library: $enable_rcu])
if test "x$enable_rcu" = "xyes"; then 
  AC_CONFIG_FILES([RCU/Makefile
		   RCU/test/Makefile
		   ])
fi

AC_MSG_NOTICE([compile TPC library: $enable_tpc])
if test "x$enable_tpc" = "xyes"; then 
  AC_CONFIG_FILES([TPCLib/Makefile	      
		   TPCLib/test/Makefile	      
		   TPCLib/mapping2array.cxx     
		   TPCLib/EVE/Makefile
		   ])
fi

AC_MSG_NOTICE([compile PHOS library: $enable_phos])
if test "x$enable_phos" = "xyes"; then 
  AC_CONFIG_FILES([PHOS/Makefile])
fi

AC_MSG_NOTICE([compile TRD library: $enable_trd])
if test "x$enable_trd" = "xyes"; then 
  AC_CONFIG_FILES([TRD/Makefile])
fi

AC_MSG_NOTICE([compile FMD library: $enable_fmd])
if test "x$enable_fmd" = "xyes"; then 
  AC_CONFIG_FILES([FMD/Makefile])
fi

AC_MSG_NOTICE([compile MUON library: $enable_muon])
if test "x$enable_muon" = "xyes"; then 
  AC_CONFIG_FILES([MUON/Makefile])
fi

AC_MSG_NOTICE([compile ITS library: $enable_its])
if test "x$enable_its" = "xyes"; then 
  AC_CONFIG_FILES([ITS/Makefile])
fi

AC_MSG_NOTICE([compile EMCAL library: $enable_emcal])
if test "x$enable_emcal" = "xyes"; then 
  AC_CONFIG_FILES([EMCAL/Makefile])
fi

AC_MSG_NOTICE([compile trigger library: $enable_trigger])
if test "x$enable_trigger" = "xyes"; then 
  AC_CONFIG_FILES([trigger/Makefile
                   trigger/test/Makefile])
fi

AC_MSG_NOTICE([compile global library: $enable_global])
if test "x$enable_global" = "xyes"; then 
  AC_CONFIG_FILES([global/Makefile])
fi

AC_MSG_NOTICE([compile jet library: $enable_jet])
if test "x$enable_jet" = "xyes"; then 
  AC_CONFIG_FILES([JET/Makefile])
fi

AC_MSG_NOTICE([compile comp library: $enable_comp])
if test "x$enable_comp" = "xyes"; then 
  AC_CONFIG_FILES([comp/Makefile])
fi

AC_OUTPUT
dnl
dnl EOF
dnl