diff --git a/CMakeLists.txt b/CMakeLists.txt
index a315542..8f8c29c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,311 +1,310 @@
 #-----------------------------------------------------------------------------
 # This is the root RTToolbox CMakeList file.
 #-----------------------------------------------------------------------------
 PROJECT(RTToolbox)
 
 CMAKE_MINIMUM_REQUIRED(VERSION 3.1)
 
 # RTToolbox version number.
 SET(RTToolbox_VERSION_MAJOR "5")
 SET(RTToolbox_VERSION_MINOR "1")
 SET(RTToolbox_VERSION_PATCH "0")
 
 # Version string should not include patch level.  The major.minor is
 # enough to distinguish available features of the toolbox.
 SET(RTToolbox_VERSION_STRING "${RTToolbox_VERSION_MAJOR}.${RTToolbox_VERSION_MINOR}")
 SET(RTToolbox_FULL_VERSION_STRING "${RTToolbox_VERSION_MAJOR}.${RTToolbox_VERSION_MINOR}.${RTToolbox_VERSION_PATCH}")
 
 # default build type
 SET(CMAKE_BUILD_TYPE Release)
 
 MARK_AS_ADVANCED(BUILD_SHARED_LIBS)
 
 IF (WIN32)
 	IF (MSVC_VERSION LESS 1800)
 		MESSAGE(FATAL_ERROR "RTToolbox requires at least Visual Studio 2013.")
 	ELSEIF (MSVC_VERSION GREATER_EQUAL 1910)
 		IF (${CMAKE_VERSION} VERSION_LESS "3.10.3")
 			MESSAGE(AUTHOR_WARNING "Please use CMake version 3.10.3 or newer for Visual Studio 2017 as new boost versions are not recognized using old CMake versions.")
 		ENDIF()
 	ENDIF()
 	add_definitions(-D_SCL_SECURE_NO_WARNINGS)
 ELSE (WIN32)
 	IF (CMAKE_COMPILER_IS_GNUCC)
-		IF (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.4 OR CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 6.0)
-			MESSAGE(AUTHOR_WARNING "RTToolbox was only tested with GCC 5.4. You are using GCC " ${CMAKE_CXX_COMPILER_VERSION} ". This compiler version might not work.")
-		ENDIF()
+		IF (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.0 OR CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 7.3)
+			MESSAGE(AUTHOR_WARNING "RTToolbox was tested with GCC 5 and GCC 7 only. You are using GCC " ${CMAKE_CXX_COMPILER_VERSION} ". You might need to change some code in order to compile RT Toolbox.")
 	ELSE()
 		MESSAGE(AUTHOR_WARNING "RTToolbox was only tested with GCC. This compiler might not work.")	
 	ENDIF()
 ENDIF(WIN32)
 
 #-----------------------------------------------------------------------------
 # CMake Function(s) and Macro(s)
 #-----------------------------------------------------------------------------
 
 include(cmake/MacroParseArguments.cmake)
 include(cmake/rttbMacroCreateModuleConf.cmake)
 include(cmake/rttbMacroCreateModule.cmake)
 include(cmake/rttbMacroCreateApplication.cmake)
 include(cmake/rttbMacroCheckModule.cmake)
 include(cmake/rttbMacroUseModule.cmake)
 include(cmake/rttbMacroCreateTestModule.cmake)
 include(cmake/rttbFunctionOrganizeSources.cmake)
 include(cmake/rttbMacroCreateApplicationTests.cmake)
 
 #-----------------------------------------------------------------------------
 # Basis config RTTB module infrastructure
 #-----------------------------------------------------------------------------
 
 set(RTTB_MODULES_CONF_DIR ${RTToolbox_BINARY_DIR}/modulesConf CACHE INTERNAL "Modules Conf")
 set(RTTB_MODULES_PACKAGE_DEPENDS_DIR ${RTToolbox_SOURCE_DIR}/cmake/PackageDepends)
 set(MODULES_PACKAGE_DEPENDS_DIRS ${RTTB_MODULES_PACKAGE_DEPENDS_DIR})
 
 #-----------------------------------------------------------------------------
 # Testing setup
 # Configure Dart testing support.  This should be done before any
 # MESSAGE(FATAL_ERROR ...) commands are invoked.
 #-----------------------------------------------------------------------------
 #build no tests as default
 OPTION(BUILD_TESTING "build tests" OFF)
 
 IF(BUILD_TESTING)
 SET(CTEST_NEW_FORMAT 1)
 INCLUDE(CTest)
 ENABLE_TESTING()
 
 
   CONFIGURE_FILE(${RTToolbox_SOURCE_DIR}/cmake/RemoveTemporaryFiles.cmake.in
     ${RTToolbox_BINARY_DIR}/cmake/RemoveTemporaryFiles.cmake @ONLY IMMEDIATE)
   CONFIGURE_FILE(${RTToolbox_SOURCE_DIR}/cmake/rttbSampleBuildTest.cmake.in
     ${RTToolbox_BINARY_DIR}/cmake/rttbSampleBuildTest.cmake @ONLY)
   CONFIGURE_FILE(${RTToolbox_SOURCE_DIR}/cmake/CTestCustom.ctest.in
     ${RTToolbox_BINARY_DIR}/cmake/CTestCustom.ctest @ONLY)
   FILE(WRITE ${RTToolbox_BINARY_DIR}/CTestCustom.cmake
     "INCLUDE(\"${RTToolbox_BINARY_DIR}/cmake/CTestCustom.ctest\")\n")
 
   SET(BUILDNAME "${BUILDNAME}" CACHE STRING "Name of build on the dashboard")
   MARK_AS_ADVANCED(BUILDNAME)
 ENDIF(BUILD_TESTING)
 
 #-----------------------------------------------------------------------------
 # Output directories.
 #-----------------------------------------------------------------------------
 
 IF(NOT LIBRARY_OUTPUT_PATH)
   SET (LIBRARY_OUTPUT_PATH ${RTToolbox_BINARY_DIR}/bin CACHE PATH "Single output directory for building all libraries.")
 ENDIF(NOT LIBRARY_OUTPUT_PATH)
 IF(NOT EXECUTABLE_OUTPUT_PATH)
   SET (EXECUTABLE_OUTPUT_PATH ${RTToolbox_BINARY_DIR}/bin CACHE PATH "Single output directory for building all executables.")
 ENDIF(NOT EXECUTABLE_OUTPUT_PATH)
 MARK_AS_ADVANCED(EXECUTABLE_OUTPUT_PATH LIBRARY_OUTPUT_PATH)
 
 
 MARK_AS_ADVANCED(LIBRARY_OUTPUT_PATH EXECUTABLE_OUTPUT_PATH)
 SET(RTToolbox_LIBRARY_PATH "${LIBRARY_OUTPUT_PATH}")
 SET(RTToolbox_EXECUTABLE_PATH "${EXECUTABLE_OUTPUT_PATH}")
 
 #-----------------------------------------------------------------------------
 # Find Doxygen.
 #-----------------------------------------------------------------------------
 FIND_PROGRAM(DOXYGEN_EXECUTABLE "doxygen")
 
 #-----------------------------------------------------------------------------
 # Installation vars.
 # RTToolbox_INSTALL_BIN_DIR          - binary dir (executables)
 # RTToolbox_INSTALL_LIB_DIR          - library dir (libs)
 # RTToolbox_INSTALL_INCLUDE_DIR      - include dir (headers)
 # RTToolbox_INSTALL_NO_DEVELOPMENT   - do not install development files
 # RTToolbox_INSTALL_NO_RUNTIME       - do not install runtime files
 # RTToolbox_INSTALL_NO_DOCUMENTATION - do not install documentation files
 #-----------------------------------------------------------------------------
 
 IF(NOT RTTOOLBOX_INSTALL_BIN_DIR)
   SET(RTTOOLBOX_INSTALL_BIN_DIR "bin")
 ENDIF(NOT RTTOOLBOX_INSTALL_BIN_DIR)
 
 IF(NOT RTTOOLBOX_INSTALL_LIB_DIR)
   SET(RTTOOLBOX_INSTALL_LIB_DIR "lib")
 ENDIF(NOT RTTOOLBOX_INSTALL_LIB_DIR)
 
 IF(NOT RTTOOLBOX_INSTALL_PACKAGE_DIR)
   SET(RTTOOLBOX_INSTALL_PACKAGE_DIR "lib")
 ENDIF(NOT RTTOOLBOX_INSTALL_PACKAGE_DIR)
 
 IF(NOT RTTOOLBOX_INSTALL_INCLUDE_DIR)
   SET(RTTOOLBOX_INSTALL_INCLUDE_DIR "include")
 ENDIF(NOT RTTOOLBOX_INSTALL_INCLUDE_DIR)
 
 IF(NOT RTTOOLBOX_INSTALL_NO_DEVELOPMENT)
   SET(RTTOOLBOX_INSTALL_NO_DEVELOPMENT 0)
 ENDIF(NOT RTTOOLBOX_INSTALL_NO_DEVELOPMENT)
 
 IF(NOT RTTOOLBOX_INSTALL_NO_RUNTIME)
   SET(RTTOOLBOX_INSTALL_NO_RUNTIME 0)
 ENDIF(NOT RTTOOLBOX_INSTALL_NO_RUNTIME)
 
 IF(NOT RTTOOLBOX_INSTALL_NO_DOCUMENTATION)
   SET(RTTOOLBOX_INSTALL_NO_DOCUMENTATION 0)
 ENDIF(NOT RTTOOLBOX_INSTALL_NO_DOCUMENTATION)
 
 SET(RTTOOLBOX_INSTALL_NO_LIBRARIES)
 IF(RTTOOLBOX_BUILD_SHARED_LIBS)
   IF(RTTOOLBOX_INSTALL_NO_RUNTIME AND RTTOOLBOX_INSTALL_NO_DEVELOPMENT)
     SET(RTTOOLBOX_INSTALL_NO_LIBRARIES 1)
   ENDIF(RTTOOLBOX_INSTALL_NO_RUNTIME AND RTTOOLBOX_INSTALL_NO_DEVELOPMENT)
 ELSE(RTTOOLBOX_BUILD_SHARED_LIBS)
   IF(RTTOOLBOX_INSTALL_NO_DEVELOPMENT)
     SET(RTTOOLBOX_INSTALL_NO_LIBRARIES 1)
   ENDIF(RTTOOLBOX_INSTALL_NO_DEVELOPMENT)
 ENDIF(RTTOOLBOX_BUILD_SHARED_LIBS)
 
 # set RTToolbox_DIR so it can be used by subprojects
 SET(RTToolbox_DIR "${CMAKE_BINARY_DIR}" CACHE INTERNAL "RTToolbox dir to be used by subprojects")
 
 #-----------------------------------------------------------------------------
 # DCMTK MT-Flag treat
 #-----------------------------------------------------------------------------
 option(RTTB_DCMTK_COMPLIANCE_ENFORCE_MT "This enforces the whole RTToolbox to be compiled with /MT,/MTd to be compliant with DCMTK" OFF)
 
 string(FIND ${CMAKE_GENERATOR} "Visual Studio" RTTB_VS_USED)
 
 if(RTTB_DCMTK_COMPLIANCE_ENFORCE_MT AND RTTB_VS_USED EQUAL 0)
   message(STATUS "Enforce DCMTK compliance: /MT and /MTd flags are used")
 
   string(REPLACE "/MD" "/MT" CMAKE_C_FLAGS_DEBUG ${CMAKE_C_FLAGS_DEBUG})
   message(STATUS "CMAKE_C_FLAGS_DEBUG set to: ${CMAKE_C_FLAGS_DEBUG}")
   string(REPLACE "/MD" "/MT" CMAKE_C_FLAGS_RELEASE ${CMAKE_C_FLAGS_RELEASE})
   message(STATUS "CMAKE_C_FLAGS_RELEASE set to: ${CMAKE_C_FLAGS_RELEASE}")
   string(REPLACE "/MD" "/MT" CMAKE_C_FLAGS_MINSIZEREL ${CMAKE_C_FLAGS_MINSIZEREL})
   message(STATUS "CMAKE_C_FLAGS_MINSIZEREL set to: ${CMAKE_C_FLAGS_MINSIZEREL}")
   string(REPLACE "/MD" "/MT" CMAKE_C_FLAGS_RELWITHDEBINFO ${CMAKE_C_FLAGS_RELWITHDEBINFO})
   message(STATUS "CMAKE_C_FLAGS_RELWITHDEBINFO set to: ${CMAKE_C_FLAGS_RELWITHDEBINFO}")
 
   string(REPLACE "/MD" "/MT" CMAKE_CXX_FLAGS_DEBUG ${CMAKE_CXX_FLAGS_DEBUG})
   message(STATUS "CMAKE_CXX_FLAGS_DEBUG set to: ${CMAKE_CXX_FLAGS_DEBUG}")
   string(REPLACE "/MD" "/MT" CMAKE_CXX_FLAGS_RELEASE ${CMAKE_CXX_FLAGS_RELEASE})
   message(STATUS "CMAKE_CXX_FLAGS_RELEASE set to: ${CMAKE_CXX_FLAGS_RELEASE}")
   string(REPLACE "/MD" "/MT" CMAKE_CXX_FLAGS_MINSIZEREL ${CMAKE_CXX_FLAGS_MINSIZEREL})
   message(STATUS "CMAKE_CXX_FLAGS_MINSIZEREL set to: ${CMAKE_CXX_FLAGS_MINSIZEREL}")
   string(REPLACE "/MD" "/MT" CMAKE_CXX_FLAGS_RELWITHDEBINFO ${CMAKE_CXX_FLAGS_RELWITHDEBINFO})
   message(STATUS "CMAKE_CXX_FLAGS_RELWITHDEBINFO set to: ${CMAKE_CXX_FLAGS_RELWITHDEBINFO}")  
 endif()
 
 #-----------------------------------------------------------------------------
 # Advanced RTToolbox configuration
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # RTToolbox build configuration options.
 
 IF (NOT RTTB_CXX_STANDARD)
  set(RTTB_CXX_STANDARD 11)
 ENDIF (NOT RTTB_CXX_STANDARD)
 
 set(CMAKE_CXX_STANDARD ${RTTB_CXX_STANDARD} CACHE STRING "")
 set(CMAKE_CXX_STANDARD_REQUIRED 1)
 OPTION(CMAKE_CXX_EXTENSIONS "" ON)
 MARK_AS_ADVANCED(CMAKE_CXX_STANDARD CMAKE_CXX_STANDARD_REQUIRED CMAKE_CXX_EXTENSIONS)
 
 IF (WIN32)
   OPTION(BUILD_SHARED_LIBS "Build RTToolbox with shared libraries." OFF)
 ELSE (WIN32)
   OPTION(BUILD_SHARED_LIBS "Build RTToolbox with shared libraries." ON)
 ENDIF (WIN32)
 
 IF(NOT BUILD_SHARED_LIBS)
   IF(UNIX)
   MESSAGE(FATAL_ERROR "RTToolbox currently does not support a static build on unix like systems. We are working on that...")
   ENDIF(UNIX)
 ENDIF(NOT BUILD_SHARED_LIBS)
 
 SET(RTTB_BUILD_SHARED_LIBS ${BUILD_SHARED_LIBS})
 
 #Raise warning level (MSVC has W3 default warning level)
 IF (WIN32)
 	IF(NOT BUILD_SHARED_LIBS)
 		set(CMAKE_CXX_FLAGS "/W4 /EHsc")
 	ENDIF()
 ELSE()
 	IF (CMAKE_COMPILER_IS_GNUCC)
 		set(CMAKE_CXX_FLAGS "-Wall")
 	ENDIF()
 ENDIF()
 
 IF(NOT RTToolbox_NO_LIBRARY_VERSION)
   # This setting of SOVERSION assumes that any API change
   # will increment either the minor or major version number of RTToolbox.
   SET(RTToolbox_LIBRARY_PROPERTIES 
       VERSION   "${RTToolbox_VERSION_MAJOR}.${RTToolbox_VERSION_MINOR}.${RTToolbox_VERSION_PATCH}"
       SOVERSION "${RTToolbox_VERSION_MAJOR}.${RTToolbox_VERSION_MINOR}"
      )
 ENDIF(NOT RTToolbox_NO_LIBRARY_VERSION)
 
 #-----------------------------------------------------------------------------
 # Configure files with settings for use by the build.
 # 
 #-----------------------------------------------------------------------------
 
 CONFIGURE_FILE(${RTToolbox_SOURCE_DIR}/RTToolboxConfigure.h.in 
   ${RTToolbox_BINARY_DIR}/RTToolboxConfigure.h)
   
 IF(NOT RTTOOLBOX_INSTALL_NO_DEVELOPMENT)
   INSTALL(FILES ${RTToolbox_BINARY_DIR}/RTToolboxConfigure.h
     DESTINATION ${RTTOOLBOX_INSTALL_INCLUDE_DIR}
     COMPONENT Development)
 ENDIF(NOT RTTOOLBOX_INSTALL_NO_DEVELOPMENT)
 
 #-----------------------------------------------------------------------------
 # The entire RTToolbox tree should use the same include path
 #-----------------------------------------------------------------------------
 
 #Default include dir. Others dirs will be defined by activated subprojects
 INCLUDE_DIRECTORIES(${RTToolbox_BINARY_DIR})
 
 LINK_DIRECTORIES(${LIBARY_OUTPUT_PATH})
 
 #Prepare the correct target information export by the subprojects
 SET(RTToolbox_TARGETS_FILE "${RTToolbox_BINARY_DIR}/RTToolboxTargets.cmake")
 FILE(WRITE ${RTToolbox_TARGETS_FILE} "# Generated by CMake, do not edit!")
 
 #-----------------------------------------------------------------------------
 # Dispatch the build into the proper subdirectories.
 #-----------------------------------------------------------------------------
 
 OPTION(BUILD_All_Modules "All modules will be built" OFF)
 
 OPTION(BUILD_Apps "Determine if the CLI applications will be generated." OFF)
 MESSAGE (STATUS "generating Project RTToolbox")
 ADD_SUBDIRECTORY (code)
 IF (BUILD_Apps)
 	ADD_SUBDIRECTORY (apps)
 ENDIF()
 
 IF (BUILD_TESTING)
   ADD_SUBDIRECTORY (testing)
 ENDIF (BUILD_TESTING)
 
 ADD_SUBDIRECTORY (documentation)
 
 #-----------------------------------------------------------------------------
 # Help other projects use RTToolbox.
 #-----------------------------------------------------------------------------
 
 EXPORT(PACKAGE RTToolbox)
 
 # Create the RTToolboxConfig.cmake file containing the RTToolbox configuration.
 INCLUDE (${RTToolbox_SOURCE_DIR}/rttbGenerateRTToolboxConfig.cmake)
 
 IF(NOT RTToolbox_INSTALL_NO_DEVELOPMENT)
 	INSTALL(FILES
 		${RTToolbox_BINARY_DIR}/RTToolboxConfig.cmake
 		DESTINATION ${RTTOOLBOX_INSTALL_PACKAGE_DIR}
 		COMPONENT Development
     )
 	INSTALL(EXPORT RTToolboxTargets 
 		FILE RTToolboxTargets.cmake
 		DESTINATION ${RTTOOLBOX_INSTALL_PACKAGE_DIR}
 		COMPONENT Development
 
     )
 ENDIF(NOT RTToolbox_INSTALL_NO_DEVELOPMENT)
diff --git a/testing/examples/RTBioModelScatterPlotExampleTest.cpp b/testing/examples/RTBioModelScatterPlotExampleTest.cpp
index a70f583..b4d5664 100644
--- a/testing/examples/RTBioModelScatterPlotExampleTest.cpp
+++ b/testing/examples/RTBioModelScatterPlotExampleTest.cpp
@@ -1,479 +1,479 @@
 // -----------------------------------------------------------------------
 // RTToolbox - DKFZ radiotherapy quantitative evaluation library
 //
 // Copyright (c) German Cancer Research Center (DKFZ),
 // Software development for Integrated Diagnostics and Therapy (SIDT).
 // ALL RIGHTS RESERVED.
 // See rttbCopyright.txt or
 // http://www.dkfz.de/en/sidt/projects/rttb/copyright.html [^]
 //
 // This software is distributed WITHOUT ANY WARRANTY; without even
 // the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 // PURPOSE. See the above copyright notices for more information.
 //
 //------------------------------------------------------------------------
 /*!
 // @file
 // @version $Revision$ (last changed revision)
 // @date $Date$ (last change date)
 // @author $Author$ (last changed by)
 */
 
 // this file defines the rttbCoreTests for the test driver
 // and all it expects is that you have a function called RegisterTests
 
 #include <boost/shared_ptr.hpp>
 
 #include "litCheckMacros.h"
 #include "rttbBioModel.h"
 #include "rttbDVH.h"
 #include "rttbTCPLQModel.h"
 #include "rttbNTCPLKBModel.h"
 #include "rttbNTCPRSModel.h"
 #include "rttbBioModelScatterPlots.h"
 #include "rttbBioModelCurve.h"
 #include "rttbDvhBasedModels.h"
 #include "../models/rttbScatterTester.h"
 #include "rttbInvalidParameterException.h"
-#include "rttbDVHXmlFileReader.h"
+#include "rttbDVHXMLFileReader.h"
 
 namespace rttb
 {
 	namespace testing
 	{
 
 
 		/*! @brief RTBioModelScatterPlotExampleTest.
 		calculating Curves and Scatterplots for TCP and NTCP models.
 		The values on curve and scatterplot need to be similar for similar dose values.
 		The range of difference is given by the variance used to generate the scatter.
 
 		WARNING: The values for comparison need to be adjusted if the input files are changed!
 		*/
 		int RTBioModelScatterPlotExampleTest(int argc, char* argv[])
 		{
 			PREPARE_DEFAULT_TEST_REPORTING;
 
 			typedef rttb::models::CurveDataType CurveDataType;
 			typedef rttb::models::ScatterPlotType ScatterPlotType;
 			typedef core::DVH::Pointer DVHPointer;
 
 			//increased accuracy requires double values in the calculation (rttbBaseType.h)
 			double toleranceEUD = 1e-5;
 
 			//ARGUMENTS: 1: ptv dvh file name
 			//           2: normal tissue 1 dvh file name
 			//           3: TV dvh file name
 
 			std::string DVH_FILENAME_PTV;
 			std::string DVH_FILENAME_NT1;
 			std::string DVH_FILENAME_TV_TEST;
 
 			if (argc > 1)
 			{
 				DVH_FILENAME_PTV = argv[1];
 			}
 
 			if (argc > 2)
 			{
 				DVH_FILENAME_NT1 = argv[2];
 			}
 
 			if (argc > 3)
 			{
 				DVH_FILENAME_TV_TEST = argv[3];
 			}
 
 			//DVH PTV
 			rttb::io::other::DVHXMLFileReader dvhReader = rttb::io::other::DVHXMLFileReader(DVH_FILENAME_PTV);
 			DVHPointer dvhPtr = dvhReader.generateDVH();
 
 			rttb::io::other::DVHXMLFileReader dvhReader_test_tv = rttb::io::other::DVHXMLFileReader(
 			            DVH_FILENAME_TV_TEST);
 			DVHPointer dvh_test_tv = dvhReader_test_tv.generateDVH();
 
 			//test TCP LQ Model
 			models::BioModelParamType alpha = 0.35;
 			models::BioModelParamType beta = 0.023333333333333;
 			models::BioModelParamType roh = 10000000;
 			int numFractions = 2;
 
 			DoseTypeGy normalizationDose = 68;
 
 			rttb::models::TCPLQModel tcplq = rttb::models::TCPLQModel(dvhPtr, alpha, beta, roh, numFractions);
 
 			CHECK_NO_THROW(tcplq.init());
 
 			CurveDataType curve = models::getCurveDoseVSBioModel(tcplq, normalizationDose);
 
 			CHECK_NO_THROW(models::getScatterPlotVary1Parameter(tcplq, 0, alpha, 0, normalizationDose, 100));
 			ScatterPlotType tcpScatter = models::getScatterPlotVary1Parameter(tcplq, 0, alpha, 0,
 			                             normalizationDose, 100);
 			CHECK_EQUAL(100, tcpScatter.size());
 
 			ScatterTester scatterCompare(curve, tcpScatter);
 			CHECK_TESTER(scatterCompare);
 
 			//test also with other parameter
 			tcpScatter = models::getScatterPlotVary1Parameter(tcplq, 3, roh, 0, normalizationDose, 100);
 
 			scatterCompare.setCompareScatter(tcpScatter);
 			CHECK_TESTER(scatterCompare);
 
 			std::vector<int> paramIdVec;
 			models::BioModel::ParamVectorType meanVec;
 			models::BioModel::ParamVectorType meanVecTest;
 			meanVecTest.push_back(alpha);
 			models::BioModel::ParamVectorType varianceVec;
 			//"alphaMean":0,"alphaVariance":1,"alpha_beta":2, "rho":3
 			paramIdVec.push_back(0);
 			meanVec.push_back(tcplq.getAlphaMean());
 			varianceVec.push_back(0);
 			//setting parameter 1 will change the resulting scatter plot dramatically - is it meant to?
 			//this is unexpected since the value was taken from the original calculation
 			//paramIdVec.push_back(1); meanVec.push_back(tcplq.getAlphaVariance()); varianceVec.push_back(0);
 			paramIdVec.push_back(2);
 			meanVec.push_back(tcplq.getAlphaBeta());
 			varianceVec.push_back(0);
 			paramIdVec.push_back(3);
 			meanVec.push_back(tcplq.getRho());
 			varianceVec.push_back(0);
 
 			CHECK_THROW_EXPLICIT(models::getScatterPlotVaryParameters(tcplq, paramIdVec, meanVecTest,
 			                     varianceVec, normalizationDose, 50), core::InvalidParameterException);
 			ScatterPlotType scatterVary = models::getScatterPlotVaryParameters(tcplq, paramIdVec, meanVec,
 			                              varianceVec, normalizationDose, 50);
 			CHECK_EQUAL(50, scatterVary.size());
 
 			scatterCompare.setCompareScatter(scatterVary);
 			CHECK_TESTER(scatterCompare);
 
 			models::BioModelParamType variance = 0.00015;
 			CHECK_NO_THROW(models::getScatterPlotVary1Parameter(tcplq, 0, alpha, variance, normalizationDose,
 			               100));
 			tcpScatter = models::getScatterPlotVary1Parameter(tcplq, 0, alpha, variance, normalizationDose,
 			             100);
 
 			scatterCompare.setVariance(variance);
 			scatterCompare.setCompareScatter(tcpScatter);
 			//allow 5% of the points to deviate more
 			scatterCompare.setAllowExceptions(true);
 			CHECK_TESTER(scatterCompare);
 
 			//test also with other parameter
 			tcpScatter = models::getScatterPlotVary1Parameter(tcplq, 3, roh, variance, normalizationDose, 100);
 			scatterCompare.setCompareScatter(tcpScatter);
 			//allow 5% of the points to deviate more
 			scatterCompare.setAllowExceptions(true);
 			CHECK_TESTER(scatterCompare);
 
 			paramIdVec.clear();
 			meanVec.clear();
 			varianceVec.clear();
 			paramIdVec.push_back(0);
 			meanVec.push_back(tcplq.getAlphaMean());
 			varianceVec.push_back(variance);
 			//paramIdVec.push_back(1); meanVec.push_back(tcplq.getAlphaVariance()); varianceVec.push_back(variance);
 			paramIdVec.push_back(2);
 			meanVec.push_back(tcplq.getAlphaBeta());
 			varianceVec.push_back(variance);
 			paramIdVec.push_back(3);
 			meanVec.push_back(tcplq.getRho());
 			varianceVec.push_back(variance);
 
 			scatterVary = models::getScatterPlotVaryParameters(tcplq, paramIdVec, meanVec, varianceVec,
 			              normalizationDose, 50);
 
 			scatterCompare.setCompareScatter(scatterVary);
 			//allow 5% of the points to deviate more
 			scatterCompare.setAllowExceptions(true);
 			CHECK_TESTER(scatterCompare);
 
 			models::BioModelParamType alphaBeta = 10;
 			tcplq.setParameters(alpha, alphaBeta, roh, 0.08);
 			tcplq.init();
 
 			normalizationDose = 40;
 			curve = models::getCurveDoseVSBioModel(tcplq, normalizationDose);
 
 			CHECK_NO_THROW(models::getScatterPlotVary1Parameter(tcplq, 0, alpha, 0, normalizationDose, 100));
 			tcpScatter = models::getScatterPlotVary1Parameter(tcplq, 0, alpha, 0, normalizationDose, 100);
 
 			scatterCompare.setReferenceCurve(curve);
 			scatterCompare.setVariance(0);
 			//do not allow larger deviations
 			scatterCompare.setAllowExceptions(false);
 			scatterCompare.setCompareScatter(tcpScatter);
 			CHECK_TESTER(scatterCompare);
 
 			variance = 0.25;
 			CHECK_NO_THROW(models::getScatterPlotVary1Parameter(tcplq, 0, alpha, variance, normalizationDose,
 			               100));
 			tcpScatter = models::getScatterPlotVary1Parameter(tcplq, 0, alpha, variance, normalizationDose,
 			             100);
 
 			scatterCompare.setCompareScatter(tcpScatter);
 			scatterCompare.setVariance(variance);
 			//allow 5% of the points to deviate more
 			scatterCompare.setAllowExceptions(true);
 			CHECK_TESTER(scatterCompare);
 
 
 			/*TCP LQ Test*/
 			alpha = 0.3;
 			beta = 0.03;
 			roh = 10000000;
 			numFractions = 20;
 			rttb::models::TCPLQModel tcplq_test = rttb::models::TCPLQModel(dvh_test_tv, alpha, beta, roh,
 			                                      numFractions);
 
 			CHECK_NO_THROW(tcplq_test.init());
 			normalizationDose = 60;
 			curve = models::getCurveDoseVSBioModel(tcplq_test, normalizationDose);
 
 			CHECK_NO_THROW(models::getScatterPlotVary1Parameter(tcplq_test, 0, alpha, 0, normalizationDose,
 			               100));
 			tcpScatter = models::getScatterPlotVary1Parameter(tcplq_test, 0, alpha, 0, normalizationDose, 100);
 
 			scatterCompare.setReferenceCurve(curve);
 			scatterCompare.setVariance(0);
 			scatterCompare.setCompareScatter(tcpScatter);
 			CHECK_TESTER(scatterCompare);
 
 			//test also with other parameter
 			tcpScatter = models::getScatterPlotVary1Parameter(tcplq_test, 3, roh, 0, normalizationDose, 100);
 			scatterCompare.setCompareScatter(tcpScatter);
 			CHECK_TESTER(scatterCompare);
 
 			paramIdVec.clear();
 			meanVec.clear();
 			varianceVec.clear();
 			paramIdVec.push_back(0);
 			meanVec.push_back(tcplq_test.getAlphaMean());
 			varianceVec.push_back(0);
 			//paramIdVec.push_back(1); meanVec.push_back(tcplq_test.getAlphaVariance()); varianceVec.push_back(0);
 			paramIdVec.push_back(2);
 			meanVec.push_back(tcplq_test.getAlphaBeta());
 			varianceVec.push_back(0);
 			paramIdVec.push_back(3);
 			meanVec.push_back(tcplq_test.getRho());
 			varianceVec.push_back(0);
 
 			scatterVary = models::getScatterPlotVaryParameters(tcplq_test, paramIdVec, meanVec, varianceVec,
 			              normalizationDose, 50);
 
 			scatterCompare.setCompareScatter(scatterVary);
 			CHECK_TESTER(scatterCompare);
 
 			variance = 0.00025;
 			CHECK_NO_THROW(models::getScatterPlotVary1Parameter(tcplq_test, 0, alpha, variance,
 			               normalizationDose, 100));
 			tcpScatter = models::getScatterPlotVary1Parameter(tcplq_test, 0, alpha, variance, normalizationDose,
 			             100);
 
 			scatterCompare.setCompareScatter(tcpScatter);
 			scatterCompare.setVariance(variance);
 			CHECK_TESTER(scatterCompare);
 
 			//test also with other parameter
 			tcpScatter = models::getScatterPlotVary1Parameter(tcplq_test, 3, roh, variance, normalizationDose,
 			             100);
 			scatterCompare.setCompareScatter(tcpScatter);
 			scatterCompare.setAllowExceptions(true);
 			CHECK_TESTER(scatterCompare);
 			scatterCompare.setAllowExceptions(false);
 
 			paramIdVec.clear();
 			meanVec.clear();
 			varianceVec.clear();
 			paramIdVec.push_back(0);
 			meanVec.push_back(tcplq_test.getAlphaMean());
 			varianceVec.push_back(variance);
 			//paramIdVec.push_back(1); meanVec.push_back(tcplq_test.getAlphaVariance()); varianceVec.push_back(variance);
 			paramIdVec.push_back(2);
 			meanVec.push_back(tcplq_test.getAlphaBeta());
 			varianceVec.push_back(variance);
 			paramIdVec.push_back(3);
 			meanVec.push_back(tcplq_test.getRho());
 			varianceVec.push_back(variance);
 
 			scatterVary = models::getScatterPlotVaryParameters(tcplq_test, paramIdVec, meanVec, varianceVec,
 			              normalizationDose, 50);
 
 			scatterCompare.setCompareScatter(scatterVary);
 			//allow 5% of the points to deviate more
 			scatterCompare.setAllowExceptions(true);
 			CHECK_TESTER(scatterCompare);
 
 			//DVH HT 1
 			rttb::io::other::DVHXMLFileReader dvhReader2 = rttb::io::other::DVHXMLFileReader(DVH_FILENAME_NT1);
 			DVHPointer dvhPtr2 = dvhReader2.generateDVH();
 
 			CHECK_CLOSE(1.07920836034015810000e+001, models::getEUD(dvhPtr2, 10), toleranceEUD);
 
 			//test RTNTCPLKBModel
 			rttb::models::NTCPLKBModel lkb = rttb::models::NTCPLKBModel();
 			models::BioModelParamType aVal = 10;
 			models::BioModelParamType mVal = 0.16;
 			models::BioModelParamType d50Val = 55;
 			lkb.setDVH(dvhPtr2);
 			lkb.setA(aVal);
 			lkb.setM(mVal);
 			lkb.setD50(d50Val);
 			CHECK_NO_THROW(lkb.init());
 
 			normalizationDose = 60;
 			curve = models::getCurveDoseVSBioModel(lkb, normalizationDose);
 
 			CHECK_NO_THROW(models::getScatterPlotVary1Parameter(lkb, 2, aVal, 0, normalizationDose, 100));
 			ScatterPlotType scatter = models::getScatterPlotVary1Parameter(lkb, 2, aVal, 0, normalizationDose,
 			                          100);
 
 			scatterCompare.setReferenceCurve(curve);
 			scatterCompare.setVariance(0);
 			scatterCompare.setCompareScatter(scatter);
 			CHECK_TESTER(scatterCompare);
 
 			//"d50":0,"m":1,"a":2
 			//test also with other parameter
 			scatter = models::getScatterPlotVary1Parameter(lkb, 0, d50Val, 0, normalizationDose, 100);
 			scatterCompare.setCompareScatter(scatter);
 			CHECK_TESTER(scatterCompare);
 
 			paramIdVec.clear();
 			meanVec.clear();
 			varianceVec.clear();
 			paramIdVec.push_back(0);
 			meanVec.push_back(lkb.getD50());
 			varianceVec.push_back(0);
 			paramIdVec.push_back(1);
 			meanVec.push_back(lkb.getM());
 			varianceVec.push_back(0);
 			paramIdVec.push_back(2);
 			meanVec.push_back(lkb.getA());
 			varianceVec.push_back(0);
 
 			scatterVary = models::getScatterPlotVaryParameters(lkb, paramIdVec, meanVec, varianceVec,
 			              normalizationDose, 50);
 
 			scatterCompare.setCompareScatter(scatterVary);
 			CHECK_TESTER(scatterCompare);
 
 			variance = 0.00025;
 			CHECK_NO_THROW(models::getScatterPlotVary1Parameter(lkb, 2, aVal, variance, normalizationDose,
 			               100));
 			scatter = models::getScatterPlotVary1Parameter(lkb, 2, aVal, variance, normalizationDose, 100);
 
 			scatterCompare.setCompareScatter(scatter);
 			scatterCompare.setVariance(variance);
 			CHECK_TESTER(scatterCompare);
 
 			//test also with other parameter
 			scatter = models::getScatterPlotVary1Parameter(lkb, 0, d50Val, variance, normalizationDose, 100);
 			scatterCompare.setCompareScatter(scatter);
 			CHECK_TESTER(scatterCompare);
 
 			paramIdVec.clear();
 			meanVec.clear();
 			varianceVec.clear();
 			paramIdVec.push_back(0);
 			meanVec.push_back(lkb.getD50());
 			varianceVec.push_back(variance);
 			paramIdVec.push_back(1);
 			meanVec.push_back(lkb.getM());
 			varianceVec.push_back(variance);
 			paramIdVec.push_back(2);
 			meanVec.push_back(lkb.getA());
 			varianceVec.push_back(variance);
 
 			scatterVary = models::getScatterPlotVaryParameters(lkb, paramIdVec, meanVec, varianceVec,
 			              normalizationDose, 50);
 
 			scatterCompare.setCompareScatter(scatterVary);
 			CHECK_TESTER(scatterCompare);
 
 			//test RTNTCPRSModel
 			rttb::models::NTCPRSModel rs = rttb::models::NTCPRSModel();
 			models::BioModelParamType gammaVal = 1.7;
 			models::BioModelParamType sVal = 1;
 			rs.setDVH(dvhPtr2);
 			rs.setD50(d50Val);
 			rs.setGamma(gammaVal);
 			rs.setS(sVal);
 			CHECK_NO_THROW(rs.init());
 
 			normalizationDose = 60;
 			curve = models::getCurveDoseVSBioModel(rs, normalizationDose);
 
 			CHECK_NO_THROW(models::getScatterPlotVary1Parameter(rs, 0, d50Val, 0, normalizationDose, 100));
 			scatter = models::getScatterPlotVary1Parameter(rs, 0, d50Val, 0, normalizationDose, 100);
 
 			scatterCompare.setReferenceCurve(curve);
 			scatterCompare.setVariance(0);
 			scatterCompare.setCompareScatter(scatter);
 			CHECK_TESTER(scatterCompare);
 
 			//"d50":0,"gamma":1,"s":2
 			//test also with other parameter
 			scatter = models::getScatterPlotVary1Parameter(rs, 1, gammaVal, 0, normalizationDose, 100);
 			scatterCompare.setCompareScatter(scatter);
 			CHECK_TESTER(scatterCompare);
 
 			paramIdVec.clear();
 			meanVec.clear();
 			varianceVec.clear();
 			paramIdVec.push_back(0);
 			meanVec.push_back(rs.getD50());
 			varianceVec.push_back(0);
 			paramIdVec.push_back(1);
 			meanVec.push_back(rs.getGamma());
 			varianceVec.push_back(0);
 			paramIdVec.push_back(2);
 			meanVec.push_back(rs.getS());
 			varianceVec.push_back(0);
 
 			scatterVary = models::getScatterPlotVaryParameters(rs, paramIdVec, meanVec, varianceVec,
 			              normalizationDose, 50);
 
 			scatterCompare.setCompareScatter(scatterVary);
 			CHECK_TESTER(scatterCompare);
 
 			variance = 0.0075;
 			CHECK_NO_THROW(models::getScatterPlotVary1Parameter(rs, 0, d50Val, variance, normalizationDose,
 			               100));
 			scatter = models::getScatterPlotVary1Parameter(rs, 0, d50Val, variance, normalizationDose, 100);
 
 			scatterCompare.setCompareScatter(scatter);
 			scatterCompare.setVariance(variance);
 			CHECK_TESTER(scatterCompare);
 
 			//test also with other parameter
 			scatter = models::getScatterPlotVary1Parameter(rs, 2, sVal, variance, normalizationDose, 100);
 			scatterCompare.setCompareScatter(scatter);
 			CHECK_TESTER(scatterCompare);
 
 			paramIdVec.clear();
 			meanVec.clear();
 			varianceVec.clear();
 			paramIdVec.push_back(0);
 			meanVec.push_back(rs.getD50());
 			varianceVec.push_back(variance);
 			paramIdVec.push_back(1);
 			meanVec.push_back(rs.getGamma());
 			varianceVec.push_back(variance);
 			paramIdVec.push_back(2);
 			meanVec.push_back(rs.getS());
 			varianceVec.push_back(variance);
 
 			scatterVary = models::getScatterPlotVaryParameters(rs, paramIdVec, meanVec, varianceVec,
 			              normalizationDose, 50);
 
 			scatterCompare.setCompareScatter(scatterVary);
 			CHECK_TESTER(scatterCompare);
 
 			RETURN_AND_REPORT_TEST_SUCCESS;
 
 		}
 
 	}//testing
 }//rttb