diff --git a/code/io/other/rttbDVHXMLFileReader.cpp b/code/io/other/rttbDVHXMLFileReader.cpp
index 020b799..e40af6a 100644
--- a/code/io/other/rttbDVHXMLFileReader.cpp
+++ b/code/io/other/rttbDVHXMLFileReader.cpp
@@ -1,147 +1,145 @@
 // -----------------------------------------------------------------------
 // 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"
 #include "rttbBaseType.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()
 			{
 				using boost::property_tree::ptree;
 				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;
 
 				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");
 
 				if (dvhType != "DIFFERENTIAL" && dvhType != "CUMULATIVE")
 				{
 					throw core::InvalidParameterException("DVH Type invalid! Only: DIFFERENTIAL/CUMULATIVE!");
 				}
 
 				int count = 0;
 				BOOST_FOREACH(boost::property_tree::ptree::value_type & v, pt.get_child("dvh.data"))
 				{
-					if (count % 2 == 1)
+					if (dvhType == "DIFFERENTIAL")
 					{
-						if (dvhType == "DIFFERENTIAL")
-						{
-							dataDifferential.push_back(boost::lexical_cast<DoseTypeGy>(v.second.data()));
+						dataDifferential.push_back(boost::lexical_cast<DoseTypeGy>(v.second.data()));
 
-						}
-						else if (dvhType == "CUMULATIVE")
-						{
-							dataCumulative.push_back(boost::lexical_cast<DoseTypeGy>(v.second.data()));
-						}
+					}
+					else if (dvhType == "CUMULATIVE")
+					{
+						dataCumulative.push_back(boost::lexical_cast<DoseTypeGy>(v.second.data()));
 					}
 
 					count++;
 				}
 
-				unsigned int numberOfBins = static_cast<unsigned int>(std::max(dataDifferential.size(), dataCumulative.size()));
+				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 77f1e50..4fbe3eb 100644
--- a/code/io/other/rttbDVHXMLFileWriter.cpp
+++ b/code/io/other/rttbDVHXMLFileWriter.cpp
@@ -1,134 +1,140 @@
 // -----------------------------------------------------------------------
 // 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)
 			{
 				if (!aDvh)
 				{
 					throw core::NullPointerException("aDvh must not be NULL! ");
 				}
 
 
 				using boost::property_tree::ptree;
 				ptree pt;
 
 				if (_dvhType.Type == DVHType::Differential)
 				{
 					pt.put("dvh.type", "DIFFERENTIAL");
 				}
 				else if (_dvhType.Type == DVHType::Cumulative)
 				{
 					pt.put("dvh.type", "CUMULATIVE");
 				}
 				else
 				{
 					throw core::InvalidParameterException("DVH Type not acceptable: Only: DIFFERENTIAL/CUMULATIVE!");
 				}
 
 
 				DataDifferentialType dataDifferential = aDvh->getDataDifferential();
 				size_t numberOfBins = dataDifferential.size();
 				pt.put("dvh.deltaD", aDvh->getDeltaD());
 				pt.put("dvh.deltaV", aDvh->getDeltaV());
 				pt.put("dvh.structureID", aDvh->getStructureID());
 				pt.put("dvh.doseID", aDvh->getDoseID());
 
 
 				if (_dvhType.Type == DVHType::Differential)
 				{
 
 					for (int i = 0; i < numberOfBins; i++)
 					{
-						pt.add("dvh.data.dosebin", i);
-						pt.add("dvh.data.volume", dataDifferential[i]);
+						boost::property_tree::ptree node;
+						node.put("", dataDifferential[i]);
+						node.put("<xmlattr>.dosebin", i);
+
+						pt.add_child("dvh.data.volume", node);
 					}
 				}
 				else if (_dvhType.Type == DVHType::Cumulative)
 				{
 
 					DataDifferentialType dataCumulative = aDvh->calcCumulativeDVH();
 
 					for (int i = 0; i < numberOfBins; i++)
 					{
-						pt.add("dvh.data.dosebin", i);
-						pt.add("dvh.data.volume", dataCumulative[i]);
+						boost::property_tree::ptree node;
+						node.put("", dataCumulative[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!");
 				}
 
 			}
 
 		}
 	}
 }
\ No newline at end of file