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
|
// Copyright (C) 2019 EDF
// All Rights Reserved
// This code is published under the GNU Lesser General Public License (GNU LGPL)
#ifndef GRIDTREEVALUEGENERS_H
#define GRIDTREEVALUEGENERS_H
#include <Eigen/Dense>
#include "geners/GenericIO.hh"
#include "StOpt/tree/GridTreeValue.h"
#include "StOpt/core/grids/SpaceGridGeners.h"
#include "StOpt/core/grids/RegularSpaceGridGeners.h"
#include "StOpt/core/grids/GeneralSpaceGridGeners.h"
#include "StOpt/core/grids/SparseSpaceGridNoBoundGeners.h"
#include "StOpt/core/grids/SparseSpaceGridBoundGeners.h"
#include "StOpt/core/grids/SparseInterpolatorSpectralGeners.h"
#include "StOpt/core/grids/InterpolatorSpectralGeners.h"
#include "StOpt/core/grids/LinearInterpolatorSpectralGeners.h"
#include "StOpt/core/grids/LegendreInterpolatorSpectralGeners.h"
/** \file GridTreeValueGeners.h
* \brief Define non intrusive serialization with random access
* \author Xavier Warin
*/
/// specialize the ClassIdSpecialization template
/// so that a ClassId object can be associated with the class we want to
/// serialize. The second argument is the version number.
///@{
gs_specialize_class_id(StOpt::GridTreeValue, 1)
/// an external class
gs_declare_type_external(StOpt::GridTreeValue)
///@}
namespace gs
{
//
/// \brief This is how the specialization of GenericWriter should look like
//
template <class Stream, class State >
struct GenericWriter < Stream, State, StOpt::GridTreeValue,
Int2Type<IOTraits<int>::ISEXTERNAL> >
{
inline static bool process(const StOpt::GridTreeValue &p_state, Stream &p_os,
State *, const bool p_processClassId)
{
// If necessary, serialize the class id
static const ClassId current(ClassId::makeId<StOpt::GridTreeValue >());
const bool status = p_processClassId ? ClassId::makeId<StOpt::GridTreeValue >().write(p_os) : true;
// Serialize object data if the class id was successfully
// written out
if (status)
{
std::shared_ptr< StOpt::SpaceGrid > ptrGrid = p_state.getGrid();
bool bSharedPtr = (ptrGrid ? true : false);
write_pod(p_os, bSharedPtr);
if (bSharedPtr)
{
write_item(p_os, ptrGrid);
write_item(p_os, p_state.getInterpolators());
}
}
// Return "true" on success, "false" on failure
return status && !p_os.fail();
}
};
/// \brief And this is the specialization of GenericReader
//
template <class Stream, class State >
struct GenericReader < Stream, State, StOpt::GridTreeValue, Int2Type<IOTraits<int>::ISEXTERNAL> >
{
inline static bool readIntoPtr(StOpt::GridTreeValue *&ptr, Stream &p_is,
State *, const bool p_processClassId)
{
if (p_processClassId)
{
static const ClassId current(ClassId::makeId<StOpt::GridTreeValue>());
ClassId id(p_is, 1);
current.ensureSameName(id);
}
// Deserialize object data.
bool bSharedPtr ;
read_pod(p_is, &bSharedPtr);
std::shared_ptr<StOpt::SpaceGrid > pgridShared;
CPP11_auto_ptr<std::vector< std::shared_ptr<StOpt::InterpolatorSpectral> > > pinterp;
if (bSharedPtr)
{
CPP11_auto_ptr<StOpt::SpaceGrid> pgrid = read_item<StOpt::SpaceGrid>(p_is);
pgridShared = std::move(pgrid);
pinterp = read_item< std::vector< std::shared_ptr<StOpt::InterpolatorSpectral> > >(p_is);
/// now affect grids to interpolator
for (size_t i = 0 ; i < pinterp->size(); ++i)
(*pinterp)[i]->setGrid(& *pgridShared);
}
if (p_is.fail())
// Return "false" on failure
return false;
//Build the object from the stored data
if (ptr)
{
if (bSharedPtr)
*ptr = StOpt::GridTreeValue(pgridShared, *pinterp);
else
*ptr = StOpt::GridTreeValue();
}
else
{
if (bSharedPtr)
ptr = new StOpt::GridTreeValue(pgridShared, *pinterp);
else
ptr = new StOpt::GridTreeValue();
}
return true;
}
inline static bool process(StOpt::GridTreeValue &s, Stream &is,
State *st, const bool p_processClassId)
{
// Simply convert reading by reference into reading by pointer
StOpt::GridTreeValue *ps = &s;
return readIntoPtr(ps, is, st, p_processClassId);
}
};
}
#endif/* GRIDANDREGRESSEDVALUEGENERS_H */
|
