end of implementation of time handling

mdal/api/mdal.h

@@ -321,8 +321,7 @@ MDAL_EXPORT bool MDAL_G_isInEditMode( DatasetGroupH group );
 //! When closed, minimum and maximum dataset group values are automatically calculated
 MDAL_EXPORT void MDAL_G_closeEditMode( DatasetGroupH group );
 
-//! Returns reference time for dataset group
-//! If returned value begins with word JULIAN, following number represents date in Julian format
+//! Returns reference time for dataset group expressed in date with ISO8601 format, return "" if reference time is not defined
 MDAL_EXPORT const char *MDAL_G_referenceTime( DatasetGroupH group );
 
 ///////////////////////////////////////////////////////////////////////////////////////

mdal/frmts/mdal_3di.cpp

@@ -140,7 +140,6 @@ void MDAL::Driver3Di::addBedElevation( MemoryMesh *mesh )
 
   std::shared_ptr<MDAL::MemoryDataset2D> dataset = std::make_shared< MemoryDataset2D >( group.get() );
   dataset->setTime( MDAL::Duration() );
-  double *values = dataset->values();
   for ( size_t i = 0; i < faceCount; ++i )
   {
     dataset->setScalarValue( i, MDAL::safeValue( coordZ[i], fillZ ) );

mdal/frmts/mdal_ascii_dat.cpp

@@ -247,7 +247,7 @@ void MDAL::DriverAsciiDat::loadNewFormat(
     else if ( cardType == "TS" && items.size() >= 3 )
     {
       double rawTime = toDouble( items[2] );
-      MDAL::Duration t( rawTime, MDAL::parseDurationUnitTime( group->getMetadata( "TIMEUNITS" ) ) );
+      MDAL::Duration t( rawTime, MDAL::parseDurationTimeUnit( group->getMetadata( "TIMEUNITS" ) ) );
 
       if ( faceCentered )
       {
@@ -523,22 +523,3 @@ bool MDAL::DriverAsciiDat::persist( MDAL::DatasetGroup *group )
 
   return false;
 }
-
-double MDAL::DriverAsciiDat::convertTimeDataToHours( double time, const std::string &originalTimeDataUnit ) const
-{
-  if ( originalTimeDataUnit == "se" || originalTimeDataUnit == "2" || originalTimeDataUnit == "Seconds"
-       || originalTimeDataUnit.empty() )
-  {
-    time /= 3600.0;
-  }
-  else if ( originalTimeDataUnit == "mi" || originalTimeDataUnit == "1" || originalTimeDataUnit == "Minutes" )
-  {
-    time /= 60.0;
-  }
-  else if ( originalTimeDataUnit == "days" )
-  {
-    time *= 24;
-  }
-  return time;
-}
-

mdal/frmts/mdal_ascii_dat.hpp

@@ -83,8 +83,6 @@ namespace MDAL
                              bool isVector,
                              std::ifstream &stream ) const;
 
-      double convertTimeDataToHours( double time, const std::string &originalTimeDataUnit ) const;
-
       std::string mDatFile;
   };
 

mdal/frmts/mdal_binary_dat.cpp

@@ -289,7 +289,7 @@ void MDAL::DriverBinaryDat::load( const std::string &datFile, MDAL::Mesh *mesh,
           return exit_with_error( status, MDAL_Status::Err_UnknownFormat, "Invalid time step" );
 
         double rawTime = static_cast<double>( time );
-        MDAL::Duration t( rawTime, MDAL::parseDurationUnitTime( timeUnitStr ) );
+        MDAL::Duration t( rawTime, MDAL::parseDurationTimeUnit( timeUnitStr ) );
 
         if ( readVertexTimestep( mesh, group, groupMax, t, istat, sflg, in ) )
           return exit_with_error( status, MDAL_Status::Err_UnknownFormat, "Unable to read vertex timestep" );
@@ -315,9 +315,10 @@ bool MDAL::DriverBinaryDat::readVertexTimestep(
   const MDAL::Mesh *mesh,
   std::shared_ptr<DatasetGroup> group,
   std::shared_ptr<DatasetGroup> groupMax,
-    MDAL::Duration time,
-    int sflg,
-    std::ifstream &in )
+  MDAL::Duration time,
+  bool hasStatus,
+  int sflg,
+  std::ifstream &in )
 {
   assert( group && groupMax && ( group->isScalar() == groupMax->isScalar() ) );
   bool isScalar = group->isScalar();
@@ -492,23 +493,3 @@ bool MDAL::DriverBinaryDat::persist( MDAL::DatasetGroup *group )
 
   return false;
 }
-
-double MDAL::DriverBinaryDat::convertTimeDataToHours( double time, int originalTimeDataUnit )
-{
-  switch ( originalTimeDataUnit )
-  {
-    case 1:
-      time /= 60.0;
-      break;
-    case 2:
-      time /= 3600.0;
-      break;
-    case 4:
-      time *= 24;
-      break;
-    case 0:
-    default:
-      break;
-  }
-  return time;
-}

mdal/frmts/mdal_binary_dat.hpp

@@ -40,7 +40,6 @@ namespace MDAL
                                int sflg,
                                std::ifstream &in );
 
-      double convertTimeDataToHours( double time, int originalTimeDataUnit );
       std::string mDatFile;
   };
 

mdal/frmts/mdal_flo2d.cpp

@@ -528,8 +528,6 @@ bool MDAL::DriverFlo2D::parseHDF5Datasets( MemoryMesh *mesh, const std::string &
     HdfGroup grp = timedataGroup.group( grpName );
     if ( !grp.isValid() ) return true;
 
-    auto g = grp.objects();
-
     HdfAttribute groupType = grp.attribute( "Grouptype" );
     if ( !groupType.isValid() ) return true;
 
@@ -575,7 +573,7 @@ bool MDAL::DriverFlo2D::parseHDF5Datasets( MemoryMesh *mesh, const std::string &
     for ( size_t ts = 0; ts < timesteps; ++ts )
     {
       std::shared_ptr< MemoryDataset2D > output = std::make_shared< MemoryDataset2D >( ds.get() );
-      output->setTime( times[ts], parseDurationUnitTime( timeUnitString ) );
+      output->setTime( times[ts], parseDurationTimeUnit( timeUnitString ) );
 
       if ( isVector )
       {

mdal/frmts/mdal_hec2d.cpp

@@ -103,7 +103,7 @@ static std::vector<MDAL::Duration> convertTimeData( std::vector<float> &times, c
 {
   std::vector<MDAL::Duration> convertedTime( times.size() );
 
-  MDAL::Duration::Unit unit = MDAL::parseDurationUnitTime( originalTimeDataUnit );
+  MDAL::Duration::Unit unit = MDAL::parseDurationTimeUnit( originalTimeDataUnit );
 
   for ( size_t i = 0; i < times.size(); i++ )
   {

mdal/frmts/mdal_selafin.cpp

@@ -232,7 +232,8 @@ void MDAL::DriverSelafin::parseFile( std::vector<std::string> &var_names,
                                      std::vector<size_t> &ikle,
                                      std::vector<double> &x,
                                      std::vector<double> &y,
-                                     std::vector<timestep_map> &data, DateTime &referenceTime )
+                                     std::vector<timestep_map> &data,
+                                     DateTime &referenceTime )
 {
 
   /* 1 record containing the title of the study (72 characters) and a 8 characters
@@ -411,7 +412,10 @@ void MDAL::DriverSelafin::createMesh(
   mMesh->vertices = nodes;
 }
 
-void MDAL::DriverSelafin::addData( const std::vector<std::string> &var_names, const std::vector<timestep_map> &data, size_t nPoints, const DateTime &referenceTime )
+void MDAL::DriverSelafin::addData( const std::vector<std::string> &var_names,
+                                   const std::vector<timestep_map> &data,
+                                   size_t nPoints,
+                                   const DateTime &referenceTime )
 {
   for ( size_t nName = 0; nName < var_names.size(); ++nName )
   {
@@ -477,7 +481,6 @@ void MDAL::DriverSelafin::addData( const std::vector<std::string> &var_names, co
       }
       else
       {
-        dataset = std::make_shared< MemoryDataset2D >( group.get() );
         dataset = std::make_shared< MemoryDataset2D >( group.get(), true );
         dataset->setTime( it->first, Duration::seconds ); //seems that time unit in this format is only seconds
         group->datasets.push_back( dataset );

mdal/frmts/mdal_xdmf.cpp

@@ -20,7 +20,7 @@
 #include "mdal_data_model.hpp"
 #include "mdal_xml.hpp"
 
-MDAL::XdmfDataset::XdmfDataset( MDAL::DatasetGroup *grp, const MDAL::HyperSlab &slab, const HdfDataset &valuesDs, double time )
+MDAL::XdmfDataset::XdmfDataset( MDAL::DatasetGroup *grp, const MDAL::HyperSlab &slab, const HdfDataset &valuesDs, Duration time )
   : MDAL::Dataset2D( grp )
   , mHdf5DatasetValues( valuesDs )
   , mHyperSlab( slab )
@@ -106,10 +106,9 @@ size_t MDAL::XdmfDataset::vectorData( size_t indexStart, size_t count, double *b
 // //////////////////////////////////////////////////////////////////////////////
 
 
-MDAL::XdmfFunctionDataset::XdmfFunctionDataset(
-  MDAL::DatasetGroup *grp,
-  MDAL::XdmfFunctionDataset::FunctionType type,
-  double time )
+MDAL::XdmfFunctionDataset::XdmfFunctionDataset( MDAL::DatasetGroup *grp,
+    MDAL::XdmfFunctionDataset::FunctionType type,
+    Duration time )
   : MDAL::Dataset2D( grp )
   , mType( type )
   , mBaseReferenceGroup( "XDMF", grp->mesh(), grp->uri() )
@@ -122,7 +121,7 @@ MDAL::XdmfFunctionDataset::XdmfFunctionDataset(
 
 MDAL::XdmfFunctionDataset::~XdmfFunctionDataset() = default;
 
-void MDAL::XdmfFunctionDataset::addReferenceDataset( const HyperSlab &slab, const HdfDataset &hdfDataset, double time )
+void MDAL::XdmfFunctionDataset::addReferenceDataset( const HyperSlab &slab, const HdfDataset &hdfDataset, MDAL::Duration time )
 {
   std::shared_ptr<MDAL::XdmfDataset> xdmfDataset = std::make_shared<MDAL::XdmfDataset>(
         &mBaseReferenceGroup,
@@ -435,8 +434,7 @@ MDAL::DatasetGroups MDAL::DriverXdmf::parseXdmfXml( )
   {
     ++nTimesteps;
     xmlNodePtr timeNod = xmfFile.getCheckChild( gridNod, "Time" );
-    double time = xmfFile.queryDoubleAttribute( timeNod, "Value" );
-
+    Duration time( xmfFile.queryDoubleAttribute( timeNod, "Value" ), Duration::hours ); //units, hours ?
     xmlNodePtr scalarNod = xmfFile.getCheckChild( gridNod, "Attribute" );
 
     for ( ;

mdal/frmts/mdal_xdmf.hpp

@@ -61,7 +61,7 @@ namespace MDAL
       XdmfDataset( DatasetGroup *grp,
                    const HyperSlab &slab,
                    const HdfDataset &valuesDs,
-                   double time
+                   MDAL::Duration time
                  );
       ~XdmfDataset() override;
 
@@ -111,12 +111,12 @@ namespace MDAL
       XdmfFunctionDataset(
         DatasetGroup *grp,
         FunctionType type,
-        double time
+        MDAL::Duration time
       );
       ~XdmfFunctionDataset() override;
 
       //! Adds reference XMDF dataset
-      void addReferenceDataset( const HyperSlab &slab, const HdfDataset &hdfDataset, double time );
+      void addReferenceDataset( const HyperSlab &slab, const HdfDataset &hdfDataset, Duration time );
       //! Swaps first and second reference dataset
       void swap();
 

mdal/frmts/mdal_xmdf.cpp

@@ -248,14 +248,15 @@ std::shared_ptr<MDAL::DatasetGroup> MDAL::DriverXmdf::readXmdfGroupAsDatasetGrou
   bool isVector = dimValues.size() == 3;
 
   std::vector<double> times = dsTimes.readArrayDouble();
-  std::string timeUnit = rootGroup.attribute( "TimeUnits" ).readString();
+  std::string timeUnitString = rootGroup.attribute( "TimeUnits" ).readString();
+  MDAL::Duration::Unit timeUnit = parseDurationTimeUnit( timeUnitString );
   HdfAttribute refTime = rootGroup.attribute( "Reftime" );
   if ( refTime.isValid() )
   {
     std::string referenceTimeJulianDay = rootGroup.attribute( "Reftime" ).readString();
     group->setReferenceTime( DateTime( MDAL::toDouble( referenceTimeJulianDay ), DateTime::JulianDay ) );
   }
-  convertTimeDataToHours( times, timeUnit );
+
   // all fine, set group and return
   group = std::make_shared<MDAL::DatasetGroup>(
             name(),
@@ -265,7 +266,7 @@ std::shared_ptr<MDAL::DatasetGroup> MDAL::DriverXmdf::readXmdfGroupAsDatasetGrou
           );
   group->setIsScalar( !isVector );
   group->setDataLocation( MDAL_DataLocation::DataOnVertices2D );
-  group->setMetadata( "TIMEUNITS", timeUnit );
+  group->setMetadata( "TIMEUNITS", timeUnitString );
 
   // lazy loading of min and max of the dataset group
   std::vector<float> mins = dsMins.readArray();
@@ -275,10 +276,11 @@ std::shared_ptr<MDAL::DatasetGroup> MDAL::DriverXmdf::readXmdfGroupAsDatasetGrou
   grpStats.maximum = static_cast<double>( *std::max_element( maxs.begin(), maxs.end() ) );
   group->setStatistics( grpStats );
 
+
   for ( hsize_t i = 0; i < nTimeSteps; ++i )
   {
     std::shared_ptr<XmdfDataset> dataset = std::make_shared< XmdfDataset >( group.get(), dsValues, dsActive, i );
-    dataset->setTime( times[i], MDAL::parseDurationUnitTime( timeUnit ) );
+    dataset->setTime( times[i], timeUnit );
     Statistics stats;
     stats.minimum = static_cast<double>( mins[i] );
     stats.maximum = static_cast<double>( maxs[i] );
@@ -288,16 +290,3 @@ std::shared_ptr<MDAL::DatasetGroup> MDAL::DriverXmdf::readXmdfGroupAsDatasetGrou
 
   return group;
 }
-
-void MDAL::DriverXmdf::convertTimeDataToHours( std::vector<double> &times, const std::string &originalTimeDataUnit )
-{
-  if ( originalTimeDataUnit != "Hours" )
-  {
-    for ( size_t i = 0; i < times.size(); i++ )
-    {
-      if ( originalTimeDataUnit == "Seconds" ) { times[i] /= 3600.0; }
-      else if ( originalTimeDataUnit == "Minutes" ) { times[i] /= 60.0; }
-      else if ( originalTimeDataUnit == "Days" ) { times[i] *= 24; }
-    }
-  }
-}

mdal/frmts/mdal_xmdf.hpp

@@ -100,8 +100,6 @@ namespace MDAL
         const std::string &nameSuffix,
         size_t vertexCount,
         size_t faceCount );
-
-      void convertTimeDataToHours( std::vector<double> &times, const std::string &originalTimeDataUnit );
   };
 
 } // namespace MDAL

mdal/mdal.cpp

@@ -829,7 +829,6 @@ double MDAL_D_time( DatasetH dataset )
   }
   MDAL::Dataset *d = static_cast< MDAL::Dataset * >( dataset );
   return d->time();
-
 }
 
 int MDAL_D_volumesCount( DatasetH dataset )
@@ -1065,3 +1064,4 @@ bool MDAL_D_hasActiveFlagCapability( DatasetH dataset )
   MDAL::Dataset *ds = static_cast< MDAL::Dataset * >( dataset );
   return ds->supportsActiveFlag();
 }
+

mdal/mdal_data_model.cpp

@@ -93,7 +93,6 @@ MDAL::Dataset2D::Dataset2D( MDAL::DatasetGroup *parent )
 
 MDAL::Dataset2D::~Dataset2D() = default;
 
-
 size_t MDAL::Dataset2D::volumesCount() const { return 0; }
 
 size_t MDAL::Dataset2D::maximumVerticalLevelsCount() const { return 0; }

mdal/mdal_date_time.cpp

@@ -1,3 +1,7 @@
+/*
+ MDAL - Mesh Data Abstraction Library (MIT License)
+ Copyright (C) 2019 Vincent Cloarec (vcloarec at gmail dot com)
+*/
 #include "mdal_date_time.hpp"
 #include "mdal_utils.hpp"
 
@@ -61,7 +65,7 @@ std::string MDAL::DateTime::toStandartCalendarISO8601() const
   if ( mValid )
     return toString( value );
   else
-    return "none";
+    return "";
 }
 
 double MDAL::DateTime::toJulianDay() const
@@ -303,25 +307,25 @@ MDAL::Duration::Duration( double duration, MDAL::Duration::Unit unit )
       mDuration = int64_t( duration );
       break;
     case MDAL::Duration::seconds:
-      mDuration = int64_t( duration * MILLISECONDS_IN_SECOND );
+      mDuration = int64_t( duration * MILLISECONDS_IN_SECOND + 0.5 );
       break;
     case MDAL::Duration::minutes:
-      mDuration = int64_t( duration * MILLISECONDS_IN_MINUTE );
+      mDuration = int64_t( duration * MILLISECONDS_IN_MINUTE + 0.5 );
       break;
     case MDAL::Duration::hours:
-      mDuration = int64_t( duration * MILLISECONDS_IN_HOUR );
+      mDuration = int64_t( duration * MILLISECONDS_IN_HOUR + 0.5 );
       break;
     case MDAL::Duration::days:
-      mDuration = int64_t( duration * MILLISECONDS_IN_DAY );
+      mDuration = int64_t( duration * MILLISECONDS_IN_DAY + 0.5 );
       break;
     case MDAL::Duration::weeks:
-      mDuration = int64_t( duration * MILLISECONDS_IN_WEEK );
+      mDuration = int64_t( duration * MILLISECONDS_IN_WEEK + 0.5 );
       break;
     case MDAL::Duration::months_CF:
-      mDuration = int64_t( duration * MILLISECONDS_IN_MONTH_CF );
+      mDuration = int64_t( duration * MILLISECONDS_IN_MONTH_CF + 0.5 );
       break;
     case MDAL::Duration::exact_years:
-      mDuration = int64_t( duration * MILLISECONDS_IN_EXACT_YEAR );
+      mDuration = int64_t( duration * MILLISECONDS_IN_EXACT_YEAR + 0.5 );
       break;
   }
 }
@@ -352,6 +356,8 @@ double MDAL::Duration::value( MDAL::Duration::Unit unit ) const
     case MDAL::Duration::exact_years:
       return double( mDuration )  / MILLISECONDS_IN_EXACT_YEAR;
   }
+
+  return 0;
 }
 
 MDAL::Duration &MDAL::Duration::operator=( const MDAL::Duration &other )