Page Menu
Home
c4science
Search
Configure Global Search
Log In
Files
F84975718
grid.hh
No One
Temporary
Actions
Download File
Edit File
Delete File
View Transforms
Subscribe
Mute Notifications
Award Token
Subscribers
None
File Metadata
Details
File Info
Storage
Attached
Created
Wed, Sep 25, 22:16
Size
7 KB
Mime Type
text/x-c++
Expires
Fri, Sep 27, 22:16 (2 d)
Engine
blob
Format
Raw Data
Handle
21113303
Attached To
rTAMAAS tamaas
grid.hh
View Options
/**
*
* @author Lucas Frérot <lucas.frerot@epfl.ch>
*
* @section LICENSE
*
* Copyright (©) 2016 EPFL (Ecole Polytechnique Fédérale de
* Lausanne) Laboratory (LSMS - Laboratoire de Simulation en Mécanique des
* Solides)
*
* Tamaas is free software: you can redistribute it and/or modify it under the
* terms of the GNU Lesser General Public License as published by the Free
* Software Foundation, either version 3 of the License, or (at your option) any
* later version.
*
* Tamaas is distributed in the hope that it will be useful, but WITHOUT ANY
* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
* A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
* details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Tamaas. If not, see <http://www.gnu.org/licenses/>.
*
*/
/* -------------------------------------------------------------------------- */
#ifndef __GRID_HH__
#define __GRID_HH__
/* -------------------------------------------------------------------------- */
#include "tamaas.hh"
#include "grid_base.hh"
#include <array>
#include <vector>
#include <numeric>
#include <utility>
/* -------------------------------------------------------------------------- */
__BEGIN_TAMAAS__
/**
* @brief Multi-dimensional & multi-component array class
*
* This class is a container for multi-component data stored on a multi-
* dimensional grid.
*
* The access function is the parenthesis operator. For a grid of dimension d,
* the operator takes d+1 arguments: the first d arguments are the position on
* the grid and the last one is the component of the stored data.
*
* It is also possible to use the access operator with only one argument, it is
* then considering the grid as a flat array, accessing the given cell of the
* array.
*/
template
<
typename
T
,
UInt
dim
>
class
Grid
:
public
GridBase
<
T
>
{
public
:
/* -------------------------------------------------------------------------- */
/* Types */
/* -------------------------------------------------------------------------- */
typedef
T
value_type
;
static
constexpr
UInt
dimension
=
dim
;
/* -------------------------------------------------------------------------- */
/* Constructors */
/* -------------------------------------------------------------------------- */
public
:
/// Constructor by default (empty array)
Grid
();
/// Constructor
Grid
(
const
std
::
array
<
UInt
,
dim
>
&
n
,
UInt
nb_components
);
/// Constructor with vectors
Grid
(
const
std
::
vector
<
UInt
>
&
n
,
UInt
nb_components
);
/// Constructor with initializer list
Grid
(
const
std
::
initializer_list
<
UInt
>
&
n
,
UInt
nb_components
);
/// Copy constructor
Grid
(
const
Grid
&
o
);
/// Move constructor (transfers data ownership)
Grid
(
Grid
&&
o
);
private
:
/// Init from standard container
template
<
typename
Container
>
void
init
(
const
Container
&
n
,
UInt
nb_components
);
public
:
/* -------------------------------------------------------------------------- */
/* Common operations */
/* -------------------------------------------------------------------------- */
/// Resize array
void
resize
(
const
std
::
array
<
UInt
,
dim
>
&
n
);
/// Compute size
inline
UInt
computeSize
()
const
;
/// Compute strides
virtual
void
computeStrides
();
/// Print
virtual
void
printself
(
std
::
ostream
&
str
)
const
;
/// Get sizes
const
std
::
array
<
UInt
,
dim
>
&
sizes
()
const
{
return
n
;}
/// Get strides
const
std
::
array
<
UInt
,
dim
+
1
>
&
getStrides
()
const
{
return
this
->
strides
;}
/* -------------------------------------------------------------------------- */
/* Access operators */
/* -------------------------------------------------------------------------- */
/// Variadic access operator (non-const)
template
<
typename
...
T1
>
inline
T
&
operator
()(
T1
...
args
);
/// Variadic access operator
template
<
typename
...
T1
>
inline
const
T
&
operator
()(
T1
...
args
)
const
;
/// Tuple index access operator
inline
T
&
operator
()(
std
::
array
<
UInt
,
dim
+
1
>
tuple
);
inline
const
T
&
operator
()(
std
::
array
<
UInt
,
dim
+
1
>
tuple
)
const
;
private
:
/// Unpacking the arguments of variadic ()
template
<
typename
...
T1
>
inline
UInt
unpackOffset
(
UInt
offset
,
UInt
index_pos
,
UInt
index
,
T1
...
rest
)
const
;
/// End case for recursion
template
<
typename
...
T1
>
inline
UInt
unpackOffset
(
UInt
offset
,
UInt
index_pos
,
UInt
index
)
const
;
/// Computing offset for a tuple index
inline
UInt
computeOffset
(
std
::
array
<
UInt
,
dim
+
1
>
tuple
)
const
;
/* -------------------------------------------------------------------------- */
/* Arithmetic operators */
/* -------------------------------------------------------------------------- */
public
:
#define GRID_VEC_OPERATOR(op) \
template <typename T1> \
Grid & operator op(const Grid<T1, dim> & other) \
GRID_VEC_OPERATOR
(
+=
);
GRID_VEC_OPERATOR
(
*=
);
GRID_VEC_OPERATOR
(
-=
);
GRID_VEC_OPERATOR
(
/=
);
#undef GRID_VEC_OPERATOR
#define GRID_SCALAR_OPERATOR(op) \
Grid & operator op(const T & e) \
GRID_SCALAR_OPERATOR
(
+=
);
GRID_SCALAR_OPERATOR
(
*=
);
GRID_SCALAR_OPERATOR
(
-=
);
GRID_SCALAR_OPERATOR
(
/=
);
GRID_SCALAR_OPERATOR
(
=
);
#undef GRID_SCALAR_OPERATOR
/* -------------------------------------------------------------------------- */
/* Move/Copy operators */
/* -------------------------------------------------------------------------- */
// = operator
Grid
&
operator
=
(
const
Grid
&
other
);
// = operator (not const input, otherwise gcc is confused)
Grid
&
operator
=
(
Grid
&
other
);
// = operator (move)
Grid
&
operator
=
(
Grid
&&
other
);
// Copy data from another grid
template
<
typename
T1
>
void
copy
(
const
Grid
<
T1
,
dim
>
&
other
);
// Move data from another grid
template
<
typename
T1
>
void
move
(
Grid
<
T1
,
dim
>
&&
other
);
/* -------------------------------------------------------------------------- */
/* Iterators */
/* -------------------------------------------------------------------------- */
public
:
using
iterator
=
typename
GridBase
<
T
>::
iterator
;
using
const_iterator
=
typename
GridBase
<
T
>::
const_iterator
;
public
:
iterator
begin
(
UInt
n
=
1
)
override
{
return
iterator
(
this
->
getInternalData
()
+
this
->
offset
,
0
,
n
);
}
iterator
end
(
UInt
n
=
1
)
override
{
return
iterator
(
this
->
getInternalData
()
+
this
->
offset
,
this
->
dataSize
(),
n
);
}
const_iterator
begin
(
UInt
n
=
1
)
const
override
{
return
const_iterator
(
this
->
getInternalData
()
+
this
->
offset
,
0
,
n
);
}
const_iterator
end
(
UInt
n
=
1
)
const
override
{
return
const_iterator
(
this
->
getInternalData
()
+
this
->
offset
,
this
->
dataSize
(),
n
);
}
/* -------------------------------------------------------------------------- */
/* Member variables */
/* -------------------------------------------------------------------------- */
protected
:
std
::
array
<
UInt
,
dim
>
n
;
std
::
array
<
UInt
,
dim
+
1
>
strides
;
};
__END_TAMAAS__
/* -------------------------------------------------------------------------- */
/* Inline/template function definitions */
/* -------------------------------------------------------------------------- */
#include "grid_tmpl.hh"
/* -------------------------------------------------------------------------- */
#endif
// __GRID_HH__
Event Timeline
Log In to Comment