diff --git a/opm/autodiff/Compat.hpp b/opm/autodiff/Compat.hpp
index f6488ae20..d93d71192 100644
--- a/opm/autodiff/Compat.hpp
+++ b/opm/autodiff/Compat.hpp
@@ -26,8 +26,9 @@
 #include <opm/core/simulator/BlackoilState.hpp>
 #include <opm/core/simulator/WellState.hpp>
 #include <opm/autodiff/BlackoilSolventState.hpp>
-#include <opm/output/Cells.hpp>
-#include <opm/output/Wells.hpp>
+#include <opm/output/data/Cells.hpp>
+#include <opm/output/data/Solution.hpp>
+#include <opm/output/data/Wells.hpp>
 
 namespace Opm {
 
@@ -69,13 +70,11 @@ inline std::vector< double >& stripe( const std::vector< double >& v,
 
 
 
-inline data::Solution simToSolution( const SimulationDataContainer& reservoir,
-                             PhaseUsage phases ) {
-    using ds = data::Solution::key;
-
+    inline data::Solution simToSolution( const SimulationDataContainer& reservoir,
+                                         PhaseUsage phases ) {
     data::Solution sol;
-    sol.insert( ds::PRESSURE, reservoir.pressure() );
-    sol.insert( ds::TEMP, reservoir.temperature() );
+    sol.insert( "PRESSURE", UnitSystem::measure::pressure, reservoir.pressure() , data::TargetType::RESTART_SOLUTION);
+    sol.insert( "TEMP"    , UnitSystem::measure::temperature, reservoir.temperature() , data::TargetType::RESTART_SOLUTION );
 
     const auto ph = reservoir.numPhases();
     const auto& sat = reservoir.saturation();
@@ -84,23 +83,23 @@ inline data::Solution simToSolution( const SimulationDataContainer& reservoir,
     const auto vapour = BlackoilPhases::Vapour;
 
     if( phases.phase_used[ aqua ] ) {
-        sol.insert( ds::SWAT, destripe( sat, ph, phases.phase_pos[ aqua ] ) );
+        sol.insert( "SWAT", UnitSystem::measure::identity, destripe( sat, ph, phases.phase_pos[ aqua ] ) , data::TargetType::RESTART_SOLUTION );
     }
 
     if( phases.phase_used[ vapour ] ) {
-        sol.insert( ds::SGAS, destripe( sat, ph, phases.phase_pos[ vapour ] ) );
+        sol.insert( "SGAS", UnitSystem::measure::identity, destripe( sat, ph, phases.phase_pos[ vapour ] ) , data::TargetType::RESTART_SOLUTION );
     }
 
     if( reservoir.hasCellData( BlackoilState::GASOILRATIO ) ) {
-        sol.insert( ds::RS, reservoir.getCellData( BlackoilState::GASOILRATIO ) );
+        sol.insert( "RS", UnitSystem::measure::identity, reservoir.getCellData( BlackoilState::GASOILRATIO ) , data::TargetType::RESTART_SOLUTION );
     }
 
     if( reservoir.hasCellData( BlackoilState::RV ) ) {
-        sol.insert( ds::RV, reservoir.getCellData( BlackoilState::RV ) );
+        sol.insert( "RV", UnitSystem::measure::identity, reservoir.getCellData( BlackoilState::RV ) , data::TargetType::RESTART_SOLUTION );
     }
 
     if (reservoir.hasCellData( BlackoilSolventState::SSOL)) {
-        sol.insert( ds::SSOL, reservoir.getCellData( BlackoilSolventState::SSOL ) );
+        sol.insert( "SSOL", UnitSystem::measure::identity, reservoir.getCellData( BlackoilSolventState::SSOL ) , data::TargetType::RESTART_SOLUTION );
     }
 
     sol.sdc = &reservoir;
@@ -118,41 +117,40 @@ inline data::Solution simToSolution( const SimulationDataContainer& reservoir,
 inline void solutionToSim( const data::Solution& sol,
                           PhaseUsage phases,
                           SimulationDataContainer& state ) {
-    using ds = data::Solution::key;
 
     const auto stride = phases.num_phases;
-    if( sol.has( ds::SWAT ) ) {
-        stripe( sol[ ds::SWAT ],
+    if( sol.has( "SWAT" ) ) {
+        stripe( sol.data( "SWAT" ),
                 stride,
                 phases.phase_pos[ BlackoilPhases::Aqua ],
                 state.saturation() );
     }
 
-    if( sol.has( ds::SGAS ) ) {
-        stripe( sol[ ds::SGAS ],
+    if( sol.has( "SGAS" ) ) {
+        stripe( sol.data( "SGAS" ),
                 stride,
                 phases.phase_pos[ BlackoilPhases::Vapour ],
                 state.saturation() );
     }
 
-    if( sol.has( ds::PRESSURE ) ) {
-        state.pressure() = sol[ ds::PRESSURE ];
+    if( sol.has( "PRESSURE" ) ) {
+        state.pressure() = sol.data( "PRESSURE" );
     }
 
-    if( sol.has( ds::TEMP ) ) {
-        state.temperature() = sol[ ds::TEMP ];
+    if( sol.has( "TEMP" ) ) {
+        state.temperature() = sol.data( "TEMP" );
     }
 
-    if( sol.has( ds::RS ) ) {
-        state.getCellData( "GASOILRATIO" ) = sol[ ds::RS ];
+    if( sol.has( "RS" ) ) {
+        state.getCellData( "GASOILRATIO" ) = sol.data( "RS" );
     }
 
-    if( sol.has( ds::RV ) ) {
-        state.getCellData( "RV" ) = sol[ ds::RV ];
+    if( sol.has( "RV" ) ) {
+        state.getCellData( "RV" ) = sol.data( "RV" );
     }
 
-    if (sol.has( ds::SSOL ) ) {
-        state.getCellData("SSOL") = sol [ ds::SSOL];
+    if (sol.has( "SSOL" ) ) {
+        state.getCellData("SSOL") = sol.data("SSOL");
     }
 
 }
diff --git a/opm/autodiff/GeoProps.hpp b/opm/autodiff/GeoProps.hpp
index 48f18e3e2..2fdba1b87 100644
--- a/opm/autodiff/GeoProps.hpp
+++ b/opm/autodiff/GeoProps.hpp
@@ -33,7 +33,8 @@
 #include <opm/parser/eclipse/EclipseState/Grid/TransMult.hpp>
 #include <opm/core/grid/PinchProcessor.hpp>
 #include <opm/common/utility/platform_dependent/disable_warnings.h>
-#include <opm/output/Cells.hpp>
+#include <opm/output/data/Cells.hpp>
+#include <opm/output/data/Solution.hpp>
 
 #include <Eigen/Eigen>
 
@@ -228,15 +229,15 @@ namespace Opm
         /// grid the whole TRAN keyword is quite meaningless.
 
         template <class Grid>
-        const std::vector<data::CellData> simProps( const Grid& grid ) const {
+        data::Solution simProps( const Grid& grid ) const {
             using namespace UgGridHelpers;
             const int* dims = cartDims( grid );
             const int globalSize = dims[0] * dims[1] * dims[2];
             const auto& trans = this->transmissibility( );
 
-            data::CellData tranx = {"TRANX" , UnitSystem::measure::transmissibility, std::vector<double>( globalSize )};
-            data::CellData trany = {"TRANY" , UnitSystem::measure::transmissibility, std::vector<double>( globalSize )};
-            data::CellData tranz = {"TRANZ" , UnitSystem::measure::transmissibility, std::vector<double>( globalSize )};
+            data::CellData tranx = {UnitSystem::measure::transmissibility, std::vector<double>( globalSize ), data::TargetType::INIT};
+            data::CellData trany = {UnitSystem::measure::transmissibility, std::vector<double>( globalSize ), data::TargetType::INIT};
+            data::CellData tranz = {UnitSystem::measure::transmissibility, std::vector<double>( globalSize ), data::TargetType::INIT};
 
             size_t num_faces = numFaces(grid);
             auto fc = faceCells(grid);
@@ -263,12 +264,9 @@ namespace Opm
                 }
             }
 
-            std::vector<data::CellData> tran;
-            tran.push_back( std::move( tranx ));
-            tran.push_back( std::move( trany ));
-            tran.push_back( std::move( tranz ));
-
-            return tran;
+            return { {"TRANX" , tranx},
+                     {"TRANY" , trany} ,
+                     {"TRANZ" , tranz } };
         }
 
 
diff --git a/opm/autodiff/SimulatorFullyImplicitBlackoilEbos.hpp b/opm/autodiff/SimulatorFullyImplicitBlackoilEbos.hpp
index 9ed1c4360..363cb2d97 100644
--- a/opm/autodiff/SimulatorFullyImplicitBlackoilEbos.hpp
+++ b/opm/autodiff/SimulatorFullyImplicitBlackoilEbos.hpp
@@ -166,7 +166,6 @@ public:
         std::ofstream tstep_os(tstep_filename.c_str());
 
         const auto& schedule = eclState()->getSchedule();
-        const auto& events = schedule->getEvents();
 
         // adaptive time stepping
         std::unique_ptr< AdaptiveTimeStepping > adaptiveTimeStepping;
diff --git a/opm/autodiff/SimulatorFullyImplicitBlackoilOutput.cpp b/opm/autodiff/SimulatorFullyImplicitBlackoilOutput.cpp
index 8338e58dc..a4ba754b1 100644
--- a/opm/autodiff/SimulatorFullyImplicitBlackoilOutput.cpp
+++ b/opm/autodiff/SimulatorFullyImplicitBlackoilOutput.cpp
@@ -24,7 +24,7 @@
 #include <opm/common/data/SimulationDataContainer.hpp>
 
 #include <opm/parser/eclipse/EclipseState/InitConfig/InitConfig.hpp>
-#include <opm/output/Cells.hpp>
+#include <opm/output/data/Cells.hpp>
 #include <opm/core/simulator/BlackoilState.hpp>
 #include <opm/core/utility/DataMap.hpp>
 #include <opm/autodiff/Compat.hpp>
@@ -262,14 +262,14 @@ namespace Opm
             std::unique_ptr< SimulatorTimerInterface > timer_;
             const SimulationDataContainer state_;
             const WellState wellState_;
-            std::vector<data::CellData> simProps_;
+            data::Solution simProps_;
             const bool substep_;
 
             explicit WriterCall( BlackoilOutputWriter& writer,
                                  const SimulatorTimerInterface& timer,
                                  const SimulationDataContainer& state,
                                  const WellState& wellState,
-                                 const std::vector<data::CellData>& simProps,
+                                 const data::Solution& simProps,
                                  bool substep )
                 : writer_( writer ),
                   timer_( timer.clone() ),
@@ -300,8 +300,7 @@ namespace Opm
                   const WellState& localWellState,
                   bool substep)
     {
-        std::vector<data::CellData> noCellProperties;
-        writeTimeStepWithCellProperties(timer, localState, localWellState, noCellProperties, substep);
+        writeTimeStepWithCellProperties(timer, localState, localWellState, {} , substep);
     }
 
 
@@ -314,7 +313,7 @@ namespace Opm
                   const SimulatorTimerInterface& timer,
                   const SimulationDataContainer& localState,
                   const WellState& localWellState,
-                  const std::vector<data::CellData>& cellData,
+                  const data::Solution& cellData,
                   bool substep)
     {
         // VTK output (is parallel if grid is parallel)
@@ -360,7 +359,7 @@ namespace Opm
     writeTimeStepSerial(const SimulatorTimerInterface& timer,
                         const SimulationDataContainer& state,
                         const WellState& wellState,
-                        const std::vector<data::CellData>& simProps,
+                        const data::Solution& simProps,
                         bool substep)
     {
         // Matlab output
@@ -379,8 +378,7 @@ namespace Opm
                                           substep,
                                           timer.simulationTimeElapsed(),
                                           simToSolution( state, phaseUsage_ ),
-                                          wellState.report(phaseUsage_),
-                                          simProps);
+                                          wellState.report(phaseUsage_));
             }
         }
 
diff --git a/opm/autodiff/SimulatorFullyImplicitBlackoilOutput.hpp b/opm/autodiff/SimulatorFullyImplicitBlackoilOutput.hpp
index 2efb79eaf..68e15beed 100644
--- a/opm/autodiff/SimulatorFullyImplicitBlackoilOutput.hpp
+++ b/opm/autodiff/SimulatorFullyImplicitBlackoilOutput.hpp
@@ -31,7 +31,8 @@
 #include <opm/core/utility/parameters/ParameterGroup.hpp>
 #include <opm/core/wells/DynamicListEconLimited.hpp>
 
-#include <opm/output/Cells.hpp>
+#include <opm/output/data/Cells.hpp>
+#include <opm/output/data/Solution.hpp>
 #include <opm/output/eclipse/EclipseWriter.hpp>
 
 #include <opm/autodiff/GridHelpers.hpp>
@@ -217,7 +218,7 @@ namespace Opm
                              const double* permeability );
 
         /** \copydoc Opm::OutputWriter::writeInit */
-        void writeInit(const std::vector<data::CellData>& simProps, const NNC& nnc);
+        void writeInit(const data::Solution& simProps, const NNC& nnc);
 
         /*!
          * \brief Write a blackoil reservoir state to disk for later inspection with
@@ -242,7 +243,7 @@ namespace Opm
                            const SimulatorTimerInterface& timer,
                            const SimulationDataContainer& reservoirState,
                            const Opm::WellState& wellState,
-                           const std::vector<data::CellData>& simProps,
+                           const data::Solution& solution,
                            bool substep = false);
 
         /*!
@@ -264,7 +265,7 @@ namespace Opm
         void writeTimeStepSerial(const SimulatorTimerInterface& timer,
                                  const SimulationDataContainer& reservoirState,
                                  const Opm::WellState& wellState,
-                                 const std::vector<data::CellData>& simProps,
+                                 const data::Solution& cellData,
                                  bool substep);
 
         /** \brief return output directory */
@@ -449,18 +450,16 @@ namespace Opm
          * Returns the data requested in the restartConfig
          */
         template<class Model>
-        void getRestartData(
-                std::vector<data::CellData>& output,
-                const Opm::PhaseUsage& phaseUsage,
-                const Model& physicalModel,
-                const RestartConfig& restartConfig,
-                const int reportStepNum,
-                const bool log) {
+        void getRestartData(data::Solution& output,
+                            const Opm::PhaseUsage& phaseUsage,
+                            const Model& physicalModel,
+                            const RestartConfig& restartConfig,
+                            const int reportStepNum,
+                            const bool log) {
 
             typedef Opm::AutoDiffBlock<double> ADB;
 
             const typename Model::SimulatorData& sd = physicalModel.getSimulatorData();
-
             //Get the value of each of the keys for the restart keywords
             std::map<std::string, int> rstKeywords = restartConfig.getRestartKeywords(reportStepNum);
             for (auto& keyValue : rstKeywords) {
@@ -482,27 +481,24 @@ namespace Opm
              */
             if (aqua_active && rstKeywords["BW"] > 0) {
                 rstKeywords["BW"] = 0;
-                output.emplace_back(data::CellData{
-                        "1OVERBW",
-                        Opm::UnitSystem::measure::water_inverse_formation_volume_factor,
-                        adbToDoubleVector(sd.rq[aqua_idx].b),
-                        true});
+                output.insert("1OVERBW",
+                              Opm::UnitSystem::measure::water_inverse_formation_volume_factor,
+                              adbToDoubleVector(sd.rq[aqua_idx].b),
+                              data::TargetType::RESTART_AUXILLARY);
             }
             if (liquid_active && rstKeywords["BO"]  > 0) {
                 rstKeywords["BO"] = 0;
-                output.emplace_back(data::CellData{
-                        "1OVERBO",
-                        Opm::UnitSystem::measure::oil_inverse_formation_volume_factor,
-                        adbToDoubleVector(sd.rq[liquid_idx].b),
-                        true});
+                output.insert("1OVERBO",
+                              Opm::UnitSystem::measure::oil_inverse_formation_volume_factor,
+                              adbToDoubleVector(sd.rq[liquid_idx].b),
+                              data::TargetType::RESTART_AUXILLARY);
             }
             if (vapour_active && rstKeywords["BG"] > 0) {
                 rstKeywords["BG"] = 0;
-                output.emplace_back(data::CellData{
-                        "1OVERBG",
-                        Opm::UnitSystem::measure::gas_inverse_formation_volume_factor,
-                        adbToDoubleVector(sd.rq[vapour_idx].b),
-                        true});
+                output.insert("1OVERBG",
+                              Opm::UnitSystem::measure::gas_inverse_formation_volume_factor,
+                              adbToDoubleVector(sd.rq[vapour_idx].b),
+                              data::TargetType::RESTART_AUXILLARY);
             }
 
             /**
@@ -511,25 +507,22 @@ namespace Opm
             if (rstKeywords["DEN"] > 0) {
                 rstKeywords["DEN"] = 0;
                 if (aqua_active) {
-                    output.emplace_back(data::CellData{
-                            "WAT_DEN",
-                            Opm::UnitSystem::measure::density,
-                            adbToDoubleVector(sd.rq[aqua_idx].rho),
-                            true});
+                    output.insert("WAT_DEN",
+                                  Opm::UnitSystem::measure::density,
+                                  adbToDoubleVector(sd.rq[aqua_idx].rho),
+                                  data::TargetType::RESTART_AUXILLARY);
                 }
                 if (liquid_active) {
-                    output.emplace_back(data::CellData{
-                            "OIL_DEN",
-                            Opm::UnitSystem::measure::density,
-                            adbToDoubleVector(sd.rq[liquid_idx].rho),
-                            true});
+                    output.insert("OIL_DEN",
+                                  Opm::UnitSystem::measure::density,
+                                  adbToDoubleVector(sd.rq[liquid_idx].rho),
+                                  data::TargetType::RESTART_AUXILLARY);
                 }
                 if (vapour_active) {
-                    output.emplace_back(data::CellData{
-                            "GAS_DEN",
-                            Opm::UnitSystem::measure::density,
-                            adbToDoubleVector(sd.rq[vapour_idx].rho),
-                            true});
+                    output.insert("GAS_DEN",
+                                  Opm::UnitSystem::measure::density,
+                                  adbToDoubleVector(sd.rq[vapour_idx].rho),
+                                  data::TargetType::RESTART_AUXILLARY);
                 }
             }
 
@@ -539,25 +532,22 @@ namespace Opm
             if (rstKeywords["VISC"] > 0) {
                 rstKeywords["VISC"] = 0;
                 if (aqua_active) {
-                    output.emplace_back(data::CellData{
-                            "WAT_VISC",
-                            Opm::UnitSystem::measure::viscosity,
-                            adbToDoubleVector(sd.rq[aqua_idx].mu),
-                            true});
+                    output.insert("WAT_VISC",
+                                  Opm::UnitSystem::measure::viscosity,
+                                  adbToDoubleVector(sd.rq[aqua_idx].mu),
+                                  data::TargetType::RESTART_AUXILLARY);
                 }
                 if (liquid_active) {
-                    output.emplace_back(data::CellData{
-                            "OIL_VISC",
-                            Opm::UnitSystem::measure::viscosity,
-                            adbToDoubleVector(sd.rq[liquid_idx].mu),
-                            true});
+                    output.insert("OIL_VISC",
+                                  Opm::UnitSystem::measure::viscosity,
+                                  adbToDoubleVector(sd.rq[liquid_idx].mu),
+                                  data::TargetType::RESTART_AUXILLARY);
                 }
                 if (vapour_active) {
-                    output.emplace_back(data::CellData{
-                            "GAS_VISC",
-                            Opm::UnitSystem::measure::viscosity,
-                            adbToDoubleVector(sd.rq[vapour_idx].mu),
-                            true});
+                    output.insert("GAS_VISC",
+                                  Opm::UnitSystem::measure::viscosity,
+                                  adbToDoubleVector(sd.rq[vapour_idx].mu),
+                                  data::TargetType::RESTART_AUXILLARY);
                 }
             }
 
@@ -567,11 +557,10 @@ namespace Opm
             if (aqua_active && rstKeywords["KRW"] > 0) {
                 if (sd.rq[aqua_idx].kr.size() > 0) {
                     rstKeywords["KRW"] = 0;
-                    output.emplace_back(data::CellData{
-                            "WATKR",
-                            Opm::UnitSystem::measure::permeability,
-                            adbToDoubleVector(sd.rq[aqua_idx].kr),
-                            true});
+                    output.insert("WATKR",
+                                  Opm::UnitSystem::measure::permeability,
+                                  adbToDoubleVector(sd.rq[aqua_idx].kr),
+                                  data::TargetType::RESTART_AUXILLARY);
                 }
                 else {
                     if ( log )
@@ -584,11 +573,10 @@ namespace Opm
             if (liquid_active && rstKeywords["KRO"] > 0) {
                 if (sd.rq[liquid_idx].kr.size() > 0) {
                     rstKeywords["KRO"] = 0;
-                    output.emplace_back(data::CellData{
-                             "OILKR",
-                             Opm::UnitSystem::measure::permeability,
-                             adbToDoubleVector(sd.rq[liquid_idx].kr),
-                             true});
+                    output.insert("OILKR",
+                                  Opm::UnitSystem::measure::permeability,
+                                  adbToDoubleVector(sd.rq[liquid_idx].kr),
+                                  data::TargetType::RESTART_AUXILLARY);
                 }
                 else {
                     if ( log )
@@ -601,11 +589,10 @@ namespace Opm
             if (vapour_active && rstKeywords["KRG"] > 0) {
                 if (sd.rq[vapour_idx].kr.size() > 0) {
                     rstKeywords["KRG"] = 0;
-                    output.emplace_back(data::CellData{
-                             "GASKR",
-                             Opm::UnitSystem::measure::permeability,
-                             adbToDoubleVector(sd.rq[vapour_idx].kr),
-                             true});
+                    output.insert("GASKR",
+                                  Opm::UnitSystem::measure::permeability,
+                                  adbToDoubleVector(sd.rq[vapour_idx].kr),
+                                  data::TargetType::RESTART_AUXILLARY);
                 }
                 else {
                     if ( log )
@@ -621,19 +608,17 @@ namespace Opm
              */
             if (vapour_active && liquid_active && rstKeywords["RSSAT"] > 0) {
                 rstKeywords["RSSAT"] = 0;
-                output.emplace_back(data::CellData{
-                        "RSSAT",
-                        Opm::UnitSystem::measure::gas_oil_ratio,
-                        adbToDoubleVector(sd.rsSat),
-                        true});
+                output.insert("RSSAT",
+                              Opm::UnitSystem::measure::gas_oil_ratio,
+                              adbToDoubleVector(sd.rsSat),
+                              data::TargetType::RESTART_AUXILLARY);
             }
             if (vapour_active && liquid_active && rstKeywords["RVSAT"] > 0) {
                 rstKeywords["RVSAT"] = 0;
-                output.emplace_back(data::CellData{
-                        "RVSAT",
-                        Opm::UnitSystem::measure::oil_gas_ratio,
-                        adbToDoubleVector(sd.rvSat),
-                        true});
+                output.insert("RVSAT",
+                              Opm::UnitSystem::measure::oil_gas_ratio,
+                              adbToDoubleVector(sd.rvSat),
+                              data::TargetType::RESTART_AUXILLARY);
             }
 
 
@@ -681,11 +666,10 @@ namespace Opm
          * Returns the data as asked for in the summaryConfig
          */
         template<class Model>
-        void getSummaryData(
-                std::vector<data::CellData>& output,
-                const Opm::PhaseUsage& phaseUsage,
-                const Model& physicalModel,
-                const SummaryConfig& summaryConfig) {
+        void getSummaryData(data::Solution& output,
+                            const Opm::PhaseUsage& phaseUsage,
+                            const Model& physicalModel,
+                            const SummaryConfig& summaryConfig) {
 
             typedef Opm::AutoDiffBlock<double> ADB;
 
@@ -701,83 +685,74 @@ namespace Opm
              */
             // Water in place
             if (aqua_active && hasFRBKeyword(summaryConfig, "WIP")) {
-                output.emplace_back(data::CellData{
-                         "WIP",
-                         Opm::UnitSystem::measure::volume,
-                         adbVToDoubleVector(sd.fip[Model::SimulatorData::FIP_AQUA]),
-                         false});
+                output.insert("WIP",
+                              Opm::UnitSystem::measure::volume,
+                              adbVToDoubleVector(sd.fip[Model::SimulatorData::FIP_AQUA]),
+                              data::TargetType::SUMMARY );
             }
             if (liquid_active) {
                 //Oil in place (liquid phase only)
                 if (hasFRBKeyword(summaryConfig, "OIPL")) {
-                    output.emplace_back(data::CellData{
-                             "OIPL",
-                             Opm::UnitSystem::measure::volume,
-                             adbVToDoubleVector(sd.fip[Model::SimulatorData::FIP_LIQUID]),
-                             false});
+                    output.insert("OIPL",
+                                  Opm::UnitSystem::measure::volume,
+                                  adbVToDoubleVector(sd.fip[Model::SimulatorData::FIP_LIQUID]),
+                                  data::TargetType::SUMMARY );
                 }
                 //Oil in place (gas phase only)
                 if (hasFRBKeyword(summaryConfig, "OIPG")) {
-                    output.emplace_back(data::CellData{
-                             "OIPG",
-                             Opm::UnitSystem::measure::volume,
-                             adbVToDoubleVector(sd.fip[Model::SimulatorData::FIP_VAPORIZED_OIL]),
-                             false});
+                    output.insert("OIPG",
+                                  Opm::UnitSystem::measure::volume,
+                                  adbVToDoubleVector(sd.fip[Model::SimulatorData::FIP_VAPORIZED_OIL]),
+                                  data::TargetType::SUMMARY );
                 }
                 // Oil in place (in liquid and gas phases)
                 if (hasFRBKeyword(summaryConfig, "OIP")) {
                     ADB::V oip = sd.fip[Model::SimulatorData::FIP_LIQUID] +
                                  sd.fip[Model::SimulatorData::FIP_VAPORIZED_OIL];
-                    output.emplace_back(data::CellData{
-                             "OIP",
-                             Opm::UnitSystem::measure::volume,
-                             adbVToDoubleVector(oip),
-                             false});
+                    output.insert("OIP",
+                                  Opm::UnitSystem::measure::volume,
+                                  adbVToDoubleVector(oip),
+                                  data::TargetType::SUMMARY );
                 }
             }
             if (vapour_active) {
                 // Gas in place (gas phase only)
                 if (hasFRBKeyword(summaryConfig, "GIPG")) {
-                    output.emplace_back(data::CellData{
-                             "GIPG",
-                             Opm::UnitSystem::measure::volume,
-                             adbVToDoubleVector(sd.fip[Model::SimulatorData::FIP_VAPOUR]),
-                             false});
+                    output.insert("GIPG",
+                                  Opm::UnitSystem::measure::volume,
+                                  adbVToDoubleVector(sd.fip[Model::SimulatorData::FIP_VAPOUR]),
+                                  data::TargetType::SUMMARY );
                 }
                 // Gas in place (liquid phase only)
                 if (hasFRBKeyword(summaryConfig, "GIPL")) {
-                    output.emplace_back(data::CellData{
-                             "GIPL",
-                             Opm::UnitSystem::measure::volume,
-                             adbVToDoubleVector(sd.fip[Model::SimulatorData::FIP_DISSOLVED_GAS]),
-                             false});
+                    output.insert("GIPL",
+                                  Opm::UnitSystem::measure::volume,
+                                  adbVToDoubleVector(sd.fip[Model::SimulatorData::FIP_DISSOLVED_GAS]),
+                                  data::TargetType::SUMMARY );
                 }
                 // Gas in place (in both liquid and gas phases)
                 if (hasFRBKeyword(summaryConfig, "GIP")) {
                     ADB::V gip = sd.fip[Model::SimulatorData::FIP_VAPOUR] +
                                  sd.fip[Model::SimulatorData::FIP_DISSOLVED_GAS];
-                    output.emplace_back(data::CellData{
-                             "GIP",
-                             Opm::UnitSystem::measure::volume,
-                             adbVToDoubleVector(gip),
-                             false});
+                    output.insert("GIP",
+                                  Opm::UnitSystem::measure::volume,
+                                  adbVToDoubleVector(gip),
+                                  data::TargetType::SUMMARY );
                 }
             }
             // Cell pore volume in reservoir conditions
             if (hasFRBKeyword(summaryConfig, "RPV")) {
-                output.emplace_back(data::CellData{
-                         "RPV",
-                         Opm::UnitSystem::measure::volume,
-                         adbVToDoubleVector(sd.fip[Model::SimulatorData::FIP_PV]),
-                         false});
+                output.insert("RPV",
+                              Opm::UnitSystem::measure::volume,
+                              adbVToDoubleVector(sd.fip[Model::SimulatorData::FIP_PV]),
+                              data::TargetType::SUMMARY );
             }
             // Pressure averaged value (hydrocarbon pore volume weighted)
             if (summaryConfig.hasKeyword("FPRH") || summaryConfig.hasKeyword("RPRH")) {
-                output.emplace_back(data::CellData{
-                         "PRH",
-                         Opm::UnitSystem::measure::pressure,
-                         adbVToDoubleVector(sd.fip[Model::SimulatorData::FIP_WEIGHTED_PRESSURE]),
-                         false});
+                output.insert("PRH",
+                              Opm::UnitSystem::measure::pressure,
+                              adbVToDoubleVector(sd.fip[Model::SimulatorData::FIP_WEIGHTED_PRESSURE]),
+                              data::TargetType::SUMMARY );
             }
         }
 
@@ -800,8 +775,8 @@ namespace Opm
         const int reportStepNum = timer.reportStepNum();
         bool logMessages = output_ && parallelOutput_->isIORank();
 
-        std::vector<data::CellData> cellData;
-        detail::getRestartData( cellData, phaseUsage_, physicalModel, 
+        data::Solution cellData;
+        detail::getRestartData( cellData, phaseUsage_, physicalModel,
                                 restartConfig, reportStepNum, logMessages );
         detail::getSummaryData( cellData, phaseUsage_, physicalModel, summaryConfig );
 
diff --git a/opm/autodiff/SimulatorFullyImplicitBlackoilOutputEbos.cpp b/opm/autodiff/SimulatorFullyImplicitBlackoilOutputEbos.cpp
index 3816544af..0415ab26e 100644
--- a/opm/autodiff/SimulatorFullyImplicitBlackoilOutputEbos.cpp
+++ b/opm/autodiff/SimulatorFullyImplicitBlackoilOutputEbos.cpp
@@ -24,7 +24,6 @@
 #include <opm/common/data/SimulationDataContainer.hpp>
 
 #include <opm/parser/eclipse/EclipseState/InitConfig/InitConfig.hpp>
-#include <opm/output/Cells.hpp>
 #include <opm/core/simulator/BlackoilState.hpp>
 #include <opm/core/utility/DataMap.hpp>
 #include <opm/autodiff/Compat.hpp>
@@ -63,14 +62,14 @@ namespace Opm
             std::unique_ptr< SimulatorTimerInterface > timer_;
             const SimulationDataContainer state_;
             const WellState wellState_;
-            std::vector<data::CellData> simProps_;
+            data::Solution simProps_;
             const bool substep_;
 
             explicit WriterCallEbos( BlackoilOutputWriterEbos& writer,
                                  const SimulatorTimerInterface& timer,
                                  const SimulationDataContainer& state,
                                  const WellState& wellState,
-                                 const std::vector<data::CellData>& simProps,
+                                 const data::Solution& simProps,
                                  bool substep )
                 : writer_( writer ),
                   timer_( timer.clone() ),
@@ -98,7 +97,7 @@ namespace Opm
                   const WellState& localWellState,
                   bool substep)
     {
-        std::vector<data::CellData> noCellProperties;
+        data::Solution noCellProperties;
         writeTimeStepWithCellProperties(timer, localState, localWellState, noCellProperties, substep);
     }
 
@@ -112,7 +111,7 @@ namespace Opm
                   const SimulatorTimerInterface& timer,
                   const SimulationDataContainer& localState,
                   const WellState& localWellState,
-                  const std::vector<data::CellData>& cellData,
+                  const data::Solution& sol,
                   bool substep)
     {
         bool isIORank = output_ ;
@@ -137,11 +136,11 @@ namespace Opm
         {
             if( asyncOutput_ ) {
                 // dispatch the write call to the extra thread
-                asyncOutput_->dispatch( detail::WriterCallEbos( *this, timer, state, wellState, cellData, substep ) );
+                asyncOutput_->dispatch( detail::WriterCallEbos( *this, timer, state, wellState, sol, substep ) );
             }
             else {
                 // just write the data to disk
-                writeTimeStepSerial( timer, state, wellState, cellData, substep );
+                writeTimeStepSerial( timer, state, wellState, sol, substep );
             }
         }
     }
@@ -153,7 +152,7 @@ namespace Opm
     writeTimeStepSerial(const SimulatorTimerInterface& timer,
                         const SimulationDataContainer& state,
                         const WellState& wellState,
-                        const std::vector<data::CellData>& simProps,
+                        const data::Solution& sol,
                         bool substep)
     {
         // ECL output
@@ -167,8 +166,7 @@ namespace Opm
                                           substep,
                                           timer.simulationTimeElapsed(),
                                           simToSolution( state, phaseUsage_ ),
-                                          wellState.report(phaseUsage_),
-                                          simProps);
+                                          wellState.report(phaseUsage_));
             }
         }
 
diff --git a/opm/autodiff/SimulatorFullyImplicitBlackoilOutputEbos.hpp b/opm/autodiff/SimulatorFullyImplicitBlackoilOutputEbos.hpp
index c827e641d..97572226a 100644
--- a/opm/autodiff/SimulatorFullyImplicitBlackoilOutputEbos.hpp
+++ b/opm/autodiff/SimulatorFullyImplicitBlackoilOutputEbos.hpp
@@ -30,7 +30,6 @@
 #include <opm/core/utility/parameters/ParameterGroup.hpp>
 #include <opm/core/wells/DynamicListEconLimited.hpp>
 
-#include <opm/output/Cells.hpp>
 #include <opm/output/eclipse/EclipseWriter.hpp>
 
 #include <opm/autodiff/Compat.hpp>
@@ -96,7 +95,7 @@ namespace Opm
                            const SimulatorTimerInterface& timer,
                            const SimulationDataContainer& reservoirState,
                            const Opm::WellState& wellState,
-                           const std::vector<data::CellData>& simProps,
+                           const data::Solution& sol,
                            bool substep = false);
 
         /*!
@@ -118,7 +117,7 @@ namespace Opm
         void writeTimeStepSerial(const SimulatorTimerInterface& timer,
                                  const SimulationDataContainer& reservoirState,
                                  const Opm::WellState& wellState,
-                                 const std::vector<data::CellData>& simProps,
+                                 const data::Solution& simProps,
                                  bool substep);
 
         /** \brief return output directory */
@@ -262,7 +261,7 @@ namespace Opm
 
     namespace detail {
         template<class Model>
-        std::vector<data::CellData> getCellDataEbos(
+        Opm::data::Solution getOutputDataEbos(
                 const Opm::PhaseUsage& phaseUsage,
                 const Model& model,
                 const RestartConfig& restartConfig,
@@ -270,7 +269,7 @@ namespace Opm
         {
             typedef typename Model::FluidSystem FluidSystem;
 
-            std::vector<data::CellData> simProps;
+            Opm::data::Solution sol;
 
             //Get the value of each of the keys
             std::map<std::string, int> outKeywords = restartConfig.getRestartKeywords(reportStepNum);
@@ -278,15 +277,17 @@ namespace Opm
                 keyValue.second = restartConfig.getKeyword(keyValue.first, reportStepNum);
             }
 
-            //Get shorthands for water, oil, gas
-            const int aqua_active = phaseUsage.phase_used[Opm::PhaseUsage::Aqua];
-            const int liquid_active = phaseUsage.phase_used[Opm::PhaseUsage::Liquid];
-            const int vapour_active = phaseUsage.phase_used[Opm::PhaseUsage::Vapour];
-
             const auto& ebosModel = model.ebosSimulator().model();
 
             // extract everything which can possibly be written to disk
             int numCells = ebosModel.numGridDof();
+
+            std::vector<double> pressureOil(numCells);
+            std::vector<double> temperature(numCells);
+
+            std::vector<double> satWater(numCells);
+            std::vector<double> satGas(numCells);
+
             std::vector<double> bWater(numCells);
             std::vector<double> bOil(numCells);
             std::vector<double> bGas(numCells);
@@ -305,15 +306,27 @@ namespace Opm
 
             std::vector<double> Rs(numCells);
             std::vector<double> Rv(numCells);
+            std::vector<double> RsSat(numCells);
+            std::vector<double> RvSat(numCells);
 
             for (int cellIdx = 0; cellIdx < numCells; ++cellIdx) {
                 const auto& intQuants = *ebosModel.cachedIntensiveQuantities(cellIdx, /*timeIdx=*/0);
                 const auto& fs = intQuants.fluidState();
 
+                pressureOil[cellIdx] = fs.pressure(FluidSystem::oilPhaseIdx).value;
+
+                temperature[cellIdx] = fs.temperature(FluidSystem::oilPhaseIdx).value;
+
+                satWater[cellIdx] = fs.saturation(FluidSystem::waterPhaseIdx).value;
+                satGas[cellIdx] = fs.saturation(FluidSystem::gasPhaseIdx).value;
+
                 bWater[cellIdx] = fs.invB(FluidSystem::waterPhaseIdx).value;
                 bOil[cellIdx] = fs.invB(FluidSystem::oilPhaseIdx).value;
                 bGas[cellIdx] = fs.invB(FluidSystem::gasPhaseIdx).value;
 
+                Rs[cellIdx] = fs.Rs().value;
+                Rs[cellIdx] = fs.Rv().value;
+
                 rhoWater[cellIdx] = fs.density(FluidSystem::waterPhaseIdx).value;
                 rhoOil[cellIdx] = fs.density(FluidSystem::oilPhaseIdx).value;
                 rhoGas[cellIdx] = fs.density(FluidSystem::gasPhaseIdx).value;
@@ -326,39 +339,85 @@ namespace Opm
                 krOil[cellIdx] = intQuants.relativePermeability(FluidSystem::oilPhaseIdx).value;
                 krGas[cellIdx] = intQuants.relativePermeability(FluidSystem::gasPhaseIdx).value;
 
-                Rs[cellIdx] = FluidSystem::saturatedDissolutionFactor(fs,
-                                                                      FluidSystem::oilPhaseIdx,
-                                                                      intQuants.pvtRegionIndex(),
-                                                                      /*maxOilSaturation=*/1.0).value;
-                Rv[cellIdx] = FluidSystem::saturatedDissolutionFactor(fs,
-                                                                      FluidSystem::gasPhaseIdx,
-                                                                      intQuants.pvtRegionIndex(),
-                                                                      /*maxOilSaturation=*/1.0).value;
+                RsSat[cellIdx] = FluidSystem::saturatedDissolutionFactor(fs,
+                                                                         FluidSystem::oilPhaseIdx,
+                                                                         intQuants.pvtRegionIndex(),
+                                                                         /*maxOilSaturation=*/1.0).value;
+                RvSat[cellIdx] = FluidSystem::saturatedDissolutionFactor(fs,
+                                                                         FluidSystem::gasPhaseIdx,
+                                                                         intQuants.pvtRegionIndex(),
+                                                                         /*maxOilSaturation=*/1.0).value;
             }
 
+            /**
+             * Oil Pressures
+             */
+            outKeywords["PRESSURE"] = 0;
+            sol.insert("PRESSURE",
+                       UnitSystem::measure::pressure,
+                       std::move(pressureOil),
+                       data::TargetType::RESTART_SOLUTION);
+
+            /**
+             * Temperatures
+             */
+            outKeywords["TEMP"] = 0;
+            sol.insert("TEMP",
+                       UnitSystem::measure::temperature,
+                       std::move(temperature),
+                       data::TargetType::RESTART_SOLUTION);
+
+            /**
+             * Water and gas saturation.
+             */
+            outKeywords["SWAT"] = 0;
+            outKeywords["SGAS"] = 0;
+            sol.insert("SWAT",
+                       UnitSystem::measure::identity,
+                       std::move(satWater),
+                       data::TargetType::RESTART_SOLUTION);
+            sol.insert("SGAS",
+                       UnitSystem::measure::identity,
+                       std::move(satGas),
+                       data::TargetType::RESTART_SOLUTION);
+
+            /**
+             * the dissolution factors
+             */
+            outKeywords["RS"] = 0;
+            outKeywords["RV"] = 0;
+            sol.insert("RS",
+                       UnitSystem::measure::gas_oil_ratio,
+                       std::move(Rs),
+                       data::TargetType::RESTART_SOLUTION);
+            sol.insert("RV",
+                       UnitSystem::measure::oil_gas_ratio,
+                       std::move(Rv),
+                       data::TargetType::RESTART_SOLUTION);
+
             /**
              * Formation volume factors for water, oil, gas
              */
-            if (aqua_active && outKeywords["BW"] > 0) {
+            if (outKeywords["BW"] > 0) {
                 outKeywords["BW"] = 0;
-                simProps.emplace_back(data::CellData{
-                        "1OVERBW",
-                        Opm::UnitSystem::measure::water_inverse_formation_volume_factor,
-                        std::move(bWater)});
+                sol.insert("BW",
+                           Opm::UnitSystem::measure::water_inverse_formation_volume_factor,
+                           std::move(bWater),
+                           data::TargetType::RESTART_AUXILLARY);
             }
-            if (liquid_active && outKeywords["BO"]  > 0) {
+            if (outKeywords["BO"]  > 0) {
                 outKeywords["BO"] = 0;
-                simProps.emplace_back(data::CellData{
-                        "1OVERBO",
-                        Opm::UnitSystem::measure::oil_inverse_formation_volume_factor,
-                        std::move(bOil)});
+                sol.insert("BO",
+                           Opm::UnitSystem::measure::oil_inverse_formation_volume_factor,
+                           std::move(bOil),
+                           data::TargetType::RESTART_AUXILLARY);
             }
-            if (vapour_active && outKeywords["BG"] > 0) {
+            if (outKeywords["BG"] > 0) {
                 outKeywords["BG"] = 0;
-                simProps.emplace_back(data::CellData{
-                        "1OVERBG",
-                        Opm::UnitSystem::measure::gas_inverse_formation_volume_factor,
-                        std::move(bGas)});
+                sol.insert("BG",
+                           Opm::UnitSystem::measure::gas_inverse_formation_volume_factor,
+                           std::move(bGas),
+                           data::TargetType::RESTART_AUXILLARY);
             }
 
             /**
@@ -366,24 +425,19 @@ namespace Opm
              */
             if (outKeywords["DEN"] > 0) {
                 outKeywords["DEN"] = 0;
-                if (aqua_active) {
-                    simProps.emplace_back(data::CellData{
-                            "WAT_DEN",
-                            Opm::UnitSystem::measure::density,
-                            std::move(rhoWater)});
-                }
-                if (liquid_active) {
-                    simProps.emplace_back(data::CellData{
-                            "OIL_DEN",
-                            Opm::UnitSystem::measure::density,
-                            std::move(rhoOil)});
-                }
-                if (vapour_active) {
-                    simProps.emplace_back(data::CellData{
-                            "GAS_DEN",
-                            Opm::UnitSystem::measure::density,
-                            std::move(rhoGas)});
-                }
+
+                sol.insert("WAT_DEN",
+                           Opm::UnitSystem::measure::density,
+                           std::move(rhoWater),
+                           data::TargetType::RESTART_AUXILLARY);
+                sol.insert("OIL_DEN",
+                           Opm::UnitSystem::measure::density,
+                           std::move(rhoOil),
+                           data::TargetType::RESTART_AUXILLARY);
+                sol.insert("GAS_DEN",
+                           Opm::UnitSystem::measure::density,
+                           std::move(rhoGas),
+                           data::TargetType::RESTART_AUXILLARY);
             }
 
             /**
@@ -391,78 +445,71 @@ namespace Opm
              */
             if (outKeywords["VISC"] > 0) {
                 outKeywords["VISC"] = 0;
-                if (aqua_active) {
-                    simProps.emplace_back(data::CellData{
-                            "WAT_VISC",
-                            Opm::UnitSystem::measure::viscosity,
-                            std::move(muWater)});
-                }
-                if (liquid_active) {
-                    simProps.emplace_back(data::CellData{
-                            "OIL_VISC",
-                            Opm::UnitSystem::measure::viscosity,
-                            std::move(muOil)});
-                }
-                if (vapour_active) {
-                    simProps.emplace_back(data::CellData{
-                            "GAS_VISC",
-                            Opm::UnitSystem::measure::viscosity,
-                            std::move(muGas)});
-                }
+                sol.insert("WAT_VISC",
+                           Opm::UnitSystem::measure::viscosity,
+                           std::move(muWater),
+                           data::TargetType::RESTART_AUXILLARY);
+                sol.insert("OIL_VISC",
+                           Opm::UnitSystem::measure::viscosity,
+                           std::move(muOil),
+                           data::TargetType::RESTART_AUXILLARY);
+                sol.insert("GAS_VISC",
+                           Opm::UnitSystem::measure::viscosity,
+                           std::move(muGas),
+                           data::TargetType::RESTART_AUXILLARY);
             }
 
             /**
              * Relative permeabilities for water, oil, gas
              */
-            if (aqua_active && outKeywords["KRW"] > 0) {
+            if (outKeywords["KRW"] > 0) {
                 outKeywords["KRW"] = 0;
-                simProps.emplace_back(data::CellData{
-                        "WATKR",
-                        Opm::UnitSystem::measure::permeability,
-                        std::move(krWater)});
+                sol.insert("WATKR",
+                           Opm::UnitSystem::measure::identity,
+                           std::move(krWater),
+                           data::TargetType::RESTART_AUXILLARY);
             }
-            if (liquid_active && outKeywords["KRO"] > 0) {
+            if (outKeywords["KRO"] > 0) {
                 outKeywords["KRO"] = 0;
-                simProps.emplace_back(data::CellData{
-                         "OILKR",
-                         Opm::UnitSystem::measure::permeability,
-                         std::move(krOil)});
+                sol.insert("OILKR",
+                           Opm::UnitSystem::measure::identity,
+                           std::move(krOil),
+                           data::TargetType::RESTART_AUXILLARY);
             }
-            if (vapour_active && outKeywords["KRG"] > 0) {
+            if (outKeywords["KRG"] > 0) {
                 outKeywords["KRG"] = 0;
-                simProps.emplace_back(data::CellData{
-                          "GASKR",
-                          Opm::UnitSystem::measure::permeability,
-                          std::move(krGas)});
+                sol.insert("GASKR",
+                           Opm::UnitSystem::measure::identity,
+                           std::move(krGas),
+                           data::TargetType::RESTART_AUXILLARY);
             }
 
             /**
              * Vaporized and dissolved gas/oil ratio
              */
-            if (vapour_active && liquid_active && outKeywords["RSSAT"] > 0) {
+            if (outKeywords["RSSAT"] > 0) {
                 outKeywords["RSSAT"] = 0;
-                simProps.emplace_back(data::CellData{
-                        "RSSAT",
-                        Opm::UnitSystem::measure::gas_oil_ratio,
-                        std::move(Rs)});
+                sol.insert("RSSAT",
+                           Opm::UnitSystem::measure::gas_oil_ratio,
+                           std::move(RsSat),
+                           data::TargetType::RESTART_AUXILLARY);
             }
-            if (vapour_active && liquid_active && outKeywords["RVSAT"] > 0) {
+            if (outKeywords["RVSAT"] > 0) {
                 outKeywords["RVSAT"] = 0;
-                simProps.emplace_back(data::CellData{
-                        "RVSAT",
-                        Opm::UnitSystem::measure::oil_gas_ratio,
-                        std::move(Rv)});
+                sol.insert("RVSAT",
+                           Opm::UnitSystem::measure::oil_gas_ratio,
+                           std::move(RvSat),
+                           data::TargetType::RESTART_AUXILLARY);
             }
 
 
             /**
              * Bubble point and dew point pressures
              */
-            if (vapour_active && liquid_active && outKeywords["PBPD"] > 0) {
-                outKeywords["PBPD"] = 0;
+            if (outKeywords["PBPD"] > 0) {
                 Opm::OpmLog::warning("Bubble/dew point pressure output unsupported",
-                        "Writing bubble points and dew points (PBPD) to file is unsupported, "
-                        "as the simulator does not use these internally.");
+                                     "Writing bubble points and dew points (PBPD) to file is unsupported, "
+                                     "as the simulator does not use these internally.");
             }
 
             //Warn for any unhandled keyword
@@ -475,7 +522,7 @@ namespace Opm
                 }
             }
 
-            return simProps;
+            return sol;
         }
     }
 
@@ -493,8 +540,8 @@ namespace Opm
     {
         const RestartConfig& restartConfig = eclipseState_->getRestartConfig();
         const int reportStepNum = timer.reportStepNum();
-        std::vector<data::CellData> cellData = detail::getCellDataEbos( phaseUsage_, physicalModel, restartConfig, reportStepNum );
-        writeTimeStepWithCellProperties(timer, localState, localWellState, cellData, substep);
+        Opm::data::Solution sol = detail::getOutputDataEbos( phaseUsage_, physicalModel, restartConfig, reportStepNum );
+        writeTimeStepWithCellProperties(timer, localState, localWellState, sol, substep);
     }
 }
 #endif
diff --git a/opm/polymer/SimulatorPolymer.cpp b/opm/polymer/SimulatorPolymer.cpp
index 82900bca7..d6a17070b 100644
--- a/opm/polymer/SimulatorPolymer.cpp
+++ b/opm/polymer/SimulatorPolymer.cpp
@@ -610,10 +610,9 @@ namespace Opm
                                const std::string& output_dir)
         {
 #ifdef HAVE_ERT
-            using ds = data::Solution::key;
             data::Solution sol;
-            sol.insert( ds::PRESSURE, state.pressure() );
-            sol.insert( ds::SWAT, destripe( state.saturation(), 0, 2 ) );
+            sol.insert( "PRESSURE", UnitSystem::measure::pressure , state.pressure() , data::TargetType::RESTART_SOLUTION );
+            sol.insert( "SWAT", UnitSystem::measure::identity, destripe( state.saturation(), 0, 2 ) , data::TargetType::RESTART_SOLUTION);
 
             writeECLData( grid.cartdims[ 0 ],
                           grid.cartdims[ 1 ],