diff --git a/code/io/other/rttbDVHXMLFileReader.cpp b/code/io/other/rttbDVHXMLFileReader.cpp
index e0846b8..80fd1b9 100644
--- a/code/io/other/rttbDVHXMLFileReader.cpp
+++ b/code/io/other/rttbDVHXMLFileReader.cpp
@@ -1,143 +1,154 @@
 // -----------------------------------------------------------------------
 // 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)
 */
 
 #include <boost/shared_ptr.hpp>
 #include <boost/make_shared.hpp>
 #include <boost/property_tree/ptree.hpp>
 #include <boost/property_tree/xml_parser.hpp>
 #include <boost/foreach.hpp>
 #include <boost/lexical_cast.hpp>
 
 #include "rttbDVHXMLFileReader.h"
 #include "rttbInvalidParameterException.h"
 
 namespace rttb
 {
 	namespace io
 	{
 		namespace other
 		{
 
 			DVHXMLFileReader::DVHXMLFileReader(FileNameString aFileName)
 			{
 				_fileName = aFileName;
 				_resetFile = true;
 			}
 
 			DVHXMLFileReader::~DVHXMLFileReader() {}
 
 			void DVHXMLFileReader::resetFileName(FileNameString aFileName)
 			{
 				_fileName = aFileName;
 				_resetFile = true;
 			}
 
 			void DVHXMLFileReader::createDVH()
 			{
 
 				boost::property_tree::ptree pt;
 
 				// Load the XML file into the property tree. If reading fails
 				// (cannot open file, parse error), an exception is thrown.
 				try
 				{
 					read_xml(_fileName, pt);
 				}
 				catch (boost::property_tree::xml_parser_error& /*e*/)
 				{
 					throw rttb::core::InvalidParameterException("DVH file name invalid: could not open the xml file!");
 				}
 
 
 				std::string dvhType;
 				std::deque<DoseTypeGy> dataDifferential, dataCumulative;
 
 				DoseTypeGy deltaD = 0;
 				DoseVoxelVolumeType deltaV = 0;
 				IDType strID;
 				IDType doseID;
+				bool normalized;
 
 				dvhType = pt.get<std::string>("dvh.type");
 				deltaD = pt.get<DoseTypeGy>("dvh.deltaD");
 				deltaV = pt.get<DoseVoxelVolumeType>("dvh.deltaV");
 				strID = pt.get<IDType>("dvh.structureID");
 				doseID = pt.get<IDType>("dvh.doseID");
+				boost::optional<bool> dvhNormalized = pt.get_optional<bool>("dvh.normalized");
+
+				if (dvhNormalized) 
+				{
+					normalized = dvhNormalized.get();
+				}
+				else
+				{
+					normalized = false;
+				}
 
 				if (dvhType != "DIFFERENTIAL" && dvhType != "CUMULATIVE")
 				{
 					throw core::InvalidParameterException("DVH Type invalid! Only: DIFFERENTIAL/CUMULATIVE!");
 				}
 
 		
 				BOOST_FOREACH(boost::property_tree::ptree::value_type & v, pt.get_child("dvh.data"))
 				{
 					if (dvhType == "DIFFERENTIAL")
 					{
-						dataDifferential.push_back(boost::lexical_cast<DoseTypeGy>(v.second.data()));
+						dataDifferential.push_back(boost::lexical_cast<DoseTypeGy>(v.second.data()) / (normalized ? deltaV : 1));
 
 					}
 					else if (dvhType == "CUMULATIVE")
 					{
-						dataCumulative.push_back(boost::lexical_cast<DoseTypeGy>(v.second.data()));
+						dataCumulative.push_back(boost::lexical_cast<DoseTypeGy>(v.second.data()) / (normalized ? deltaV : 1));
 					}
 
 				}
 
 				unsigned int numberOfBins = static_cast<unsigned int>(std::max(dataDifferential.size(),
 				                            dataCumulative.size()));
 
 				if (dvhType == "CUMULATIVE") //dataDifferential should be calculated
 				{
 					DoseCalcType differentialDVHi = 0;
 					std::deque<DoseCalcType>::iterator it;
 
 					for (it = dataCumulative.begin(); it != dataCumulative.end(); ++it)
 					{
 						if (dataDifferential.size() == numberOfBins - 1)
 						{
 							differentialDVHi = *it;
 						}
 						else
 						{
 							differentialDVHi = *it - *(it + 1);
 						}
 
 						dataDifferential.push_back(differentialDVHi);
 					}
 				}
 
 				_dvh = boost::make_shared<core::DVH>(dataDifferential, deltaD, deltaV, strID, doseID);
 				_resetFile = false;
 			}
 
 			DVHXMLFileReader::DVHPointer DVHXMLFileReader::generateDVH()
 			{
 				if (_resetFile)
 				{
 					this->createDVH();
 				}
 
 				return _dvh;
 			}
 		}//end namespace other
 	}//end namespace io
 }//end namespace rttb
 
diff --git a/code/io/other/rttbDVHXMLFileWriter.cpp b/code/io/other/rttbDVHXMLFileWriter.cpp
index b15a685..430b7df 100644
--- a/code/io/other/rttbDVHXMLFileWriter.cpp
+++ b/code/io/other/rttbDVHXMLFileWriter.cpp
@@ -1,146 +1,146 @@
 // -----------------------------------------------------------------------
 // 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)
 */
 
 
 #include "rttbDVHXMLFileWriter.h"
 #include "rttbNullPointerException.h"
 #include "rttbInvalidParameterException.h"
 #include "rttbException.h"
 
 #include <boost/property_tree/ptree.hpp>
 #include <boost/property_tree/xml_parser.hpp>
 
 namespace rttb
 {
 	namespace io
 	{
 		namespace other
 		{
 
 			DVHXMLFileWriter::DVHXMLFileWriter(FileNameString aFileName, DVHType aDVHType)
 			{
 				this->setFileName(aFileName);
 				this->setDVHType(aDVHType);
 			}
 
 			void DVHXMLFileWriter::setDVHType(DVHType aDVHType)
 			{
 				_dvhType = aDVHType;
 			}
 
 			FileNameString DVHXMLFileWriter::getFileName() const
 			{
 				return _fileName;
 			}
 
 			void DVHXMLFileWriter::setFileName(FileNameString aFileName)
 			{
 				_fileName = aFileName;
 			}
 
 			DVHType DVHXMLFileWriter::getDVHType() const
 			{
 				return _dvhType;
 			}
 
 			void DVHXMLFileWriter::writeDVH(DVHPointer aDvh, bool normalized)
 			{
 				if (!aDvh)
 				{
 					throw core::NullPointerException("aDvh must not be NULL! ");
 				}
 
 				using boost::property_tree::ptree;
 				ptree pt;
 				DataDifferentialType data;
 				std::map <DoseTypeGy, PercentType> normalizedData;
 
 				if (_dvhType.Type == DVHType::Differential)
 				{
 					pt.put("dvh.type", "DIFFERENTIAL");
 					if (normalized) {
-						normalizedData = aDvh->getNormalizedDVH();
+						normalizedData = aDvh->getNormalizedDVH(true);
 					} 
 					else 
 					{
 						data = aDvh->getDataDifferential();
 					}					
 				}
 				else if (_dvhType.Type == DVHType::Cumulative)
 				{
 					pt.put("dvh.type", "CUMULATIVE");
 					if (normalized) {
-						normalizedData = aDvh->getNormalizedDVH(true);
+						normalizedData = aDvh->getNormalizedDVH();
 					}
 					else
 					{
 						data = aDvh->calcCumulativeDVH();
 					}
 				}
 				else
 				{
 					throw core::InvalidParameterException("DVH Type not acceptable: Only: DIFFERENTIAL/CUMULATIVE!");
 				}
 
 				pt.put("dvh.deltaD", aDvh->getDeltaD());
 				pt.put("dvh.deltaV", aDvh->getDeltaV());
 				pt.put("dvh.structureID", aDvh->getStructureID());
 				pt.put("dvh.doseID", aDvh->getDoseID());
 				pt.put("dvh.normalized", normalized);
 
 				if (normalized) {
 					for (auto elem : normalizedData) 
 					{
 						boost::property_tree::ptree node;
 						node.put("", elem.second);
 						node.put("<xmlattr>.doseGy", elem.first);
 
 						pt.add_child("dvh.data.volumeInCcm", node);
 					}
 				}
 				else
 				{
 					for (size_t i = 0; i < data.size(); i++)
 					{
 						boost::property_tree::ptree node;
 						node.put("", data[i]);
 						node.put("<xmlattr>.dosebin", i);
 
 						pt.add_child("dvh.data.volume", node);
 					}
 				}
 				
 				try
 				{
 					boost::property_tree::xml_parser::xml_writer_settings<std::string> settings =
 					    boost::property_tree::xml_writer_make_settings<std::string> ('\t', 1);
 					boost::property_tree::xml_parser::write_xml(_fileName, pt, std::locale(), settings);
 				}
 				catch (boost::property_tree::xml_parser_error& /*e*/)
 				{
 					throw core::InvalidParameterException("Write xml failed: xml_parser_error!");
 				}
 
 			}
 
 		}
 	}
 }
diff --git a/testing/core/DVHTest.cpp b/testing/core/DVHTest.cpp
index 5981171..8a5efde 100644
--- a/testing/core/DVHTest.cpp
+++ b/testing/core/DVHTest.cpp
@@ -1,197 +1,197 @@
 // -----------------------------------------------------------------------
 // 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)
 */
 
 #include <deque>
 
 #include <boost/make_shared.hpp>
 #include <boost/shared_ptr.hpp>
 
 #include "litCheckMacros.h"
 
 #include "rttbBaseType.h"
 #include "rttbDVH.h"
 #include "DummyDoseAccessor.h"
 #include "DummyMaskAccessor.h"
 
 namespace rttb
 {
 
 	namespace testing
 	{
 
 		typedef core::DVH::DataDifferentialType DataDifferentialType;
 
 		/*! @brief DVHTest - test the API of DVH
 		1) test constructors (values as expected?)
 		2) test asignement
 		3) test set/getLabel
 		4) test set/get<Values>
 		5) test equality
 		*/
 		int DVHTest(int argc, char* argv[])
 		{
 			PREPARE_DEFAULT_TEST_REPORTING;
 
 			//generate artificial DVH and corresponding statistical values
 			DoseTypeGy binSize = DoseTypeGy(0.1);
 			DoseVoxelVolumeType voxelVolume = 8;
 
 			DataDifferentialType anEmptyDataDifferential;
 			DataDifferentialType aDataDifferential;
 			DataDifferentialType aDataDifferential2;
 			DataDifferentialType aDataDifferentialRelative;
 			DoseStatisticType maximum = 0;
 			DoseStatisticType minimum = 0;
 			double sum = 0;
 			double squareSum = 0;
 			DoseCalcType value = 0;
 			DVHVoxelNumber numberOfVoxels = 0;
 
 			// creat default values [0,100)
 			for (int i = 0; i < 100; i++)
 			{
 				value = DoseCalcType((double(rand()) / RAND_MAX) * 1000);
 				numberOfVoxels += value;
 				aDataDifferential.push_back(value);
 				aDataDifferential2.push_back(value * 10);
 
 				if (value > 0)
 				{
 					maximum = (i + 0.5) * binSize;
 
 					if (minimum == 0)
 					{
 						minimum = (i + 0.5) * binSize;
 					}
 				}
 
 				sum += value * (i + 0.5) * binSize;
 				squareSum += value * pow((i + 0.5) * binSize, 2);
 			}
 
 			DoseStatisticType mean = sum / numberOfVoxels;
 			DoseStatisticType variance = (squareSum / numberOfVoxels - mean * mean);
 			DoseStatisticType stdDeviation = pow(variance, 0.5);
 
 			std::deque<DoseCalcType>::iterator it;
 
 			for (it = aDataDifferential.begin(); it != aDataDifferential.end(); ++it)
 			{
 				aDataDifferentialRelative.push_back((*it) / numberOfVoxels);
 			}
 
 			const IDType structureID = "myStructure";
 			const IDType doseID = "myDose";
 			const IDType voxelizationID = "myVoxelization";
 
 			//1) test default constructor (values as expected?)
 			CHECK_THROW(core::DVH(anEmptyDataDifferential, binSize, voxelVolume, structureID, doseID,
 			                      voxelizationID));
 			CHECK_THROW(core::DVH(anEmptyDataDifferential, binSize, voxelVolume, structureID, doseID));
 			CHECK_NO_THROW(core::DVH(aDataDifferential, binSize, voxelVolume, structureID, doseID,
 			                         voxelizationID));
 			CHECK_NO_THROW(core::DVH(aDataDifferential, binSize, voxelVolume, structureID, doseID));
 			CHECK_THROW(core::DVH(aDataDifferential, 0, voxelVolume, structureID, doseID, voxelizationID));
 			CHECK_THROW(core::DVH(aDataDifferential, 0, voxelVolume, structureID, doseID));
 			CHECK_THROW(core::DVH(aDataDifferential, binSize, 0, structureID, doseID, voxelizationID));
 			CHECK_THROW(core::DVH(aDataDifferential, binSize, 0, structureID, doseID));
 
 			//2) test asignement
 			core::DVH myTestDVH(aDataDifferential, binSize, voxelVolume, structureID, doseID);
 			CHECK_NO_THROW(core::DVH myOtherDVH = myTestDVH);
 
 			const core::DVH myOtherDVH = myTestDVH;
 
 			CHECK_NO_THROW(core::DVH aDVH(myOtherDVH));
 
 			//3) test set/getLabel
 			core::DVH myDVH(aDataDifferential, binSize, voxelVolume, structureID, doseID, voxelizationID);
 
 			StructureLabel label = "";
 			CHECK_EQUAL(myDVH.getLabel(), label);
 			CHECK_EQUAL(myDVH.getLabel(), label);
 			label = "myLabel";
 			CHECK_NO_THROW(myDVH.setLabel(label));
 			CHECK_NO_THROW(myDVH.setLabel(label));
 			CHECK_EQUAL(myDVH.getLabel(), label);
 			CHECK_EQUAL(myDVH.getLabel(), label);
 			label = "myLabel2";
 			CHECK_NO_THROW(myDVH.setLabel(label));
 			CHECK_NO_THROW(myDVH.setLabel(label));
 			CHECK_EQUAL(myDVH.getLabel(), label);
 			CHECK_EQUAL(myDVH.getLabel(), label);
 
 			//4) test set/get<Values>
 			//IDs
 			CHECK_EQUAL(myDVH.getStructureID(), structureID);
 			CHECK_EQUAL(myDVH.getDoseID(), doseID);
 			CHECK_EQUAL(myDVH.getVoxelizationID(), voxelizationID);
 			/*! is related to #2029*/
 			myDVH.setDoseID("somethingElse");
 			CHECK_EQUAL(myDVH.getDoseID(), "somethingElse");
 			CHECK_EQUAL(myDVH.getVoxelizationID(), voxelizationID);
 			CHECK_EQUAL(myDVH.getStructureID(), structureID);
 			/*! is related to #2029*/
 			myDVH.setStructureID("somethingOther");
 			CHECK_EQUAL(myDVH.getDoseID(), "somethingElse");
 			CHECK_EQUAL(myDVH.getVoxelizationID(), voxelizationID);
 			CHECK_EQUAL(myDVH.getStructureID(), "somethingOther");
 
 
 			//dataDifferential
 			CHECK(myDVH.getDataDifferential() == aDataDifferential);
 			CHECK(myDVH.getDataDifferential(false) == aDataDifferential);
 			CHECK(myDVH.getDataDifferential(true) == aDataDifferentialRelative);
 
 			CHECK_EQUAL(myDVH.getNumberOfVoxels(), numberOfVoxels);
 			CHECK_EQUAL(myDVH.getDeltaV(), voxelVolume);
 			CHECK_EQUAL(myDVH.getDeltaD(), binSize);
 
 			CHECK_EQUAL(myDVH.getMaximum(), maximum);
 			CHECK_EQUAL(myDVH.getMinimum(), minimum);
 			CHECK_EQUAL(myDVH.getMean(), mean);
 			CHECK_EQUAL(myDVH.getVariance(), variance);
 			CHECK_EQUAL(myDVH.getStdDeviation(), stdDeviation);
 
 
 			int percentage = 20;
 			VolumeType absVol = VolumeType(percentage * numberOfVoxels * voxelVolume / 100.0);
 			CHECK_EQUAL(myDVH.getAbsoluteVolume(percentage), absVol);
 
 			//5) test equality
 			core::DVH myDVH2(aDataDifferential2, binSize, voxelVolume, structureID, doseID);
 
 			CHECK(!(myDVH == myDVH2));
 			CHECK_EQUAL(myDVH, myDVH);
 			core::DVH aDVH(myOtherDVH);
 			CHECK_EQUAL(aDVH, myOtherDVH);
 
 			std::map <DoseTypeGy, PercentType> normalizedDVH = myDVH.getNormalizedDVH(true);
 			for (auto elem : normalizedDVH)
-			{				
+			{
 				CHECK_EQUAL(aDataDifferential.at(std::round(elem.first / binSize)), (elem.second / voxelVolume));
 			}
 
 			RETURN_AND_REPORT_TEST_SUCCESS;
 		}
 
 	}//end namespace testing
 }//end namespace rttb
diff --git a/testing/io/other/DVHXMLIOTest.cpp b/testing/io/other/DVHXMLIOTest.cpp
index 31675ce..51c0973 100644
--- a/testing/io/other/DVHXMLIOTest.cpp
+++ b/testing/io/other/DVHXMLIOTest.cpp
@@ -1,141 +1,168 @@
 // -----------------------------------------------------------------------
 // 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/make_shared.hpp>
 #include <boost/shared_ptr.hpp>
 #include <boost/lexical_cast.hpp>
 
 #include "litCheckMacros.h"
 
 #include "rttbBaseType.h"
 #include "rttbDVH.h"
 #include "rttbDVHSet.h"
 #include "rttbDVHTxtFileReader.h"
 #include "rttbDVHTxtFileWriter.h"
 #include "rttbDVHXMLFileReader.h"
 #include "rttbDVHXMLFileWriter.h"
 #include "rttbInvalidParameterException.h"
 #include "rttbNullPointerException.h"
 
 #include "../../core/DummyDVHGenerator.h"
 
 #include "CompareDVH.h"
 
 namespace rttb
 {
 
 	namespace testing
 	{
 
 		/*! @brief DVHXMLIOTest - test the IO for DVH xml data
 		1) test writing dvh to xml file
 		2) test reading DVH from xml file
 		3) test reading dvh from txt file and writing to xml, check equal
 		*/
 
 		int DVHXMLIOTest(int argc, char* argv[])
 		{
 			typedef core::DVHSet::DVHSetType DVHSetType;
 			typedef core::DVH::DVHPointer DVHPointer;
 
 			PREPARE_DEFAULT_TEST_REPORTING;
 
 			std::string DVHTXT_FILENAME;
 
 			if (argc > 1)
 			{
 				DVHTXT_FILENAME = argv[1];
 			}
 
 			/* generate dummy DVH */
 			const IDType structureIDPrefix = "myStructure";
 			const IDType doseID = "myDose";
 
 			DummyDVHGenerator dvhGenerator;
 
 			DVHPointer spMyDVH = boost::make_shared<core::DVH>(dvhGenerator.generateDVH(structureIDPrefix,
 			                     doseID));
 
 			// 1) test writing DVH to xml file
 			DVHType typeCum = {DVHType::Cumulative};
 			DVHType typeDiff = {DVHType::Differential};
 			FileNameString fN1 = "test.xml";
 			CHECK_NO_THROW(io::other::DVHXMLFileWriter(fN1, typeDiff));
 			CHECK_NO_THROW(io::other::DVHXMLFileWriter(fN1, typeCum));
 
 			io::other::DVHXMLFileWriter dvhWriter(fN1, typeCum);
 
 			CHECK_EQUAL(fN1, dvhWriter.getFileName());
 
 			FileNameString fN2 = "otherFile.xml";
 			CHECK_NO_THROW(dvhWriter.setFileName(fN2));
 			CHECK_EQUAL(fN2, dvhWriter.getFileName());
 
 			CHECK_EQUAL(DVHType::Cumulative, dvhWriter.getDVHType().Type);
 			CHECK_NO_THROW(dvhWriter.setDVHType(typeDiff));
 			CHECK_EQUAL(DVHType::Differential, dvhWriter.getDVHType().Type);
 
 			DVHPointer emptyDvh;
 			CHECK_THROW_EXPLICIT(dvhWriter.writeDVH(emptyDvh), core::NullPointerException);
 			//CHECK_THROW_EXPLICIT(dvhWriter.writeDVH(spMyDVH), core::InvalidParameterException);
 			CHECK_NO_THROW(dvhWriter.setDVHType(typeDiff));
 			CHECK_NO_THROW(dvhWriter.writeDVH(spMyDVH));
 
 			// 2) test reading DVH from xml file
 			io::other::DVHXMLFileReader dvhReader(fN2);
 
 			DVHPointer importedDVH = dvhReader.generateDVH();
 
 			CHECK_EQUAL(*importedDVH, *spMyDVH);
 
 			//3) test reading dvh from txt file and writing to xml
 			io::other::DVHTxtFileReader dvhReader2(DVHTXT_FILENAME);
 			DVHPointer importedDVH2 = dvhReader2.generateDVH();
 
 			//write dvh to a xml file as differential
 			FileNameString toWrite_diff = "test_diff.xml";
 			io::other::DVHXMLFileWriter xmlWriter(toWrite_diff, typeDiff);
 			xmlWriter.writeDVH(importedDVH2);
 
 			io::other::DVHXMLFileReader xmlReader(toWrite_diff);
 			DVHPointer readDVH = xmlReader.generateDVH();
 
 			CHECK(checkEqualDVH(importedDVH2, readDVH));
 
 			//write dvh to a xml file as cummulative
 			FileNameString toWrite_cum = "test_cum.xml";
 			io::other::DVHXMLFileWriter xmlWriter_cum(toWrite_cum, typeCum);
 			xmlWriter_cum.writeDVH(importedDVH2);
 
 			io::other::DVHXMLFileReader xmlReader_cum(toWrite_cum);
 			DVHPointer readDVH_cum = xmlReader_cum.generateDVH();
 
 			CHECK(checkEqualDVH(importedDVH2, readDVH_cum));
 
+			//write dvh to a normalized xml file as differential
+			FileNameString toWrite_normalized_diff = "test_normalized_diff.xml";
+			io::other::DVHXMLFileWriter xmlWriter_normalized_dif(toWrite_normalized_diff, typeDiff);
+			xmlWriter_normalized_dif.writeDVH(importedDVH2, true);
+
+			io::other::DVHXMLFileReader xmlReader_normalized_diff(toWrite_normalized_diff);
+			DVHPointer readDVH_normalized_diff = xmlReader.generateDVH();
+
+			CHECK(checkEqualDVH(importedDVH2, readDVH_normalized_diff));
+
+			//write dvh to a normalized xml file as cummulative
+			FileNameString toWrite_normalized_cum = "test_normalized_cum.xml";
+			io::other::DVHXMLFileWriter xmlWriter_normalized_cum(toWrite_normalized_cum, typeCum);
+			xmlWriter_normalized_cum.writeDVH(importedDVH2, true);
+
+			io::other::DVHXMLFileReader xmlReader_normalized_cum(toWrite_normalized_cum);
+			DVHPointer readDVH_normalized_cum = xmlReader_normalized_cum.generateDVH();
+
+			CHECK(checkEqualDVH(importedDVH2, readDVH_normalized_cum));
+
+			//delete files again
+			CHECK_EQUAL(std::remove(toWrite_diff.c_str()), 0);
+			CHECK_EQUAL(std::remove(toWrite_cum.c_str()), 0);
+			CHECK_EQUAL(std::remove(toWrite_normalized_diff.c_str()), 0);
+			CHECK_EQUAL(std::remove(toWrite_normalized_cum.c_str()), 0);
+
+
 			RETURN_AND_REPORT_TEST_SUCCESS;
 		}
 
 	}//testing
 }//rttb