diff --git a/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeaderCnv_p3.h b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeaderCnv_p3.h
new file mode 100755
index 0000000000000000000000000000000000000000..da1a6767b92fdec29f741138ba2230e8be708a9d
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeaderCnv_p3.h
@@ -0,0 +1,62 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef PERSISTENTDATAMODELTPCNV_DATAHEADERCNV_P3_H
+#define PERSISTENTDATAMODELTPCNV_DATAHEADERCNV_P3_H
+
+/**
+ *  @file DataHeaderCnv_p3.h
+ *  @brief This file contains the class definition for the DataHeaderCnv_p3 and DataHeaderElementCnv_p3 classes.
+ *  @author Peter van Gemmeren <gemmeren@anl.gov>
+ *  $Id: DataHeaderCnv_p3.h,v 1.3 2009-04-21 21:48:34 gemmeren Exp $
+ **/
+
+#include "PersistentDataModel/DataHeader.h"
+#include "PersistentDataModelTPCnv/DataHeader_p3.h"
+
+/** @class DataHeaderElementCnv_p3
+ *  @brief This class provides the converter to customize the saving of DataHeaderElement_p3.
+ **/
+class DataHeaderElementCnv_p3 {
+public:
+   DataHeaderElementCnv_p3();
+   virtual ~DataHeaderElementCnv_p3();
+
+   void persToTrans(const DataHeaderElement_p3* pers, DataHeaderElement* trans, const std::vector<std::string>& map);
+   void transToPers(const DataHeaderElement* trans, DataHeaderElement_p3* pers, std::vector<std::string>& map);
+
+friend class DataHeaderCnv_p3;
+};
+
+/** @class DataHeaderCnv_p3
+ *  @brief This class provides the converter to customize the saving of DataHeader_p3.
+ **/
+class DataHeaderCnv_p3 {
+public:
+   DataHeaderCnv_p3();
+   virtual ~DataHeaderCnv_p3();
+
+   DataHeader* createTransient(const DataHeader_p3* persObj);
+   void persToTrans(const DataHeader_p3* pers, DataHeader* trans);
+   DataHeader_p3* createPersistent(const DataHeader* transObj);
+   void transToPers(const DataHeader* trans, DataHeader_p3* pers);
+
+   void insertDHRef(DataHeader_p3* pers, const std::string& key, const std::string& token);
+
+private:
+   DataHeaderElementCnv_p3 m_elemCnv;
+};
+
+inline DataHeader* DataHeaderCnv_p3::createTransient(const DataHeader_p3* persObj) {
+   DataHeader* trans = new DataHeader();
+   persToTrans(persObj, trans);
+   return(trans);
+}
+inline DataHeader_p3* DataHeaderCnv_p3::createPersistent(const DataHeader* transObj){
+   DataHeader_p3* pers = new DataHeader_p3();
+   transToPers(transObj, pers);
+   return(pers);
+}
+
+#endif
diff --git a/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeaderCnv_p4.h b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeaderCnv_p4.h
new file mode 100755
index 0000000000000000000000000000000000000000..dec2f26f82f480ff67d642c653d90e36b7085dfc
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeaderCnv_p4.h
@@ -0,0 +1,62 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef PERSISTENTDATAMODELTPCNV_DATAHEADERCNV_P4_H
+#define PERSISTENTDATAMODELTPCNV_DATAHEADERCNV_P4_H
+
+/**
+ *  @file DataHeaderCnv_p4.h
+ *  @brief This file contains the class definition for the DataHeaderCnv_p4 and DataHeaderElementCnv_p4 classes.
+ *  @author Peter van Gemmeren <gemmeren@anl.gov>
+ *  $Id: DataHeaderCnv_p4.h,v 1.1 2009-04-21 21:48:34 gemmeren Exp $
+ **/
+
+#include "PersistentDataModel/DataHeader.h"
+#include "PersistentDataModelTPCnv/DataHeader_p4.h"
+
+/** @class DataHeaderElementCnv_p4
+ *  @brief This class provides the converter to customize the saving of DataHeaderElement_p4.
+ **/
+class DataHeaderElementCnv_p4 {
+public:
+   DataHeaderElementCnv_p4();
+   virtual ~DataHeaderElementCnv_p4();
+
+   void persToTrans(const DataHeaderElement_p4* pers, DataHeaderElement* trans, const std::vector<std::string>& map);
+   void transToPers(const DataHeaderElement* trans, DataHeaderElement_p4* pers, std::vector<std::string>& map);
+
+friend class DataHeaderCnv_p4;
+};
+
+/** @class DataHeaderCnv_p4
+ *  @brief This class provides the converter to customize the saving of DataHeader_p4.
+ **/
+class DataHeaderCnv_p4 {
+public:
+   DataHeaderCnv_p4();
+   virtual ~DataHeaderCnv_p4();
+
+   DataHeader* createTransient(const DataHeader_p4* persObj);
+   void persToTrans(const DataHeader_p4* pers, DataHeader* trans);
+   DataHeader_p4* createPersistent(const DataHeader* transObj);
+   void transToPers(const DataHeader* trans, DataHeader_p4* pers);
+
+   void insertDHRef(DataHeader_p4* pers, const std::string& key, const std::string& token);
+
+private:
+   DataHeaderElementCnv_p4 m_elemCnv;
+};
+
+inline DataHeader* DataHeaderCnv_p4::createTransient(const DataHeader_p4* persObj) {
+   DataHeader* trans = new DataHeader();
+   persToTrans(persObj, trans);
+   return(trans);
+}
+inline DataHeader_p4* DataHeaderCnv_p4::createPersistent(const DataHeader* transObj){
+   DataHeader_p4* pers = new DataHeader_p4();
+   transToPers(transObj, pers);
+   return(pers);
+}
+
+#endif
diff --git a/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeaderCnv_p5.h b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeaderCnv_p5.h
new file mode 100755
index 0000000000000000000000000000000000000000..77a796a8e9ed926ae3b51378394fd8da3df515b3
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeaderCnv_p5.h
@@ -0,0 +1,64 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef PERSISTENTDATAMODELTPCNV_DATAHEADERCNV_P5_H
+#define PERSISTENTDATAMODELTPCNV_DATAHEADERCNV_P5_H
+
+/**
+ *  @file DataHeaderCnv_p5.h
+ *  @brief This file contains the class definition for the DataHeaderCnv_p5 and DataHeaderElementCnv_p5 classes.
+ *  @author Peter van Gemmeren <gemmeren@anl.gov>
+ *  $Id: DataHeaderCnv_p5.h,v 1.1 2009-04-21 21:48:34 gemmeren Exp $
+ **/
+
+#include "PersistentDataModel/DataHeader.h"
+#include "PersistentDataModelTPCnv/DataHeader_p5.h"
+
+#include <map>
+
+/** @class DataHeaderElementCnv_p5
+ *  @brief This class provides the converter to customize the saving of DataHeaderElement_p5.
+ **/
+class DataHeaderElementCnv_p5 {
+public:
+   DataHeaderElementCnv_p5();
+   virtual ~DataHeaderElementCnv_p5();
+
+   void persToTrans(const DataHeaderElement_p5* pers, DataHeaderElement* trans, const DataHeaderForm_p5& form);
+   void transToPers(const DataHeaderElement* trans, DataHeaderElement_p5* pers, DataHeaderForm_p5& form);
+
+friend class DataHeaderCnv_p5;
+};
+
+/** @class DataHeaderCnv_p5
+ *  @brief This class provides the converter to customize the saving of DataHeader_p5.
+ **/
+class DataHeaderCnv_p5 {
+public:
+   DataHeaderCnv_p5();
+   virtual ~DataHeaderCnv_p5();
+
+   DataHeader* createTransient(const DataHeader_p5* persObj);
+   void persToTrans(const DataHeader_p5* pers, DataHeader* trans);
+   DataHeader_p5* createPersistent(const DataHeader* transObj);
+   void transToPers(const DataHeader* trans, DataHeader_p5* pers);
+
+   void insertDHRef(DataHeader_p5* pers, const std::string& key, const std::string& strToken);
+
+private:
+   DataHeaderElementCnv_p5 m_elemCnv;
+};
+
+inline DataHeader* DataHeaderCnv_p5::createTransient(const DataHeader_p5* persObj) {
+   DataHeader* trans = new DataHeader();
+   persToTrans(persObj, trans);
+   return(trans);
+}
+inline DataHeader_p5* DataHeaderCnv_p5::createPersistent(const DataHeader* transObj){
+   DataHeader_p5* pers = new DataHeader_p5();
+   transToPers(transObj, pers);
+   return(pers);
+}
+
+#endif
diff --git a/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeaderCnv_p6.h b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeaderCnv_p6.h
new file mode 100755
index 0000000000000000000000000000000000000000..573dfeac2a46f6a1eddb7f15dd4402f470166f86
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeaderCnv_p6.h
@@ -0,0 +1,64 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef PERSISTENTDATAMODELTPCNV_DATAHEADERCNV_P6_H
+#define PERSISTENTDATAMODELTPCNV_DATAHEADERCNV_P6_H
+
+/**
+ *  @file DataHeaderCnv_p6.h
+ *  @brief This file contains the class definition for the DataHeaderCnv_p6 and DataHeaderElementCnv_p6 classes.
+ *  @author Peter van Gemmeren <gemmeren@anl.gov>
+ *  $Id: DataHeaderCnv_p6.h,v 1.1 2009-04-21 21:48:34 gemmeren Exp $
+ **/
+
+#include "PersistentDataModel/DataHeader.h"
+#include "PersistentDataModelTPCnv/DataHeader_p6.h"
+
+#include <map>
+
+/** @class DataHeaderElementCnv_p6
+ *  @brief This class provides the converter to customize the saving of DataHeaderElement_p6.
+ **/
+class DataHeaderElementCnv_p6 {
+public:
+   DataHeaderElementCnv_p6();
+   virtual ~DataHeaderElementCnv_p6();
+
+   void persToTrans(const DataHeaderElement_p6* pers, DataHeaderElement* trans, const DataHeaderForm_p6& form);
+   void transToPers(const DataHeaderElement* trans, DataHeaderElement_p6* pers, DataHeaderForm_p6& form);
+
+friend class DataHeaderCnv_p6;
+};
+
+/** @class DataHeaderCnv_p6
+ *  @brief This class provides the converter to customize the saving of DataHeader_p6.
+ **/
+class DataHeaderCnv_p6 {
+public:
+   DataHeaderCnv_p6();
+   virtual ~DataHeaderCnv_p6();
+
+   DataHeader* createTransient(const DataHeader_p6* persObj);
+   void persToTrans(const DataHeader_p6* pers, DataHeader* trans);
+   DataHeader_p6* createPersistent(const DataHeader* transObj);
+   void transToPers(const DataHeader* trans, DataHeader_p6* pers);
+
+   void insertDHRef(DataHeader_p6* pers, const std::string& key, const std::string& strToken);
+
+private:
+   DataHeaderElementCnv_p6 m_elemCnv;
+};
+
+inline DataHeader* DataHeaderCnv_p6::createTransient(const DataHeader_p6* persObj) {
+   DataHeader* trans = new DataHeader();
+   persToTrans(persObj, trans);
+   return(trans);
+}
+inline DataHeader_p6* DataHeaderCnv_p6::createPersistent(const DataHeader* transObj){
+   DataHeader_p6* pers = new DataHeader_p6();
+   transToPers(transObj, pers);
+   return(pers);
+}
+
+#endif
diff --git a/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeader_p3.h b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeader_p3.h
new file mode 100755
index 0000000000000000000000000000000000000000..91dbfed275a9739d67097c84f8fca7527eadd6ae
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeader_p3.h
@@ -0,0 +1,74 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef PERSISTENTDATAMODELTPCNV_DATAHEADER_P3_H
+#define PERSISTENTDATAMODELTPCNV_DATAHEADER_P3_H
+
+/** @file DataHeader_p3.h
+ *  @brief This file contains the class definition for the DataHeader_p3 and DataHeaderElement_p3 classes.
+ *  @author Peter van Gemmeren <gemmeren@anl.gov>
+ *  $Id: DataHeader_p3.h,v 1.4 2009-04-08 19:13:19 gemmeren Exp $
+ **/
+
+#include <vector>
+#include <string>
+#include <stdint.h>
+
+/** @class DataHeaderElement_p3
+ *  @brief This class provides a persistent representation for the DataHeaderElement class.
+ **/
+class DataHeaderElement_p3 {
+public: // Constructor and Destructor
+   DataHeaderElement_p3();
+   DataHeaderElement_p3(const DataHeaderElement_p3& rhs);
+   virtual ~DataHeaderElement_p3();
+
+   DataHeaderElement_p3& operator=(const DataHeaderElement_p3& rhs);
+
+friend class DataHeaderCnv_p3;
+friend class DataHeaderElementCnv_p3;
+
+   const std::string& key() const;
+   unsigned int pClid() const;
+   const std::vector<unsigned int>& clids() const;
+   const std::string& token() const;
+   const std::vector<std::string> alias() const;
+   unsigned int oid1() const;
+   unsigned int oid2() const;
+   void overwriteOid2(unsigned int oid2);
+
+private:
+   std::vector<unsigned int> m_clids;
+   std::string m_token;
+   std::vector<std::string> m_alias;
+   unsigned int m_technology, m_oid1, m_oid2;
+   unsigned short m_dbGuidIdx, m_classIdIdx, m_prefixIdx;
+   unsigned short m_keyPos;
+   std::vector<uint64_t> m_hashes;
+};
+
+/** @class DataHeader_p3
+ *  @brief This class provides a persistent representation for the DataHeader class.
+ **/
+class  DataHeader_p3 {
+public: // Constructor and Destructor
+   DataHeader_p3();
+   DataHeader_p3(const DataHeader_p3& rhs);
+   virtual ~DataHeader_p3();
+
+   DataHeader_p3& operator=(const DataHeader_p3& rhs);
+
+friend class DataHeaderCnv_p3;
+
+   const std::vector<DataHeaderElement_p3>& elements() const;
+   const std::vector<DataHeaderElement_p3>& inputElements() const;
+   const std::vector<std::string>& GuidMap() const;
+
+private:
+   std::vector<DataHeaderElement_p3> m_DataHeader;
+   std::vector<DataHeaderElement_p3> m_InputDataHeader;
+   std::vector<std::string> m_GuidMap;
+};
+
+#endif
diff --git a/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeader_p4.h b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeader_p4.h
new file mode 100755
index 0000000000000000000000000000000000000000..01b30567ea73bf94037827812b0f3865e02c6a78
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeader_p4.h
@@ -0,0 +1,74 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef PERSISTENTDATAMODELTPCNV_DATAHEADER_P4_H
+#define PERSISTENTDATAMODELTPCNV_DATAHEADER_P4_H
+
+/** @file DataHeader_p4.h
+ *  @brief This file contains the class definition for the DataHeader_p4 and DataHeaderElement_p4 classes.
+ *  @author Peter van Gemmeren <gemmeren@anl.gov>
+ *  $Id: DataHeader_p4.h,v 1.1 2009-04-21 21:48:34 gemmeren Exp $
+ **/
+
+#include <vector>
+#include <string>
+#include <stdint.h>
+
+/** @class DataHeaderElement_p4
+ *  @brief This class provides a persistent representation for the DataHeaderElement class.
+ **/
+class DataHeaderElement_p4 {
+public: // Constructor and Destructor
+   DataHeaderElement_p4();
+   DataHeaderElement_p4(const DataHeaderElement_p4& rhs);
+   virtual ~DataHeaderElement_p4();
+
+   DataHeaderElement_p4& operator=(const DataHeaderElement_p4& rhs);
+
+friend class DataHeaderCnv_p4;
+friend class DataHeaderElementCnv_p4;
+
+   unsigned int pClid() const;
+   const std::vector<unsigned int>& clids() const;
+   const std::string& key() const;
+   const std::vector<std::string>& alias() const;
+   const std::string& token() const;
+   unsigned int oid1() const;
+   unsigned int oid2() const;
+   void overwriteOid2(unsigned int oid2);
+
+private:
+   std::vector<unsigned int> m_clids;
+   std::string m_token;
+   std::vector<std::string> m_alias;
+   unsigned int m_technology, m_oid1, m_oid2;
+   unsigned short m_dbGuidIdx, m_classIdIdx, m_prefixIdx;
+   unsigned short m_keyPos;
+   std::vector<uint64_t> m_hashes;
+};
+
+/** @class DataHeader_p4
+ *  @brief This class provides a persistent representation for the DataHeader class.
+ **/
+class  DataHeader_p4 {
+public: // Constructor and Destructor
+   DataHeader_p4();
+   DataHeader_p4(const DataHeader_p4& rhs);
+   virtual ~DataHeader_p4();
+
+   DataHeader_p4& operator=(const DataHeader_p4& rhs);
+
+friend class DataHeaderCnv_p4;
+
+   const std::vector<DataHeaderElement_p4>& elements() const;
+   unsigned int provenanceSize() const;
+   const std::vector<std::string>& guidMap() const;
+
+private:
+   std::vector<DataHeaderElement_p4> m_dataHeader;
+   unsigned int m_provSize;
+   std::vector<std::string> m_guidMap;
+};
+
+#endif
diff --git a/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeader_p5.h b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeader_p5.h
new file mode 100755
index 0000000000000000000000000000000000000000..79ef61e44c90cb86241261ecdfb9e736a8a8a7d6
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeader_p5.h
@@ -0,0 +1,99 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef PERSISTENTDATAMODELTPCNV_DATAHEADER_P5_H
+#define PERSISTENTDATAMODELTPCNV_DATAHEADER_P5_H
+
+/** @file DataHeader_p5.h
+ *  @brief This file contains the class definition for the DataHeader_p5,
+ *  DataHeaderForm_p5 and DataHeaderElement_p5 classes.
+ *  @author Peter van Gemmeren <gemmeren@anl.gov>
+ *  $Id: DataHeader_p5.h,v 1.1 2009-04-21 21:48:34 gemmeren Exp $
+ **/
+
+#include <vector>
+#include <string>
+
+/** @class DataHeaderElement_p5
+ *  @brief This class provides a persistent representation for the DataHeaderElement class.
+ **/
+class DataHeaderElement_p5 {
+public: // Constructor and Destructor
+   DataHeaderElement_p5();
+   DataHeaderElement_p5(const DataHeaderElement_p5& rhs);
+   virtual ~DataHeaderElement_p5();
+
+   DataHeaderElement_p5& operator=(const DataHeaderElement_p5& rhs);
+
+friend class DataHeaderCnv_p5;
+friend class DataHeaderElementCnv_p5;
+
+   const std::string& token() const;
+   unsigned int oid2() const;
+   void overwriteOid2(unsigned int oid2);
+
+private:
+   std::string m_token;
+   unsigned int m_oid2;
+};
+
+/** @class DataHeaderForm_p5
+ *  @brief This class provides storage for the constant fields of the persistent DataHeader class.
+ **/
+class  DataHeaderForm_p5 {
+public: // Constructor and Destructor
+   DataHeaderForm_p5();
+   DataHeaderForm_p5(const DataHeaderForm_p5& rhs);
+   virtual ~DataHeaderForm_p5();
+
+   DataHeaderForm_p5& operator=(const DataHeaderForm_p5& rhs);
+
+friend class DataHeaderCnv_p5;
+
+   const std::vector<std::string>& map() const;
+   void insertMap(const std::string& element);
+
+   const std::vector<unsigned int>& params() const;
+   void insertParam(unsigned int param);
+
+   unsigned int entry() const;
+   void start() const;
+   void next() const;
+   unsigned int size();
+   void resize(unsigned int size);
+
+private:
+   std::vector<std::string> m_map;
+   std::vector<std::vector<unsigned int> > m_uints;
+   mutable unsigned int m_entry;
+};
+
+/** @class DataHeader_p5
+ *  @brief This class provides a persistent representation for the DataHeader class.
+ **/
+class  DataHeader_p5 {
+public: // Constructor and Destructor
+   DataHeader_p5();
+   DataHeader_p5(const DataHeader_p5& rhs);
+   virtual ~DataHeader_p5();
+
+   DataHeader_p5& operator=(const DataHeader_p5& rhs);
+
+friend class DataHeaderCnv_p5;
+
+   const std::vector<DataHeaderElement_p5>& elements() const;
+   const DataHeaderForm_p5& dhForm() const;
+   void setDhForm(const DataHeaderForm_p5& form);
+   const std::string& dhFormToken() const;
+   void setDhFormToken(const std::string& formToken);
+   const std::string& dhFormMdx() const;
+
+private:
+   std::vector<DataHeaderElement_p5> m_dataHeader;
+   DataHeaderForm_p5 m_dhForm;
+   std::string m_dhFormToken;
+   std::string m_dhFormMdx;
+};
+
+#endif
diff --git a/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeader_p6.h b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeader_p6.h
new file mode 100755
index 0000000000000000000000000000000000000000..93493969b48fa442ba3cf105efb2ed85e0d1e29f
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeader_p6.h
@@ -0,0 +1,131 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef PERSISTENTDATAMODELTPCNV_DATAHEADER_P6_H
+#define PERSISTENTDATAMODELTPCNV_DATAHEADER_P6_H
+
+/** @file DataHeader_p6.h
+ *  @brief This file contains the class definition for the DataHeader_p6,
+ *  DataHeaderForm_p6 and DataHeaderElement_p6 classes.
+ *  @author Peter van Gemmeren <gemmeren@anl.gov>
+ *  $Id: DataHeader_p6.h,v 1.1 2009-04-21 21:48:34 gemmeren Exp $
+ **/
+
+#include "PersistentDataModel/Guid.h"
+
+#include <vector>
+#include <set>
+#include <string>
+
+/** @class DataHeaderElement_p6
+ *  @brief This class provides a persistent representation for the DataHeaderElement class.
+ **/
+class DataHeaderElement_p6 {
+public: // Constructor and Destructor
+   DataHeaderElement_p6();
+   DataHeaderElement_p6(const DataHeaderElement_p6& rhs);
+   virtual ~DataHeaderElement_p6();
+
+   DataHeaderElement_p6& operator=(const DataHeaderElement_p6& rhs);
+
+friend class DataHeaderCnv_p6;
+friend class DataHeaderElementCnv_p6;
+
+   const std::string& token() const;
+   unsigned long long oid1() const;
+   unsigned long long oid2() const;
+   void overwriteOid2(unsigned long long oid2);
+
+private:
+   std::string m_token;
+   unsigned long long m_oid1;
+   unsigned long long m_oid2;
+
+   unsigned int m_dbIdx; // entry with GUID & technology
+   unsigned int m_objIdx; // Will get entry with ClassId and transient CLID/key, direct clid for now...
+};
+
+/** @class DataHeaderForm_p6
+ *  @brief This class provides storage for the constant fields of the persistent DataHeader class.
+ **/
+class  DataHeaderForm_p6 {
+public:
+   typedef std::pair<Guid, unsigned int> DbRecord;
+   typedef std::pair<std::string, unsigned int> SgRecord;
+   typedef std::pair<Guid, SgRecord> ObjRecord;
+public: // Constructor and Destructor
+   DataHeaderForm_p6();
+   DataHeaderForm_p6(const DataHeaderForm_p6& rhs);
+   virtual ~DataHeaderForm_p6();
+
+   DataHeaderForm_p6& operator=(const DataHeaderForm_p6& rhs);
+
+friend class DataHeaderCnv_p6;
+
+   unsigned int insertDb(const DbRecord& rec);
+   std::size_t sizeDb() const;
+   Guid getDbGuid(unsigned int index) const;
+   unsigned int getDbTech(unsigned int index) const;
+
+   unsigned int insertObj(const ObjRecord& rec,
+	   const std::set<std::string>& alias = std::set<std::string>(),
+	   const std::set<unsigned int>& symLinks = std::set<unsigned int>(),
+	   const std::vector<unsigned int>& hashes = std::vector<unsigned int>());
+   std::size_t sizeObj() const;
+   std::string getObjKey(unsigned int index) const;
+   unsigned int getObjType(unsigned int index) const;
+   Guid getObjClassId(unsigned int index) const;
+   std::set<std::string> getObjAlias(unsigned int index) const;
+   std::set<unsigned int> getObjSymLinks(unsigned int index) const;
+   std::vector<unsigned int> getObjHashes(unsigned int index) const;
+
+   const std::vector<unsigned int>& params() const;
+   void insertParam(unsigned int param);
+
+   unsigned int entry() const;
+   void start() const;
+   void next() const;
+   unsigned int size() const;
+   void resize(unsigned int size);
+
+private:
+   std::vector<std::vector<unsigned int> > m_uints;
+   std::vector<DbRecord> m_dbRecords;
+   std::vector<ObjRecord> m_objRecords;
+   std::vector<std::vector<std::string> > m_objAlias;
+   std::vector<std::vector<unsigned int> > m_objSymLinks;
+   std::vector<std::vector<unsigned int> > m_objHashes;
+   mutable unsigned int m_entry;
+};
+
+/** @class DataHeader_p6
+ *  @brief This class provides a persistent representation for the DataHeader class.
+ **/
+class  DataHeader_p6 {
+public: // Constructor and Destructor
+   DataHeader_p6();
+   DataHeader_p6(const DataHeader_p6& rhs);
+   virtual ~DataHeader_p6();
+
+   DataHeader_p6& operator=(const DataHeader_p6& rhs);
+
+friend class DataHeaderCnv_p6;
+
+   const std::vector<DataHeaderElement_p6>& elements() const;
+   const DataHeaderForm_p6& dhForm() const;
+   void setDhForm(const DataHeaderForm_p6& form);
+   const std::string& dhFormToken() const;
+   void setDhFormToken(const std::string& formToken);
+   void calculateDhFormMdx();
+   const std::string& dhFormMdx() const;
+
+private:
+   std::vector<DataHeaderElement_p6> m_dataHeader;
+   unsigned int m_provenanceSize;
+   DataHeaderForm_p6 m_dhForm;
+   std::string m_dhFormToken;
+   std::string m_dhFormMdx;
+};
+
+#endif
diff --git a/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/PersistentDataModelTPCnvDict.h b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/PersistentDataModelTPCnvDict.h
new file mode 100755
index 0000000000000000000000000000000000000000..a400a019cfa9363b43347cb00582737645c12e43
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/PersistentDataModelTPCnvDict.h
@@ -0,0 +1,25 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef PERSISTENTDATAMODEL_PERSISTENTDATAMODELTPCNVDICT_H
+#define PERSISTENTDATAMODEL_PERSISTENTDATAMODELTPCNVDICT_H
+
+#include "PersistentDataModelTPCnv/DataHeader_p3.h"
+#include "PersistentDataModelTPCnv/DataHeader_p4.h"
+#include "PersistentDataModelTPCnv/DataHeader_p5.h"
+#include "PersistentDataModelTPCnv/DataHeader_p6.h"
+#include "PersistentDataModelTPCnv/DataHeaderCnv_p5.h"
+#include "PersistentDataModelTPCnv/DataHeaderCnv_p6.h"
+
+// Need to instantiate iterators
+namespace PersistentDataModelTPCnvDict {
+   // template instantiations
+   std::pair<Guid, unsigned int> dummy_dbRecord;
+   std::vector<std::pair<Guid, unsigned int> > dummy_dbRecords;
+   std::pair<std::string, unsigned int> dummy_sgRecord;
+   std::pair<Guid, std::pair<std::string, unsigned int> > dummy_objRecord;
+   std::vector<std::pair<Guid, std::pair<std::string, unsigned int> > >dummy_objRecords;
+}
+
+#endif
diff --git a/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/selection.xml b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/selection.xml
new file mode 100755
index 0000000000000000000000000000000000000000..a393fad05ac4a033740af3b7fea4d11abce74780
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/selection.xml
@@ -0,0 +1,32 @@
+<lcgdict>
+   <class name="DataHeader_p3" id="EC1318F0-8E28-45F8-9A2D-2597C1CC87A6" />
+   <class name="std::vector<DataHeaderElement_p3>" />
+   <class name="DataHeaderElement_p3" />
+   <class name="DataHeader_p4" id="9630EB7B-CCD7-47D9-A39B-CBBF4133CDF2" />
+   <class name="std::vector<DataHeaderElement_p4>" />
+   <class name="DataHeaderElement_p4" />
+   <class name="DataHeader_p5" id="D82968A1-CF91-4320-B2DD-E0F739CBC7E6">
+      <field name="m_dhForm" transient="true" />
+   </class>
+   <class name="std::vector<DataHeaderElement_p5>" />
+   <class name="DataHeaderElement_p5" />
+   <class name="DataHeaderForm_p5" id="3397D8A3-BBE6-463C-9F8E-4B3DFD8831FE">
+      <field name="m_entry" transient="true" />
+   </class>
+   <class name="DataHeaderCnv_p5"/>
+   <class name="DataHeader_p6" id="4DDBD295-EFCE-472A-9EC8-15CD35A9EB8D">
+      <field name="m_dhForm" transient="true" />
+   </class>
+   <class name="std::vector<DataHeaderElement_p6>" />
+   <class name="DataHeaderElement_p6" />
+   <class name="DataHeaderForm_p6" id="7BE56CEF-C866-4BEE-9348-A5F34B5F1DAD">
+      <field name="m_entry" transient="true" />
+   </class>
+   <class name="std::vector<std::pair<Guid, unsigned int> >" />
+   <class name="std::pair<Guid, unsigned int>" />
+   <class name="Guid" />
+   <class name="std::vector<std::pair<Guid, std::pair<std::string, unsigned int> > >" />
+   <class name="std::pair<Guid, std::pair<std::string, unsigned int> >" />
+   <class name="std::pair<std::string, unsigned int>" />
+   <class name="DataHeaderCnv_p6"/>
+</lcgdict>
diff --git a/Database/PersistentDataModelTPCnv/cmt/requirements b/Database/PersistentDataModelTPCnv/cmt/requirements
new file mode 100755
index 0000000000000000000000000000000000000000..42b9cb5e702b873230709cce9725a846293be7c7
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/cmt/requirements
@@ -0,0 +1,18 @@
+package PersistentDataModelTPCnv
+
+author Peter van Gemmeren <gemmeren@anl.gov>
+
+use AtlasPolicy           AtlasPolicy-*
+
+use PersistentDataModel   PersistentDataModel-*      Database
+
+library PersistentDataModelTPCnv *.cxx
+apply_pattern installed_library
+
+private
+use AtlasReflex           AtlasReflex-*              External -no_auto_imports
+use uuid                  *                          LCG_Interfaces
+
+use CxxUtils              CxxUtils-*                 Control
+
+apply_pattern lcgdict dict=PersistentDataModelTPCnv selectionfile=selection.xml headerfiles="-s=${PersistentDataModelTPCnv_root}/PersistentDataModelTPCnv PersistentDataModelTPCnvDict.h"
diff --git a/Database/PersistentDataModelTPCnv/src/DataHeaderCnv_p3.cxx b/Database/PersistentDataModelTPCnv/src/DataHeaderCnv_p3.cxx
new file mode 100755
index 0000000000000000000000000000000000000000..278b724f40c8b581a381b5cb4a5b3ad4cadf9204
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/src/DataHeaderCnv_p3.cxx
@@ -0,0 +1,123 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/** @file DataHeaderCnv_p3.cxx
+ *  @brief This file contains the implementation for the DataHeaderCnv_p3 class.
+ *  @author Peter van Gemmeren <gemmeren@anl.gov>
+ *  $Id: DataHeaderCnv_p3.cxx,v 1.6 2009-05-15 01:01:57 gemmeren Exp $
+ **/
+
+#define private public
+#define protected public
+#include "PersistentDataModel/DataHeader.h"
+#undef private
+#undef protected
+
+#include "PersistentDataModelTPCnv/DataHeaderCnv_p3.h"
+
+#include <cstdio>
+#include <sstream>
+
+DataHeaderElementCnv_p3::DataHeaderElementCnv_p3() {}
+DataHeaderElementCnv_p3::~DataHeaderElementCnv_p3() {}
+
+//______________________________________________________________________________
+void DataHeaderElementCnv_p3::persToTrans(const DataHeaderElement_p3* pers,
+	DataHeaderElement* trans,
+	const std::vector<std::string>& map) {
+   trans->m_pClid = *pers->m_clids.begin();
+   trans->m_clids.clear();
+   std::set<CLID>::iterator lastClid = trans->m_clids.begin();
+   for (std::vector<unsigned int>::const_iterator iter = pers->m_clids.begin() + 1,
+		   last = pers->m_clids.end(); iter != last; iter++) {
+      lastClid = trans->m_clids.insert(lastClid, *iter);
+   }
+   trans->m_key = *pers->m_alias.begin();
+   trans->m_alias.clear();
+   std::set<std::string>::iterator lastAlias = trans->m_alias.begin();
+   for (std::vector<std::string>::const_iterator iter = pers->m_alias.begin() + 1,
+		   last = pers->m_alias.end(); iter != last; iter++) {
+      lastAlias = trans->m_alias.insert(lastAlias, *iter);
+   }
+   trans->m_hashes.clear();
+   trans->m_hashes.reserve(pers->m_hashes.size());
+   for (std::vector<uint64_t>::const_iterator iter = pers->m_hashes.begin(),
+		   last = pers->m_hashes.end(); iter != last; iter++) {
+      trans->m_hashes.push_back((unsigned int)(*iter));
+   }
+// Translate PoolToken
+   std::string tokenStr;
+   if (map.empty()) {
+      tokenStr = pers->m_token;
+   } else {
+      unsigned int tokenSize = 129 + pers->m_token.size();
+      if (pers->m_prefixIdx > 0) {
+         tokenSize += map[pers->m_prefixIdx].size();
+      }
+      if (pers->m_keyPos > 0) {
+         tokenSize += trans->m_key.size();
+      }
+      tokenStr.reserve(tokenSize);
+// Append DbGuid
+      tokenStr = "[DB=";
+      tokenStr.append(map[pers->m_dbGuidIdx]);
+// Still optimize
+      tokenStr.append("][CNT=");
+      if (pers->m_prefixIdx > 0) {
+         tokenStr.append(map[pers->m_prefixIdx]);
+      }
+// insert key
+      if (pers->m_keyPos > 0) {
+         tokenStr.append(pers->m_token.substr(0, pers->m_keyPos - 1));
+         tokenStr.append(trans->m_key);
+         tokenStr.append(pers->m_token.substr(pers->m_keyPos - 1));
+      } else {
+         tokenStr.append(pers->m_token);
+      }
+// Append ClassId
+      tokenStr.append("][CLID=");
+      tokenStr.append(map[pers->m_classIdIdx]);
+      const unsigned int length = 40;
+      char text[length];
+      snprintf(text, length, "][TECH=%08X][OID=%08X-%08X]", pers->m_technology, pers->m_oid1, pers->m_oid2);
+      tokenStr.append(text);
+   }
+   delete trans->m_token; trans->m_token = new Token;
+   const_cast<Token*>(trans->m_token)->fromString(tokenStr);
+}
+//______________________________________________________________________________
+void DataHeaderElementCnv_p3::transToPers(const DataHeaderElement* /*trans*/,
+	DataHeaderElement_p3* /*pers*/,
+	std::vector<std::string>& /*map*/) {
+// Moved to next _p version
+}
+//______________________________________________________________________________
+//______________________________________________________________________________
+DataHeaderCnv_p3::DataHeaderCnv_p3() {}
+DataHeaderCnv_p3::~DataHeaderCnv_p3() {}
+//______________________________________________________________________________
+void DataHeaderCnv_p3::persToTrans(const DataHeader_p3* pers, DataHeader* trans) {
+   trans->m_dataHeader.resize(pers->m_DataHeader.size());
+   std::vector<DataHeaderElement>::iterator it = trans->m_dataHeader.begin();
+   for (std::vector<DataHeaderElement_p3>::const_iterator pit = pers->m_DataHeader.begin(),
+		   last = pers->m_DataHeader.end(); pit != last; it++, pit++) {
+      m_elemCnv.persToTrans(&(*pit), &(*it), pers->m_GuidMap);
+   }
+   trans->m_inputDataHeader.resize(pers->m_InputDataHeader.size());
+   it = trans->m_inputDataHeader.begin();
+   for (std::vector<DataHeaderElement_p3>::const_iterator pit = pers->m_InputDataHeader.begin(),
+		   last = pers->m_InputDataHeader.end(); pit != last; it++, pit++) {
+      m_elemCnv.persToTrans(&(*pit), &(*it), pers->m_GuidMap);
+   }
+}
+//______________________________________________________________________________
+void DataHeaderCnv_p3::transToPers(const DataHeader* /*trans*/, DataHeader_p3* /*pers*/) {
+// Moved to next _p version
+}
+//______________________________________________________________________________
+void DataHeaderCnv_p3::insertDHRef(DataHeader_p3* /*pers*/,
+	const std::string& /*key*/,
+	const std::string& /*token*/) {
+// Moved to next _p version
+}
diff --git a/Database/PersistentDataModelTPCnv/src/DataHeaderCnv_p4.cxx b/Database/PersistentDataModelTPCnv/src/DataHeaderCnv_p4.cxx
new file mode 100755
index 0000000000000000000000000000000000000000..c8e373d113b7c173a2c52de05ed6b540a46e6b35
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/src/DataHeaderCnv_p4.cxx
@@ -0,0 +1,127 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/** @file DataHeaderCnv_p4.cxx
+ *  @brief This file contains the implementation for the DataHeaderCnv_p4 class.
+ *  @author Peter van Gemmeren <gemmeren@anl.gov>
+ *  $Id: DataHeaderCnv_p4.cxx,v 1.3 2009-05-15 01:01:57 gemmeren Exp $
+ **/
+
+#define private public
+#define protected public
+#include "PersistentDataModel/DataHeader.h"
+#undef private
+#undef protected
+
+#include "PersistentDataModelTPCnv/DataHeaderCnv_p4.h"
+
+#include <cstdio>
+#include <sstream>
+
+DataHeaderElementCnv_p4::DataHeaderElementCnv_p4() {}
+DataHeaderElementCnv_p4::~DataHeaderElementCnv_p4() {}
+
+//______________________________________________________________________________
+void DataHeaderElementCnv_p4::persToTrans(const DataHeaderElement_p4* pers,
+	DataHeaderElement* trans,
+	const std::vector<std::string>& map) {
+   std::vector<unsigned int>::const_iterator intIter = pers->m_clids.begin();
+   const std::vector<unsigned int>::const_iterator intLast = pers->m_clids.end();
+   trans->m_pClid = *intIter; intIter++;
+   trans->m_clids.clear();
+   for (std::set<CLID>::const_iterator lastClid = trans->m_clids.begin();
+		   intIter != intLast; intIter++) {
+      lastClid = trans->m_clids.insert(lastClid, *intIter);
+   }
+   std::vector<std::string>::const_iterator strIter = pers->m_alias.begin();
+   const std::vector<std::string>::const_iterator strLast = pers->m_alias.end();
+   trans->m_key = *strIter; strIter++;
+   trans->m_alias.clear();
+   for (std::set<std::string>::const_iterator lastAlias = trans->m_alias.begin();
+		   strIter != strLast; strIter++) {
+      lastAlias = trans->m_alias.insert(lastAlias, *strIter);
+   }
+   trans->m_hashes.clear();
+   trans->m_hashes.reserve(pers->m_hashes.size());
+   for (std::vector<uint64_t>::const_iterator iter = pers->m_hashes.begin(),
+		   last = pers->m_hashes.end(); iter != last; iter++) {
+      trans->m_hashes.push_back((unsigned int)(*iter));
+   }
+// Translate PoolToken
+   std::string tokenStr;
+   if (map.empty()) {
+      tokenStr = pers->m_token;
+   } else {
+      unsigned int tokenSize = 129 + pers->m_token.size();
+      if (pers->m_prefixIdx > 0) {
+         tokenSize += map[pers->m_prefixIdx].size();
+      }
+      if (pers->m_keyPos > 0) {
+         tokenSize += trans->m_key.size();
+      }
+      tokenStr.reserve(tokenSize);
+// Append DbGuid
+      tokenStr = "[DB=";
+      tokenStr.append(map[pers->m_dbGuidIdx]);
+// Still optimize
+      tokenStr.append("][CNT=");
+      std::string cntName;
+      if (pers->m_prefixIdx > 0) {
+         tokenStr.append(map[pers->m_prefixIdx]);
+      }
+// insert key
+      if (pers->m_keyPos > 0) {
+         tokenStr.append(pers->m_token.substr(0, pers->m_keyPos - 1));
+         tokenStr.append(trans->m_key);
+         tokenStr.append(pers->m_token.substr(pers->m_keyPos - 1));
+      } else {
+         tokenStr.append(pers->m_token);
+      }
+// Append ClassId
+      tokenStr.append("][CLID=");
+      tokenStr.append(map[pers->m_classIdIdx]);
+// Add Technology and Offsets
+      const unsigned int length = 40;
+      char text[length];
+      snprintf(text, length, "][TECH=%08X][OID=%08X-%08X]", pers->m_technology, pers->m_oid1, pers->m_oid2);
+      tokenStr.append(text);
+   }
+   delete trans->m_token; trans->m_token = new Token;
+   const_cast<Token*>(trans->m_token)->fromString(tokenStr);
+}
+//______________________________________________________________________________
+void DataHeaderElementCnv_p4::transToPers(const DataHeaderElement* /*trans*/,
+	DataHeaderElement_p4* /*pers*/,
+	std::vector<std::string>& /*map*/) {
+// Moved to next _p version
+}
+//______________________________________________________________________________
+//______________________________________________________________________________
+DataHeaderCnv_p4::DataHeaderCnv_p4() {}
+DataHeaderCnv_p4::~DataHeaderCnv_p4() {}
+//______________________________________________________________________________
+void DataHeaderCnv_p4::persToTrans(const DataHeader_p4* pers, DataHeader* trans) {
+   trans->m_inputDataHeader.resize(pers->m_provSize);
+   std::vector<DataHeaderElement>::iterator it = trans->m_inputDataHeader.begin();
+   std::vector<DataHeaderElement_p4>::const_iterator pit = pers->m_dataHeader.begin();
+   for (unsigned int i = 0U; i != pers->m_provSize; i++, it++, pit++) {
+      m_elemCnv.persToTrans(&(*pit), &(*it), pers->m_guidMap);
+   }
+   trans->m_dataHeader.resize(pers->m_dataHeader.size() - pers->m_provSize);
+   it = trans->m_dataHeader.begin();
+   for (std::vector<DataHeaderElement_p4>::const_iterator last = pers->m_dataHeader.end();
+		   pit != last; it++, pit++) {
+      m_elemCnv.persToTrans(&(*pit), &(*it), pers->m_guidMap);
+   }
+}
+//______________________________________________________________________________
+void DataHeaderCnv_p4::transToPers(const DataHeader* /*trans*/, DataHeader_p4* /*pers*/) {
+// Moved to next _p version
+}
+//______________________________________________________________________________
+void DataHeaderCnv_p4::insertDHRef(DataHeader_p4* /*pers*/,
+	const std::string& /*key*/,
+	const std::string& /*token*/) {
+// Moved to next _p version
+}
diff --git a/Database/PersistentDataModelTPCnv/src/DataHeaderCnv_p5.cxx b/Database/PersistentDataModelTPCnv/src/DataHeaderCnv_p5.cxx
new file mode 100755
index 0000000000000000000000000000000000000000..9cad285a1fbfbc9ebddf1b45536204a30e47ee97
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/src/DataHeaderCnv_p5.cxx
@@ -0,0 +1,241 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/** @file DataHeaderCnv_p5.cxx
+ *  @brief This file contains the implementation for the DataHeaderCnv_p5 class.
+ *  @author Peter van Gemmeren <gemmeren@anl.gov>
+ *  $Id: DataHeaderCnv_p5.cxx,v 1.3.2.2 2009-05-22 19:26:54 gemmeren Exp $
+ **/
+
+#define private public
+#define protected public
+#include "PersistentDataModel/DataHeader.h"
+#undef private
+#undef protected
+
+#include "PersistentDataModelTPCnv/DataHeaderCnv_p5.h"
+
+DataHeaderElementCnv_p5::DataHeaderElementCnv_p5() {}
+DataHeaderElementCnv_p5::~DataHeaderElementCnv_p5() {}
+
+//______________________________________________________________________________
+void DataHeaderElementCnv_p5::persToTrans(const DataHeaderElement_p5* pers,
+	DataHeaderElement* trans,
+	const DataHeaderForm_p5& form) {
+   delete trans->m_token; trans->m_token = new Token; trans->m_ownToken = true;
+   Token* token = const_cast<Token*>(trans->m_token);
+   std::vector<unsigned int>::const_iterator intIter = form.params().begin();
+   unsigned int keyIdx = 0U, aliasNum = 0U, clidNum = 0U;
+// Translate PoolToken
+   if ((*intIter&0x0000FFFF) == 0) {
+      intIter++;
+      keyIdx = *intIter; intIter++;
+      aliasNum = *intIter; intIter++;
+      clidNum = *intIter; intIter++;
+      token->fromString(pers->m_token);
+   } else {
+      const unsigned int keyPos = (unsigned short)(*intIter>>16); intIter++;
+      const unsigned int guidIdx = (unsigned short)(*intIter>>16),
+	      classIdx = (unsigned short)(*intIter&0x0000FFFF); intIter++;
+      const unsigned int prefixIdx = (unsigned short)(*intIter>>16),
+	      typeIdx = (unsigned short)(*intIter&0x0000FFFF); intIter++;
+// Add Technology and Offsets
+      unsigned int tech = *intIter; intIter++;
+      unsigned int oid1 = *intIter; intIter++;
+      keyIdx = *intIter; intIter++;
+      aliasNum = *intIter; intIter++;
+      clidNum = *intIter; intIter++;
+// Append DbGuid
+      Guid guid(form.map()[guidIdx]);
+      token->setDb(guid);
+// Container name, may be optimized
+      std::string cntName;
+      if (prefixIdx > 0) {
+         cntName += form.map()[prefixIdx];
+         if (typeIdx > 0) {
+            cntName += form.map()[typeIdx];
+         }
+      }
+// Insert key
+      if (keyPos > 0) {
+         cntName += pers->m_token.substr(0, keyPos - 1) + form.map()[keyIdx] + pers->m_token.substr(keyPos - 1);
+      } else {
+         cntName += pers->m_token;
+      }
+      //token->setCont(cntName);
+// Append ClassId
+      Guid clid(form.map()[classIdx]);
+      token->setClassID(clid);
+      token->setTechnology(tech);
+      token->setOid(Token::OID_t(oid1, pers->m_oid2));
+   }
+   unsigned int aliasCur = 0U, clidCur = 0U;
+   trans->m_key = form.map()[keyIdx];
+   trans->m_alias.clear();
+   for (std::set<std::string>::const_iterator lastAlias = trans->m_alias.begin();
+		   aliasCur < aliasNum; aliasCur++) {
+      lastAlias = trans->m_alias.insert(lastAlias, form.map()[keyIdx + aliasCur + 1]);
+   }
+   trans->m_pClid = *intIter; intIter++;
+   trans->m_clids.clear();
+   const std::vector<unsigned int>::const_iterator intLast = form.params().end();
+   for (std::set<CLID>::const_iterator lastClid = trans->m_clids.begin();
+		   intIter != intLast && clidCur < clidNum; intIter++, clidCur++) {
+      lastClid = trans->m_clids.insert(lastClid, *intIter);
+   }
+   trans->m_hashes.clear();
+   for (; intIter != intLast; intIter++) {
+      trans->m_hashes.push_back(*intIter);
+   }
+}
+//______________________________________________________________________________
+void DataHeaderElementCnv_p5::transToPers(const DataHeaderElement* trans,
+	DataHeaderElement_p5* pers,
+	DataHeaderForm_p5& form) {
+   unsigned int tech = 0U, oid1 = 0U;
+   unsigned short guidIdx = 0U, classIdx = 0U, prefixIdx = 0U, typeIdx = 0U, keyPos = 0U;
+// Translate PoolToken
+   if (trans->getToken() != 0) {
+// Database GUID
+      const std::string guid = trans->getToken()->dbID().toString();
+      for (std::vector<std::string>::const_iterator iter = form.map().begin(), last = form.map().end();
+	      iter != last; iter++, guidIdx++) {
+         if (*iter == guid) break;
+      }
+      if (guidIdx == form.map().size()) {
+         form.insertMap(guid);
+      }
+// Class GUID
+      const std::string clid = trans->getToken()->classID().toString();
+      for (std::vector<std::string>::const_iterator iter = form.map().begin(), last = form.map().end();
+	      iter != last; iter++, classIdx++) {
+         if (*iter == clid) break;
+      }
+      if (classIdx == form.map().size()) {
+         form.insertMap(clid);
+      }
+// Container name, can be optimized
+      pers->m_token = trans->getToken()->contID();
+// Get Prefix
+      std::string::size_type delim = pers->m_token.find_first_of("_/(");
+      if (delim != std::string::npos) {
+         const std::string persComp1 = pers->m_token.substr(0, delim + 1);
+         for (std::vector<std::string>::const_iterator iter = form.map().begin(), last = form.map().end();
+	         iter != last; iter++, prefixIdx++) {
+            if (*iter == persComp1) break;
+         }
+         if (prefixIdx == form.map().size()) {
+            form.insertMap(persComp1);
+         }
+         pers->m_token = pers->m_token.substr(delim + 1);
+// Get TypeName
+         std::string::size_type delim = pers->m_token.find_first_of("/()");
+         if (delim != std::string::npos) {
+            const std::string persComp2 = pers->m_token.substr(0, delim + 1);
+            for (std::vector<std::string>::const_iterator iter = form.map().begin(), last = form.map().end();
+	            iter != last; iter++, typeIdx++) {
+               if (*iter == persComp2) break;
+            }
+            if (typeIdx == form.map().size()) {
+               form.insertMap(persComp2);
+            }
+            pers->m_token = pers->m_token.substr(delim + 1);
+         } else if (pers->m_token == "DataHeader") {
+            for (std::vector<std::string>::const_iterator iter = form.map().begin(), last = form.map().end();
+	            iter != last; iter++, typeIdx++) {
+               if (*iter == "DataHeader") break;
+            }
+            if (typeIdx == form.map().size()) {
+               form.insertMap("DataHeader");
+            }
+            pers->m_token.clear();
+         }
+      }
+      delim = pers->m_token.rfind(trans->m_key);
+      if (delim != std::string::npos) {
+         keyPos = delim + 1;
+         pers->m_token = pers->m_token.substr(0, delim) + pers->m_token.substr(delim + trans->m_key.size());
+      }
+      tech = trans->getToken()->technology();
+      oid1 = trans->getToken()->oid().first;
+      pers->m_oid2 = trans->getToken()->oid().second;
+   }
+   form.insertParam((unsigned int)(keyPos) * 0x00010000U + 0x0000FFFFU);
+   form.insertParam((unsigned int)(guidIdx) * 0x00010000U + (unsigned int)(classIdx));
+   form.insertParam((unsigned int)(prefixIdx) * 0x00010000U + (unsigned int)(typeIdx));
+   form.insertParam(tech);
+   form.insertParam(oid1);
+   unsigned int keyIdx = form.map().size(), aliasNum = trans->m_alias.size(), clidNum = trans->m_clids.size();
+   form.insertParam(keyIdx);
+   form.insertParam(aliasNum);
+   form.insertParam(clidNum);
+   form.insertMap(trans->m_key);
+   for (std::set<std::string>::const_iterator iter = trans->m_alias.begin(),
+		   last = trans->m_alias.end(); iter != last; iter++) {
+      form.insertMap(*iter);
+   }
+   form.insertParam(trans->m_pClid);
+   for (std::set<CLID>::const_iterator iter = trans->m_clids.begin(),
+		   last = trans->m_clids.end(); iter != last; iter++) {
+      form.insertParam(*iter);
+   }
+   for (std::vector<unsigned int>::const_iterator iter = trans->m_hashes.begin(),
+		   last = trans->m_hashes.end(); iter != last; iter++) {
+      form.insertParam(*iter);
+   }
+}
+//______________________________________________________________________________
+//______________________________________________________________________________
+DataHeaderCnv_p5::DataHeaderCnv_p5() {}
+DataHeaderCnv_p5::~DataHeaderCnv_p5() {}
+//______________________________________________________________________________
+void DataHeaderCnv_p5::persToTrans(const DataHeader_p5* pers, DataHeader* trans) {
+   pers->m_dhForm.start();
+   const unsigned int provSize = pers->m_dhForm.params()[0];
+   trans->m_inputDataHeader.resize(provSize);
+   std::vector<DataHeaderElement>::iterator it = trans->m_inputDataHeader.begin();
+   std::vector<DataHeaderElement_p5>::const_iterator pit = pers->m_dataHeader.begin();
+   for (unsigned int i = 0U; i < provSize; i++, it++, pit++) {
+      pers->m_dhForm.next();
+      m_elemCnv.persToTrans(&(*pit), &(*it), pers->m_dhForm);
+   }
+   trans->m_dataHeader.resize(pers->m_dataHeader.size() - provSize);
+   it = trans->m_dataHeader.begin();
+   for (std::vector<DataHeaderElement_p5>::const_iterator last = pers->m_dataHeader.end();
+		   pit != last; it++, pit++) {
+      pers->m_dhForm.next();
+      m_elemCnv.persToTrans(&(*pit), &(*it), pers->m_dhForm);
+   }
+}
+//______________________________________________________________________________
+void DataHeaderCnv_p5::transToPers(const DataHeader* trans, DataHeader_p5* pers) {
+   const unsigned int provSize = trans->m_inputDataHeader.size();
+   pers->m_dataHeader.resize(provSize + trans->m_dataHeader.size());
+   pers->m_dhForm.resize(provSize + trans->m_dataHeader.size() + 2);
+   pers->m_dhForm.start();
+   pers->m_dhForm.insertParam(provSize);
+   std::vector<DataHeaderElement_p5>::iterator pit = pers->m_dataHeader.begin();
+   for (std::vector<DataHeaderElement>::const_iterator it = trans->m_inputDataHeader.begin(),
+		   last = trans->m_inputDataHeader.end(); it != last; it++, pit++) {
+      pers->m_dhForm.next();
+      m_elemCnv.transToPers(&(*it), &(*pit), pers->m_dhForm);
+   }
+   for (std::vector<DataHeaderElement>::const_iterator it = trans->m_dataHeader.begin(),
+		   last = trans->m_dataHeader.end(); it != last; it++, pit++) {
+      pers->m_dhForm.next();
+      m_elemCnv.transToPers(&(*it), &(*pit), pers->m_dhForm);
+   }
+}
+//______________________________________________________________________________
+void DataHeaderCnv_p5::insertDHRef(DataHeader_p5* pers,
+	const std::string& key,
+	const std::string& strToken) {
+   Token* token = new Token;
+   token->fromString(strToken);
+   DataHeaderElement tEle(ClassID_traits<DataHeader>::ID(), key, token);
+   DataHeaderElement_p5 pEle;
+   pers->m_dhForm.next();
+   m_elemCnv.transToPers(&tEle, &pEle, pers->m_dhForm);
+   pers->m_dataHeader.push_back(pEle);
+}
diff --git a/Database/PersistentDataModelTPCnv/src/DataHeaderCnv_p6.cxx b/Database/PersistentDataModelTPCnv/src/DataHeaderCnv_p6.cxx
new file mode 100755
index 0000000000000000000000000000000000000000..ca99a28c26fd23a75a91bc22cc919cae48880d82
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/src/DataHeaderCnv_p6.cxx
@@ -0,0 +1,111 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/** @file DataHeaderCnv_p6.cxx
+ *  @brief This file contains the implementation for the DataHeaderCnv_p6 class.
+ *  @author Peter van Gemmeren <gemmeren@anl.gov>
+ *  $Id: DataHeaderCnv_p6.cxx,v 1.3.2.2 2009-05-22 19:26:54 gemmeren Exp $
+ **/
+
+#define private public
+#define protected public
+#include "PersistentDataModel/DataHeader.h"
+#undef private
+#undef protected
+
+#include "PersistentDataModelTPCnv/DataHeaderCnv_p6.h"
+
+DataHeaderElementCnv_p6::DataHeaderElementCnv_p6() {}
+DataHeaderElementCnv_p6::~DataHeaderElementCnv_p6() {}
+
+//______________________________________________________________________________
+void DataHeaderElementCnv_p6::persToTrans(const DataHeaderElement_p6* pers,
+	DataHeaderElement* trans,
+	const DataHeaderForm_p6& form) {
+   delete trans->m_token; trans->m_token = new Token;
+   Token* token = const_cast<Token*>(trans->m_token);
+// Append DbGuid
+   token->setDb(form.getDbGuid(pers->m_dbIdx));
+   token->setTechnology(form.getDbTech(pers->m_dbIdx));
+// Append ClassId
+   token->setClassID(form.getObjClassId(pers->m_objIdx));
+   token->setOid(Token::OID_t(pers->m_oid1, pers->m_oid2));
+// StoreGate
+   trans->m_key = form.getObjKey(pers->m_objIdx);
+   trans->m_alias = form.getObjAlias(pers->m_objIdx);
+   trans->m_pClid = form.getObjType(pers->m_objIdx);
+   trans->m_clids = form.getObjSymLinks(pers->m_objIdx);
+   trans->m_hashes = form.getObjHashes(pers->m_objIdx);
+}
+//______________________________________________________________________________
+void DataHeaderElementCnv_p6::transToPers(const DataHeaderElement* trans,
+	DataHeaderElement_p6* pers,
+	DataHeaderForm_p6& form) {
+// Translate PoolToken
+   if (trans->getToken() != 0) {
+// Database GUID & Technology
+      DataHeaderForm_p6::DbRecord transDb(trans->getToken()->dbID(), trans->getToken()->technology());
+      pers->m_dbIdx = form.insertDb(transDb);
+// StoreGate Type/Key & persistent Class GUID
+      DataHeaderForm_p6::SgRecord transSg(trans->m_key, trans->m_pClid);
+      DataHeaderForm_p6::ObjRecord transObj(trans->getToken()->classID(), transSg);
+      pers->m_objIdx = form.insertObj(transObj, trans->m_alias, trans->m_clids, trans->m_hashes);
+      pers->m_oid1 = trans->getToken()->oid().first;
+      pers->m_oid2 = trans->getToken()->oid().second;
+   }
+}
+//______________________________________________________________________________
+//______________________________________________________________________________
+DataHeaderCnv_p6::DataHeaderCnv_p6() {}
+DataHeaderCnv_p6::~DataHeaderCnv_p6() {}
+//______________________________________________________________________________
+void DataHeaderCnv_p6::persToTrans(const DataHeader_p6* pers, DataHeader* trans) {
+   pers->m_dhForm.start();
+   const unsigned int provSize = pers->m_provenanceSize;
+   trans->m_inputDataHeader.resize(provSize);
+   std::vector<DataHeaderElement>::iterator it = trans->m_inputDataHeader.begin();
+   std::vector<DataHeaderElement_p6>::const_iterator pit = pers->m_dataHeader.begin();
+   for (unsigned int i = 0U; i < provSize; i++, it++, pit++) {
+      m_elemCnv.persToTrans(&(*pit), &(*it), pers->m_dhForm);
+      pers->m_dhForm.next();
+   }
+   trans->m_dataHeader.resize(pers->m_dataHeader.size() - provSize);
+   it = trans->m_dataHeader.begin();
+   for (std::vector<DataHeaderElement_p6>::const_iterator last = pers->m_dataHeader.end();
+		   pit != last; it++, pit++) {
+      m_elemCnv.persToTrans(&(*pit), &(*it), pers->m_dhForm);
+      pers->m_dhForm.next();
+   }
+}
+//______________________________________________________________________________
+void DataHeaderCnv_p6::transToPers(const DataHeader* trans, DataHeader_p6* pers) {
+   const unsigned int provSize = trans->m_inputDataHeader.size();
+   pers->m_dataHeader.resize(provSize + trans->m_dataHeader.size());
+   pers->m_provenanceSize = provSize;
+   pers->m_dhForm.resize(provSize + trans->m_dataHeader.size() + 1);
+   pers->m_dhForm.start();
+   std::vector<DataHeaderElement_p6>::iterator pit = pers->m_dataHeader.begin();
+   for (std::vector<DataHeaderElement>::const_iterator it = trans->m_inputDataHeader.begin(),
+		   last = trans->m_inputDataHeader.end(); it != last; it++, pit++) {
+      m_elemCnv.transToPers(&(*it), &(*pit), pers->m_dhForm);
+      pers->m_dhForm.next();
+   }
+   for (std::vector<DataHeaderElement>::const_iterator it = trans->m_dataHeader.begin(),
+		   last = trans->m_dataHeader.end(); it != last; it++, pit++) {
+      m_elemCnv.transToPers(&(*it), &(*pit), pers->m_dhForm);
+      pers->m_dhForm.next();
+   }
+}
+//______________________________________________________________________________
+void DataHeaderCnv_p6::insertDHRef(DataHeader_p6* pers,
+	const std::string& key,
+	const std::string& strToken) {
+   Token* token = new Token;
+   token->fromString(strToken);
+   DataHeaderElement tEle(ClassID_traits<DataHeader>::ID(), key, token);
+   DataHeaderElement_p6 pEle;
+   pers->m_dhForm.next();
+   m_elemCnv.transToPers(&tEle, &pEle, pers->m_dhForm);
+   pers->m_dataHeader.push_back(pEle);
+}
diff --git a/Database/PersistentDataModelTPCnv/src/DataHeader_p3.cxx b/Database/PersistentDataModelTPCnv/src/DataHeader_p3.cxx
new file mode 100755
index 0000000000000000000000000000000000000000..e2287534ea7a56ec97ab083d4fb7f1a78a1a9192
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/src/DataHeader_p3.cxx
@@ -0,0 +1,106 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "PersistentDataModelTPCnv/DataHeader_p3.h"
+
+DataHeaderElement_p3::DataHeaderElement_p3() : m_clids(),
+	m_token(),
+	m_alias(),
+	m_technology(0U),
+	m_oid1(0U),
+	m_oid2(0U),
+	m_dbGuidIdx(0U),
+	m_classIdIdx(0U),
+	m_prefixIdx(0U),
+	m_keyPos(0U),
+	m_hashes() {}
+DataHeaderElement_p3::DataHeaderElement_p3(const DataHeaderElement_p3& rhs) : m_clids(rhs.m_clids),
+	m_token(rhs.m_token),
+	m_alias(rhs.m_alias),
+	m_technology(rhs.m_technology),
+	m_oid1(rhs.m_oid1),
+	m_oid2(rhs.m_oid2),
+	m_dbGuidIdx(rhs.m_dbGuidIdx),
+	m_classIdIdx(rhs.m_classIdIdx),
+	m_prefixIdx(rhs.m_prefixIdx),
+	m_keyPos(rhs.m_keyPos),
+	m_hashes(rhs.m_hashes) {}
+DataHeaderElement_p3::~DataHeaderElement_p3() {}
+
+DataHeaderElement_p3& DataHeaderElement_p3::operator=(const DataHeaderElement_p3& rhs) {
+   if (this != &rhs) {
+      m_clids = rhs.m_clids;
+      m_token = rhs.m_token;
+      m_alias = rhs.m_alias;
+      m_technology  = rhs.m_technology;
+      m_oid1 = rhs.m_oid1;
+      m_oid2 = rhs.m_oid2;
+      m_dbGuidIdx = rhs.m_dbGuidIdx;
+      m_classIdIdx = rhs.m_classIdIdx;
+      m_keyPos = rhs.m_keyPos;
+      m_hashes = rhs.m_hashes;
+   }
+   return(*this);
+}
+
+const std::vector<unsigned int>& DataHeaderElement_p3::clids() const {
+   return(m_clids);
+}
+
+const std::string& DataHeaderElement_p3::token() const {
+   return(m_token);
+}
+
+const std::vector<std::string> DataHeaderElement_p3::alias() const {
+   return(m_alias);
+}
+
+const std::string& DataHeaderElement_p3::key() const {
+   return(m_alias.front());
+}
+
+unsigned int DataHeaderElement_p3::pClid() const {
+   return(m_clids.front());
+}
+
+unsigned int DataHeaderElement_p3::oid1() const {
+   return(m_oid1);
+}
+
+unsigned int DataHeaderElement_p3::oid2() const {
+   return(m_oid2);
+}
+
+void DataHeaderElement_p3::overwriteOid2(unsigned int oid2) {
+   m_oid2 = oid2;
+}
+
+
+DataHeader_p3::DataHeader_p3()
+	: m_DataHeader(), m_InputDataHeader(), m_GuidMap() {}
+DataHeader_p3::DataHeader_p3(const DataHeader_p3& rhs) : m_DataHeader(rhs.m_DataHeader),
+	m_InputDataHeader(rhs.m_InputDataHeader),
+	m_GuidMap(rhs.m_GuidMap) {}
+DataHeader_p3::~DataHeader_p3() {}
+
+DataHeader_p3& DataHeader_p3::operator=(const DataHeader_p3& rhs) {
+   if (this != &rhs) {
+      m_DataHeader = rhs.m_DataHeader;
+      m_InputDataHeader = rhs.m_InputDataHeader;
+      m_GuidMap = rhs.m_GuidMap;
+   }
+   return(*this);
+}
+
+const std::vector<DataHeaderElement_p3>& DataHeader_p3::elements() const {
+   return(m_DataHeader);
+}
+
+const std::vector<DataHeaderElement_p3>& DataHeader_p3::inputElements() const {
+   return(m_InputDataHeader);
+}
+
+const std::vector<std::string>& DataHeader_p3::GuidMap() const {
+   return(m_GuidMap);
+}
diff --git a/Database/PersistentDataModelTPCnv/src/DataHeader_p4.cxx b/Database/PersistentDataModelTPCnv/src/DataHeader_p4.cxx
new file mode 100755
index 0000000000000000000000000000000000000000..a786afdc33c12f2b55466f21be6fa7521cae93ea
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/src/DataHeader_p4.cxx
@@ -0,0 +1,105 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "PersistentDataModelTPCnv/DataHeader_p4.h"
+
+DataHeaderElement_p4::DataHeaderElement_p4() : m_clids(),
+	m_token(),
+	m_alias(),
+	m_technology(0U),
+	m_oid1(0U),
+	m_oid2(0U),
+	m_dbGuidIdx(0U),
+	m_classIdIdx(0U),
+	m_prefixIdx(0U),
+	m_keyPos(0U),
+	m_hashes() {}
+DataHeaderElement_p4::DataHeaderElement_p4(const DataHeaderElement_p4& rhs) : m_clids(rhs.m_clids),
+	m_token(rhs.m_token),
+	m_alias(rhs.m_alias),
+	m_technology(rhs.m_technology),
+	m_oid1(rhs.m_oid1),
+	m_oid2(rhs.m_oid2),
+	m_dbGuidIdx(rhs.m_dbGuidIdx),
+	m_classIdIdx(rhs.m_classIdIdx),
+	m_prefixIdx(rhs.m_prefixIdx),
+	m_keyPos(rhs.m_keyPos),
+	m_hashes(rhs.m_hashes) {}
+DataHeaderElement_p4::~DataHeaderElement_p4() {}
+
+DataHeaderElement_p4& DataHeaderElement_p4::operator=(const DataHeaderElement_p4& rhs) {
+   if (this != &rhs) {
+      m_clids = rhs.m_clids;
+      m_token = rhs.m_token;
+      m_alias = rhs.m_alias;
+      m_technology  = rhs.m_technology;
+      m_oid1 = rhs.m_oid1;
+      m_oid2 = rhs.m_oid2;
+      m_dbGuidIdx = rhs.m_dbGuidIdx;
+      m_classIdIdx = rhs.m_classIdIdx;
+      m_keyPos = rhs.m_keyPos;
+      m_hashes = rhs.m_hashes;
+   }
+   return(*this);
+}
+
+unsigned int DataHeaderElement_p4::pClid() const {
+   return(m_clids.front());
+}
+
+const std::vector<unsigned int>& DataHeaderElement_p4::clids() const {
+   return(m_clids);
+}
+
+const std::string& DataHeaderElement_p4::key() const {
+   return(m_alias.front());
+}
+
+const std::vector<std::string>& DataHeaderElement_p4::alias() const {
+   return(m_alias);
+}
+
+const std::string& DataHeaderElement_p4::token() const {
+   return(m_token);
+}
+
+unsigned int DataHeaderElement_p4::oid1() const {
+   return(m_oid1);
+}
+
+unsigned int DataHeaderElement_p4::oid2() const {
+   return(m_oid2);
+}
+
+void DataHeaderElement_p4::overwriteOid2(unsigned int oid2) {
+   m_oid2 = oid2;
+}
+
+
+DataHeader_p4::DataHeader_p4() : m_dataHeader(), m_provSize(0U), m_guidMap() {}
+DataHeader_p4::DataHeader_p4(const DataHeader_p4& rhs) : m_dataHeader(rhs.m_dataHeader),
+	m_provSize(rhs.m_provSize),
+	m_guidMap(rhs.m_guidMap) {}
+DataHeader_p4::~DataHeader_p4() {}
+
+DataHeader_p4& DataHeader_p4::operator=(const DataHeader_p4& rhs) {
+   if (this != &rhs) {
+      m_dataHeader = rhs.m_dataHeader;
+      m_provSize = rhs.m_provSize;
+      m_guidMap = rhs.m_guidMap;
+   }
+   return(*this);
+}
+
+const std::vector<DataHeaderElement_p4>& DataHeader_p4::elements() const {
+   return(m_dataHeader);
+}
+
+unsigned int DataHeader_p4::provenanceSize() const {
+   return(m_provSize);
+}
+
+const std::vector<std::string>& DataHeader_p4::guidMap() const {
+   return(m_guidMap);
+}
diff --git a/Database/PersistentDataModelTPCnv/src/DataHeader_p5.cxx b/Database/PersistentDataModelTPCnv/src/DataHeader_p5.cxx
new file mode 100755
index 0000000000000000000000000000000000000000..0d577295de635083764259273dcfae4f80f8be28
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/src/DataHeader_p5.cxx
@@ -0,0 +1,143 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "PersistentDataModelTPCnv/DataHeader_p5.h"
+
+#include "CxxUtils/MD5.h"
+
+#include <uuid/uuid.h>
+#include <sstream>
+
+DataHeaderElement_p5::DataHeaderElement_p5() : m_token(), m_oid2(0U) {}
+DataHeaderElement_p5::DataHeaderElement_p5(const DataHeaderElement_p5& rhs) : m_token(rhs.m_token),
+	m_oid2(rhs.m_oid2) {}
+DataHeaderElement_p5::~DataHeaderElement_p5() {}
+
+DataHeaderElement_p5& DataHeaderElement_p5::operator=(const DataHeaderElement_p5& rhs) {
+   if (this != &rhs) {
+      m_token = rhs.m_token;
+      m_oid2 = rhs.m_oid2;
+   }
+   return(*this);
+}
+
+const std::string& DataHeaderElement_p5::token() const {
+   return(m_token);
+}
+
+unsigned int DataHeaderElement_p5::oid2() const {
+   return(m_oid2);
+}
+
+void DataHeaderElement_p5::overwriteOid2(unsigned int oid2) {
+   m_oid2 = oid2;
+}
+
+
+DataHeaderForm_p5::DataHeaderForm_p5() : m_map(), m_uints(), m_entry(0U) {}
+DataHeaderForm_p5::DataHeaderForm_p5(const DataHeaderForm_p5& rhs) : m_map(rhs.m_map), m_uints(rhs.m_uints), m_entry(0U) {}
+DataHeaderForm_p5::~DataHeaderForm_p5() {}
+DataHeaderForm_p5& DataHeaderForm_p5::operator=(const DataHeaderForm_p5& rhs) {
+   if (&rhs != this) {
+      m_map = rhs.m_map;
+      m_uints = rhs.m_uints;
+      m_entry = 0U;
+   }
+   return(*this);
+}
+
+const std::vector<std::string>& DataHeaderForm_p5::map() const {
+   return(m_map);
+}
+
+void DataHeaderForm_p5::insertMap(const std::string& element) {
+   m_map.push_back(element);
+}
+
+const std::vector<unsigned int>& DataHeaderForm_p5::params() const {
+   return(m_uints[m_entry - 1]);
+}
+
+void DataHeaderForm_p5::insertParam(unsigned int param) {
+   m_uints[m_entry - 1].push_back(param);
+}
+
+unsigned int DataHeaderForm_p5::entry() const {
+   return(m_entry);
+}
+
+void DataHeaderForm_p5::start() const {
+   m_entry = 1;
+}
+
+void DataHeaderForm_p5::next() const {
+   m_entry++;
+}
+
+unsigned int DataHeaderForm_p5::size() {
+   return(m_uints.size());
+}
+
+void DataHeaderForm_p5::resize(unsigned int size) {
+   m_uints.resize(size);
+}
+
+
+DataHeader_p5::DataHeader_p5() : m_dataHeader(), m_dhForm(), m_dhFormToken(), m_dhFormMdx() {}
+DataHeader_p5::DataHeader_p5(const DataHeader_p5& rhs) : m_dataHeader(rhs.m_dataHeader),
+	m_dhForm(rhs.m_dhForm),
+	m_dhFormToken(rhs.m_dhFormToken),
+	m_dhFormMdx(rhs.m_dhFormMdx) {}
+DataHeader_p5::~DataHeader_p5() {}
+
+DataHeader_p5& DataHeader_p5::operator=(const DataHeader_p5& rhs) {
+   if (this != &rhs) {
+      m_dataHeader = rhs.m_dataHeader;
+      m_dhForm = rhs.m_dhForm;
+      m_dhFormToken = rhs.m_dhFormToken;
+      m_dhFormMdx = rhs.m_dhFormMdx;
+   }
+   return(*this);
+}
+
+const std::vector<DataHeaderElement_p5>& DataHeader_p5::elements() const {
+   return(m_dataHeader);
+}
+
+const DataHeaderForm_p5& DataHeader_p5::dhForm() const {
+   return(m_dhForm);
+}
+
+void DataHeader_p5::setDhForm(const DataHeaderForm_p5& form) {
+   m_dhForm = form;
+}
+
+const std::string& DataHeader_p5::dhFormToken() const {
+   return(m_dhFormToken);
+}
+
+void DataHeader_p5::setDhFormToken(const std::string& formToken) {
+   m_dhFormToken = formToken;
+   std::ostringstream stream;
+   for (std::vector<std::string>::const_iterator iter = m_dhForm.map().begin(),
+		   last = m_dhForm.map().end(); iter != last; iter++) {
+      stream << *iter << "\n";
+   }
+   for (m_dhForm.start(); m_dhForm.entry() <= m_dhForm.size(); m_dhForm.next()) {
+      for (std::vector<unsigned int>::const_iterator iter = m_dhForm.params().begin(),
+		      last = m_dhForm.params().end(); iter != last; iter++) {
+         stream << *iter << ",";
+      }
+      stream << "\n";
+   }
+   MD5 checkSum((unsigned char*)stream.str().c_str(), stream.str().size());
+   uuid_t checkSumUuid;
+   checkSum.raw_digest((unsigned char*)(&checkSumUuid));
+   char text[37];
+   uuid_unparse_upper(checkSumUuid, text);
+   m_dhFormMdx = text;
+}
+const std::string& DataHeader_p5::dhFormMdx() const {
+   return(m_dhFormMdx);
+}
diff --git a/Database/PersistentDataModelTPCnv/src/DataHeader_p6.cxx b/Database/PersistentDataModelTPCnv/src/DataHeader_p6.cxx
new file mode 100755
index 0000000000000000000000000000000000000000..2095e2d6bea5eac687dad402961a1b792d8aa941
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/src/DataHeader_p6.cxx
@@ -0,0 +1,221 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "PersistentDataModelTPCnv/DataHeader_p6.h"
+
+#include "CxxUtils/MD5.h"
+
+#include <uuid/uuid.h>
+#include <sstream>
+
+DataHeaderElement_p6::DataHeaderElement_p6() : m_token(), m_oid1(0ULL), m_oid2(0ULL) {}
+DataHeaderElement_p6::DataHeaderElement_p6(const DataHeaderElement_p6& rhs) : m_token(rhs.m_token),
+	m_oid1(rhs.m_oid1),
+	m_oid2(rhs.m_oid2),
+	m_dbIdx(rhs.m_dbIdx),
+	m_objIdx(rhs.m_objIdx) {}
+DataHeaderElement_p6::~DataHeaderElement_p6() {}
+
+DataHeaderElement_p6& DataHeaderElement_p6::operator=(const DataHeaderElement_p6& rhs) {
+   if (this != &rhs) {
+      m_token = rhs.m_token;
+      m_oid1 = rhs.m_oid1;
+      m_oid2 = rhs.m_oid2;
+      m_dbIdx = rhs.m_dbIdx;
+      m_objIdx = rhs.m_objIdx;
+   }
+   return(*this);
+}
+
+const std::string& DataHeaderElement_p6::token() const {
+   return(m_token);
+}
+
+unsigned long long DataHeaderElement_p6::oid1() const {
+   return(m_oid1);
+}
+
+unsigned long long DataHeaderElement_p6::oid2() const {
+   return(m_oid2);
+}
+
+void DataHeaderElement_p6::overwriteOid2(unsigned long long oid2) {
+   m_oid2 = oid2;
+}
+
+
+DataHeaderForm_p6::DataHeaderForm_p6() : m_uints(), m_dbRecords(), m_objRecords(), m_objAlias(), m_objSymLinks(), m_objHashes(), m_entry(0U) {}
+DataHeaderForm_p6::DataHeaderForm_p6(const DataHeaderForm_p6& rhs) : m_uints(rhs.m_uints), m_dbRecords(rhs.m_dbRecords), m_objRecords(rhs.m_objRecords), m_objAlias(rhs.m_objAlias), m_objSymLinks(rhs.m_objSymLinks), m_objHashes(rhs.m_objHashes), m_entry(0U) {}
+DataHeaderForm_p6::~DataHeaderForm_p6() {}
+DataHeaderForm_p6& DataHeaderForm_p6::operator=(const DataHeaderForm_p6& rhs) {
+   if (&rhs != this) {
+      m_uints = rhs.m_uints;
+      m_dbRecords = rhs.m_dbRecords;
+      m_objRecords = rhs.m_objRecords;
+      m_objAlias = rhs.m_objAlias;
+      m_objSymLinks = rhs.m_objSymLinks;
+      m_objHashes = rhs.m_objHashes;
+      m_entry = 0U;
+   }
+   return(*this);
+}
+
+unsigned int DataHeaderForm_p6::insertDb(const DbRecord& rec) {
+   unsigned int index = 0U;
+   for (std::vector<DbRecord>::const_iterator iter = m_dbRecords.begin(), last = m_dbRecords.end();
+	   iter != last; iter++, index++) {
+      if (*iter == rec) break;
+   }
+   if (index == m_dbRecords.size()) {
+      m_dbRecords.push_back(rec);
+   }
+   return(index);
+}
+
+std::size_t DataHeaderForm_p6::sizeDb() const {
+   return(m_dbRecords.size());
+}
+
+Guid DataHeaderForm_p6::getDbGuid(unsigned int index) const {
+   return(m_dbRecords[index].first);
+}
+
+unsigned int DataHeaderForm_p6::getDbTech(unsigned int index) const {
+   return(m_dbRecords[index].second);
+}
+
+unsigned int DataHeaderForm_p6::insertObj(const ObjRecord& rec,
+	const std::set<std::string>& alias,
+	const std::set<unsigned int>& symLinks,
+	const std::vector<unsigned int>& hashes) {
+   unsigned int index = 0U;
+   for (std::vector<ObjRecord>::const_iterator iter = m_objRecords.begin(), last = m_objRecords.end();
+           iter != last; iter++, index++) {
+      if (*iter == rec) break;
+   }
+   if (index == m_objRecords.size()) {
+      m_objRecords.push_back(rec);
+      m_objAlias.push_back(std::vector<std::string>(alias.begin(), alias.end()));
+      m_objSymLinks.push_back(std::vector<unsigned int>(symLinks.begin(), symLinks.end()));
+      m_objHashes.push_back(hashes);
+   }
+   return(index);
+}
+
+std::size_t DataHeaderForm_p6::sizeObj() const {
+   return(m_objRecords.size());
+}
+
+std::string DataHeaderForm_p6::getObjKey(unsigned int index) const {
+   return(m_objRecords[index].second.first);
+}
+
+unsigned int DataHeaderForm_p6::getObjType(unsigned int index) const {
+   return(m_objRecords[index].second.second);
+}
+
+Guid DataHeaderForm_p6::getObjClassId(unsigned int index) const {
+   return(m_objRecords[index].first);
+}
+
+std::set<std::string> DataHeaderForm_p6::getObjAlias(unsigned int index) const {
+   return(std::set<std::string>(m_objAlias[index].begin(), m_objAlias[index].end()));
+}
+
+std::set<unsigned int> DataHeaderForm_p6::getObjSymLinks(unsigned int index) const {
+   return(std::set<unsigned int>(m_objSymLinks[index].begin(), m_objSymLinks[index].end()));
+}
+
+std::vector<unsigned int> DataHeaderForm_p6::getObjHashes(unsigned int index) const {
+   return(m_objHashes[index]);
+}
+
+
+
+const std::vector<unsigned int>& DataHeaderForm_p6::params() const {
+   return(m_uints[m_entry]);
+}
+
+void DataHeaderForm_p6::insertParam(unsigned int param) {
+   m_uints[m_entry].push_back(param);
+}
+
+unsigned int DataHeaderForm_p6::entry() const {
+   return(m_entry);
+}
+
+void DataHeaderForm_p6::start() const {
+   m_entry = 0;
+}
+
+void DataHeaderForm_p6::next() const {
+   m_entry++;
+}
+
+unsigned int DataHeaderForm_p6::size() const {
+   return(m_uints.size());
+}
+
+void DataHeaderForm_p6::resize(unsigned int size) {
+   m_uints.resize(size);
+}
+
+
+DataHeader_p6::DataHeader_p6() : m_dataHeader(), m_provenanceSize(0U), m_dhForm(), m_dhFormToken(), m_dhFormMdx() {}
+DataHeader_p6::DataHeader_p6(const DataHeader_p6& rhs) : m_dataHeader(rhs.m_dataHeader),
+	m_dhForm(rhs.m_dhForm),
+	m_dhFormToken(rhs.m_dhFormToken),
+	m_dhFormMdx(rhs.m_dhFormMdx) {}
+DataHeader_p6::~DataHeader_p6() {}
+
+DataHeader_p6& DataHeader_p6::operator=(const DataHeader_p6& rhs) {
+   if (this != &rhs) {
+      m_dataHeader = rhs.m_dataHeader;
+      m_provenanceSize = rhs.m_provenanceSize;
+      m_dhForm = rhs.m_dhForm;
+      m_dhFormToken = rhs.m_dhFormToken;
+      m_dhFormMdx = rhs.m_dhFormMdx;
+   }
+   return(*this);
+}
+
+const std::vector<DataHeaderElement_p6>& DataHeader_p6::elements() const {
+   return(m_dataHeader);
+}
+
+const DataHeaderForm_p6& DataHeader_p6::dhForm() const {
+   return(m_dhForm);
+}
+
+void DataHeader_p6::setDhForm(const DataHeaderForm_p6& form) {
+   m_dhForm = form;
+}
+
+const std::string& DataHeader_p6::dhFormToken() const {
+   return(m_dhFormToken);
+}
+
+void DataHeader_p6::setDhFormToken(const std::string& formToken) {
+   m_dhFormToken = formToken;
+}
+
+void DataHeader_p6::calculateDhFormMdx() {
+   std::ostringstream stream;
+   for (std::size_t iter = 0, last = m_dhForm.sizeDb(); iter != last; iter++) {
+	stream << m_dhForm.getDbGuid(iter) << "," << m_dhForm.getDbTech(iter) << "\n";
+   }
+   for (std::size_t iter = 0, last = m_dhForm.sizeObj(); iter != last; iter++) {
+	stream << m_dhForm.getObjKey(iter) << "," << m_dhForm.getObjType(iter) << "," << m_dhForm.getObjClassId(iter) << "\n";
+   }
+   MD5 checkSum((unsigned char*)stream.str().c_str(), stream.str().size());
+   uuid_t checkSumUuid;
+   checkSum.raw_digest((unsigned char*)(&checkSumUuid));
+   char text[37];
+   uuid_unparse_upper(checkSumUuid, text);
+   m_dhFormMdx = text;
+}
+
+const std::string& DataHeader_p6::dhFormMdx() const {
+   return(m_dhFormMdx);
+}