diff --git a/Modules/DICOMReader/include/mitkBaseDICOMReaderService.h b/Modules/DICOMReader/include/mitkBaseDICOMReaderService.h
index 5d5402a1c1..8a191076e9 100644
--- a/Modules/DICOMReader/include/mitkBaseDICOMReaderService.h
+++ b/Modules/DICOMReader/include/mitkBaseDICOMReaderService.h
@@ -1,64 +1,64 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef MITKBASEDICOMREADERSERVICE_H
 #define MITKBASEDICOMREADERSERVICE_H
 
 #include <mitkAbstractFileReader.h>
 #include <mitkDICOMFileReader.h>
 
 #include "MitkDICOMReaderExports.h"
 
 namespace mitk {
 
   /**
   Base class for service wrappers that make DICOMFileReader from
   the DICOMReader module usable.
   */
 class MITKDICOMREADER_EXPORT BaseDICOMReaderService : public AbstractFileReader
 {
 public:
   BaseDICOMReaderService(const std::string& description);
   BaseDICOMReaderService(const mitk::CustomMimeType& customType, const std::string& description);
 
   using AbstractFileReader::Read;
 
   /** Uses this->GetRelevantFile() and this->GetReader to load the image.
    * data and puts it into base data instances-*/
   std::vector<itk::SmartPointer<BaseData> > Read() override;
 
   IFileReader::ConfidenceLevel GetConfidenceLevel() const override;
 
 protected:
   /** Returns the list of all DCM files that are in the same directory
    * like this->GetLocalFileName().*/
   mitk::StringList GetRelevantFiles() const;
 
   /** Returns the reader instance that should be used. The descission may be based
    * one the passed relevant file list.*/
   virtual mitk::DICOMFileReader::Pointer GetReader(const mitk::StringList& relevantFiles) const = 0;
 };
 
 
 class IPropertyProvider;
 
-///** Helper function that generates a name string (e.g. for DataNode names) from the DICOM properties of the passed
-//  provider instance. If the instance is nullptr, or has no dicom properties DataNode::NO_NAME_VALUE() will be returned.*/
-//std::string MITKDICOMREADER_EXPORT GenerateNameFromDICOMProperties(const mitk::IPropertyProvider* provider);
+/** Helper function that generates a name string (e.g. for DataNode names) from the DICOM properties of the passed
+  provider instance. If the instance is nullptr, or has no dicom properties DataNode::NO_NAME_VALUE() will be returned.*/
+std::string MITKDICOMREADER_EXPORT GenerateNameFromDICOMProperties(const mitk::IPropertyProvider* provider);
 
 }
 
 #endif // MITKBASEDICOMREADERSERVICE_H
diff --git a/Modules/DICOMReader/src/mitkBaseDICOMReaderService.cpp b/Modules/DICOMReader/src/mitkBaseDICOMReaderService.cpp
index 3e337985ac..c88d333a49 100644
--- a/Modules/DICOMReader/src/mitkBaseDICOMReaderService.cpp
+++ b/Modules/DICOMReader/src/mitkBaseDICOMReaderService.cpp
@@ -1,224 +1,208 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkBaseDICOMReaderService.h"
 
 #include <mitkCustomMimeType.h>
 #include <mitkIOMimeTypes.h>
 #include <mitkDICOMFileReaderSelector.h>
 #include <mitkImage.h>
 #include <mitkDICOMFilesHelper.h>
 #include <mitkDICOMTagsOfInterestHelper.h>
 #include <mitkDICOMProperty.h>
 #include "legacy/mitkDicomSeriesReader.h"
 #include <mitkDICOMDCMTKTagScanner.h>
 #include <mitkLocaleSwitch.h>
 #include "mitkIPropertyProvider.h"
+#include "mitkPropertyNameHelper.h"
 
 #include <iostream>
 
 
 #include <itksys/SystemTools.hxx>
 #include <itksys/Directory.hxx>
 
 namespace mitk {
 
   BaseDICOMReaderService::BaseDICOMReaderService(const std::string& description)
     : AbstractFileReader(CustomMimeType(IOMimeTypes::DICOM_MIMETYPE()), description)
 {
 }
 
   BaseDICOMReaderService::BaseDICOMReaderService(const mitk::CustomMimeType& customType, const std::string& description)
     : AbstractFileReader(customType, description)
   {
   }
 
 std::vector<itk::SmartPointer<BaseData> > BaseDICOMReaderService::Read()
 {
   std::vector<BaseData::Pointer> result;
 
 
   std::string fileName = this->GetLocalFileName();
   //special handling of Philips 3D US DICOM.
   //Copied from DICOMSeriesReaderService
   if (DicomSeriesReader::IsPhilips3DDicom(fileName))
   {
       MITK_INFO << "it is a Philips3D US Dicom file" << std::endl;
       mitk::LocaleSwitch localeSwitch("C");
       std::locale previousCppLocale(std::cin.getloc());
       std::locale l("C");
       std::cin.imbue(l);
 
       DataNode::Pointer node = DataNode::New();
       mitk::DicomSeriesReader::StringContainer stringvec;
       stringvec.push_back(fileName);
       if (DicomSeriesReader::LoadDicomSeries(stringvec, *node))
       {
           BaseData::Pointer data = node->GetData();
           StringProperty::Pointer nameProp = StringProperty::New(itksys::SystemTools::GetFilenameName(fileName));
           data->GetPropertyList()->SetProperty("name", nameProp);
           result.push_back(data);
       }
       std::cin.imbue(previousCppLocale);
       return result;
   }
 
   //Normal DICOM handling (It wasn't a Philips 3D US)
   mitk::StringList relevantFiles = this->GetRelevantFiles();
 
   // check whether directory or file
   // if directory try to find first file within it instead
   // We only support this for a single directory at once
   if (relevantFiles.empty())
   {
     bool pathIsDirectory = itksys::SystemTools::FileIsDirectory(this->GetLocalFileName());
     if (pathIsDirectory)
     {
       itksys::Directory input;
       input.Load(this->GetLocalFileName().c_str());
 
       std::vector<std::string> files;
       for (unsigned long idx = 0; idx<input.GetNumberOfFiles(); idx++)
       {
         if (!itksys::SystemTools::FileIsDirectory(input.GetFile(idx)))
         {
           std::string fullpath = this->GetLocalFileName() + "/" + std::string(input.GetFile(idx));
           files.push_back(fullpath.c_str());
         }
       }
       relevantFiles = files;
     }
   }
 
   if (relevantFiles.empty())
   {
       MITK_INFO << "DICOMReader service found no relevant files in specified location. No data is loaded. Location: "<<fileName;
   }
   else
   {
       mitk::DICOMFileReader::Pointer reader = this->GetReader(relevantFiles);
 
       if(reader.IsNull())
       {
           MITK_INFO << "DICOMReader service found no suitable reader configuration for relevant files.";
       }
       else
       {
           const unsigned int ntotalfiles = relevantFiles.size();
 
           for( unsigned int i=0; i< ntotalfiles; i++)
           {
             m_ReadFiles.push_back( relevantFiles.at(i) );
           }
 
           reader->SetAdditionalTagsOfInterest(mitk::GetCurrentDICOMTagsOfInterest());
           reader->SetTagLookupTableToPropertyFunctor(mitk::GetDICOMPropertyForDICOMValuesFunctor);
           reader->SetInputFiles(relevantFiles);
 
           mitk::DICOMDCMTKTagScanner::Pointer scanner = mitk::DICOMDCMTKTagScanner::New();
           scanner->AddTagPaths(reader->GetTagsOfInterest());
           scanner->SetInputFiles(relevantFiles);
           scanner->Scan();
 
           reader->SetTagCache(scanner->GetScanCache());
           reader->AnalyzeInputFiles();
           reader->LoadImages();
 
           for (unsigned int i = 0; i < reader->GetNumberOfOutputs(); ++i)
           {
             const mitk::DICOMImageBlockDescriptor& desc = reader->GetOutput(i);
             mitk::BaseData::Pointer data = desc.GetMitkImage().GetPointer();
 
-            std::string nodeName = mitk::DataNode::NO_NAME_VALUE();
-
-            std::string studyDescription = desc.GetPropertyAsString("studyDescription");
-            std::string seriesDescription = desc.GetPropertyAsString("seriesDescription");
-
-            if (!studyDescription.empty())
-            {
-              nodeName = studyDescription;
-            }
-
-            if (!seriesDescription.empty())
-            {
-              if (!studyDescription.empty())
-              {
-                nodeName += "/";
-              }
-              nodeName += seriesDescription;
-            }
+            std::string nodeName = GenerateNameFromDICOMProperties(&desc);
 
             StringProperty::Pointer nameProp = StringProperty::New(nodeName);
             data->SetProperty("name", nameProp);
 
             result.push_back(data);
           }
       }
   }
 
   return result;
 }
 
 StringList BaseDICOMReaderService::GetRelevantFiles() const
 {
   std::string fileName = this->GetLocalFileName();
 
   mitk::StringList relevantFiles = mitk::GetDICOMFilesInSameDirectory(fileName);
 
   return relevantFiles;
 }
 
 IFileReader::ConfidenceLevel BaseDICOMReaderService::GetConfidenceLevel() const
 {
   IFileReader::ConfidenceLevel abstractConfidence = AbstractFileReader::GetConfidenceLevel();
 
   if (Unsupported == abstractConfidence)
   {
     if (itksys::SystemTools::FileIsDirectory(this->GetInputLocation().c_str()))
     {
       // In principle we support dicom directories
       return Supported;
     }
   }
 
   return abstractConfidence;
 }
 
-//std::string GenerateNameFromDICOMProperties(const mitk::IPropertyProvider* provider)
-//{
-//  std::string result = mitk::DataNode::NO_NAME_VALUE();
-//
-//  std::string studyDescription = desc.GetPropertyAsString("studyDescription");
-//  std::string seriesDescription = desc.GetPropertyAsString("seriesDescription");
-//
-//  if (!studyDescription.empty())
-//  {
-//    nodeName = studyDescription;
-//  }
-//
-//  if (!seriesDescription.empty())
-//  {
-//    if (!studyDescription.empty())
-//    {
-//      nodeName += "/";
-//    }
-//    nodeName += seriesDescription;
-//  }
-//
-//  return result;
-//};
+std::string GenerateNameFromDICOMProperties(const mitk::IPropertyProvider* provider)
+{
+  std::string nodeName = mitk::DataNode::NO_NAME_VALUE();
+
+  auto studyProp = provider->GetConstProperty(mitk::GeneratePropertyNameForDICOMTag(0x0020, 0x000D).c_str());
+  if (studyProp.IsNotNull())
+  {
+    nodeName = studyProp->GetValueAsString();
+  }
+
+  auto seriesProp = provider->GetConstProperty(mitk::GeneratePropertyNameForDICOMTag(0x0020, 0x000E).c_str());
+
+  if (seriesProp.IsNotNull())
+  {
+    if (studyProp.IsNotNull())
+    {
+      nodeName += " / ";
+    }
+    nodeName += seriesProp->GetValueAsString();
+  }
+
+  return nodeName;
+};
 
 }
diff --git a/Plugins/org.mitk.gui.qt.dicom/src/internal/DicomEventHandler.cpp b/Plugins/org.mitk.gui.qt.dicom/src/internal/DicomEventHandler.cpp
index 8aa6709bb7..25632a6c96 100644
--- a/Plugins/org.mitk.gui.qt.dicom/src/internal/DicomEventHandler.cpp
+++ b/Plugins/org.mitk.gui.qt.dicom/src/internal/DicomEventHandler.cpp
@@ -1,260 +1,254 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkPluginActivator.h"
 #include "DicomEventHandler.h"
 #include <service/event/ctkEventConstants.h>
 #include <ctkDictionary.h>
 #include <mitkLogMacros.h>
 #include <mitkDataNode.h>
 #include <mitkIDataStorageService.h>
 #include <service/event/ctkEventAdmin.h>
 #include <ctkServiceReference.h>
 #include <mitkRenderingManager.h>
 #include <QVector>
 #include "mitkImage.h"
 #include <mitkContourModelSet.h>
 
 #include <mitkDICOMFileReaderSelector.h>
 #include <mitkDICOMDCMTKTagScanner.h>
 #include <mitkDICOMEnums.h>
 #include <mitkDICOMTagsOfInterestHelper.h>
 #include <mitkDICOMProperty.h>
 #include <mitkPropertyNameHelper.h>
+#include "mitkBaseDICOMReaderService.h"
 
 #include <mitkRTDoseReaderService.h>
 #include <mitkRTPlanReaderService.h>
 #include <mitkRTStructureSetReaderService.h>
 #include <mitkRTConstants.h>
 #include <mitkIsoDoseLevelCollections.h>
 #include <mitkIsoDoseLevelSetProperty.h>
 #include <mitkIsoDoseLevelVectorProperty.h>
 #include <mitkDoseImageVtkMapper2D.h>
 #include <mitkRTUIConstants.h>
 #include <mitkIsoLevelsGenerator.h>
 #include <mitkDoseNodeHelper.h>
 
 #include <vtkSmartPointer.h>
 #include <vtkMath.h>
 #include <mitkTransferFunction.h>
 #include <mitkTransferFunctionProperty.h>
 #include <mitkRenderingModeProperty.h>
 #include <mitkLocaleSwitch.h>
 #include <mitkIOUtil.h>
 
 #include <berryIPreferencesService.h>
 #include <berryIPreferences.h>
 #include <berryPlatform.h>
 
 DicomEventHandler::DicomEventHandler()
 {
 }
 
 DicomEventHandler::~DicomEventHandler()
 {
 }
 
 void DicomEventHandler::OnSignalAddSeriesToDataManager(const ctkEvent& ctkEvent)
 {
   QStringList listOfFilesForSeries;
   listOfFilesForSeries = ctkEvent.getProperty("FilesForSeries").toStringList();
 
   if (!listOfFilesForSeries.isEmpty())
   {
     //for rt data, if the modality tag isn't defined or is "CT" the image is handled like before
     if(ctkEvent.containsProperty("Modality") &&
        (ctkEvent.getProperty("Modality").toString().compare("RTDOSE",Qt::CaseInsensitive) == 0 ||
         ctkEvent.getProperty("Modality").toString().compare("RTSTRUCT",Qt::CaseInsensitive) == 0 ||
         ctkEvent.getProperty("Modality").toString().compare("RTPLAN", Qt::CaseInsensitive) == 0))
     {
       QString modality = ctkEvent.getProperty("Modality").toString();
 
       if(modality.compare("RTDOSE",Qt::CaseInsensitive) == 0)
       {
           auto doseReader = mitk::RTDoseReaderService();
           doseReader.SetInput(listOfFilesForSeries.front().toStdString());
           std::vector<itk::SmartPointer<mitk::BaseData> > readerOutput = doseReader.Read();
           if (!readerOutput.empty()){
             mitk::Image::Pointer doseImage = dynamic_cast<mitk::Image*>(readerOutput.at(0).GetPointer());
 
             mitk::DataNode::Pointer doseImageNode = mitk::DataNode::New();
             doseImageNode->SetData(doseImage);
             doseImageNode->SetName("RTDose");
 
             if (doseImage != nullptr)
             {
                 std::string sopUID;
                 if (mitk::GetBackwardsCompatibleDICOMProperty(0x0008, 0x0016, "dicomseriesreader.SOPClassUID", doseImage->GetPropertyList(), sopUID))
                 {
                   doseImageNode->SetName(sopUID);
                 };
 
                 berry::IPreferencesService* prefService = berry::Platform::GetPreferencesService();
                 berry::IPreferences::Pointer prefNode = prefService->GetSystemPreferences()->Node(mitk::RTUIConstants::ROOT_DOSE_VIS_PREFERENCE_NODE_ID.c_str());
 
                 if (prefNode.IsNull())
                 {
                     mitkThrow() << "Error in preference interface. Cannot find preset node under given name. Name: " << prefNode->ToString().toStdString();
                 }
 
                 //set some specific colorwash and isoline properties
                 bool showColorWashGlobal = prefNode->GetBool(mitk::RTUIConstants::GLOBAL_VISIBILITY_COLORWASH_ID.c_str(), true);
                 bool showIsolinesGlobal = prefNode->GetBool(mitk::RTUIConstants::GLOBAL_VISIBILITY_ISOLINES_ID.c_str(), true);
 
                 //Set reference dose property
                 double referenceDose = prefNode->GetDouble(mitk::RTUIConstants::REFERENCE_DOSE_ID.c_str(), mitk::RTUIConstants::DEFAULT_REFERENCE_DOSE_VALUE);
 
                 mitk::ConfigureNodeAsDoseNode(doseImageNode, mitk::GeneratIsoLevels_Virtuos(), referenceDose, showColorWashGlobal);
 
                 ctkServiceReference serviceReference = mitk::PluginActivator::getContext()->getServiceReference<mitk::IDataStorageService>();
                 mitk::IDataStorageService* storageService = mitk::PluginActivator::getContext()->getService<mitk::IDataStorageService>(serviceReference);
                 mitk::DataStorage* dataStorage = storageService->GetDefaultDataStorage().GetPointer()->GetDataStorage();
 
                 dataStorage->Add(doseImageNode);
 
                 mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(dataStorage);
             }
         }//END DOSE
       }
       else if(modality.compare("RTSTRUCT",Qt::CaseInsensitive) == 0)
       {
           auto structReader = mitk::RTStructureSetReaderService();
           structReader.SetInput(listOfFilesForSeries.front().toStdString());
           std::vector<itk::SmartPointer<mitk::BaseData> > readerOutput = structReader.Read();
 
           if (readerOutput.empty()){
               MITK_ERROR << "No structure sets were created" << endl;
           }
           else {
               std::vector<mitk::DataNode::Pointer> modelVector;
 
               ctkServiceReference serviceReference = mitk::PluginActivator::getContext()->getServiceReference<mitk::IDataStorageService>();
               mitk::IDataStorageService* storageService = mitk::PluginActivator::getContext()->getService<mitk::IDataStorageService>(serviceReference);
               mitk::DataStorage* dataStorage = storageService->GetDefaultDataStorage().GetPointer()->GetDataStorage();
 
               for (const auto& aStruct : readerOutput){
                   mitk::ContourModelSet::Pointer countourModelSet = dynamic_cast<mitk::ContourModelSet*>(aStruct.GetPointer());
 
                   mitk::DataNode::Pointer structNode = mitk::DataNode::New();
                   structNode->SetData(countourModelSet);
                   structNode->SetProperty("name", aStruct->GetProperty("name"));
                   structNode->SetProperty("color", aStruct->GetProperty("contour.color"));
                   structNode->SetProperty("contour.color", aStruct->GetProperty("contour.color"));
                   structNode->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
                   structNode->SetVisibility(true, mitk::BaseRenderer::GetInstance(
                       mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1")));
                   structNode->SetVisibility(false, mitk::BaseRenderer::GetInstance(
                       mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget2")));
                   structNode->SetVisibility(false, mitk::BaseRenderer::GetInstance(
                       mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget3")));
                   structNode->SetVisibility(true, mitk::BaseRenderer::GetInstance(
                       mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4")));
 
                   dataStorage->Add(structNode);
               }
               mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(dataStorage);
           }
       }
       else if (modality.compare("RTPLAN", Qt::CaseInsensitive) == 0)
       {
           auto planReader = mitk::RTPlanReaderService();
           planReader.SetInput(listOfFilesForSeries.front().toStdString());
           std::vector<itk::SmartPointer<mitk::BaseData> > readerOutput = planReader.Read();
           if (!readerOutput.empty()){
               //there is no image, only the properties are interesting
               mitk::Image::Pointer planDummyImage = dynamic_cast<mitk::Image*>(readerOutput.at(0).GetPointer());
 
               mitk::DataNode::Pointer planImageNode = mitk::DataNode::New();
               planImageNode->SetData(planDummyImage);
               planImageNode->SetName("RTPlan");
 
               ctkServiceReference serviceReference = mitk::PluginActivator::getContext()->getServiceReference<mitk::IDataStorageService>();
               mitk::IDataStorageService* storageService = mitk::PluginActivator::getContext()->getService<mitk::IDataStorageService>(serviceReference);
               mitk::DataStorage* dataStorage = storageService->GetDefaultDataStorage().GetPointer()->GetDataStorage();
 
               dataStorage->Add(planImageNode);
           }
       }
     }
     else
     {
       mitk::StringList seriesToLoad;
       QStringListIterator it(listOfFilesForSeries);
 
       while (it.hasNext())
       {
         seriesToLoad.push_back(it.next().toStdString());
       }
 
       //Get Reference for default data storage.
       ctkServiceReference serviceReference = mitk::PluginActivator::getContext()->getServiceReference<mitk::IDataStorageService>();
       mitk::IDataStorageService* storageService = mitk::PluginActivator::getContext()->getService<mitk::IDataStorageService>(serviceReference);
       mitk::DataStorage* dataStorage = storageService->GetDefaultDataStorage().GetPointer()->GetDataStorage();
 
       std::vector<mitk::BaseData::Pointer> baseDatas = mitk::IOUtil::Load(seriesToLoad.front());
       for (const auto &data : baseDatas)
       {
         mitk::DataNode::Pointer node = mitk::DataNode::New();
         node->SetData(data);
 
         std::string nodeName = mitk::DataNode::NO_NAME_VALUE();
 
-        auto studyProp = data->GetProperty(mitk::GeneratePropertyNameForDICOMTag(0x0020, 0x000D).c_str());
-        if (studyProp.IsNotNull())
-        {
-          nodeName = studyProp->GetValueAsString();
+        auto nameDataProp = data->GetProperty("name");
+        if (nameDataProp.IsNotNull())
+        { //if data has a name property set by reader, use this name
+          nodeName = nameDataProp->GetValueAsString();
         }
-
-        auto seriesProp = data->GetProperty(mitk::GeneratePropertyNameForDICOMTag(0x0020, 0x000E).c_str());
-
-        if (seriesProp.IsNotNull())
-        {
-          if (studyProp.IsNotNull())
-          {
-            nodeName += " / ";
-          }
-          nodeName += seriesProp->GetValueAsString();
+        else
+        { //reader didn't specify a name, generate one.
+          nodeName = mitk::GenerateNameFromDICOMProperties(node);
         }
 
         node->SetName(nodeName);
 
         dataStorage->Add(node);
       }
     }
   }
   else
   {
     MITK_INFO << "There are no files for the current series";
   }
 }
 
 void DicomEventHandler::OnSignalRemoveSeriesFromStorage(const ctkEvent& /*ctkEvent*/)
 {
 }
 
 void DicomEventHandler::SubscribeSlots()
 {
   ctkServiceReference ref = mitk::PluginActivator::getContext()->getServiceReference<ctkEventAdmin>();
   if (ref)
   {
     ctkEventAdmin* eventAdmin = mitk::PluginActivator::getContext()->getService<ctkEventAdmin>(ref);
     ctkDictionary properties;
     properties[ctkEventConstants::EVENT_TOPIC] = "org/mitk/gui/qt/dicom/ADD";
     eventAdmin->subscribeSlot(this, SLOT(OnSignalAddSeriesToDataManager(ctkEvent)), properties);
     properties[ctkEventConstants::EVENT_TOPIC] = "org/mitk/gui/qt/dicom/DELETED";
     eventAdmin->subscribeSlot(this, SLOT(OnSignalRemoveSeriesFromStorage(ctkEvent)), properties);
   }
 }