Replace raw conversion_table with UnitSystem

The to_si/from_si functions were moved into UnitSystem which now manages
table lookup for clients, rather than having to store the raw
conversion tables.

opm/output/eclipse/Summary.hpp

@@ -59,7 +59,6 @@ class Summary {
         std::map< const char*, std::vector< sum_node > > wvar;
         std::map< const char*, std::vector< sum_node > > gvar;
         const ecl_sum_tstep_type* prev_tstep = nullptr;
-        const double* conversions;
 };
 
 }

src/opm/output/eclipse/EclipseReader.cpp

@@ -28,7 +28,7 @@
 #include <opm/parser/eclipse/EclipseState/IOConfig/IOConfig.hpp>
 #include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/TableManager.hpp>
-#include <opm/parser/eclipse/Units/ConversionFactors.hpp>
+#include <opm/parser/eclipse/Units/UnitSystem.hpp>
 
 #include <algorithm>
 
@@ -37,7 +37,7 @@ namespace {
 
     inline data::Solution restoreSOLUTION( ecl_file_type* file,
                                            int numcells,
-                                           const double* conversion_table ) {
+                                           const UnitSystem& units ) {
 
         for( const auto* key : { "PRESSURE", "TEMP", "SWAT", "SGAS" } ) {
             if( !ecl_file_has_kw( file, key ) )
@@ -80,13 +80,12 @@ namespace {
         sol.insert( ds::SWAT,     { swat.data, swat.data + swat.size } );
         sol.insert( ds::SGAS,     { sgas.data, sgas.data + sgas.size } );
 
-        using namespace conversions;
-        const auto apply_pressure = [=]( double x ) {
-            return to_si( conversion_table, dim::pressure, x );
+        const auto apply_pressure = [&]( double x ) {
+            return units.to_si( UnitSystem::measure::pressure, x );
         };
 
         const auto apply_temperature = [=]( double x ) {
-            return to_si( conversion_table, dim::temperature, x );
+            return units.to_si( UnitSystem::measure::temperature, x );
         };
 
         std::transform( sol[ ds::PRESSURE ].begin(), sol[ ds::PRESSURE ].end(),
@@ -171,13 +170,8 @@ init_from_restart_file( const EclipseState& es, int numcells ) {
                 + std::to_string( restart_step ) + "!" );
     }
 
-    const auto* conv_table = es.getDeckUnitSystem()
-        .getType() == UnitSystem::UNIT_TYPE_METRIC
-        ? conversions::metric2si
-        : conversions::field2si;
-
     return {
-        restoreSOLUTION( file.get(), numcells, conv_table ),
+        restoreSOLUTION( file.get(), numcells, es.getUnits() ),
         restoreOPM_XWEL( file.get(), num_wells, num_phases )
     };
 }

src/opm/output/eclipse/EclipseWriter.cpp

@@ -24,7 +24,6 @@
 #include "EclipseWriter.hpp"
 
 #include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
-#include <opm/parser/eclipse/Units/ConversionFactors.hpp>
 #include <opm/parser/eclipse/Units/Dimension.hpp>
 #include <opm/parser/eclipse/Units/UnitSystem.hpp>
 #include <opm/parser/eclipse/EclipseState/Eclipse3DProperties.hpp>
@@ -79,10 +78,10 @@ void restrictAndReorderToActiveCells(std::vector<double> &data,
 }
 
 inline void convertFromSiTo( std::vector< double >& siValues,
-                                    const double* table,
-                                    conversions::dim d ) {
+                                    const UnitSystem& units,
+                                    UnitSystem::measure m ) {
     for (size_t curIdx = 0; curIdx < siValues.size(); ++curIdx) {
-        siValues[curIdx] = conversions::from_si( table, d, siValues[ curIdx ] );
+        siValues[curIdx] = units.from_si( m, siValues[ curIdx ] );
     }
 }
 
@@ -395,14 +394,6 @@ inline int ertPhaseMask( const TableManager& tm ) {
          | ( tm.hasPhase( Phase::PhaseEnum::GAS ) ? ECL_GAS_PHASE : 0 );
 }
 
-inline const double* get_conv_table( UnitSystem::UnitType t ) {
-    switch( t ) {
-        case UnitSystem::UNIT_TYPE_METRIC: return conversions::si2metric;
-        case UnitSystem::UNIT_TYPE_FIELD:  return conversions::si2field;
-        default: return conversions::si2metric;
-    }
-}
-
 class RFT {
     public:
         RFT( const char* output_dir,
@@ -531,7 +522,6 @@ class EclipseWriter::Impl {
         std::array< int, 3 > cartesianSize;
         const int* compressed_to_cartesian;
         std::vector< int > gridToEclipseIdx;
-        const double* conversion_table;
         bool output_enabled;
         int ert_phase_mask;
 };
@@ -551,7 +541,6 @@ EclipseWriter::Impl::Impl( std::shared_ptr< const EclipseState > eclipseState,
     , numCells( numCells )
     , compressed_to_cartesian( compressed_to_cart )
     , gridToEclipseIdx( numCells, int(-1) )
-    , conversion_table( get_conv_table( eclipseState->getDeckUnitSystem().getType() ) )
     , output_enabled( eclipseState->getIOConfig()->getOutputEnabled() )
     , ert_phase_mask( ertPhaseMask( eclipseState->getTableManager() ) )
 {}
@@ -577,30 +566,30 @@ void EclipseWriter::writeInit( const NNC& nnc ) {
 
     if( !ioConfig->getWriteINITFile() ) return;
 
-    const auto* conversion_table = this->impl->conversion_table;
     const auto& gridToEclipseIdx = this->impl->gridToEclipseIdx;
+    const auto& units = es.getUnits();
 
     if (props.hasDeckDoubleGridProperty("PERMX")) {
         auto data = props.getDoubleGridProperty("PERMX").getData();
         convertFromSiTo( data,
-                conversion_table,
-                conversions::dim::permeability );
+                         units,
+                         units.measure::permeability );
         restrictAndReorderToActiveCells(data, gridToEclipseIdx.size(), gridToEclipseIdx.data());
         fortio.writeKeyword("PERMX", data);
     }
     if (props.hasDeckDoubleGridProperty("PERMY")) {
         auto data = props.getDoubleGridProperty("PERMY").getData();
         convertFromSiTo( data,
-                conversion_table,
-                conversions::dim::permeability );
+                         units,
+                         units.measure::permeability );
         restrictAndReorderToActiveCells(data, gridToEclipseIdx.size(), gridToEclipseIdx.data());
         fortio.writeKeyword("PERMY", data);
     }
     if (props.hasDeckDoubleGridProperty("PERMZ")) {
         auto data = props.getDoubleGridProperty("PERMZ").getData();
         convertFromSiTo( data,
-                conversion_table,
-                conversions::dim::permeability );
+                         units,
+                         units.measure::permeability );
         restrictAndReorderToActiveCells(data, gridToEclipseIdx.size(), gridToEclipseIdx.data());
         fortio.writeKeyword("PERMZ", data);
     }
@@ -612,7 +601,7 @@ void EclipseWriter::writeInit( const NNC& nnc ) {
         tran.push_back( nd.trans );
     }
 
-    convertFromSiTo( tran, conversion_table, conversions::dim::transmissibility );
+    convertFromSiTo( tran, units, units.measure::transmissibility );
     fortio.writeKeyword("TRANNNC", tran);
 
 }
@@ -631,14 +620,14 @@ void EclipseWriter::writeTimeStep(int report_step,
     using dc = data::Solution::key;
 
     time_t current_posix_time = this->impl->sim_start_time + secs_elapsed;
-    const auto* conversion_table = this->impl->conversion_table;
     const auto& gridToEclipseIdx = this->impl->gridToEclipseIdx;
     const auto& es = *this->impl->es;
+    const auto& units = es.getUnits();
 
     auto& pressure = cells[ dc::PRESSURE ];
     convertFromSiTo( pressure,
-                     conversion_table,
-                     conversions::dim::pressure );
+                     units,
+                     units.measure::pressure );
     restrictAndReorderToActiveCells(pressure, gridToEclipseIdx.size(), gridToEclipseIdx.data());
 
     if( cells.has( dc::SWAT ) ) {
@@ -655,9 +644,7 @@ void EclipseWriter::writeTimeStep(int report_step,
     IOConfigConstPtr ioConfig = this->impl->es->getIOConfigConst();
 
 
-    const auto days = conversions::from_si( conversion_table,
-                                            conversions::dim::time,
-                                            secs_elapsed );
+    const auto days = units.from_si( units.measure::time, secs_elapsed );
     const auto& schedule = *es.getSchedule();
 
     // Write restart file
@@ -731,8 +718,8 @@ void EclipseWriter::writeTimeStep(int report_step,
         // write the cell temperature
         auto& temperature = cells[ dc::TEMP ];
         convertFromSiTo( temperature,
-                         conversion_table,
-                         conversions::dim::temperature );
+                         units,
+                         units.measure::temperature );
         sol.add(Keyword<float>("TEMP", temperature));