thirdparty/SZ/sz/include/defines.h

+/**
+ *  @file defines.h
+ *  @author Sheng Di
+ *  @date July, 2019
+ *  @brief Header file for the dataCompression.c.
+ *  (C) 2016 by Mathematics and Computer Science (MCS), Argonne National Laboratory.
+ *      See COPYRIGHT in top-level directory.
+ */
+
+#ifndef _SZ_DEFINES_H
+#define _SZ_DEFINES_H
+
+#define SZ_VERNUM 0x0200
+#define SZ_VER_MAJOR 2
+#define SZ_VER_MINOR 1
+#define SZ_VER_BUILD 12
+#define SZ_VER_REVISION 4
+
+#define PASTRI 103
+#define HZ 102 //deprecated
+#define SZ 101
+#define SZ_Transpose 104
+
+//prediction mode of temporal dimension based compression
+#define SZ_PREVIOUS_VALUE_ESTIMATE 0
+
+#define MIN_NUM_OF_ELEMENTS 20 //if the # elements <= 20, skip the compression
+
+#define ABS 0
+#define REL 1
+#define VR_REL 1  //alternative name to REL
+#define ABS_AND_REL 2
+#define ABS_OR_REL 3
+#define PSNR 4
+#define NORM 5
+
+#define PW_REL 10
+#define ABS_AND_PW_REL 11
+#define ABS_OR_PW_REL 12
+#define REL_AND_PW_REL 13
+#define REL_OR_PW_REL 14
+
+#define SZ_FLOAT 0
+#define SZ_DOUBLE 1
+#define SZ_UINT8 2
+#define SZ_INT8 3
+#define SZ_UINT16 4
+#define SZ_INT16 5
+#define SZ_UINT32 6
+#define SZ_INT32 7
+#define SZ_UINT64 8
+#define SZ_INT64 9
+
+#define LITTLE_ENDIAN_DATA 0 //refers to the endian type of the data read from the disk
+#define BIG_ENDIAN_DATA 1 //big_endian (ppc, max, etc.) ; little_endian (x86, x64, etc.)
+
+#define LITTLE_ENDIAN_SYSTEM 0 //refers to the endian type of the system
+#define BIG_ENDIAN_SYSTEM 1
+
+#define DynArrayInitLen 1024
+
+#define MIN_ZLIB_DEC_ALLOMEM_BYTES 1000000
+
+//#define maxRangeRadius 32768
+//#define maxRangeRadius 1048576//131072
+
+#define SZ_BEST_SPEED 0
+#define SZ_BEST_COMPRESSION 1
+#define SZ_DEFAULT_COMPRESSION 2
+#define SZ_TEMPORAL_COMPRESSION 3
+
+#define SZ_NO_REGRESSION 0
+#define SZ_WITH_LINEAR_REGRESSION 1
+
+#define SZ_PWR_MIN_TYPE 0
+#define SZ_PWR_AVG_TYPE 1
+#define SZ_PWR_MAX_TYPE 2
+
+#define SZ_FORCE_SNAPSHOT_COMPRESSION 0
+#define SZ_FORCE_TEMPORAL_COMPRESSION 1
+#define SZ_PERIO_TEMPORAL_COMPRESSION 2
+
+//SUCCESS returning status
+#define SZ_SCES 0  //successful
+#define SZ_NSCS -1 //Not successful
+#define SZ_FERR -2 //Failed to open input file
+#define SZ_TERR -3 //wrong data type (should be only float or double)
+#define SZ_DERR -4 //dimension error
+#define SZ_MERR -5 //sz_mode error
+#define SZ_BERR -6 //bound-mode error (should be only ABS, REL, ABS_AND_REL, ABS_OR_REL, or PW_REL)
+
+#define SZ_MAINTAIN_VAR_DATA 0
+#define SZ_DESTROY_WHOLE_VARSET 1
+
+#define GROUP_COUNT 16 //2^{16}=65536
+	
+#define MetaDataByteLength 28
+#define MetaDataByteLength_double 36 //meta data length for double type
+	
+#define numOfBufferedSteps 1 //the number of time steps in the buffer	
+
+
+#define GZIP_COMPRESSOR 0 //i.e., ZLIB_COMPRSSOR
+#define ZSTD_COMPRESSOR 1
+
+#endif /* _SZ_DEFINES_H */

thirdparty/SZ/sz/include/exafelSZ.h

+#ifndef EXAFELSZ_H
+#define EXAFELSZ_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct exafelSZ_params{
+  //uint8_t *peaks;
+  uint16_t *peaksSegs;
+  uint16_t *peaksRows;
+  uint16_t *peaksCols;
+  uint64_t numPeaks;
+
+  uint8_t *calibPanel;
+
+  uint8_t binSize; //Binning: (pr->binSize x pr->binSize) to (1 x 1)
+  double tolerance; //SZ pr->tolerance
+  uint8_t szDim; //1D/2D/3D compression/decompression
+  //uint8_t szBlockSize; //Currently unused
+  uint8_t peakSize; //MUST BE ODD AND NOT EVEN! Each peak will have size of: (peakSize x peakSize)
+ 
+  // uint64_t nEvents;
+  // uint64_t panels;
+  // uint64_t rows;
+  // uint64_t cols;
+  
+  //CALCULATED VARIBALES:
+  uint64_t binnedRows;
+  uint64_t binnedCols;
+  uint8_t peakRadius; //Will be calculated using peakSize
+
+} exafelSZ_params;
+
+
+void exafelSZ_params_process(exafelSZ_params*pr, size_t panels, size_t rows, size_t cols);
+void exafelSZ_params_checkDecomp(exafelSZ_params*pr, size_t panels, size_t rows, size_t cols);
+void exafelSZ_params_checkComp(exafelSZ_params*pr, size_t panels, size_t rows, size_t cols);
+
+unsigned char * exafelSZ_Compress(void* _pr,
+                         void* _origData,
+                        size_t events, size_t panels, size_t rows, size_t cols,
+                        size_t *compressedSize);
+					   
+void* exafelSZ_Decompress(void *_pr,
+                         unsigned char*_compressedBuffer,
+                         size_t events, size_t panels, size_t rows, size_t cols,
+                         size_t compressedSize);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ----- #ifndef _EXAFELSZ_H  ----- */
+

thirdparty/SZ/sz/include/rw.h

@@ -23,6 +23,11 @@
 extern "C" {
 #endif
 
+#if defined(_MSC_VER) /* MSVC Compiler Case */
+#define F_OK    0       /* Test for existence.  */
+#define access _access
+#endif
+
 int checkFileExistance(char* filePath);
 
 float** create2DArray_float(size_t m, size_t n);

thirdparty/SZ/sz/include/sz.h

@@ -2,7 +2,7 @@
  *  @file sz.h
  *  @author Sheng Di
  *  @date April, 2015
- *  @brief Header file for the whole detector.
+ *  @brief Header file for the whole compressor.
  *  (C) 2015 by Mathematics and Computer Science (MCS), Argonne National Laboratory.
  *      See COPYRIGHT in top-level directory.
  */
@@ -12,9 +12,10 @@
 
 #include <stdio.h>
 #include <stdint.h>
+#ifdef HAVE_SYS_TIME_H
 #include <sys/time.h>      /* For gettimeofday(), in microseconds */
+#endif
 #include <time.h>          /* For time(), in seconds */
-#include "iniparser.h"
 #include "CompressElement.h"
 #include "DynamicByteArray.h"
 #include "DynamicIntArray.h"
@@ -49,12 +50,18 @@
 #include "szd_double.h"
 #include "sz_float_pwr.h"
 #include "sz_double_pwr.h"
+#include "sz_opencl.h"
 #include "callZlib.h"
 #include "rw.h"
 #include "pastri.h"
 #include "sz_float_ts.h"
 #include "szd_float_ts.h"
 #include "utility.h"
+#include "CacheTable.h"
+#include "MultiLevelCacheTable.h"
+#include "MultiLevelCacheTableWideInterval.h"
+#include "exafelSZ.h"
+#include "sz_stats.h"
 
 #ifdef _WIN32
 #define PATH_SEPARATOR ';'
@@ -75,91 +82,8 @@ extern "C" {
 //typedef long int64_t;
 //typedef unsigned long uint64_t;
 
-#define SZ_VERNUM 0x0200
-#define SZ_VER_MAJOR 2
-#define SZ_VER_MINOR 0
-#define SZ_VER_BUILD 2
-#define SZ_VER_REVISION 0
-
-#define PASTRI 103
-#define HZ 102
-#define SZ 101
-
-//prediction mode of temporal dimension based compression
-#define SZ_PREVIOUS_VALUE_ESTIMATE 0
-
-#define MIN_NUM_OF_ELEMENTS 20 //if the # elements <= 20, skip the compression
-
-#define ABS 0
-#define REL 1
-#define ABS_AND_REL 2
-#define ABS_OR_REL 3
-#define PSNR 4
-
-#define PW_REL 10
-#define ABS_AND_PW_REL 11
-#define ABS_OR_PW_REL 12
-#define REL_AND_PW_REL 13
-#define REL_OR_PW_REL 14
-
-#define SZ_FLOAT 0
-#define SZ_DOUBLE 1
-#define SZ_UINT8 2
-#define SZ_INT8 3
-#define SZ_UINT16 4
-#define SZ_INT16 5
-#define SZ_UINT32 6
-#define SZ_INT32 7
-#define SZ_UINT64 8
-#define SZ_INT64 9
-
-#define LITTLE_ENDIAN_DATA 0 //refers to the endian type of the data read from the disk
-#define BIG_ENDIAN_DATA 1 //big_endian (ppc, max, etc.) ; little_endian (x86, x64, etc.)
-
-#define LITTLE_ENDIAN_SYSTEM 0 //refers to the endian type of the system
-#define BIG_ENDIAN_SYSTEM 1
-
-#define DynArrayInitLen 1024
-
-#define MIN_ZLIB_DEC_ALLOMEM_BYTES 1000000
-
-//#define maxRangeRadius 32768
-//#define maxRangeRadius 1048576//131072
-
-#define SZ_BEST_SPEED 0
-#define SZ_BEST_COMPRESSION 1
-#define SZ_DEFAULT_COMPRESSION 2
-#define SZ_TEMPORAL_COMPRESSION 3
-
-#define SZ_NO_REGRESSION 0
-#define SZ_WITH_LINEAR_REGRESSION 1
-
-#define SZ_PWR_MIN_TYPE 0
-#define SZ_PWR_AVG_TYPE 1
-#define SZ_PWR_MAX_TYPE 2
-
-//SUCCESS returning status
-#define SZ_SCES 0  //successful
-#define SZ_NSCS -1 //Not successful
-#define SZ_FERR -2 //Failed to open input file
-#define SZ_TERR -3 //wrong data type (should be only float or double)
-#define SZ_DERR -4 //dimension error
-#define SZ_MERR -5 //sz_mode error
-#define SZ_BERR -6 //bound-mode error (should be only ABS, REL, ABS_AND_REL, ABS_OR_REL, or PW_REL)
-
-#define SZ_MAINTAIN_VAR_DATA 0
-#define SZ_DESTROY_WHOLE_VARSET 1
-
-#define GROUP_COUNT 16 //2^{16}=65536
-	
-#define MetaDataByteLength 20	
-	
-#define numOfBufferedSteps 1 //the number of time steps in the buffer	
-
-
-#define GZIP_COMPRESSOR 0 //i.e., ZLIB_COMPRSSOR
-#define ZSTD_COMPRESSOR 1
-	
+#include "defines.h"
+
 //Note: the following setting should be consistent with stateNum in Huffman.h
 //#define intvCapacity 65536
 //#define intvRadius 32768
@@ -241,24 +165,36 @@ typedef struct sz_params
 {
 	int dataType;
 	unsigned int max_quant_intervals; //max number of quantization intervals for quantization
-	unsigned int quantization_intervals; 
+	unsigned int quantization_intervals;
 	unsigned int maxRangeRadius;
-	int sol_ID;// it's always SZ, unless the setting is PASTRI compression mode (./configure --enable-pastri)
+	int sol_ID;// it's SZ or SZ_Transpose, unless the setting is PASTRI compression mode (./configure --enable-pastri)
 	int losslessCompressor;
 	int sampleDistance; //2 bytes
 	float predThreshold;  // 2 bytes
-	int szMode; //* 0 (best speed) or 1 (better compression with Gzip) or 3 temporal-dimension based compression
+	int szMode; //* 0 (best speed) or 1 (better compression with Zstd/Gzip) or 3 temporal-dimension based compression
 	int gzipMode; //* four options: Z_NO_COMPRESSION, or Z_BEST_SPEED, Z_BEST_COMPRESSION, Z_DEFAULT_COMPRESSION
 	int  errorBoundMode; //4bits (0.5byte), //ABS, REL, ABS_AND_REL, or ABS_OR_REL, PSNR, or PW_REL, PSNR
 	double absErrBound; //absolute error bound
 	double relBoundRatio; //value range based relative error bound ratio
 	double psnr; //PSNR
+	double normErr;
 	double pw_relBoundRatio; //point-wise relative error bound
-	int segment_size; //only used for 2D/3D data compression with pw_relBoundRatio
+	int segment_size; //only used for 2D/3D data compression with pw_relBoundRatio (deprecated)
 	int pwr_type; //only used for 2D/3D data compression with pw_relBoundRatio
-	
+
+	int protectValueRange; //0 or 1
+	float fmin, fmax;
+	double dmin, dmax;
+
 	int snapshotCmprStep; //perform single-snapshot-based compression if time_step == snapshotCmprStep
 	int predictionMode;
+
+	int accelerate_pw_rel_compression;
+	int plus_bits;
+
+	int randomAccess;
+	int withRegression;
+
 } sz_params;
 
 typedef struct sz_metadata
@@ -274,10 +210,10 @@ typedef struct sz_metadata
 
 typedef struct sz_exedata
 {
-	char optQuantMode;	//opt Quantization (0: fixed ; 1: optimized)	
+	char optQuantMode;	//opt Quantization (0: fixed ; 1: optimized)
 	int intvCapacity; // the number of intervals for the linear-scaling quantization
 	int intvRadius;  // the number of intervals for the radius of the quantization range (intvRadius=intvCapacity/2)
-	int SZ_SIZE_TYPE; //the length (# bytes) of the size_t in the system at runtime //4 or 8: sizeof(size_t) 
+	unsigned int SZ_SIZE_TYPE; //the length (# bytes) of the size_t in the system at runtime //4 or 8: sizeof(size_t)
 } sz_exedata;
 
 /*We use a linked list to maintain time-step meta info for time-step based compression*/
@@ -289,7 +225,7 @@ typedef struct sz_tsc_metainfo
 	FILE *metadata_file;
 	unsigned char* bit_array; //sihuan added
 	size_t intersect_size; //sihuan added
-	int64_t* hist_index; //sihuan added: prestep index 
+	int64_t* hist_index; //sihuan added: prestep index
 
 } sz_tsc_metadata;
 
@@ -302,16 +238,15 @@ extern int sysEndianType; //*sysEndianType is actually set automatically.
 extern sz_params *confparams_cpr;
 extern sz_params *confparams_dec;
 extern sz_exedata *exe_params;
-extern int sz_with_regression;
 
 //------------------------------------------------
 extern SZ_VarSet* sz_varset;
 extern sz_multisteps *multisteps; //compression based on multiple time steps (time-dimension based compression)
 extern sz_tsc_metadata *sz_tsc;
 
-//for pastri 
+//for pastri
 #ifdef PASTRI
-extern pastri_params pastri_par; 
+extern pastri_params pastri_par;
 #endif
 
 //sz.h
@@ -324,6 +259,7 @@ int SZ_Init_Params(sz_params *params);
 size_t computeDataLength(size_t r5, size_t r4, size_t r3, size_t r2, size_t r1);
 
 int computeDimension(size_t r5, size_t r4, size_t r3, size_t r2, size_t r1);
+int filterDimension(size_t r5, size_t r4, size_t r3, size_t r2, size_t r1, size_t* correctedDimension);
 
 int SZ_compress_args_float_subblock(unsigned char* compressedBytes, float *oriData,
 size_t r5, size_t r4, size_t r3, size_t r2, size_t r1,
@@ -339,22 +275,22 @@ size_t *outSize, int errBoundMode, double absErr_Bound, double relBoundRatio);
 
 unsigned char *SZ_compress(int dataType, void *data, size_t *outSize, size_t r5, size_t r4, size_t r3, size_t r2, size_t r1);
 
-unsigned char* SZ_compress_args(int dataType, void *data, size_t *outSize, int errBoundMode, double absErrBound, 
+unsigned char* SZ_compress_args(int dataType, void *data, size_t *outSize, int errBoundMode, double absErrBound,
 double relBoundRatio, double pwrBoundRatio, size_t r5, size_t r4, size_t r3, size_t r2, size_t r1);
 
-int SZ_compress_args2(int dataType, void *data, unsigned char* compressed_bytes, size_t *outSize, 
-int errBoundMode, double absErrBound, double relBoundRatio, double pwrBoundRatio, 
+int SZ_compress_args2(int dataType, void *data, unsigned char* compressed_bytes, size_t *outSize,
+int errBoundMode, double absErrBound, double relBoundRatio, double pwrBoundRatio,
 size_t r5, size_t r4, size_t r3, size_t r2, size_t r1);
 
-int SZ_compress_args3(int dataType, void *data, unsigned char* compressed_bytes, size_t *outSize, int errBoundMode, double absErrBound, double relBoundRatio, 
+int SZ_compress_args3(int dataType, void *data, unsigned char* compressed_bytes, size_t *outSize, int errBoundMode, double absErrBound, double relBoundRatio,
 size_t r5, size_t r4, size_t r3, size_t r2, size_t r1,
 size_t s5, size_t s4, size_t s3, size_t s2, size_t s1,
 size_t e5, size_t e4, size_t e3, size_t e2, size_t e1);
 
-unsigned char *SZ_compress_rev_args(int dataType, void *data, void *reservedValue, size_t *outSize, int errBoundMode, double absErrBound, double relBoundRatio, 
+unsigned char *SZ_compress_rev_args(int dataType, void *data, void *reservedValue, size_t *outSize, int errBoundMode, double absErrBound, double relBoundRatio,
 size_t r5, size_t r4, size_t r3, size_t r2, size_t r1);
 
-int SZ_compress_rev_args2(int dataType, void *data, void *reservedValue, unsigned char* compressed_bytes, size_t *outSize, int errBoundMode, double absErrBound, double relBoundRatio, 
+int SZ_compress_rev_args2(int dataType, void *data, void *reservedValue, unsigned char* compressed_bytes, size_t *outSize, int errBoundMode, double absErrBound, double relBoundRatio,
 size_t r5, size_t r4, size_t r3, size_t r2, size_t r1);
 unsigned char *SZ_compress_rev(int dataType, void *data, void *reservedValue, size_t *outSize, size_t r5, size_t r4, size_t r3, size_t r2, size_t r1);
 
@@ -371,19 +307,31 @@ void filloutDimArray(size_t* dim, size_t r5, size_t r4, size_t r3, size_t r2, si
 
 size_t compute_total_batch_size();
 
-void SZ_registerVar(char* varName, int dataType, void* data, 
-			int errBoundMode, double absErrBound, double relBoundRatio, double pwRelBoundRatio, 
+void SZ_registerVar(int var_id, char* varName, int dataType, void* data,
+			int errBoundMode, double absErrBound, double relBoundRatio, double pwRelBoundRatio,
 			size_t r5, size_t r4, size_t r3, size_t r2, size_t r1);
+
+int SZ_deregisterVar_ID(int var_id);
 int SZ_deregisterVar(char* varName);
 int SZ_deregisterAllVars();
 
-int SZ_compress_ts(unsigned char** newByteData, size_t *outSize);
+int SZ_compress_ts_select_var(int cmprType, unsigned char* var_ids, unsigned char var_count, unsigned char** newByteData, size_t *outSize);
+int SZ_compress_ts(int cmprType, unsigned char** newByteData, size_t *outSize);
+void SZ_decompress_ts_select_var(unsigned char* var_ids, unsigned char var_count, unsigned char *bytes, size_t bytesLength);
 void SZ_decompress_ts(unsigned char *bytes, size_t byteLength);
 
 void SZ_Finalize();
 
 void convertSZParamsToBytes(sz_params* params, unsigned char* result);
-sz_params* convertBytesToSZParams(unsigned char* bytes);
+void convertBytesToSZParams(unsigned char* bytes, sz_params* params);
+
+unsigned char* SZ_compress_customize(const char* appName, void* userPara, int dataType, void* data, size_t r5, size_t r4, size_t r3, size_t r2, size_t r1, size_t *outSize, int *status);
+
+unsigned char* SZ_compress_customize_threadsafe(const char* cmprName, void* userPara, int dataType, void* data, size_t r5, size_t r4, size_t r3, size_t r2, size_t r1, size_t *outSize, int *status);
+
+void* SZ_decompress_customize(const char* appName, void* userPara, int dataType, unsigned char* bytes, size_t byteLength, size_t r5, size_t r4, size_t r3, size_t r2, size_t r1, int* status);
+
+void* SZ_decompress_customize_threadsafe(const char* cmprName, void* userPara, int dataType, unsigned char* bytes, size_t byteLength, size_t r5, size_t r4, size_t r3, size_t r2, size_t r1, int *status);
 
 #ifdef __cplusplus
 }

thirdparty/SZ/sz/include/sz_api.h

+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#ifndef SZ_API_H
+#define SZ_API_H
+
+/* =====   SZLIB_API : control library symbols visibility   ===== */
+#ifndef SZLIB_VISIBILITY
+#  if defined(__GNUC__) && (__GNUC__ >= 4)
+#    define SZLIB_VISIBILITY __attribute__ ((visibility ("default")))
+#  else
+#    define SZLIB_VISIBILITY
+#  endif
+#endif
+#if defined(SZ_DLL_EXPORT) && (SZ_DLL_EXPORT==1)
+#  define SZLIB_API __declspec(dllexport) SZLIB_VISIBILITY
+#elif defined(SZ_DLL_IMPORT) && (SZ_DLL_IMPORT==1)
+#  define SZLIB_API __declspec(dllimport) SZLIB_VISIBILITY /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/
+#else
+#  define SZLIB_API SZLIB_VISIBILITY
+#endif
+
+#include "defines.h"
+#include "ByteToolkit.h"
+
+/* array meta data and compression parameters for SZ_Init_Params() */
+typedef struct sz_params
+{
+    int dataType;
+    unsigned int max_quant_intervals; //max number of quantization intervals for quantization
+    unsigned int quantization_intervals;
+    unsigned int maxRangeRadius;
+    int sol_ID;// it's SZ or SZ_Transpose, unless the setting is PASTRI compression mode (./configure --enable-pastri)
+    int losslessCompressor;
+    int sampleDistance; //2 bytes
+    float predThreshold;  // 2 bytes
+    int szMode; //* 0 (best speed) or 1 (better compression with Zstd/Gzip) or 3 temporal-dimension based compression
+    int gzipMode; //* four options: Z_NO_COMPRESSION, or Z_BEST_SPEED, Z_BEST_COMPRESSION, Z_DEFAULT_COMPRESSION
+    int  errorBoundMode; //4bits (0.5byte), //ABS, REL, ABS_AND_REL, or ABS_OR_REL, PSNR, or PW_REL, PSNR
+    double absErrBound; //absolute error bound
+    double relBoundRatio; //value range based relative error bound ratio
+    double psnr; //PSNR
+    double normErr;
+    double pw_relBoundRatio; //point-wise relative error bound
+    int segment_size; //only used for 2D/3D data compression with pw_relBoundRatio (deprecated)
+    int pwr_type; //only used for 2D/3D data compression with pw_relBoundRatio
+
+    int protectValueRange; //0 or 1
+    float fmin, fmax;
+    double dmin, dmax;
+
+    int snapshotCmprStep; //perform single-snapshot-based compression if time_step == snapshotCmprStep
+    int predictionMode;
+
+    int accelerate_pw_rel_compression;
+    int plus_bits;
+
+    int randomAccess;
+    int withRegression;
+
+} sz_params;
+
+//-------------------key global variables--------------
+extern int dataEndianType; //*endian type of the data read from disk
+extern int sysEndianType; //*sysEndianType is actually set automatically.
+
+extern sz_params *confparams_cpr;
+extern sz_params *confparams_dec;
+
+int SZ_Init(const char *configFilePath);
+
+int SZ_Init_Params(sz_params *params);
+
+size_t computeDataLength(size_t r5, size_t r4, size_t r3, size_t r2, size_t r1);
+
+int computeDimension(size_t r5, size_t r4, size_t r3, size_t r2, size_t r1);
+int filterDimension(size_t r5, size_t r4, size_t r3, size_t r2, size_t r1, size_t* correctedDimension);
+
+unsigned char *SZ_compress(int dataType, void *data, size_t *outSize, size_t r5, size_t r4, size_t r3, size_t r2, size_t r1);
+
+unsigned char* SZ_compress_args(int dataType, void *data, size_t *outSize, int errBoundMode, double absErrBound,
+double relBoundRatio, double pwrBoundRatio, size_t r5, size_t r4, size_t r3, size_t r2, size_t r1);
+
+void *SZ_decompress(int dataType, unsigned char *bytes, size_t byteLength, size_t r5, size_t r4, size_t r3, size_t r2, size_t r1);
+size_t SZ_decompress_args(int dataType, unsigned char *bytes, size_t byteLength, void* decompressed_array, size_t r5, size_t r4, size_t r3, size_t r2, size_t r1);
+
+void SZ_Finalize();
+
+#endif  /* SZ_API_H */
+
+#if defined (__cplusplus)
+}
+#endif

thirdparty/SZ/sz/include/sz_double.h

@@ -17,7 +17,9 @@ extern "C" {
 #include <stdio.h>
 unsigned char* SZ_skip_compress_double(double* data, size_t dataLength, size_t* outSize);
 
-void computeReqLength_double(double realPrecision, short radExpo, int* reqLength, double* medianValue);
+extern void computeReqLength_double(double realPrecision, short radExpo, int* reqLength, double* medianValue);
+extern short computeReqLength_double_MSST19(double realPrecision);
+
 unsigned int optimize_intervals_double_1D(double *oriData, size_t dataLength, double realPrecision);
 unsigned int optimize_intervals_double_2D(double *oriData, size_t r1, size_t r2, double realPrecision);
 unsigned int optimize_intervals_double_3D(double *oriData, size_t r1, size_t r2, size_t r3, double realPrecision);
@@ -27,29 +29,38 @@ unsigned int optimize_intervals_double_3D_opt(double *oriData, size_t r1, size_t
 unsigned int optimize_intervals_double_2D_opt(double *oriData, size_t r1, size_t r2, double realPrecision);
 unsigned int optimize_intervals_double_1D_opt(double *oriData, size_t dataLength, double realPrecision);
 
-TightDataPointStorageD* SZ_compress_double_1D_MDQ(double *oriData, 
+size_t SZ_compress_double_3D_MDQ_RA_block(double * block_ori_data, double * mean, size_t dim_0, size_t dim_1, size_t dim_2, size_t block_dim_0, size_t block_dim_1, size_t block_dim_2, double realPrecision, double * P0, double * P1, int * type, double * unpredictable_data);
+
+unsigned int optimize_intervals_double_1D_opt_MSST19(double *oriData, size_t dataLength, double realPrecision);
+unsigned int optimize_intervals_double_2D_opt_MSST19(double *oriData, size_t r1, size_t r2, double realPrecision);
+unsigned int optimize_intervals_double_3D_opt_MSST19(double *oriData, size_t r1, size_t r2, size_t r3, double realPrecision);
+TightDataPointStorageD* SZ_compress_double_1D_MDQ(double *oriData,
 size_t dataLength, double realPrecision, double valueRangeSize, double medianValue_d);
-void SZ_compress_args_double_StoreOriData(double* oriData, size_t dataLength, TightDataPointStorageD* tdps, unsigned char** newByteData, size_t *outSize);
+void SZ_compress_args_double_StoreOriData(double* oriData, size_t dataLength, unsigned char** newByteData, size_t *outSize);
 
-char SZ_compress_args_double_NoCkRngeNoGzip_1D(unsigned char** newByteData, double *oriData, size_t dataLength, double realPrecision, size_t *outSize, double valueRangeSize, double medianValue_d);
+char SZ_compress_args_double_NoCkRngeNoGzip_1D(int cmprType, unsigned char** newByteData, double *oriData, size_t dataLength, double realPrecision, size_t *outSize, double valueRangeSize, double medianValue_d);
 
 TightDataPointStorageD* SZ_compress_double_2D_MDQ(double *oriData, size_t r1, size_t r2, double realPrecision, double valueRangeSize, double medianValue_d);
-char SZ_compress_args_double_NoCkRngeNoGzip_2D(unsigned char** newByteData, double *oriData, size_t r1, size_t r2, double realPrecision, size_t *outSize, double valueRangeSize, double medianValue_d);
+char SZ_compress_args_double_NoCkRngeNoGzip_2D(int cmprType, unsigned char** newByteData, double *oriData, size_t r1, size_t r2, double realPrecision, size_t *outSize, double valueRangeSize, double medianValue_d);
 
 TightDataPointStorageD* SZ_compress_double_3D_MDQ(double *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, double valueRangeSize, double medianValue_d);
-char SZ_compress_args_double_NoCkRngeNoGzip_3D(unsigned char** newByteData, double *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, size_t *outSize, double valueRangeSize, double medianValue_d);
+char SZ_compress_args_double_NoCkRngeNoGzip_3D(int cmprType, unsigned char** newByteData, double *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, size_t *outSize, double valueRangeSize, double medianValue_d);
 
 TightDataPointStorageD* SZ_compress_double_4D_MDQ(double *oriData, size_t r1, size_t r2, size_t r3, size_t r4, double realPrecision, double valueRangeSize, double medianValue_d);
 char SZ_compress_args_double_NoCkRngeNoGzip_4D(unsigned char** newByteData, double *oriData, size_t r1, size_t r2, size_t r3, size_t r4, double realPrecision, size_t *outSize, double valueRangeSize, double medianValue_d);
 
+TightDataPointStorageD* SZ_compress_double_1D_MDQ_MSST19(double *oriData, size_t dataLength, double realPrecision, double valueRangeSize, double medianValue_f);
+TightDataPointStorageD* SZ_compress_double_2D_MDQ_MSST19(double *oriData, size_t r1, size_t r2, double realPrecision, double valueRangeSize, double medianValue_f);
+TightDataPointStorageD* SZ_compress_double_3D_MDQ_MSST19(double *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, double valueRangeSize, double medianValue_f);
+
 void SZ_compress_args_double_withinRange(unsigned char** newByteData, double *oriData, size_t dataLength, size_t *outSize);
 
-int SZ_compress_args_double_wRngeNoGzip(unsigned char** newByteData, double *oriData, 
-size_t r5, size_t r4, size_t r3, size_t r2, size_t r1, size_t *outSize, 
-int errBoundMode, double absErr_Bound, double relBoundRatio, double pwrErrRatio);
+/*int SZ_compress_args_double_wRngeNoGzip(unsigned char** newByteData, double *oriData,
+size_t r5, size_t r4, size_t r3, size_t r2, size_t r1, size_t *outSize,
+int errBoundMode, double absErr_Bound, double relBoundRatio, double pwrErrRatio);*/
 
-int SZ_compress_args_double(unsigned char** newByteData, double *oriData, 
-size_t r5, size_t r4, size_t r3, size_t r2, size_t r1, size_t *outSize, 
+int SZ_compress_args_double(int cmprType, int withRegression, unsigned char** newByteData, double *oriData,
+size_t r5, size_t r4, size_t r3, size_t r2, size_t r1, size_t *outSize,
 int errBoundMode, double absErr_Bound, double relBoundRatio, double pwRelBoundRatio);
 
 void SZ_compress_args_double_NoCkRnge_1D_subblock(unsigned char* compressedBytes, double *oriData, double realPrecision, size_t *outSize, double valueRangeSize, double medianValue_d,

thirdparty/SZ/sz/include/sz_double_pwr.h

@@ -15,6 +15,7 @@ extern "C" {
 #endif
 
 #include <stdio.h>
+#include <stdbool.h>
 
 void compute_segment_precisions_double_1D(double *oriData, size_t dataLength, double* pwrErrBound, unsigned char* pwrErrBoundBytes, double globalPrecision);
 unsigned int optimize_intervals_double_1D_pwr(double *oriData, size_t dataLength, double* pwrErrBound); 
@@ -41,6 +42,13 @@ void SZ_compress_args_double_NoCkRngeNoGzip_1D_pwr_pre_log(unsigned char** newBy
 void SZ_compress_args_double_NoCkRngeNoGzip_2D_pwr_pre_log(unsigned char** newByteData, double *oriData, double globalPrecision, size_t r1, size_t r2, size_t *outSize, double min, double max);
 void SZ_compress_args_double_NoCkRngeNoGzip_3D_pwr_pre_log(unsigned char** newByteData, double *oriData, double globalPrecision, size_t r1, size_t r2, size_t r3, size_t *outSize, double min, double max);
 
+void SZ_compress_args_double_NoCkRngeNoGzip_1D_pwr_pre_log_MSST19(unsigned char** newByteData, double *oriData, double pwrErrRatio, size_t dataLength, size_t *outSize, double valueRangeSize, double medianValue_f,
+																unsigned char* signs, bool* positive, double min, double max, double nearZero);
+void SZ_compress_args_double_NoCkRngeNoGzip_2D_pwr_pre_log_MSST19(unsigned char** newByteData, double *oriData, double pwrErrRatio, size_t r1, size_t r2, size_t *outSize, double valueRangeSize,
+																unsigned char* signs, bool* positive, double min, double max, double nearZero);
+void SZ_compress_args_double_NoCkRngeNoGzip_3D_pwr_pre_log_MSST19(unsigned char** newByteData, double *oriData, double pwrErrRatio, size_t r1, size_t r2, size_t r3, size_t *outSize, double valueRangeSize, 
+																unsigned char* signs, bool* positive, double min, double max, double nearZero);
+
 #ifdef __cplusplus
 }
 #endif

thirdparty/SZ/sz/include/sz_float.h

@@ -17,6 +17,7 @@ extern "C" {
 unsigned char* SZ_skip_compress_float(float* data, size_t dataLength, size_t* outSize);
 
 void computeReqLength_float(double realPrecision, short radExpo, int* reqLength, float* medianValue);
+short computeReqLength_float_MSST19(double realPrecision);
 
 unsigned int optimize_intervals_float_1D(float *oriData, size_t dataLength, double realPrecision);
 unsigned int optimize_intervals_float_2D(float *oriData, size_t r1, size_t r2, double realPrecision);
@@ -30,30 +31,32 @@ unsigned int optimize_intervals_float_3D_opt(float *oriData, size_t r1, size_t r
 unsigned int optimize_intervals_float_2D_opt(float *oriData, size_t r1, size_t r2, double realPrecision);
 unsigned int optimize_intervals_float_1D_opt(float *oriData, size_t dataLength, double realPrecision);
 
+unsigned int optimize_intervals_float_1D_opt_MSST19(float *oriData, size_t dataLength, double realPrecision);
+unsigned int optimize_intervals_float_2D_opt_MSST19(float *oriData, size_t r1, size_t r2, double realPrecision);
+unsigned int optimize_intervals_float_3D_opt_MSST19(float *oriData, size_t r1, size_t r2, size_t r3, double realPrecision);
 
 TightDataPointStorageF* SZ_compress_float_1D_MDQ(float *oriData, 
-size_t dataLength, double realPrecision, float valueRangeSize, float medianValue_f);
+size_t dataLength, float realPrecision, float valueRangeSize, float medianValue_f);
 
-void SZ_compress_args_float_StoreOriData(float* oriData, size_t dataLength, TightDataPointStorageF* tdps, 
-unsigned char** newByteData, size_t *outSize);
+void SZ_compress_args_float_StoreOriData(float* oriData, size_t dataLength, unsigned char** newByteData, size_t *outSize);
 
-char SZ_compress_args_float_NoCkRngeNoGzip_1D(unsigned char** newByteData, float *oriData, 
+char SZ_compress_args_float_NoCkRngeNoGzip_1D(int cmprType, unsigned char** newByteData, float *oriData, 
 size_t dataLength, double realPrecision, size_t *outSize, float valueRangeSize, float medianValue_f);
 
-TightDataPointStorageF* SZ_compress_float_2D_MDQ(float *oriData, size_t r1, size_t r2, double realPrecision, float valueRangeSize, float medianValue_f);
+TightDataPointStorageF* SZ_compress_float_2D_MDQ(float *oriData, size_t r1, size_t r2, float realPrecision, float valueRangeSize, float medianValue_f);
 
-char SZ_compress_args_float_NoCkRngeNoGzip_2D(unsigned char** newByteData, float *oriData, size_t r1, size_t r2, double realPrecision, size_t *outSize, float valueRangeSize, float medianValue_f);
+char SZ_compress_args_float_NoCkRngeNoGzip_2D(int cmprType, unsigned char** newByteData, float *oriData, size_t r1, size_t r2, double realPrecision, size_t *outSize, float valueRangeSize, float medianValue_f);
 
-TightDataPointStorageF* SZ_compress_float_3D_MDQ(float *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, float valueRangeSize, float medianValue_f);
+TightDataPointStorageF* SZ_compress_float_3D_MDQ(float *oriData, size_t r1, size_t r2, size_t r3, float realPrecision, float valueRangeSize, float medianValue_f);
 
-char SZ_compress_args_float_NoCkRngeNoGzip_3D(unsigned char** newByteData, float *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, size_t *outSize, float valueRangeSize, float medianValue_f);
+char SZ_compress_args_float_NoCkRngeNoGzip_3D(int cmprType, unsigned char** newByteData, float *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, size_t *outSize, float valueRangeSize, float medianValue_f);
 
 size_t SZ_compress_float_1D_MDQ_RA_block(float * block_ori_data, float * mean, size_t dim_0, size_t block_dim_0, double realPrecision, int * type, float * unpredictable_data);
 size_t SZ_compress_float_2D_MDQ_RA_block(float * block_ori_data, float * mean, size_t dim_0, size_t dim_1, size_t block_dim_0, size_t block_dim_1, double realPrecision, float * P0, float * P1, int * type, float * unpredictable_data);
 
 size_t SZ_compress_float_1D_MDQ_RA_block_1D_pred(float * block_ori_data, float * mean, float dense_pos, size_t dim_0, size_t block_dim_0, double realPrecision, int * type, DynamicFloatArray * unpredictable_data);
 size_t SZ_compress_float_2D_MDQ_RA_block_2D_pred(float * block_ori_data, float * mean, float dense_pos, size_t dim_0, size_t dim_1, size_t block_dim_0, size_t block_dim_1, double realPrecision, float * P0, float * P1, int * type, float * unpredictable_data);
-size_t SZ_compress_float_3D_MDQ_RA_block(float * block_ori_data, float * mean, size_t dim_0, size_t dim_1, size_t dim_2, size_t block_dim_0, size_t block_dim_1, size_t block_dim_2, double realPrecision, float * P0, float * P1, int * type, float * unpredictable_data);
+size_t SZ_compress_float_3D_MDQ_RA_block(float * block_ori_data, float * mean, size_t dim_0, size_t dim_1, size_t dim_2, size_t block_dim_0, size_t block_dim_1, size_t block_dim_2, float realPrecision, float * P0, float * P1, int * type, float * unpredictable_data);
 size_t SZ_compress_float_3D_MDQ_RA_block_3D_pred(float * block_ori_data, float * mean, float dense_pos, size_t dim_0, size_t dim_1, size_t dim_2, size_t block_dim_0, size_t block_dim_1, size_t block_dim_2, double realPrecision, float * P0, float * P1, int * type, float * unpredictable_data);
 size_t SZ_compress_float_3D_MDQ_RA_block_adaptive(float * block_ori_data, float * mean, size_t dim_0, size_t dim_1, size_t dim_2, size_t block_dim_0, size_t block_dim_1, size_t block_dim_2, double realPrecision, float * P0, float * P1, int * type, float * unpredictable_data);
 //unsigned short SZ_compress_float_3D_MDQ_RA_block_1D_pred(float * block_ori_data, float * mean, float dense_pos, size_t dim_0, size_t dim_1, size_t dim_2, int block_dim_0, int block_dim_1, int block_dim_2, double realPrecision, int * type, float * unpredictable_data);
@@ -76,20 +79,26 @@ unsigned char * SZ_compress_float_3D_MDQ_nonblocked_ori(float *oriData, size_t r
 unsigned char * SZ_compress_float_3D_MDQ_nonblocked_multi_means(float *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, size_t * comp_size);
 unsigned char * SZ_compress_float_3D_MDQ_RA_multi_means(float *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, size_t * comp_size);
 unsigned char * SZ_compress_float_3D_MDQ_nonblocked_adaptive(float *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, size_t * comp_size);
-unsigned char * SZ_compress_float_3D_MDQ_nonblocked_with_blocked_regression(float *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, size_t * comp_size);
-unsigned char * SZ_compress_float_2D_MDQ_nonblocked_with_blocked_regression(float *oriData, size_t r1, size_t r2, double realPrecision, size_t * comp_size);
+
+unsigned char * SZ_compress_float_2D_MDQ_decompression_random_access_with_blocked_regression(float *oriData, size_t r1, size_t r2, double realPrecision, size_t * comp_size);
+unsigned char * SZ_compress_float_1D_MDQ_decompression_random_access_with_blocked_regression(float *oriData, size_t r1, double realPrecision, size_t * comp_size);
 
 TightDataPointStorageF* SZ_compress_float_4D_MDQ(float *oriData, size_t r1, size_t r2, size_t r3, size_t r4, double realPrecision, float valueRangeSize, float medianValue_f);
 
 char SZ_compress_args_float_NoCkRngeNoGzip_4D(unsigned char** newByteData, float *oriData, size_t r1, size_t r2, size_t r3, size_t r4, double realPrecision, size_t *outSize, float valueRangeSize, float medianValue_f);
 
+TightDataPointStorageF* SZ_compress_float_1D_MDQ_MSST19(float *oriData, 
+size_t dataLength, double realPrecision, float valueRangeSize, float medianValue_f);
+TightDataPointStorageF* SZ_compress_float_2D_MDQ_MSST19(float *oriData, size_t r1, size_t r2, double realPrecision, float valueRangeSize, float medianValue_f);
+TightDataPointStorageF* SZ_compress_float_3D_MDQ_MSST19(float *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, float valueRangeSize, float medianValue_f);
+
 void SZ_compress_args_float_withinRange(unsigned char** newByteData, float *oriData, size_t dataLength, size_t *outSize);
 
-int SZ_compress_args_float_wRngeNoGzip(unsigned char** newByteData, float *oriData, 
+/*int SZ_compress_args_float_wRngeNoGzip(unsigned char** newByteData, float *oriData, 
 size_t r5, size_t r4, size_t r3, size_t r2, size_t r1, size_t *outSize, 
-int errBoundMode, double absErr_Bound, double relBoundRatio, double pwrErrRatio);
+int errBoundMode, double absErr_Bound, double relBoundRatio, double pwrErrRatio);*/
 
-int SZ_compress_args_float(unsigned char** newByteData, float *oriData, 
+int SZ_compress_args_float(int cmprType, int withRegression, unsigned char** newByteData, float *oriData, 
 size_t r5, size_t r4, size_t r3, size_t r2, size_t r1, size_t *outSize, 
 int errBoundMode, double absErr_Bound, double relBoundRatio, double pwRelBoundRatio);
 
@@ -132,10 +141,10 @@ size_t r1, size_t r2, size_t r3, size_t r4, size_t s1, size_t s2, size_t s3, siz
 unsigned int optimize_intervals_float_2D_with_freq_and_dense_pos(float *oriData, size_t r1, size_t r2, double realPrecision, float * dense_pos, float * max_freq, float * mean_freq);
 unsigned int optimize_intervals_float_3D_with_freq_and_dense_pos(float *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, float * dense_pos, float * max_freq, float * mean_freq);
 
-unsigned char * SZ_compress_float_2D_MDQ_nonblocked_with_blocked_regression(float *oriData, size_t r1, size_t r2, double realPrecision, size_t * comp_size);
-unsigned char * SZ_compress_float_3D_MDQ_nonblocked_with_blocked_regression(float *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, size_t * comp_size);
+unsigned char * SZ_compress_float_2D_MDQ_nonblocked_with_blocked_regression(float *oriData, size_t r1, size_t r2, float realPrecision, size_t * comp_size);
+unsigned char * SZ_compress_float_3D_MDQ_nonblocked_with_blocked_regression(float *oriData, size_t r1, size_t r2, size_t r3, float realPrecision, size_t * comp_size);
 unsigned char * SZ_compress_float_3D_MDQ_random_access_with_blocked_regression(float *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, size_t * comp_size);
-
+unsigned char * SZ_compress_float_3D_MDQ_decompression_random_access_with_blocked_regression(float *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, size_t * comp_size);
 #ifdef __cplusplus
 }
 #endif

thirdparty/SZ/sz/include/sz_float_pwr.h

@@ -14,6 +14,9 @@
 extern "C" {
 #endif
 
+#include <stdio.h>
+#include <stdbool.h>
+
 void compute_segment_precisions_float_1D(float *oriData, size_t dataLength, float* pwrErrBound, unsigned char* pwrErrBoundBytes, double globalPrecision);
 unsigned int optimize_intervals_float_1D_pwr(float *oriData, size_t dataLength, float* pwrErrBound);
 
@@ -48,6 +51,13 @@ void SZ_compress_args_float_NoCkRngeNoGzip_1D_pwr_pre_log(unsigned char** newByt
 void SZ_compress_args_float_NoCkRngeNoGzip_2D_pwr_pre_log(unsigned char** newByteData, float *oriData, double pwrErrRatio, size_t r1, size_t r2, size_t *outSize, float min, float max);
 void SZ_compress_args_float_NoCkRngeNoGzip_3D_pwr_pre_log(unsigned char** newByteData, float *oriData, double pwrErrRatio, size_t r1, size_t r2, size_t r3, size_t *outSize, float min, float max);
 
+void SZ_compress_args_float_NoCkRngeNoGzip_1D_pwr_pre_log_MSST19(unsigned char** newByteData, float *oriData, double pwrErrRatio, size_t dataLength, size_t *outSize, float valueRangeSize, float medianValue_f,
+																unsigned char* signs, bool* positive, float min, float max, float nearZero);
+void SZ_compress_args_float_NoCkRngeNoGzip_2D_pwr_pre_log_MSST19(unsigned char** newByteData, float *oriData, double pwrErrRatio, size_t r1, size_t r2, size_t *outSize, float valueRangeSize,
+																unsigned char* signs, bool* positive, float min, float max, float nearZero);																
+void SZ_compress_args_float_NoCkRngeNoGzip_3D_pwr_pre_log_MSST19(unsigned char** newByteData, float *oriData, double pwrErrRatio, size_t r1, size_t r2, size_t r3, size_t *outSize, float valueRangeSize, 
+																unsigned char* signs, bool* positive, float min, float max, float nearZero);
+
 #ifdef __cplusplus
 }
 #endif

thirdparty/SZ/sz/include/sz_omp.h

@@ -9,7 +9,9 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#ifdef _OPENMP
 #include "omp.h"
+#endif
 #include "sz.h"
 
 #ifndef _SZ_OMP_H
@@ -20,17 +22,21 @@ extern "C" {
 #endif
 
 unsigned char * SZ_compress_float_1D_MDQ_openmp(float *oriData, size_t r1, double realPrecision, size_t * comp_size);
-
 unsigned char * SZ_compress_float_2D_MDQ_openmp(float *oriData, size_t r1, size_t r2, double realPrecision, size_t * comp_size);
-
-unsigned char * SZ_compress_float_3D_MDQ_openmp(float *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, size_t * comp_size);
+unsigned char * SZ_compress_float_3D_MDQ_openmp(float *oriData, size_t r1, size_t r2, size_t r3, float realPrecision, size_t * comp_size);
 
 void decompressDataSeries_float_1D_openmp(float** data, size_t r1, unsigned char* comp_data);
-
 void decompressDataSeries_float_3D_openmp(float** data, size_t r1, size_t r2, size_t r3, unsigned char* comp_data);
-
 void decompressDataSeries_float_2D_openmp(float** data, size_t r1, size_t r2, unsigned char* comp_data);
 
+unsigned char * SZ_compress_double_1D_MDQ_openmp(double *oriData, size_t r1, double realPrecision, size_t * comp_size);
+unsigned char * SZ_compress_double_2D_MDQ_openmp(double *oriData, size_t r1, size_t r2, double realPrecision, size_t * comp_size);
+unsigned char * SZ_compress_double_3D_MDQ_openmp(double *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, size_t * comp_size);
+
+void decompressDataSeries_double_1D_openmp(double** data, size_t r1, unsigned char* comp_data);
+void decompressDataSeries_double_2D_openmp(double** data, size_t r1, size_t r2, unsigned char* comp_data);
+void decompressDataSeries_double_3D_openmp(double** data, size_t r1, size_t r2, size_t r3, unsigned char* comp_data);
+
 //void Huffman_init_openmp(HuffmanTree* huffmanTree, int *s, size_t length, int thread_num);
 void Huffman_init_openmp(HuffmanTree* huffmanTree, int *s, size_t length, int thread_num, size_t * freq);
 

thirdparty/SZ/sz/include/sz_opencl.h

+//make header C++/C inter-operable
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef SZ_OPENCL_H
+#define SZ_OPENCL_H
+
+#include<stddef.h>
+
+	//opaque pointer for opencl state
+  struct sz_opencl_state;
+
+  /**
+   * creates an opencl state for multiple uses of the compressor or
+   * returns an error code.
+   *
+   * \post if return code is SZ_NCES, the state object may only be passed to
+   * sz_opencl_release or sz_opencl_error_* otherwise it may be used in any
+   * sz_opencl_* function.
+   *
+   * \param[out] state the sz opencl state
+   * \return SZ_SCES for success or SZ_NCES on error
+   */
+  int sz_opencl_init(struct sz_opencl_state** state);
+
+	/**
+	 * deinitializes an opencl state
+	 *
+	 * \param[in] state the sz opencl state
+	 * \return SZ_SCES
+	 */
+  int sz_opencl_release(struct sz_opencl_state** state);
+
+	/**
+	 * returns a human readable error message for the last error recieved by state
+	 *
+	 * \param[in] state the sz opencl state
+	 * \return a pointer to a string that describes the error
+	 */
+	const char* sz_opencl_error_msg(struct sz_opencl_state* state);
+
+
+	/**
+	 * returns a numeric code for the last error recieved by state
+	 *
+	 * \param[in] state the sz opencl state
+	 * \return the numeric error code
+	 */
+  int sz_opencl_error_code(struct sz_opencl_state* state);
+
+	/**
+	 * confirms that the sz opencl state is ready to use by performing a vector addition
+	 *
+	 * \param[in] state the sz opencl state
+	 * \return SZ_SCES if the opencl implementation is functioning
+	 */
+	int sz_opencl_check(struct sz_opencl_state*);
+
+  unsigned char* sz_compress_float3d_opencl(float* data, size_t r1, size_t r2, size_t r3, double, size_t* out_size);
+
+
+#endif /* SZ_OPENCL_H */
+
+//make header C++/C inter-operable
+#ifdef __cplusplus
+}
+#endif

thirdparty/SZ/sz/include/sz_stats.h

+/**
+ *  @file ByteToolkit.h
+ *  @author Sheng Di
+ *  @date July, 2017
+ *  @brief Header file for the ByteToolkit.c.
+ *  (C) 2016 by Mathematics and Computer Science (MCS), Argonne National Laboratory.
+ *      See COPYRIGHT in top-level directory.
+ */
+
+#ifndef _STATS_H
+#define _STATS_H
+
+#include <stdint.h>
+#include <stdio.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct sz_stats
+{
+	int constant_flag;
+	int use_mean;
+	
+	size_t blockSize;
+	
+	float lorenzoPercent;
+	float regressionPercent;
+	size_t lorenzoBlocks;
+	size_t regressionBlocks;
+	size_t totalBlocks;
+	
+	//size_t huffmanTreeHeight;
+	size_t huffmanTreeSize; //before the final zstd
+	size_t huffmanCodingSize; //before the final zstd
+	float huffmanCompressionRatio;
+	int huffmanNodeCount;
+		
+	size_t unpredictCount;
+	float unpredictPercent;
+	
+	float zstdCompressionRatio; //not available yet
+
+  unsigned int quantization_intervals;
+
+  size_t pre_encoding_size;
+} sz_stats;
+
+extern sz_stats sz_stat;
+
+
+void writeBlockInfo(int use_mean, size_t blockSize, size_t regressionBlocks, size_t totalBlocks);
+void writeHuffmanInfo(size_t huffmanTreeSize, size_t huffmanCodingSize, size_t totalDataSize, int huffmanNocdeCount);
+void writeZstdCompressionRatio(float zstdCompressionRatio);
+void writeConstantFlag(int flag);
+void writeUnpredictDataCounts(size_t unpredictCount, size_t totalNumElements);
+void writeQuantizationInfo(unsigned int quantization_intervals);
+void writePreEncodingSize(size_t pre_encoding_size);
+void printSZStats();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ----- #ifndef _STATS_H  ----- */

thirdparty/SZ/sz/include/szd_double.h

@@ -16,18 +16,25 @@ extern "C" {
 
 #include "TightDataPointStorageD.h"
 
-void decompressDataSeries_double_1D(double** data, size_t dataSeriesLength, TightDataPointStorageD* tdps);
-void decompressDataSeries_double_2D(double** data, size_t r1, size_t r2, TightDataPointStorageD* tdps);
-void decompressDataSeries_double_3D(double** data, size_t r1, size_t r2, size_t r3, TightDataPointStorageD* tdps);
-void decompressDataSeries_double_4D(double** data, size_t r1, size_t r2, size_t r3, size_t r4, TightDataPointStorageD* tdps);
-void getSnapshotData_double_1D(double** data, size_t dataSeriesLength, TightDataPointStorageD* tdps, int errBoundMode);
-void getSnapshotData_double_2D(double** data, size_t r1, size_t r2, TightDataPointStorageD* tdps, int errBoundMode);
-void getSnapshotData_double_3D(double** data, size_t r1, size_t r2, size_t r3, TightDataPointStorageD* tdps, int errBoundMode);
-void getSnapshotData_double_4D(double** data, size_t r1, size_t r2, size_t r3, size_t r4, TightDataPointStorageD* tdps, int errBoundMode);
-void decompressDataSeries_double_2D_nonblocked_with_blocked_regression(double** data, size_t r1, size_t r2, unsigned char* comp_data);
-void decompressDataSeries_double_3D_nonblocked_with_blocked_regression(double** data, size_t r1, size_t r2, size_t r3, unsigned char* comp_data);
-
-int SZ_decompress_args_double(double** newData, size_t r5, size_t r4, size_t r3, size_t r2, size_t r1, unsigned char* cmpBytes, size_t cmpSize);
+void decompressDataSeries_double_1D(double** data, size_t dataSeriesLength, double* hist_data, TightDataPointStorageD* tdps);
+void decompressDataSeries_double_2D(double** data, size_t r1, size_t r2, double* hist_data, TightDataPointStorageD* tdps);
+void decompressDataSeries_double_3D(double** data, size_t r1, size_t r2, size_t r3, double* hist_data, TightDataPointStorageD* tdps);
+void decompressDataSeries_double_4D(double** data, size_t r1, size_t r2, size_t r3, size_t r4, double* hist_data, TightDataPointStorageD* tdps);
+
+void decompressDataSeries_double_1D_MSST19(double** data, size_t dataSeriesLength, TightDataPointStorageD* tdps);
+void decompressDataSeries_double_2D_MSST19(double** data, size_t r1, size_t r2, TightDataPointStorageD* tdps);
+void decompressDataSeries_double_3D_MSST19(double** data, size_t r1, size_t r2, size_t r3, TightDataPointStorageD* tdps);
+
+void getSnapshotData_double_1D(double** data, size_t dataSeriesLength, TightDataPointStorageD* tdps, int errBoundMode, int compressionType, double* hist_data);
+void getSnapshotData_double_2D(double** data, size_t r1, size_t r2, TightDataPointStorageD* tdps, int errBoundMode, int compressionType, double* hist_data);
+void getSnapshotData_double_3D(double** data, size_t r1, size_t r2, size_t r3, TightDataPointStorageD* tdps, int errBoundMode, int compressionType, double* hist_data);
+void getSnapshotData_double_4D(double** data, size_t r1, size_t r2, size_t r3, size_t r4, TightDataPointStorageD* tdps, int errBoundMode, int compressionType, double* hist_data);
+void decompressDataSeries_double_2D_nonblocked_with_blocked_regression(double** data, size_t r1, size_t r2, unsigned char* comp_data, double* hist_data);
+void decompressDataSeries_double_3D_nonblocked_with_blocked_regression(double** data, size_t r1, size_t r2, size_t r3, unsigned char* comp_data, double* hist_data);
+
+size_t decompressDataSeries_double_3D_RA_block(double * data, double mean, size_t dim_0, size_t dim_1, size_t dim_2, size_t block_dim_0, size_t block_dim_1, size_t block_dim_2, double realPrecision, int * type, double * unpredictable_data);
+
+int SZ_decompress_args_double(double** newData, size_t r5, size_t r4, size_t r3, size_t r2, size_t r1, unsigned char* cmpBytes, size_t cmpSize, int compressionType, double* hist_data);
 
 #ifdef __cplusplus
 }

thirdparty/SZ/sz/include/szd_double_pwr.h

@@ -25,6 +25,10 @@ void decompressDataSeries_double_1D_pwr_pre_log(double** data, size_t dataSeries
 void decompressDataSeries_double_2D_pwr_pre_log(double** data, size_t r1, size_t r2, TightDataPointStorageD* tdps);
 void decompressDataSeries_double_3D_pwr_pre_log(double** data, size_t r1, size_t r2, size_t r3, TightDataPointStorageD* tdps);
 
+void decompressDataSeries_double_1D_pwr_pre_log_MSST19(double** data, size_t dataSeriesLength, TightDataPointStorageD* tdps);
+void decompressDataSeries_double_2D_pwr_pre_log_MSST19(double** data, size_t r1, size_t r2, TightDataPointStorageD* tdps);
+void decompressDataSeries_double_3D_pwr_pre_log_MSST19(double** data, size_t r1, size_t r2, size_t r3, TightDataPointStorageD* tdps);
+
 #ifdef __cplusplus
 }
 #endif

thirdparty/SZ/sz/include/szd_double_ts.h

@@ -16,7 +16,7 @@ extern "C" {
 
 #include "TightDataPointStorageD.h"
 
-void decompressDataSeries_double_1D_ts(double** data, size_t dataSeriesLength, sz_multisteps* multisteps, TightDataPointStorageD* tdps);
+void decompressDataSeries_double_1D_ts(double** data, size_t dataSeriesLength, double* hist_data, TightDataPointStorageD* tdps);
 
 #ifdef __cplusplus
 }

thirdparty/SZ/sz/include/szd_float.h

@@ -16,25 +16,40 @@ extern "C" {
 
 #include "TightDataPointStorageF.h"
 
-void decompressDataSeries_float_1D(float** data, size_t dataSeriesLength, TightDataPointStorageF* tdps);
-void decompressDataSeries_float_2D(float** data, size_t r1, size_t r2, TightDataPointStorageF* tdps);
-void decompressDataSeries_float_3D(float** data, size_t r1, size_t r2, size_t r3, TightDataPointStorageF* tdps);
-void decompressDataSeries_float_4D(float** data, size_t r1, size_t r2, size_t r3, size_t r4, TightDataPointStorageF* tdps);
-void getSnapshotData_float_1D(float** data, size_t dataSeriesLength, TightDataPointStorageF* tdps, int errBoundMode);
-void getSnapshotData_float_2D(float** data, size_t r1, size_t r2, TightDataPointStorageF* tdps, int errBoundMode);
-void getSnapshotData_float_3D(float** data, size_t r1, size_t r2, size_t r3, TightDataPointStorageF* tdps, int errBoundMode);
-void getSnapshotData_float_4D(float** data, size_t r1, size_t r2, size_t r3, size_t r4, TightDataPointStorageF* tdps, int errBoundMode);
+void decompressDataSeries_float_1D(float** data, size_t dataSeriesLength, float* hist_data, TightDataPointStorageF* tdps);
+void decompressDataSeries_float_2D(float** data, size_t r1, size_t r2, float* hist_data, TightDataPointStorageF* tdps);
+void decompressDataSeries_float_3D(float** data, size_t r1, size_t r2, size_t r3, float* hist_data, TightDataPointStorageF* tdps);
+void decompressDataSeries_float_4D(float** data, size_t r1, size_t r2, size_t r3, size_t r4, float* hist_data, TightDataPointStorageF* tdps);
+
+void decompressDataSeries_float_1D_MSST19(float** data, size_t dataSeriesLength, TightDataPointStorageF* tdps);
+void decompressDataSeries_float_2D_MSST19(float** data, size_t r1, size_t r2, TightDataPointStorageF* tdps);
+void decompressDataSeries_float_3D_MSST19(float** data, size_t r1, size_t r2, size_t r3, TightDataPointStorageF* tdps);
+
+void getSnapshotData_float_1D(float** data, size_t dataSeriesLength, TightDataPointStorageF* tdps, int errBoundMode, int compressionType, float* hist_data);
+void getSnapshotData_float_2D(float** data, size_t r1, size_t r2, TightDataPointStorageF* tdps, int errBoundMode, int compressionType, float* hist_data);
+void getSnapshotData_float_3D(float** data, size_t r1, size_t r2, size_t r3, TightDataPointStorageF* tdps, int errBoundMode, int compressionType, float* hist_data);
+void getSnapshotData_float_4D(float** data, size_t r1, size_t r2, size_t r3, size_t r4, TightDataPointStorageF* tdps, int errBoundMode, int compressionType, float* hist_data);
 
 size_t decompressDataSeries_float_1D_RA_block(float * data, float mean, size_t dim_0, size_t block_dim_0, double realPrecision, int * type, float * unpredictable_data);
 size_t decompressDataSeries_float_2D_RA_block(float * data, float mean, size_t dim_0, size_t dim_1, size_t block_dim_0, size_t block_dim_1, double realPrecision, int * type, float * unpredictable_data);
 
-int SZ_decompress_args_float(float** newData, size_t r5, size_t r4, size_t r3, size_t r2, size_t r1, unsigned char* cmpBytes, size_t cmpSize);
+int SZ_decompress_args_float(float** newData, size_t r5, size_t r4, size_t r3, size_t r2, size_t r1, unsigned char* cmpBytes, size_t cmpSize, int compressionType, float* hist_data);
+
+size_t decompressDataSeries_float_3D_RA_block(float * data, float mean, size_t dim_0, size_t dim_1, size_t dim_2, size_t block_dim_0, size_t block_dim_1, size_t block_dim_2, float realPrecision, int * type, float * unpredictable_data);
 
-size_t decompressDataSeries_float_3D_RA_block(float * data, float mean, size_t dim_0, size_t dim_1, size_t dim_2, size_t block_dim_0, size_t block_dim_1, size_t block_dim_2, double realPrecision, int * type, float * unpredictable_data);
+void decompressDataSeries_float_1D_decompression_given_areas_with_blocked_regression(float** data, size_t r1, size_t s1, size_t e1, unsigned char* comp_data);
 
-void decompressDataSeries_float_2D_nonblocked_with_blocked_regression(float** data, size_t r1, size_t r2, unsigned char* comp_data);
-void decompressDataSeries_float_3D_nonblocked_with_blocked_regression(float** data, size_t r1, size_t r2, size_t r3, unsigned char* comp_data);
+void decompressDataSeries_float_2D_nonblocked_with_blocked_regression(float** data, size_t r1, size_t r2, unsigned char* comp_data, float* hist_data);
+void decompressDataSeries_float_2D_decompression_given_areas_with_blocked_regression(float** data, size_t r1, size_t r2, size_t s1, size_t s2, size_t e1, size_t e2, unsigned char* comp_data);
+void decompressDataSeries_float_3D_nonblocked_with_blocked_regression(float** data, size_t r1, size_t r2, size_t r3, unsigned char* comp_data, float* hist_data);
 void decompressDataSeries_float_3D_random_access_with_blocked_regression(float** data, size_t r1, size_t r2, size_t r3, unsigned char* comp_data);
+void decompressDataSeries_float_3D_decompression_random_access_with_blocked_regression(float** data, size_t r1, size_t r2, size_t r3, unsigned char* comp_data);
+void decompressDataSeries_float_3D_decompression_given_areas_with_blocked_regression(float** data, size_t r1, size_t r2, size_t r3, size_t s1, size_t s2, size_t s3, size_t e1, size_t e2, size_t e3, unsigned char* comp_data);
+int SZ_decompress_args_randomaccess_float(float** newData, 
+size_t r5, size_t r4, size_t r3, size_t r2, size_t r1, 
+size_t s5, size_t s4, size_t s3, size_t s2, size_t s1, // start point
+size_t e5, size_t e4, size_t e3, size_t e2, size_t e1, // end point
+unsigned char* cmpBytes, size_t cmpSize);
 
 #ifdef __cplusplus
 }

thirdparty/SZ/sz/include/szd_float_pwr.h

@@ -26,6 +26,10 @@ void decompressDataSeries_float_1D_pwr_pre_log(float** data, size_t dataSeriesLe
 void decompressDataSeries_float_2D_pwr_pre_log(float** data, size_t r1, size_t r2, TightDataPointStorageF* tdps);
 void decompressDataSeries_float_3D_pwr_pre_log(float** data, size_t r1, size_t r2, size_t r3, TightDataPointStorageF* tdps);
 
+void decompressDataSeries_float_1D_pwr_pre_log_MSST19(float** data, size_t dataSeriesLength, TightDataPointStorageF* tdps);
+void decompressDataSeries_float_2D_pwr_pre_log_MSST19(float** data, size_t r1, size_t r2, TightDataPointStorageF* tdps);
+void decompressDataSeries_float_3D_pwr_pre_log_MSST19(float** data, size_t r1, size_t r2, size_t r3, TightDataPointStorageF* tdps);
+
 #ifdef __cplusplus
 }
 #endif

thirdparty/SZ/sz/include/szd_float_ts.h

@@ -16,7 +16,7 @@ extern "C" {
 
 #include "TightDataPointStorageF.h"
 
-void decompressDataSeries_float_1D_ts(float** data, size_t dataSeriesLength, sz_multisteps* multisteps, TightDataPointStorageF* tdps);
+void decompressDataSeries_float_1D_ts(float** data, size_t dataSeriesLength, float* hist_data, TightDataPointStorageF* tdps);
 
 #ifdef __cplusplus
 }

thirdparty/SZ/sz/include/szf.h

@@ -75,16 +75,16 @@ void sz_decompress_d3_double_(unsigned char *bytes, size_t *byteLength, double *
 void sz_decompress_d4_double_(unsigned char *bytes, size_t *byteLength, double *data, size_t *r1, size_t *r2, size_t *r3, size_t *r4);
 void sz_decompress_d5_double_(unsigned char *bytes, size_t *byteLength, double *data, size_t *r1, size_t *r2, size_t *r3, size_t *r4, size_t *r5);
 
-void sz_batchaddVar_d1_float_(char* varName, int *len, float* data, int *errBoundMode, float *absErrBound, float *relBoundRatio, size_t *r1);
-void sz_batchaddvar_d2_float_(char* varName, int *len, float* data, int *errBoundMode, float *absErrBound, float *relBoundRatio, size_t *r1, size_t *r2);
-void sz_batchaddvar_d3_float_(char* varName, int *len, float* data, int *errBoundMode, float *absErrBound, float *relBoundRatio, size_t *r1, size_t *r2, size_t *r3);
-void sz_batchaddvar_d4_float_(char* varName, int *len, float* data, int *errBoundMode, float *absErrBound, float *relBoundRatio, size_t *r1, size_t *r2, size_t *r3, size_t *r4);
-void sz_batchaddvar_d5_float_(char* varName, int *len, float* data, int *errBoundMode, float *absErrBound, float *relBoundRatio, size_t *r1, size_t *r2, size_t *r3, size_t *r4, size_t *r5);
-void sz_batchaddvar_d1_double_(char* varName, int *len, double* data, int *errBoundMode, double *absErrBound, double *relBoundRatio, size_t *r1);
-void sz_batchaddvar_d2_double_(char* varName, int *len, double* data, int *errBoundMode, double *absErrBound, double *relBoundRatio, size_t *r1, size_t *r2);
-void sz_batchaddvar_d3_double_(char* varName, int *len, double* data, int *errBoundMode, double *absErrBound, double *relBoundRatio, size_t *r1, size_t *r2, size_t *r3);
-void sz_batchaddvar_d4_double_(char* varName, int *len, double* data, int *errBoundMode, double *absErrBound, double *relBoundRatio, size_t *r1, size_t *r2, size_t *r3, size_t *r4);
-void sz_batchaddvar_d5_double_(char* varName, int *len, double* data, int *errBoundMode, double *absErrBound, double *relBoundRatio, size_t *r1, size_t *r2, size_t *r3, size_t *r4, size_t *r5);
+void sz_batchaddVar_d1_float_(int var_id, char* varName, int *len, float* data, int *errBoundMode, float *absErrBound, float *relBoundRatio, size_t *r1);
+void sz_batchaddvar_d2_float_(int var_id, char* varName, int *len, float* data, int *errBoundMode, float *absErrBound, float *relBoundRatio, size_t *r1, size_t *r2);
+void sz_batchaddvar_d3_float_(int var_id, char* varName, int *len, float* data, int *errBoundMode, float *absErrBound, float *relBoundRatio, size_t *r1, size_t *r2, size_t *r3);
+void sz_batchaddvar_d4_float_(int var_id, char* varName, int *len, float* data, int *errBoundMode, float *absErrBound, float *relBoundRatio, size_t *r1, size_t *r2, size_t *r3, size_t *r4);
+void sz_batchaddvar_d5_float_(int var_id, char* varName, int *len, float* data, int *errBoundMode, float *absErrBound, float *relBoundRatio, size_t *r1, size_t *r2, size_t *r3, size_t *r4, size_t *r5);
+void sz_batchaddvar_d1_double_(int var_id, char* varName, int *len, double* data, int *errBoundMode, double *absErrBound, double *relBoundRatio, size_t *r1);
+void sz_batchaddvar_d2_double_(int var_id, char* varName, int *len, double* data, int *errBoundMode, double *absErrBound, double *relBoundRatio, size_t *r1, size_t *r2);
+void sz_batchaddvar_d3_double_(int var_id, char* varName, int *len, double* data, int *errBoundMode, double *absErrBound, double *relBoundRatio, size_t *r1, size_t *r2, size_t *r3);
+void sz_batchaddvar_d4_double_(int var_id, char* varName, int *len, double* data, int *errBoundMode, double *absErrBound, double *relBoundRatio, size_t *r1, size_t *r2, size_t *r3, size_t *r4);
+void sz_batchaddvar_d5_double_(int var_id, char* varName, int *len, double* data, int *errBoundMode, double *absErrBound, double *relBoundRatio, size_t *r1, size_t *r2, size_t *r3, size_t *r4, size_t *r5);
 void sz_batchdelvar_c_(char* varName, int *len, int *errState);
 void sz_batch_compress_c_(unsigned char* bytes, size_t *outSize);
 void sz_batch_decompress_c_(unsigned char* bytes, size_t *byteLength, int *ierr);

thirdparty/SZ/sz/include/utility.h

@@ -35,6 +35,8 @@ int is_lossless_compressed_data(unsigned char* compressedBytes, size_t cmpSize);
 unsigned long sz_lossless_compress(int losslessCompressor, int level, unsigned char* data, unsigned long dataLength, unsigned char** compressBytes);
 unsigned long sz_lossless_decompress(int losslessCompressor, unsigned char* compressBytes, unsigned long cmpSize, unsigned char** oriData, unsigned long targetOriSize);
 unsigned long sz_lossless_decompress65536bytes(int losslessCompressor, unsigned char* compressBytes, unsigned long cmpSize, unsigned char** oriData);
+void* detransposeData(void* data, int dataType, size_t r5, size_t r4, size_t r3, size_t r2, size_t r1);
+void* transposeData(void* data, int dataType, size_t r5, size_t r4, size_t r3, size_t r2, size_t r1);
 
 #ifdef __cplusplus
 }