DynEarthSol/binaryio.hpp at master · GeoFLAC/DynEarthSol · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
#ifndef DYNEARTHSOL3D_BINARYIO_HPP
#define DYNEARTHSOL3D_BINARYIO_HPP

#include <map>
#ifdef HDF5
#include "H5Lpublic.h"
#include "H5Gpublic.h"
#include "H5Ppublic.h"
#include "H5Tpublic.h"
#include "H5Fpublic.h"
#include "H5Apublic.h"
#include "H5Spublic.h"
#endif
#include "array2d.hpp"

void rename_to_old_backup(const char *filename);

#ifndef HDF5

class BinaryOutput
{
private:
    long eof_pos;
    char *header;
    char *hd_pos;
    std::FILE* f;

    void write_header(const char *name);

public:
    BinaryOutput(const char *filename, const bool rename_if_exists=false);
    ~BinaryOutput();

    template <typename T>
    void write_scalar(const T& A, const std::string& name);

    template <typename T>
    void write_array(const std::vector<T>& A, const char *name, std::size_t size);

    void write_array(const std::vector<uint>& A, const char *name, std::size_t size);

    template <typename T, int N>
    void write_array(const Array2D<T,N>& A, const char *name, std::size_t size);

    void write_nodal_vec_array(const Array2D<double,NDIMS>& A, const char *name, std::size_t len);
};


class BinaryInput
{
private:
    std::FILE* f;
    std::map<std::string, std::size_t> offset;

    void read_header();
    void seek_to_array(const char *name);

public:
    BinaryInput(const char *filename);
    ~BinaryInput();

    bool has_array(const char *name) const;

    template <typename T>
    void read_scalar(T& A, const std::string& name);

    template <typename T>
    void read_array(std::vector<T>& A, const char *name, std::size_t size = 0);

    template <typename T, int N>
    void read_array(Array2D<T,N>& A, const char *name, std::size_t size = 0);
};

#else

class HDF5Output
{
private:
    hid_t file_id = -1;
    const int compression_level;
    long nnode = 0, nelem = 0, nseg = 0, etop = 0, nnode_cell = 0;
    bool has_metadata = false;
    const bool is_checkpoint;
    std::string kind, block_base;

    void write_header();

public:
    HDF5Output(const char *filename, const int hdf5_compression_level,
               const bool is_chkpt=false, const bool rename_if_exists=false);
    ~HDF5Output();

    template<typename T>
    void write_fieldData(const T& A, const std::string& name);

    template <typename T>
    void write_scalar(const T& A, const std::string& name);

    template <typename T>
    void write_array(const std::vector<T>& A, const char *name, hsize_t len);

    template <typename T, int N>
    void write_array(const Array2D<T,N>& A, const char *name, hsize_t len, int dest_N = -1);

    void write_nodal_vec_array(const Array2D<double,NDIMS>& A, const char *name, hsize_t len);

    void write_attribute(const std::string& A, const std::string& name, hid_t& vtkgrpBlock_id);
    template <typename T>
    void write_attribute(const T& A, const std::string& name, hid_t& vtkgrpBlock_id);
    template <typename T>
    void write_attribute(const std::vector<T>& A, const std::string& name, hsize_t len, hid_t& vtkgrpBlock_id);

    void write_block_metadata(const Variables& var, const std::string& base, MarkerSet* ms = nullptr);

    void create_virtual_dataset(const std::string& src_name, const std::string& dest_name, hid_t& src_space_id, hid_t& dtype_id);
    void create_virtual_dataset(const std::string& src_name, const std::string& dest_name, hid_t& space_id, hid_t& dtype_id, hsize_t len);
    void create_virtual_dataset(const std::string& src_name, const std::string& dest_name, hid_t& space_id, hid_t& dtype_id, hsize_t len, int N, int dest_N = -1);

    void add_soft_link(const std::string& assemblyNodePath, const std::string& linkName,
                        const std::string& targetAbsPath);
    hid_t create_group_with_order(const std::string& path);
};

class HDF5Input
{
private:
    hid_t file_id = -1;

    void read_header();

public:
    HDF5Input(const char *filename);
    ~HDF5Input();

    bool has_array(const char *name) const;

    template <typename T>
    void read_scalar(T& A, const std::string& name);

    template <typename T>
    void read_array(std::vector<T>& A, const char *name, std::size_t size = 0);

    template <typename T, int N>
    void read_array(Array2D<T,N>& A, const char *name, std::size_t size = 0);
};

#endif // HDF5

#endif