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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
|
#ifndef WARPX_INTERVALSPARSER_H_
#define WARPX_INTERVALSPARSER_H_
#include <limits>
#include <string>
#include <vector>
/**
* \brief This class is a parser for slices of the form i:j:k where i, j and k are integers
* representing respectively the starting point, the stopping point and the period.
*/
class SliceParser
{
public:
/**
* \brief Constructor of the SliceParser class.
*
* @param[in] instr an input string of the form "i:j:k", "i:j" or "k" where i, j and k are
* integers representing respectively the starting point, the stopping point and the period.
* Any of these integers may be omitted in which case it will be equal to their default value
* (0 for the starting point, std::numeric_limits<int>::max() for the stopping point and 1 for
* the period). For example SliceParser(":1000:") is equivalent to SliceParser("0:1000:1").
*/
SliceParser (const std::string& instr, bool isBTD=false);
/**
* \brief A method that returns true if the input integer is contained in the slice. (e.g. if
* the list is initialized with "300:500:100", this method returns true if and only if n is
* 300, 400 or 500). If the period is negative or 0, the function always returns false.
*
* @param[in] n the input integer
*/
bool contains (const int n) const;
/**
* \brief A method that returns the smallest integer strictly greater than n such that
* contains(n) is true. Returns std::numeric_limits<int>::max() if there is no such integer.
*
* @param[in] n the input integer
*/
int nextContains (const int n) const;
/**
* \brief A method that returns the greatest integer strictly smaller than n such that
* contains(n) is true. Returns 0 if there is no such integer.
*
* @param[in] n the input integer
*/
int previousContains (const int n) const;
/**
* \brief A method that returns the slice period.
*
*/
int getPeriod () const;
/**
* \brief A method that returns the slice start.
*
*/
int getStart () const;
/**
* \brief A method that returns the slice stop.
*
*/
int getStop () const;
/**
* @brief A method that returns the number of integers contained by the slice.
*
*/
int numContained() const;
private:
bool m_isBTD = false;
int m_start = 0;
int m_stop = std::numeric_limits<int>::max();
int m_period = 1;
std::string m_separator = ":";
};
/**
* \brief This class is a parser for multiple slices of the form x,y,z,... where x, y and z are
* slices of the form i:j:k, as defined in the SliceParser class. This class contains a vector of
* SliceParsers.
*/
class IntervalsParser
{
public:
/**
* \brief Default constructor of the IntervalsParser class.
*/
IntervalsParser () = default;
/**
* \brief Constructor of the IntervalsParser class.
*
* @param[in] instr_vec an input vector string, which when concatenated is of the form
* "x,y,z,...". This will call the constructor of SliceParser using x, y and z as input
* arguments.
*/
IntervalsParser (const std::vector<std::string>& instr_vec);
/**
* \brief A method that returns true if the input integer is contained in any of the slices
* contained by the IntervalsParser.
*
* @param[in] n the input integer
*/
bool contains (const int n) const;
/**
* \brief A method that returns the smallest integer strictly greater than n such that
* contains(n) is true. Returns std::numeric_limits<int>::max() if there is no such integer.
*
* @param[in] n the input integer
*/
int nextContains (const int n) const;
/**
* \brief A method that returns the greatest integer strictly smaller than n such that
* contains(n) is true. Returns 0 if there is no such integer.
*
* @param[in] n the input integer
*/
int previousContains (const int n) const;
/**
* \brief A method that returns the greatest integer smaller than or equal to n such that
* contains(n) is true. Returns 0 if there is no such integer.
*
* @param[in] n the input integer
*/
int previousContainsInclusive (const int n) const;
/**
* \brief A method the local period (in timesteps) of the IntervalsParser at timestep n.
* The period is defined by nextContains(n) - previousContainsInclusive(n)
*
* @param[in] n the input integer
*/
int localPeriod (const int n) const;
/**
* \brief A method that returns true if any of the slices contained by the IntervalsParser
* has a strictly positive period.
*/
bool isActivated () const;
private:
std::vector<SliceParser> m_slices;
std::string m_separator = ",";
bool m_activated = false;
};
/**
* \brief This class is a parser for multiple slices of the form x,y,z,... where x, y and z are
* slices of the form i:j:k, as defined in the SliceParser class. This class contains a vector of
* SliceParsers. The supported function set differs from the IntervalsParser
*/
class BTDIntervalsParser
{
public:
/**
* \brief Default constructor of the BTDIntervalsParser class.
*/
BTDIntervalsParser () = default;
/**
* \brief Constructor of the BTDIntervalsParser class.
*
* @param[in] instr_vec an input vector string, which when concatenated is of the form
* "x,y,z,...". This will call the constructor of SliceParser using x, y and z as input
* arguments.
*/
BTDIntervalsParser (const std::vector<std::string>& instr_vec);
/**
* @brief Return the total number of unique labframe snapshots
*/
int NumSnapshots ();
/**
* @brief Return the iteration number stored at index i_buffer
*
* @param i_buffer buffer or iteration index, between 0 and NumSnapshots
*/
int GetBTDIteration(int i_buffer);
/**
* \brief A method that returns true if any of the slices contained by the IntervalsParser
* has a strictly positive period.
*/
bool isActivated () const;
private:
std::vector<int> m_btd_iterations;
std::vector<SliceParser> m_slices;
std::vector<int> m_slice_starting_i_buffer;
int m_n_snapshots;
static constexpr char m_separator = ',';
bool m_activated = false;
};
#endif // WARPX_INTERVALSPARSER_H_
|
