diff --git a/Build/AtlasBuildScripts/LCG_RELEASE_BASE.sh b/Build/AtlasBuildScripts/LCG_RELEASE_BASE.sh
new file mode 100644
index 0000000000000000000000000000000000000000..9125180f8f038c8f3615f00cf4c710c89325958c
--- /dev/null
+++ b/Build/AtlasBuildScripts/LCG_RELEASE_BASE.sh
@@ -0,0 +1,24 @@
+#
+# This helper script is meant to set up a valid value for the
+# LCG_RELEASE_BASE environment variable for the builds.
+#
+# If the environment variable is already set when the script runs, its
+# value is not modified. If it isn't set yet, then the script tries to
+# check for the existence of a number of standard directories in which
+# LCG releases usually reside.
+#
+
+if [ -z "${LCG_RELEASE_BASE}" ]; then
+
+    if [ -d /cvmfs/sft.cern.ch/lcg/releases ]; then
+        export LCG_RELEASE_BASE=/cvmfs/sft.cern.ch/lcg/releases
+    elif [ -d /afs/cern.ch/sw/lcg/releases ]; then
+        export LCG_RELEASE_BASE=/afs/cern.ch/sw/lcg/releases
+    elif [ -d /cvmfs/atlas.cern.ch/repo/sw/software/21.0/sw/lcg/releases ]; then
+        export LCG_RELEASE_BASE=/cvmfs/atlas.cern.ch/repo/sw/software/21.0/sw/lcg/releases
+    fi
+    echo "Set LCG_RELEASE_BASE = ${LCG_RELEASE_BASE}"
+
+else
+    echo "Leaving LCG_RELEASE_BASE = ${LCG_RELEASE_BASE}"
+fi
diff --git a/Build/AtlasBuildScripts/README.md b/Build/AtlasBuildScripts/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..dd50ee543bb8cec2dd123e76fd8cbac1a1b24a2b
--- /dev/null
+++ b/Build/AtlasBuildScripts/README.md
@@ -0,0 +1,5 @@
+Build Scripts For ATLAS External Projects
+=========================================
+
+This directory collects the helper scripts needed to build / set up everything
+necessary to build the projects of this repository.
diff --git a/Build/AtlasBuildScripts/TDAQ_RELEASE_BASE.sh b/Build/AtlasBuildScripts/TDAQ_RELEASE_BASE.sh
new file mode 100644
index 0000000000000000000000000000000000000000..7eb581f6e25829e6664e2e2be0ce7a6b95141498
--- /dev/null
+++ b/Build/AtlasBuildScripts/TDAQ_RELEASE_BASE.sh
@@ -0,0 +1,22 @@
+#
+# This helper script is meant to set up a valid value for the
+# TDAQ_RELEASE_BASE environment variable for the builds.
+#
+# If the environment variable is already set when the script runs, its
+# value is not modified. If it isn't set yet, then the script tries to
+# check for the existence of a number of standard directories in which
+# TDAQ releases usually reside.
+#
+
+if [ -z "${TDAQ_RELEASE_BASE}" ]; then
+
+    if [ -d /afs/cern.ch/atlas/project/tdaq/prod ]; then
+        export TDAQ_RELEASE_BASE=/afs/cern.ch/atlas/project/tdaq/prod
+    elif [ -d /cvmfs/atlas.cern.ch/repo/sw/software/21.0 ]; then
+        export TDAQ_RELEASE_BASE=/cvmfs/atlas.cern.ch/repo/sw/software/21.0
+    fi
+    echo "Set TDAQ_RELEASE_BASE = ${TDAQ_RELEASE_BASE}"
+
+else
+    echo "Leaving TDAQ_RELEASE_BASE = ${TDAQ_RELEASE_BASE}"
+fi
diff --git a/Build/AtlasBuildScripts/build_Gaudi.sh b/Build/AtlasBuildScripts/build_Gaudi.sh
new file mode 100755
index 0000000000000000000000000000000000000000..b07758d86280ab1262df5a393a197e219a30d9aa
--- /dev/null
+++ b/Build/AtlasBuildScripts/build_Gaudi.sh
@@ -0,0 +1,104 @@
+#!/bin/bash
+#
+# Script used for building Gaudi.
+#
+
+# Don't stop on errors:
+set +e
+
+# Function printing the usage information for the script
+usage() {
+    echo "Usage: build_Gaudi.sh <-s source dir> <-b build dir> " \
+        "<-i install dir> <-e externals dir> <-p externals project name> " \
+        "<-f platform name> [-r RPM dir] [-t build type]"
+}
+
+# Parse the command line arguments:
+SOURCEDIR=""
+BUILDDIR=""
+INSTALLDIR=""
+EXTDIR=""
+EXTPROJECT=""
+PLATFORM=""
+RPMDIR=""
+BUILDTYPE="Release"
+while getopts ":s:b:i:e:p:f:r:t:h" opt; do
+    case $opt in
+        s)
+            SOURCEDIR=$OPTARG
+            ;;
+        b)
+            BUILDDIR=$OPTARG
+            ;;
+        i)
+            INSTALLDIR=$OPTARG
+            ;;
+        e)
+            EXTDIR=$OPTARG
+            ;;
+        p)
+            EXTPROJECT=$OPTARG
+            ;;
+        f)
+            PLATFORM=$OPTARG
+            ;;
+        r)
+            RPMDIR=$OPTARG
+            ;;
+        t)
+            BUILDTYPE=$OPTARG
+            ;;
+        h)
+            usage
+            exit 0
+            ;;
+        :)
+            echo "Argument -$OPTARG requires a parameter!"
+            usage
+            exit 1
+            ;;
+        ?)
+            echo "Unknown argument: -$OPTARG"
+            usage
+            exit 1
+            ;;
+    esac
+done
+
+# Make sure that the required options were all specified:
+if [ "$SOURCEDIR" = "" ] || [ "$BUILDDIR" = "" ] || [ "$INSTALLDIR" = "" ] \
+    || [ "$EXTDIR" = "" ] || [ "$EXTPROJECT" = "" ] \
+    || [ "$PLATFORM" = "" ]; then
+    echo "Not all required parameters received!"
+    usage
+    exit 1
+fi
+
+# Create the build directory if it doesn't exist, and move to it:
+mkdir -p ${BUILDDIR}
+cd ${BUILDDIR}
+
+# Set up the externals project:
+source ${EXTDIR}/setup.sh
+
+# Configure the build:
+cmake -DCMAKE_BUILD_TYPE:STRING=${BUILDTYPE} -DCTEST_USE_LAUNCHERS:BOOL=TRUE \
+    -DGAUDI_ATLAS:BOOL=TRUE -DGAUDI_ATLAS_BASE_PROJECT:STRING=${EXTPROJECT} \
+    -DCMAKE_INSTALL_PREFIX:PATH=/InstallArea/${PLATFORM} \
+    ${SOURCEDIR} 2>&1 | tee cmake_config.log
+
+# Build it:
+make -k
+
+# Install it:
+make -k install/fast DESTDIR=${INSTALLDIR}
+
+# If no RPM directory was specified, stop here:
+if [ "$RPMDIR" = "" ]; then
+    exit 0
+fi
+
+# Build the RPM for the project:
+cpack
+mkdir -p ${RPMDIR}
+cp GAUDI*.rpm ${RPMDIR}
diff --git a/Build/AtlasBuildScripts/build_atlasexternals.sh b/Build/AtlasBuildScripts/build_atlasexternals.sh
new file mode 100755
index 0000000000000000000000000000000000000000..20f6dfbcfd4e286904b61cbc84aaa576ff765395
--- /dev/null
+++ b/Build/AtlasBuildScripts/build_atlasexternals.sh
@@ -0,0 +1,97 @@
+#!/bin/bash
+#
+# Example script used for building one of the projects from the atlasexternals
+# repository.
+#
+
+# Don't stop on errors:
+set +e
+
+# Function printing the usage information for the script
+usage() {
+    echo "Usage: build_atlasexternals.sh <-s source dir> <-b build dir> " \
+        "<-i install dir> [-p project] [-r RPM dir] [-t build type]"
+}
+
+# Parse the command line arguments:
+SOURCEDIR=""
+BUILDDIR=""
+INSTALLDIR=""
+PROJECT="AthenaExternals"
+RPMDIR=""
+BUILDTYPE="Release"
+PROJECTVERSION=""
+while getopts ":s:b:i:p:r:t:v:h" opt; do
+    case $opt in
+        s)
+            SOURCEDIR=$OPTARG
+            ;;
+        b)
+            BUILDDIR=$OPTARG
+            ;;
+        i)
+            INSTALLDIR=$OPTARG
+            ;;
+        p)
+            PROJECT=$OPTARG
+            ;;
+        r)
+            RPMDIR=$OPTARG
+            ;;
+        t)
+            BUILDTYPE=$OPTARG
+            ;;
+        v)
+            PROJECTVERSION=$OPTARG
+            ;;
+        :)
+            echo "Argument -$OPTARG requires a parameter!"
+            usage
+            exit 1
+            ;;
+        ?)
+            echo "Unknown argument: -$OPTARG"
+            usage
+            exit 1
+            ;;
+    esac
+done
+
+# Make sure that the required options were all specified:
+if [ "$SOURCEDIR" = "" ] || [ "$BUILDDIR" = "" ] || [ "$INSTALLDIR" = "" ]; then
+    echo "Not all required parameters received!"
+    usage
+    exit 1
+fi
+
+# Create the build directory if it doesn't exist, and move to it:
+mkdir -p ${BUILDDIR}
+cd ${BUILDDIR}
+
+# Extra settings for providing a project version for the build if necessary:
+EXTRACONF=
+if [ "$PROJECTVERSION" != "" ]; then
+    PNAME=$(echo ${PROJECT} | awk '{print toupper($0)}')
+    EXTRACONF=-D${PNAME}_PROJECT_VERSION:STRING=${PROJECTVERSION}
+fi
+
+# Configure the build:
+cmake -DCMAKE_BUILD_TYPE:STRING=${BUILDTYPE} -DCTEST_USE_LAUNCHERS:BOOL=TRUE \
+    ${EXTRACONF} \
+    ${SOURCEDIR}/Projects/${PROJECT}/ 2>&1 | tee cmake_config.log
+
+# Build it:
+make -k
+
+# Install it:
+make -k install/fast DESTDIR=${INSTALLDIR}
+
+# If no RPM directory was specified, stop here:
+if [ "$RPMDIR" = "" ]; then
+    exit 0
+fi
+
+# Build the RPM for the project:
+cpack
+mkdir -p ${RPMDIR}
+cp ${PROJECT}*.rpm ${RPMDIR}
diff --git a/Build/AtlasBuildScripts/checkout_Gaudi.sh b/Build/AtlasBuildScripts/checkout_Gaudi.sh
new file mode 100755
index 0000000000000000000000000000000000000000..8d89cc12a443d3bec8f48daceddba04fa18c4f91
--- /dev/null
+++ b/Build/AtlasBuildScripts/checkout_Gaudi.sh
@@ -0,0 +1,80 @@
+#!/bin/bash
+#
+# Script for automating the checkout of the Gaudi repository when
+# building the whole software stack in a nightly/release.
+#
+# The script must receive the tag/branch that should be checked out of the
+# Gaudi repository. And it can write the commit hash that the
+# checkout ended up with, into another file.
+#
+
+# Stop on errors:
+set -e
+
+# Function printing the usage information for the script
+usage() {
+    echo "Usage: checkout_Gaudi.sh <-t branch/tag> " \
+        "<-s source directory> [-o hash_file.txt]"
+}
+
+# Parse the command line arguments:
+TAGBRANCH=""
+SOURCEDIR=""
+HASHFILE=""
+while getopts ":t:o:s:h" opt; do
+    case $opt in
+        t)
+            TAGBRANCH=$OPTARG
+            ;;
+        s)
+            SOURCEDIR=$OPTARG
+            ;;
+        o)
+            HASHFILE=$OPTARG
+            ;;
+        h)
+            usage
+            exit 0
+            ;;
+        :)
+            echo "Argument -$OPTARG requires a parameter!"
+            usage
+            exit 1
+            ;;
+        ?)
+            echo "Unknown argument: -$OPTARG"
+            usage
+            exit 1
+            ;;
+    esac
+done
+
+# The tag/branch and a source directory must have been specified:
+if [ "$TAGBRANCH" = "" ] || [ "$SOURCEDIR" = "" ]; then
+    echo "Not all required arguments were provided!"
+    usage
+    exit 1
+fi
+
+# Tell the user what will happen:
+echo "Checking out Gaudi tag/branch: $TAGBRANCH"
+if [ "$HASHFILE" != "" ]; then
+    echo "Writing the commit hash into file: $HASHFILE"
+fi
+
+# Clone the repository:
+git clone https://gitlab.cern.ch/atlas/Gaudi.git \
+    ${SOURCEDIR}
+
+# Get the appropriate tag of it:
+cd ${SOURCEDIR}
+git checkout ${TAGBRANCH}
+
+# If an output file was not specified, stop here:
+if [ "$HASHFILE" = "" ]; then
+    exit 0
+fi
+
+# Write the hash of whatever we have checked out currently, into the
+# specified output file:
+git rev-parse ${TAGBRANCH} > ${HASHFILE}
diff --git a/Build/AtlasBuildScripts/checkout_atlasexternals.sh b/Build/AtlasBuildScripts/checkout_atlasexternals.sh
new file mode 100755
index 0000000000000000000000000000000000000000..93c068d7cb1c4d180ba8c0a7ad5031b1016ed20a
--- /dev/null
+++ b/Build/AtlasBuildScripts/checkout_atlasexternals.sh
@@ -0,0 +1,80 @@
+#!/bin/bash
+#
+# Script for automating the checkout of the atlasexternals repository when
+# building the whole software stack in a nightly/release.
+#
+# The script must receive the tag/branch that should be checked out of the
+# atlasexternals repository. And it can write the commit hash that the
+# checkout ended up with, into another file.
+#
+
+# Stop on errors:
+set -e
+
+# Function printing the usage information for the script
+usage() {
+    echo "Usage: checkout_atlasexternals.sh <-t branch/tag> " \
+        "<-s source directory> [-o hash_file.txt]"
+}
+
+# Parse the command line arguments:
+TAGBRANCH=""
+SOURCEDIR=""
+HASHFILE=""
+while getopts ":t:o:s:h" opt; do
+    case $opt in
+        t)
+            TAGBRANCH=$OPTARG
+            ;;
+        s)
+            SOURCEDIR=$OPTARG
+            ;;
+        o)
+            HASHFILE=$OPTARG
+            ;;
+        h)
+            usage
+            exit 0
+            ;;
+        :)
+            echo "Argument -$OPTARG requires a parameter!"
+            usage
+            exit 1
+            ;;
+        ?)
+            echo "Unknown argument: -$OPTARG"
+            usage
+            exit 1
+            ;;
+    esac
+done
+
+# The tag/branch and a source directory must have been specified:
+if [ "$TAGBRANCH" = "" ] || [ "$SOURCEDIR" = "" ]; then
+    echo "Not all required arguments were provided!"
+    usage
+    exit 1
+fi
+
+# Tell the user what will happen:
+echo "Checking out atlasexternals tag/branch: $TAGBRANCH"
+if [ "$HASHFILE" != "" ]; then
+    echo "Writing the commit hash into file: $HASHFILE"
+fi
+
+# Clone the repository:
+git clone ssh://git@gitlab.cern.ch:7999/atlas/atlasexternals.git \
+    ${SOURCEDIR}
+
+# Get the appropriate tag of it:
+cd ${SOURCEDIR}
+git checkout ${TAGBRANCH}
+
+# If an output file was not specified, stop here:
+if [ "$HASHFILE" = "" ]; then
+    exit 0
+fi
+
+# Write the hash of whatever we have checked out currently, into the
+# specified output file:
+git rev-parse ${TAGBRANCH} > ${HASHFILE}
diff --git a/Calorimeter/CaloGeoHelpers/CMakeLists.txt b/Calorimeter/CaloGeoHelpers/CMakeLists.txt
index 1310aa65da8d5fef857662dd2039c6f94f7eea4b..9bee11c66a15f68ac5f8245b95f786d05b257b74 100644
--- a/Calorimeter/CaloGeoHelpers/CMakeLists.txt
+++ b/Calorimeter/CaloGeoHelpers/CMakeLists.txt
@@ -11,8 +11,6 @@ atlas_depends_on_subdirs( PUBLIC
                           PRIVATE
                           AtlasTest/TestTools )
 
-athena_install_nonstandard_headers(CaloGeoHelpers/CaloSampling.def)
-
 # Component(s) in the package:
 atlas_add_library( CaloGeoHelpers
                    Root/*.cxx
diff --git a/Event/xAOD/xAODCaloRings/CMakeLists.txt b/Event/xAOD/xAODCaloRings/CMakeLists.txt
index 099cc4d5935968d1a4bcbe5f775fbcb5e168de74..8ee53701c89227273d94f6cd091e0a8e2d7e754e 100644
--- a/Event/xAOD/xAODCaloRings/CMakeLists.txt
+++ b/Event/xAOD/xAODCaloRings/CMakeLists.txt
@@ -17,8 +17,6 @@ atlas_depends_on_subdirs( PUBLIC
 # External dependencies:
 find_package( ROOT COMPONENTS Core Tree MathCore Hist RIO pthread )
 
-athena_install_nonstandard_headers(xAODCaloRings/versions)
-
 # Component(s) in the package:
 atlas_add_library( xAODCaloRings
                    Root/*.cxx
diff --git a/InnerDetector/InDetConditions/PixelCoralClientUtils/CMakeLists.txt b/InnerDetector/InDetConditions/PixelCoralClientUtils/CMakeLists.txt
index 4b43a06419d87a9642342e5ca30a869a499fd96f..4503f63812e26341b05340690525ba8a1361caeb 100644
--- a/InnerDetector/InDetConditions/PixelCoralClientUtils/CMakeLists.txt
+++ b/InnerDetector/InDetConditions/PixelCoralClientUtils/CMakeLists.txt
@@ -14,8 +14,6 @@ find_package( COOL COMPONENTS CoolKernel )
 find_package( CORAL COMPONENTS CoralBase CoralKernel RelationalAccess )
 find_package( ROOT COMPONENTS Core Tree MathCore Hist RIO pthread )
 
-athena_install_nonstandard_headers(PixelCoralClientUtils/*.hh)
-
 # Component(s) in the package:
 atlas_add_library( PixelCoralClientUtils
                    src/CoralClient.cc
diff --git a/MuonSpectrometer/MuonCalib/MuonCalibUtils/MuonCalibMath/CMakeLists.txt b/MuonSpectrometer/MuonCalib/MuonCalibUtils/MuonCalibMath/CMakeLists.txt
index f805a3ffd98be028411944f493931d2e4444c9c8..d6238fd0d7a99c56efb4bad8ebabb8aa889d1afb 100644
--- a/MuonSpectrometer/MuonCalib/MuonCalibUtils/MuonCalibMath/CMakeLists.txt
+++ b/MuonSpectrometer/MuonCalib/MuonCalibUtils/MuonCalibMath/CMakeLists.txt
@@ -14,8 +14,6 @@ find_package( CLHEP )
 find_package( Eigen )
 find_package( ROOT COMPONENTS MathCore MathMore Core Tree Hist RIO pthread )
 
-athena_install_nonstandard_headers(MuonCalibMath/*.ixx)
-
 # Component(s) in the package:
 atlas_add_library( MuonCalibMath
                    src/*.cxx
diff --git a/PackDist/CMakeLists.txt b/PackDist/CMakeLists.txt
index 0dd46447e0b0779c34024098bacb6b2e531b898e..8da3a1343637f9f86fb1414591b36c86deb1a0c5 100644
--- a/PackDist/CMakeLists.txt
+++ b/PackDist/CMakeLists.txt
@@ -4,13 +4,3 @@
 
 # Declare the package name:
 atlas_subdir( PackDist )
-
-# this line failed automatic conversion in cmt2cmake :
-# set_remove PACKOPTS "-w"
-
-# this line failed automatic conversion in cmt2cmake :
-# set_append PACKOPTS " -w "
-
-athena_env( SET PACKCFG ../config/pack-nightly-bugfix.cfg
-            SET PACKOPTS \\\${PACKOPTS} )
-
diff --git a/PhysicsAnalysis/AnalysisCommon/IsolationSelection/CMakeLists.txt b/PhysicsAnalysis/AnalysisCommon/IsolationSelection/CMakeLists.txt
index 6e20b2f1102f23a4b50e1c1d6e6935b87a0bb82c..619d93c45a02b88f7be0e0f35f5fe10dea3d2ea1 100644
--- a/PhysicsAnalysis/AnalysisCommon/IsolationSelection/CMakeLists.txt
+++ b/PhysicsAnalysis/AnalysisCommon/IsolationSelection/CMakeLists.txt
@@ -32,7 +32,7 @@ atlas_add_library( IsolationSelectionLib
   PUBLIC_HEADERS IsolationSelection
   PRIVATE_INCLUDE_DIRS ${ROOT_INCLUDE_DIRS}
   LINK_LIBRARIES AthContainers AsgTools xAODBase xAODEgamma xAODMuon
-  xAODPrimitives PATCoreLib PATInterfaces InDetTrackSelectionTool
+  xAODPrimitives PATCoreLib PATInterfaces InDetTrackSelectionToolLib
   PRIVATE_LINK_LIBRARIES ${ROOT_LIBRARIES} PathResolver )
 
 
diff --git a/PhysicsAnalysis/MuonID/MuonPerformanceAnalysis/MuonPerformanceAlgs/CMakeLists.txt b/PhysicsAnalysis/MuonID/MuonPerformanceAnalysis/MuonPerformanceAlgs/CMakeLists.txt
index 23b2f2ebd4826c7519a169baab5f382016d32933..a622fdc63a39b8a503d5b69fe27c2ff13a5dbc36 100644
--- a/PhysicsAnalysis/MuonID/MuonPerformanceAnalysis/MuonPerformanceAlgs/CMakeLists.txt
+++ b/PhysicsAnalysis/MuonID/MuonPerformanceAnalysis/MuonPerformanceAlgs/CMakeLists.txt
@@ -33,7 +33,7 @@ atlas_add_component( MuonPerformanceAlgs
                      src/*.cxx
                      src/components/*.cxx
                      INCLUDE_DIRS ${ROOT_INCLUDE_DIRS}
-                     LINK_LIBRARIES ${ROOT_LIBRARIES} RecoToolInterfaces AthenaBaseComps AthAnalysisBaseComps xAODCutFlow xAODBase xAODCore xAODEventInfo xAODMuon xAODPrimitives xAODTracking EventBookkeeperMetaData GaudiKernel MuonPerformanceHistUtils MuonResonanceToolsLib  )
+                     LINK_LIBRARIES ${ROOT_LIBRARIES} RecoToolInterfaces AthenaBaseComps AthAnalysisBaseCompsLib xAODCutFlow xAODBase xAODCore xAODEventInfo xAODMuon xAODPrimitives xAODTracking EventBookkeeperMetaData GaudiKernel MuonPerformanceHistUtils MuonResonanceToolsLib  )
 
 # Install files from the package:
 atlas_install_python_modules( python/*.py )
diff --git a/Projects/Athena/CMakeLists.txt b/Projects/Athena/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ab2539bb05ba141fe11db821b72834226c09b4b4
--- /dev/null
+++ b/Projects/Athena/CMakeLists.txt
@@ -0,0 +1,86 @@
+
+# The minimum required CMake version:
+cmake_minimum_required( VERSION 3.2 FATAL_ERROR )
+
+# Read in the project's version from a file called version.txt. But let it be
+# overridden from the command line if necessary.
+file( READ ${CMAKE_SOURCE_DIR}/version.txt _version )
+string( STRIP ${_version} _version )
+set( ATHENA_PROJECT_VERSION ${_version}
+   CACHE STRING "Version of the Athena project to build" )
+unset( _version )
+
+# Set the versions of the TDAQ externals to pick up for the build:
+set( TDAQ-COMMON_VERSION "02-01-00" )
+set( TDAQ-COMMON_ROOT
+   "$ENV{TDAQ_RELEASE_BASE}/tdaq-common/tdaq-common-${TDAQ-COMMON_VERSION}" )
+
+set( DQM-COMMON_VERSION "01-01-00" )
+set( DQM-COMMON_ROOT
+   "$ENV{TDAQ_RELEASE_BASE}/dqm-common/dqm-common-${DQM-COMMON_VERSION}" )
+
+set( TDAQ_PROJECT_NAME "tdaq")
+set( TDAQ_VERSION "07-00-00" )
+set( TDAQ_ROOT "$ENV{TDAQ_RELEASE_BASE}/${TDAQ_PROJECT_NAME}/${TDAQ_PROJECT_NAME}-${TDAQ_VERSION}" )
+
+# Find the ATLAS CMake code:
+find_package( AtlasCMake QUIET )
+
+# Find the base project(s):
+find_package( AthenaExternals REQUIRED )
+find_package( Gaudi REQUIRED )
+
+# Set up CTest:
+atlas_ctest_setup()
+
+# Declare project name and version
+atlas_project( Athena ${ATHENA_PROJECT_VERSION}
+   USE AthenaExternals 0.0.1
+   PROJECT_ROOT ${CMAKE_SOURCE_DIR}/../../
+   FORTRAN )
+
+# Generate the environment setup for the externals, to be used during the build:
+lcg_generate_env( SH_FILE ${CMAKE_BINARY_DIR}/${ATLAS_PLATFORM}/env_setup.sh )
+
+# Generate replacement rules for the installed paths:
+set( _replacements )
+if( NOT "$ENV{NICOS_PROJECT_HOME}" STREQUAL "" )
+   get_filename_component( _buildDir $ENV{NICOS_PROJECT_HOME} PATH )
+   list( APPEND _replacements ${_buildDir} "\${Athena_DIR}/../../../.." )
+endif()
+if( NOT "$ENV{NICOS_PROJECT_RELNAME}" STREQUAL "" )
+   list( APPEND _replacements $ENV{NICOS_PROJECT_RELNAME}
+      "\${Athena_VERSION}" )
+endif()
+if( NOT "$ENV{TDAQ_RELEASE_BASE}" STREQUAL "" )
+   list( APPEND _replacements $ENV{TDAQ_RELEASE_BASE}
+      "\${TDAQ_RELEASE_BASE}" )
+endif()
+
+# Now generate and install the installed setup files:
+lcg_generate_env( SH_FILE ${CMAKE_BINARY_DIR}/env_setup_install.sh
+   REPLACE ${_replacements} )
+install( FILES ${CMAKE_BINARY_DIR}/env_setup_install.sh
+   DESTINATION . RENAME env_setup.sh )
+
+# Configure and install the post-configuration file:
+string( REPLACE "$ENV{TDAQ_RELEASE_BASE}" "\$ENV{TDAQ_RELEASE_BASE}"
+   TDAQ-COMMON_ROOT "${TDAQ-COMMON_ROOT}" )
+string( REPLACE "${TDAQ-COMMON_VERSION}" "\${TDAQ-COMMON_VERSION}"
+   TDAQ-COMMON_ROOT "${TDAQ-COMMON_ROOT}" )
+string( REPLACE "$ENV{TDAQ_RELEASE_BASE}" "\$ENV{TDAQ_RELEASE_BASE}"
+   DQM-COMMON_ROOT "${DQM-COMMON_ROOT}" )
+string( REPLACE "${DQM-COMMON_VERSION}" "\${DQM-COMMON_VERSION}"
+   DQM-COMMON_ROOT "${DQM-COMMON_ROOT}" )
+configure_file( ${CMAKE_SOURCE_DIR}/PostConfig.cmake.in
+   ${CMAKE_BINARY_DIR}/PostConfig.cmake @ONLY )
+install( FILES ${CMAKE_BINARY_DIR}/PostConfig.cmake
+   DESTINATION ${CMAKE_INSTALL_CMAKEDIR} )
+
+# Turn off the compression of the created RPM. This makes the RPM a lot
+# bigger, but should push the RPM creation time down by a lot.
+set( CPACK_RPM_SPEC_MORE_DEFINE
+   "%define _source_payload w0.gzdio\n%define _binary_payload w0.gzdio" )
+
+# Package up the release using CPack:
+atlas_cpack_setup()
diff --git a/Projects/Athena/PostConfig.cmake.in b/Projects/Athena/PostConfig.cmake.in
new file mode 100644
index 0000000000000000000000000000000000000000..04f63f68fe67dec80e728d7a7c9e955593efa22b
--- /dev/null
+++ b/Projects/Athena/PostConfig.cmake.in
@@ -0,0 +1,12 @@
+#
+# File taking care of pointing the downstream projects at the right
+# version of the externals.
+#
+
+set( TDAQ-COMMON_VERSION "@TDAQ-COMMON_VERSION@" )
+set( TDAQ-COMMON_ROOT "@TDAQ-COMMON_ROOT@" )
+
+set( DQM-COMMON_VERSION "@DQM-COMMON_VERSION@" )
+set( DQM-COMMON_ROOT "@DQM-COMMON_ROOT@" )
+
+find_package( Gaudi )
diff --git a/Projects/Athena/README.md b/Projects/Athena/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..59582d5780bee80da12521cecf1ed13d836ee4ee
--- /dev/null
+++ b/Projects/Athena/README.md
@@ -0,0 +1,44 @@
+The Full ATLAS Offline Software Project
+=======================================
+
+This is the configuration for building the full offline software from the
+repository.
+
+Build Instructions
+------------------
+
+To build the externals necessary for building this project itself, use the
+
+    build_externals.sh
+
+script. It will build all the externals necessary for this project into a
+subdirectory of the directory holding this repository, called `build`.
+
+The sources of the externals will be checked out under `build/src`, the
+build of the projects will commence under `build/build`, and the results of
+the build will be installed under `build/install`.
+
+RPMs created from the externals are copied under `build/` by the script.
+
+Once the externals have finished building, you can initiate the full build
+of the project against these newly built externals by executing the
+
+    build.sh
+
+script. It uses the same directory layout inside the `build` directory as
+was used for the externals.
+
+Custom Builds
+-------------
+
+Of course it is perfectly allowed to set up a build by hand, not using the
+`build.sh` script as well. In that case you have to make sure to have a
+functional version of AthenaExternals set up in your environment, and point
+the `GAUDI_ROOT` environment variable against the Gaudi version that you
+want to use for the build.
+
+You will also need to set the `TDAQ_RELEASE_BASE` environment variable for
+the build to be successful. The simplest way of doing this is to use the
+helper script:
+
+    Build/AtlasBuildScripts/TDAQ_RELEASE_BASE.sh
diff --git a/Projects/Athena/build.sh b/Projects/Athena/build.sh
new file mode 100755
index 0000000000000000000000000000000000000000..61c6278ac3c01667de7678c639f316fdec5e0e95
--- /dev/null
+++ b/Projects/Athena/build.sh
@@ -0,0 +1,100 @@
+#!/bin/bash
+#
+# Script for building the release on top of externals built using one of the
+# scripts in this directory.
+#
+
+# Function printing the usage information for the script
+usage() {
+    echo "Usage: build.sh [-t build type] [-b build dir]"
+}
+
+# Parse the command line arguments:
+BUILDDIR=""
+BUILDTYPE="RelWithDebInfo"
+while getopts ":t:s:b:h" opt; do
+    case $opt in
+        t)
+            BUILDTYPE=$OPTARG
+            ;;
+        b)
+            BUILDDIR=$OPTARG
+            ;;
+        :)
+            echo "Argument -$OPTARG requires a parameter!"
+            usage
+            exit 1
+            ;;
+        ?)
+            echo "Unknown argument: -$OPTARG"
+            usage
+            exit 1
+            ;;
+    esac
+done
+
+# Stop on errors from here on out:
+set -e
+
+# We are in BASH, get the path of this script in a simple way:
+AthenaSrcDir=$(dirname ${BASH_SOURCE[0]})
+AthenaSrcDir=$(cd ${AthenaSrcDir};pwd)
+
+# The directory holding the helper scripts:
+scriptsdir=${AthenaSrcDir}/../../Build/AtlasBuildScripts
+
+# Go to the main directory of the repository:
+cd ${AthenaSrcDir}/../..
+
+# Check if the user specified any source/build directories:
+if [ "$BUILDDIR" = "" ]; then
+    BUILDDIR=${AthenaSrcDir}/../../../build
+fi
+
+# Set up the environment for the build:
+export NICOS_PROJECT_VERSION=`cat ${AthenaSrcDir}/version.txt`
+export NICOS_ATLAS_RELEASE=${NICOS_PROJECT_VERSION}
+export NICOS_PROJECT_RELNAME=${NICOS_PROJECT_VERSION}
+export NICOS_PROJECT_HOME=$(cd ${BUILDDIR}/install;pwd)/Athena
+
+# Set up the environment variables for finding LCG and the TDAQ externals:
+source ${scriptsdir}/LCG_RELEASE_BASE.sh
+source ${scriptsdir}/TDAQ_RELEASE_BASE.sh
+
+# Set up the AthenaExternals project:
+extDir=${BUILDDIR}/install/AthenaExternals/${NICOS_PROJECT_VERSION}/InstallArea
+if [ ! -d ${extDir} ]; then
+    echo "Didn't find the AthenaExternals project under ${extDir}"
+    exit 1
+fi
+echo "Setting up AthenaExternals from: ${extDir}"
+source ${extDir}/*/setup.sh
+
+# Get the "platform name" from the directory created by the AthenaExternals
+# build:
+platform=$(cd ${extDir};ls)
+
+# Point to Gaudi:
+export GAUDI_ROOT=${BUILDDIR}/install/GAUDI/${NICOS_PROJECT_VERSION}/InstallArea/${platform}
+echo "Taking Gaudi from: ${GAUDI_ROOT}"
+
+# Configure the build:
+mkdir -p ${BUILDDIR}/build/Athena
+cd ${BUILDDIR}/build/Athena
+time cmake -DCMAKE_BUILD_TYPE:STRING=${BUILDTYPE} \
+    -DCTEST_USE_LAUNCHERS:BOOL=TRUE \
+    ${AthenaSrcDir} 2>&1 | tee cmake_config.log
+
+# At this point stop worrying about errors:
+set +e
+
+# Execute the build:
+time make -k
+
+# Install the results:
+time make install/fast \
+    DESTDIR=${BUILDDIR}/install/Athena/${NICOS_PROJECT_VERSION}
+
+# Build an RPM for the release:
+time cpack
+cp Athena*.rpm ${BUILDDIR}/
diff --git a/Projects/Athena/build_externals.sh b/Projects/Athena/build_externals.sh
new file mode 100755
index 0000000000000000000000000000000000000000..5009b5f5d36bd04b9c3aa59e94c9a468d3016ac9
--- /dev/null
+++ b/Projects/Athena/build_externals.sh
@@ -0,0 +1,120 @@
+#!/bin/bash
+#
+# Script building all the externals necessary for the nightly build.
+#
+
+# Function printing the usage information for the script
+usage() {
+    echo "Usage: build_externals.sh [-t build type] [-b build dir]"
+}
+
+# Parse the command line arguments:
+BUILDDIR=""
+BUILDTYPE="RelWithDebInfo"
+while getopts ":t:s:b:h" opt; do
+    case $opt in
+        t)
+            BUILDTYPE=$OPTARG
+            ;;
+        b)
+            BUILDDIR=$OPTARG
+            ;;
+        :)
+            echo "Argument -$OPTARG requires a parameter!"
+            usage
+            exit 1
+            ;;
+        ?)
+            echo "Unknown argument: -$OPTARG"
+            usage
+            exit 1
+            ;;
+    esac
+done
+
+# Version comparison function. Taken from a StackOverflow article.
+verlte() {
+    if [ "$1" = "`echo -e "$1\n$2" | sort -V | head -n1`" ]; then
+        return 1
+    fi
+    return 0
+}
+
+# First off, check that we are using a new enough version of Git. We need
+# at least version 1.8.1.
+git_min_version=1.8.1
+git_version=`git --version | awk '{print $3}'`
+verlte "${git_min_version}" "${git_version}"
+if [ $? = 0 ]; then
+    echo "Detected git version (${git_version}) not new enough."
+    echo "Need at least: ${git_min_version}"
+    exit 1
+fi
+
+# Stop on errors from here on out:
+set -e
+
+# We are in BASH, get the path of this script in a simple way:
+thisdir=$(dirname ${BASH_SOURCE[0]})
+thisdir=$(cd ${thisdir};pwd)
+
+# Go to the main directory of the repository:
+cd ${thisdir}/../..
+
+# Check if the user specified any source/build directories:
+if [ "$BUILDDIR" = "" ]; then
+    BUILDDIR=${thisdir}/../../../build
+fi
+
+# Create some directories:
+mkdir -p ${BUILDDIR}/install
+
+# Set some environment variables that the builds use internally:
+export NICOS_PROJECT_VERSION=`cat ${thisdir}/version.txt`
+export NICOS_ATLAS_RELEASE=${NICOS_PROJECT_VERSION}
+export NICOS_PROJECT_RELNAME=${NICOS_PROJECT_VERSION}
+
+# The directory holding the helper scripts:
+scriptsdir=${thisdir}/../../Build/AtlasBuildScripts
+
+# Set the environment variable for finding LCG releases:
+source ${scriptsdir}/LCG_RELEASE_BASE.sh
+
+# Read in the tag/branch to use for AthenaExternals:
+AthenaExternalsVersion=$(awk '/^AthenaExternalsVersion/{print $3}' ${thisdir}/externals.txt)
+
+# Check out AthenaExternals from the right branch/tag:
+${scriptsdir}/checkout_atlasexternals.sh \
+    -t ${AthenaExternalsVersion} \
+    -s ${BUILDDIR}/src/AthenaExternals
+
+# Build AthenaExternals:
+export NICOS_PROJECT_HOME=$(cd ${BUILDDIR}/install;pwd)/AthenaExternals
+${scriptsdir}/build_atlasexternals.sh \
+    -s ${BUILDDIR}/src/AthenaExternals \
+    -b ${BUILDDIR}/build/AthenaExternals \
+    -i ${BUILDDIR}/install/AthenaExternals/${NICOS_PROJECT_VERSION} \
+    -p AthenaExternals -r ${BUILDDIR} -t ${BUILDTYPE} \
+    -v ${NICOS_PROJECT_VERSION}
+
+# Get the "platform name" from the directory created by the AthenaExternals
+# build:
+platform=$(cd ${BUILDDIR}/install/AthenaExternals/${NICOS_PROJECT_VERSION}/InstallArea;ls)
+
+# Read in the tag/branch to use for Gaudi:
+GaudiVersion=$(awk '/^GaudiVersion/{print $3}' ${thisdir}/externals.txt)
+
+# Check out Gaudi from the right branch/tag:
+${scriptsdir}/checkout_Gaudi.sh \
+    -t ${GaudiVersion} \
+    -s ${BUILDDIR}/src/GAUDI
+
+# Build Gaudi:
+export NICOS_PROJECT_HOME=$(cd ${BUILDDIR}/install;pwd)/Gaudi
+${scriptsdir}/build_Gaudi.sh \
+    -s ${BUILDDIR}/src/GAUDI \
+    -b ${BUILDDIR}/build/GAUDI \
+    -i ${BUILDDIR}/install/GAUDI/${NICOS_PROJECT_VERSION} \
+    -e ${BUILDDIR}/install/AthenaExternals/${NICOS_PROJECT_VERSION}/InstallArea/${platform} \
+    -p AthenaExternals -f ${platform} \
+    -r ${BUILDDIR} -t ${BUILDTYPE}
diff --git a/Projects/Athena/externals.txt b/Projects/Athena/externals.txt
new file mode 100644
index 0000000000000000000000000000000000000000..41aaab97057b9912f6662d5250a1697e1e12f8c8
--- /dev/null
+++ b/Projects/Athena/externals.txt
@@ -0,0 +1,5 @@
+# Versions of the various externals to build before starting the build of
+# this project, when doing a full stack nightly build.
+
+AthenaExternalsVersion = master
+GaudiVersion = v28r0.004
diff --git a/Projects/Athena/package_filters.txt b/Projects/Athena/package_filters.txt
new file mode 100644
index 0000000000000000000000000000000000000000..55da4f6938eb8bb0dc156ebee544c5c3abb021d5
--- /dev/null
+++ b/Projects/Athena/package_filters.txt
@@ -0,0 +1,20 @@
+# Package filtering rules for the Athena project build.
+#
+# Only pick up a few packages from the External directory:
++External/AtlasDataArea
++External/pyAMI
++External/FWDet/TwissFiles
++External/Herwigpp
++External/AtlasMKL
+-External
+# Only pick up the RunTime packages from Projects:
++Projects/.*RunTime
+-Projects
+# Remove HLT and Java requiring packages:
+-HLT
+-Trigger/TrigConfiguration/TrigDb
+-Trigger/TrigConfiguration/TriggerTool
+
+# Offload service has build problems
+-External/APEGlue
+-Offloading
diff --git a/Projects/Athena/version.txt b/Projects/Athena/version.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1d975bef24600397fac77d1374026127c59eb85f
--- /dev/null
+++ b/Projects/Athena/version.txt
@@ -0,0 +1 @@
+22.0.0
diff --git a/Reconstruction/Jet/JetSubStructureUtils/CMakeLists.txt b/Reconstruction/Jet/JetSubStructureUtils/CMakeLists.txt
index 7ed6d8ce73d3a5c117797dac085e1507040b8c6d..b9b38474e07599dd7b601fc96bece4b59fab2bfb 100644
--- a/Reconstruction/Jet/JetSubStructureUtils/CMakeLists.txt
+++ b/Reconstruction/Jet/JetSubStructureUtils/CMakeLists.txt
@@ -6,31 +6,45 @@
 atlas_subdir( JetSubStructureUtils )
 
 # Declare the package's dependencies:
-atlas_depends_on_subdirs( PUBLIC
-                          Event/xAOD/xAODJet
-                          Event/xAOD/xAODMuon
-                          PhysicsAnalysis/MuonID/MuonSelectorTools
-                          Reconstruction/Jet/JetEDM
-                          PRIVATE
-                          Tools/PathResolver )
+atlas_depends_on_subdirs(
+   PUBLIC
+   Event/xAOD/xAODJet
+   Event/xAOD/xAODMuon
+   PhysicsAnalysis/MuonID/MuonSelectorTools
+   Reconstruction/Jet/JetEDM
+   PRIVATE
+   Tools/PathResolver )
 
 # External dependencies:
 find_package( FastJet )
-find_package( FastJetContrib )
-find_package( ROOT COMPONENTS Matrix RooFit Core Tree MathCore Hist RIO pthread )
+find_package( FastJetContrib COMPONENTS Nsubjettiness EnergyCorrelator )
+find_package( ROOT COMPONENTS Matrix Core MathCore Physics )
 find_package( ShowerDeconstruction )
 
+# If ShowerDeconstruction is not found, like in standalone mode, then
+# build the library without it.
+set( SHOWERDECONSTRUCTION_DEFINES )
+if( NOT SHOWERDECONSTRUCTION_FOUND )
+   set( SHOWERDECONSTRUCTION_INCLUDE_DIRS )
+   set( SHOWERDECONSTRUCTION_LIBRARIES )
+   set( SHOWERDECONSTRUCTION_DEFINES -DNO_SHOWERDECONSTRUCTION )
+endif()
+
 # Component(s) in the package:
 atlas_add_library( JetSubStructureUtils
-                   Root/*.cxx
-                   PUBLIC_HEADERS JetSubStructureUtils
-                   INCLUDE_DIRS ${FASTJET_INCLUDE_DIRS} ${FASTJETCONTRIB_INCLUDE_DIRS} ${SHOWERDECONSTRUCTION_INCLUDE_DIRS}
-                   PRIVATE_INCLUDE_DIRS ${ROOT_INCLUDE_DIRS}
-                   LINK_LIBRARIES ${FASTJET_LIBRARIES} ${FASTJETCONTRIB_LIBRARIES} ${SHOWERDECONSTRUCTION_LIBRARIES} xAODJet xAODMuon JetEDM MuonSelectorToolsLib
-                   PRIVATE_LINK_LIBRARIES ${ROOT_LIBRARIES} PathResolver )
+   JetSubStructureUtils/*.h Root/*.cxx
+   PUBLIC_HEADERS JetSubStructureUtils
+   INCLUDE_DIRS ${FASTJET_INCLUDE_DIRS} ${FASTJETCONTRIB_INCLUDE_DIRS}
+   ${SHOWERDECONSTRUCTION_INCLUDE_DIRS}
+   PRIVATE_INCLUDE_DIRS ${ROOT_INCLUDE_DIRS}
+   LINK_LIBRARIES ${FASTJET_LIBRARIES} ${FASTJETCONTRIB_LIBRARIES}
+   ${SHOWERDECONSTRUCTION_LIBRARIES} xAODJet xAODMuon JetEDM
+   MuonSelectorToolsLib
+   PRIVATE_LINK_LIBRARIES ${ROOT_LIBRARIES} PathResolver
+   DEFINITIONS ${SHOWERDECONSTRUCTION_DEFINES} )
 
 # Install files from the package:
 atlas_install_generic( data/*.dat
-                       DESTINATION XML/JetSubStructureUtils/data
-                       EXECUTABLE )
-
+   DESTINATION XML/JetSubStructureUtils/data
+   EXECUTABLE )
+atlas_install_data( data/*.dat )
diff --git a/Reconstruction/Jet/JetSubStructureUtils/Root/ShowerDeconstruction.cxx b/Reconstruction/Jet/JetSubStructureUtils/Root/ShowerDeconstruction.cxx
index f38260a9f9bdb1c78d5d54a00cb024b3be992dac..29f6955d556f26e860d726d8355ea7d1e182cd47 100644
--- a/Reconstruction/Jet/JetSubStructureUtils/Root/ShowerDeconstruction.cxx
+++ b/Reconstruction/Jet/JetSubStructureUtils/Root/ShowerDeconstruction.cxx
@@ -4,17 +4,14 @@
 
 #include "JetSubStructureUtils/ShowerDeconstruction.h"
 
-#if defined(ROOTCORE)
-#include <RootCore/Packages.h>
-#endif
-#if defined(ROOTCORE_PACKAGE_AtlasShowerDeconstructionRootCore) || !defined(ROOTCORE)
+#ifndef NO_SHOWERDECONSTRUCTION
 #include <Deconstruct.h>
 #include <AnalysisParameters.h>
 #include <TopGluonModel.h>
 #include <WDecayModel.h>
 #include <BackgroundModel.h>
 #include <ISRModel.h>
-#endif
+#endif // NOT NO_SHOWERDECONSTRUCTION
 
 #include <fastjet/ClusterSequence.hh>
 #include "xAODJet/Jet.h"
@@ -33,7 +30,7 @@ ShowerDeconstruction::ShowerDeconstruction(SignalModel signalModel)
   m_isrModel = 0;
   m_deconstruct = 0;
 
-#if defined(ROOTCORE_PACKAGE_AtlasShowerDeconstructionRootCore) || !defined(ROOTCORE)
+#ifndef NO_SHOWEDECONSTRUCTION
   m_param = new AnalysisParameters();
   (*m_param)["R"] = 1.0;
   (*m_param)["lambda_mu_ext"] = 1.0;
@@ -68,19 +65,19 @@ ShowerDeconstruction::ShowerDeconstruction(SignalModel signalModel)
   }
 
   m_deconstruct = new Deconstruction::Deconstruct(*m_param, *sigModelPtr, *m_bkgModel, *m_isrModel);
-#endif
+#endif // NOT NO_SHOWERDECONSTRUCTION
 }
 
 ShowerDeconstruction::~ShowerDeconstruction()
 {
-#if defined(ROOTCORE_PACKAGE_AtlasShowerDeconstructionRootCore) || !defined(ROOTCORE)
+#ifndef NO_SHOWERDECONSTRUCTION
   if (m_param) delete m_param;
   if (m_topModel) delete m_topModel;
   if (m_WModel) delete m_WModel;
   if (m_bkgModel) delete m_bkgModel;
   if (m_isrModel) delete m_isrModel;
   if (m_deconstruct) delete m_deconstruct;
-#endif
+#endif // NOT NO_SHOWERDECONSTRUCTION
 }
 
 double ShowerDeconstruction::result(const xAOD::Jet &jet)
@@ -92,7 +89,7 @@ double ShowerDeconstruction::result(const xAOD::Jet &jet)
 
 double ShowerDeconstruction::result(const fastjet::PseudoJet &jet, const float R)
 {
-#if defined(ROOTCORE_PACKAGE_AtlasShowerDeconstructionRootCore) || !defined(ROOTCORE)
+#ifndef NO_SHOWERDECONSTRUCTION
   if(jet.constituents().size() == 0) return -999;
 
   (*m_param)["R"] = R;
@@ -124,6 +121,5 @@ double ShowerDeconstruction::result(const fastjet::PseudoJet &jet, const float R
   return lchi;
 #else
   return -999;
-#endif
+#endif // NOT NO_SHOWERDECONSTRUCTION
 }
-
diff --git a/Simulation/ISF/ISF_Core/ISF_Algorithms/CMakeLists.txt b/Simulation/ISF/ISF_Core/ISF_Algorithms/CMakeLists.txt
index 40085d649aa8b3ca73cd16a85a1adcbf3c1b3dc9..72f93b25f773f4c962f2e79e92c03d7a70612120 100644
--- a/Simulation/ISF/ISF_Core/ISF_Algorithms/CMakeLists.txt
+++ b/Simulation/ISF/ISF_Core/ISF_Algorithms/CMakeLists.txt
@@ -34,7 +34,7 @@ atlas_add_component( ISF_Algorithms
                      src/*.cxx
                      src/components/*.cxx
                      INCLUDE_DIRS ${Boost_INCLUDE_DIRS} ${ROOT_INCLUDE_DIRS}
-                     LINK_LIBRARIES ${Boost_LIBRARIES} ${ROOT_LIBRARIES} GaudiKernel AthenaBaseComps StoreGate CxxUtils AtlasDetDescr GeneratorObjects ISF_Event ISF_Interfaces PmbCxxUtils InDetSimEvent LArSimEvent TileSimEvent MuonSimEvent )
+                     LINK_LIBRARIES ${Boost_LIBRARIES} ${ROOT_LIBRARIES} GaudiKernel AthenaBaseComps StoreGateLib CxxUtils AtlasDetDescr GeneratorObjects ISF_Event ISF_Interfaces PmbCxxUtils InDetSimEvent LArSimEvent TileSimEvent MuonSimEvent )
 
 atlas_add_test( CollectionMerger_test
                 SOURCES test/CollectionMerger_test.cxx src/*.cxx
diff --git a/Tools/CodeCheck/CMakeLists.txt b/Tools/CodeCheck/CMakeLists.txt
index 300e13e81e3743c9ae19817768627ade970dd41d..45fde9ae1508ede35c9b4b0db3d0511448139fb6 100644
--- a/Tools/CodeCheck/CMakeLists.txt
+++ b/Tools/CodeCheck/CMakeLists.txt
@@ -4,7 +4,3 @@
 
 # Declare the package name:
 atlas_subdir( CodeCheck )
-
-athena_env( SET atlas_checker_command \"\"
-            SET atlas_patch_command \"\" )
-
diff --git a/Tools/JobTransforms/CMakeLists.txt b/Tools/JobTransforms/CMakeLists.txt
index 842c57f41441ef04d6647ca3835b377907536f35..d7d8fedbbc6087973238ff57bfb52d6d99845d79 100644
--- a/Tools/JobTransforms/CMakeLists.txt
+++ b/Tools/JobTransforms/CMakeLists.txt
@@ -7,7 +7,3 @@ atlas_subdir( JobTransforms )
 
 # External dependencies:
 find_package( PythonLibs )
-
-athena_env( SET T_INCPATH \\\${CMTINSTALLAREA}/share/JT/include
-            SET T_RELEASE \\\${JobTransforms_project_release} )
-
diff --git a/Tools/Scripts/CMakeLists.txt b/Tools/Scripts/CMakeLists.txt
index 97ca5f0fe92665d72588d32701e237213f56d72a..864556a2ed25f44239006e99c714bf6550998224 100644
--- a/Tools/Scripts/CMakeLists.txt
+++ b/Tools/Scripts/CMakeLists.txt
@@ -9,8 +9,7 @@ atlas_subdir( Scripts )
 # setup_script $(SETUPCOMPLETIONROOT)/cmt/completion/setup_completion_main
 
 # Install files from the package:
-atlas_install_scripts( share/get_joboptions share/get_files share/lookup_local_joboptions.sh share/lookup_joboptions.sh share/lookup_scripts.sh share/lookup_xmls.sh share/lookup_data.sh share/checkDbgSymbols.sh )
-
-athena_env( SET DO_EXT_ATHENA_TAB_COMPLETION 0
-            SET SETUPCOMPLETIONROOT \\\${SCRIPTSROOT} )
-
+atlas_install_scripts( share/get_joboptions share/get_files
+   share/lookup_local_joboptions.sh share/lookup_joboptions.sh
+   share/lookup_scripts.sh share/lookup_xmls.sh share/lookup_data.sh
+   share/checkDbgSymbols.sh )
diff --git a/Trigger/TrigL1Upgrade/TrigL1CaloUpgrade/CMakeLists.txt b/Trigger/TrigL1Upgrade/TrigL1CaloUpgrade/CMakeLists.txt
index 5b1a6a358726adc871be7308fadb1c087929ee45..fc2d7bd7b00a294832e0f218611ea4198727afac 100644
--- a/Trigger/TrigL1Upgrade/TrigL1CaloUpgrade/CMakeLists.txt
+++ b/Trigger/TrigL1Upgrade/TrigL1CaloUpgrade/CMakeLists.txt
@@ -32,7 +32,7 @@ atlas_add_component( TrigL1CaloUpgrade
                      src/*.cxx
                      src/components/*.cxx
                      INCLUDE_DIRS ${ROOT_INCLUDE_DIRS}
-                     LINK_LIBRARIES ${ROOT_LIBRARIES} GaudiKernel CaloDetDescrLib CaloEvent CaloIdentifier AthenaBaseComps xAODEgamma xAODTracking xAODTrigCalo xAODTrigL1Calo xAODTrigger xAODTruth LArRawEvent LArTools LArCabling )
+                     LINK_LIBRARIES ${ROOT_LIBRARIES} GaudiKernel CaloDetDescrLib CaloEvent CaloIdentifier AthenaBaseComps xAODEgamma xAODTracking xAODTrigCalo xAODTrigL1Calo xAODTrigger xAODTruth LArRawEvent LArToolsLib LArCablingLib )
 
 # Install files from the package:
 atlas_install_python_modules( python/*.py )
diff --git a/graphics/AtlantisJava/CMakeLists.txt b/graphics/AtlantisJava/CMakeLists.txt
index dbdecf499942302acba7d0e4a47917ac8321ada1..7d9ae4dd60085d27fe898ae42a7229607783a2fc 100644
--- a/graphics/AtlantisJava/CMakeLists.txt
+++ b/graphics/AtlantisJava/CMakeLists.txt
@@ -6,7 +6,7 @@
 atlas_subdir( AtlantisJava )
 
 # External dependencies:
-find_package( JavaSDK )
+find_package( Java )
 
 # Install files from the package:
 atlas_install_joboptions( share/InteractiveServer.py )
@@ -29,6 +29,3 @@ atlas_install_generic( geometry/*.xml
 atlas_install_generic( help/help.jar help/online.xml help/*.png
                        DESTINATION "share/AtlantisJava/help"
                        EXECUTABLE )
-
-athena_env( SET ANT_OPTS "-Xms64m -Xmx64m" )
-