Skip to content
GitLab
Menu
Projects
Groups
Snippets
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
Toggle navigation
Menu
Open sidebar
amdis
amdis-core
Commits
97813675
Commit
97813675
authored
Sep 03, 2019
by
Praetorius, Simon
Browse files
Added flat matrix and vector used for ElementMatrix and ElementVector
parent
9f35f6d0
Changes
7
Hide whitespace changes
Inline
Side-by-side
src/amdis/common/CMakeLists.txt
View file @
97813675
...
...
@@ -15,6 +15,8 @@ install(FILES
FieldMatVec.hpp
FieldMatVec.inc.hpp
Filesystem.hpp
FlatMatrix.hpp
FlatVector.hpp
ForEach.hpp
HybridSize.hpp
Index.hpp
...
...
src/amdis/common/FlatMatrix.hpp
0 → 100644
View file @
97813675
#pragma once
#include
<type_traits>
#include
<vector>
namespace
AMDiS
{
/// Dense matrix with row-wise storage in flat data vector
template
<
class
T
,
class
Allocator
=
std
::
allocator
<
T
>
>
class
FlatMatrix
:
public
std
::
vector
<
T
,
Allocator
>
{
using
Super
=
std
::
vector
<
T
,
Allocator
>
;
public:
using
value_type
=
T
;
using
size_type
=
typename
Super
::
size_type
;
using
reference
=
typename
Super
::
reference
;
using
const_reference
=
typename
Super
::
const_reference
;
private:
/// Accessor to a row of the matrix.
template
<
class
Vector
>
struct
AccessProxy
{
/// Access the column entry `col` of the row `row_` of this accessor.
/// @{
template
<
class
V
=
Vector
,
std
::
enable_if_t
<
not
std
::
is_const
<
V
>
::
value
,
int
>
=
0
>
reference
operator
[](
size_type
col
)
{
return
(
*
vector_
)[
row_
*
cols_
+
col
];
}
const_reference
operator
[](
size_type
col
)
const
{
return
(
*
vector_
)[
row_
*
cols_
+
col
];
}
// @}
Vector
*
vector_
;
size_type
row_
;
size_type
cols_
;
};
public:
/// Default constructor, creates an empty 0x0 matrix.
FlatMatrix
()
=
default
;
/// Construct a new matrix with rows `r` and columns `c` and all values
/// initialized by copies of value `v`.
FlatMatrix
(
size_type
r
,
size_type
c
,
value_type
v
=
{})
:
Super
(
r
*
c
,
v
)
,
rows_
(
r
)
,
cols_
(
c
)
{}
/// Assign value `s` to all entries of the matrix
FlatMatrix
&
operator
=
(
value_type
s
)
{
Super
::
assign
(
Super
::
size
(),
s
);
return
*
this
;
}
/// Resizes the container to contain r x c elements.
/**
* If the current `rows*cols` is greater than `r*c`, the container is reduced
* to its first `r*c` elements. If the current `rows*cols` is less than `r*c`,
* additional copies of value `v` are appended.
**/
void
resize
(
size_type
r
,
size_type
c
,
value_type
v
=
{})
{
Super
::
resize
(
r
*
c
,
v
);
rows_
=
r
;
cols_
=
c
;
}
/// Return the number of rows of the matrix
size_type
rows
()
const
noexcept
{
return
rows_
;
}
/// Return the number of columns of the matrix
size_type
cols
()
const
noexcept
{
return
cols_
;
}
/// Return the number of entries in the matrix, i.e. `rows*cols`.
using
Super
::
size
;
/// Return accessor to the `row` of the matrix, see \ref AccessProxy
/// @{
AccessProxy
<
Super
>
operator
[](
size_type
row
)
{
return
AccessProxy
<
Super
>
{
static_cast
<
Super
*>
(
this
),
row
,
cols_
};
}
AccessProxy
<
Super
const
>
operator
[](
size_type
row
)
const
{
return
AccessProxy
<
Super
const
>
{
static_cast
<
Super
const
*>
(
this
),
row
,
cols_
};
}
/// @}
private:
size_type
rows_
=
0
;
size_type
cols_
=
0
;
};
}
// end namespace AMDiS
src/amdis/common/FlatVector.hpp
0 → 100644
View file @
97813675
#pragma once
#include
<vector>
namespace
AMDiS
{
/// Flat data vector to be used in assembling as element vector
template
<
class
T
,
class
Allocator
=
std
::
allocator
<
T
>
>
class
FlatVector
:
public
std
::
vector
<
T
,
Allocator
>
{
public:
using
std
::
vector
<
T
,
Allocator
>::
vector
;
/// Assign value `s` to all entries of the vector
FlatVector
&
operator
=
(
T
s
)
{
this
->
assign
(
this
->
size
(),
s
);
return
*
this
;
}
};
}
// end namespace AMDiS
src/amdis/linearalgebra/DOFMatrixBase.hpp
View file @
97813675
...
...
@@ -5,6 +5,7 @@
#include
<dune/common/timer.hh>
#include
<amdis/OperatorList.hpp>
#include
<amdis/common/FlatMatrix.hpp>
#include
<amdis/common/Math.hpp>
#include
<amdis/typetree/MultiIndex.hpp>
#include
<amdis/typetree/TreePath.hpp>
...
...
@@ -43,7 +44,7 @@ namespace AMDiS
using
BaseMatrix
=
typename
Backend
::
BaseMatrix
;
/// The type of the matrix filled on an element with local contributions
using
ElementMatrix
=
Dune
::
Dynamic
Matrix
<
value_type
>
;
using
ElementMatrix
=
Flat
Matrix
<
value_type
>
;
public:
/// Constructor. Stores the shared_ptr to the bases.
...
...
src/amdis/linearalgebra/DOFVectorBase.hpp
View file @
97813675
...
...
@@ -9,6 +9,7 @@
#include
<amdis/DataTransfer.hpp>
#include
<amdis/GridTransferManager.hpp>
#include
<amdis/OperatorList.hpp>
#include
<amdis/common/FlatVector.hpp>
#include
<amdis/common/Math.hpp>
#include
<amdis/common/TypeTraits.hpp>
#include
<amdis/linearalgebra/DOFVectorInterface.hpp>
...
...
@@ -73,7 +74,7 @@ namespace AMDiS
using
BaseVector
=
typename
Backend
::
BaseVector
;
/// The type of the vector filled on an element with local contributions
using
ElementVector
=
Dune
::
Dynamic
Vector
<
value_type
>
;
using
ElementVector
=
Flat
Vector
<
value_type
>
;
/// Defines an interface to transfer the data during grid adaption
using
DataTransfer
=
DataTransferInterface
<
Self
>
;
...
...
test/CMakeLists.txt
View file @
97813675
...
...
@@ -45,6 +45,9 @@ dune_add_test(SOURCES FiniteElementTypeTest.cpp
dune_add_test
(
SOURCES FilesystemTest.cpp
LINK_LIBRARIES amdis
)
dune_add_test
(
SOURCES FlatMatVecTest.cpp
LINK_LIBRARIES amdis
)
dune_add_test
(
SOURCES GlobalIdSetTest.cpp
LINK_LIBRARIES amdis
MPI_RANKS 2
...
...
test/FlatMatVecTest.cpp
0 → 100644
View file @
97813675
#include
<cmath>
#include
<amdis/common/FlatMatrix.hpp>
#include
<amdis/common/FlatVector.hpp>
#include
"Tests.hpp"
using
namespace
AMDiS
;
// -----------------------------------------------------------------------------
void
test0
()
{
using
V
=
FlatVector
<
double
>
;
// create an empty vector
V
a
;
// size of the vector
AMDIS_TEST_EQ
(
a
.
size
(),
0
);
// Resize the vector
a
.
resize
(
3
,
0.0
);
AMDIS_TEST_EQ
(
a
.
size
(),
3
);
AMDIS_TEST_EQ
(
a
[
0
],
0.0
);
AMDIS_TEST_EQ
(
a
[
1
],
0.0
);
AMDIS_TEST_EQ
(
a
[
2
],
0.0
);
// access component
a
[
0
]
=
0.0
;
a
[
1
]
=
0.5
;
a
[
2
]
=
1.0
;
// assign value to all entries
a
=
2.0
;
AMDIS_TEST_EQ
(
a
[
0
],
2.0
);
AMDIS_TEST_EQ
(
a
[
1
],
2.0
);
AMDIS_TEST_EQ
(
a
[
2
],
2.0
);
}
// -----------------------------------------------------------------------------
void
test1
()
{
using
M
=
FlatMatrix
<
double
>
;
// create an empty matrix
M
m
;
AMDIS_TEST_EQ
(
m
.
size
(),
0
);
AMDIS_TEST_EQ
(
m
.
rows
(),
0
);
AMDIS_TEST_EQ
(
m
.
cols
(),
0
);
// resize the matrix
m
.
resize
(
2
,
3
,
0.0
);
AMDIS_TEST_EQ
(
m
.
size
(),
2
*
3
);
AMDIS_TEST_EQ
(
m
.
rows
(),
2
);
AMDIS_TEST_EQ
(
m
.
cols
(),
3
);
typename
M
::
difference_type
s
=
std
::
distance
(
m
.
begin
(),
m
.
end
());
AMDIS_TEST_EQ
(
s
,
2
*
3
);
// test element access
AMDIS_TEST_EQ
(
m
[
0
][
0
],
0.0
);
AMDIS_TEST_EQ
(
m
[
1
][
2
],
0.0
);
// test assignment of value
m
=
1.0
;
AMDIS_TEST_EQ
(
m
[
0
][
0
],
1.0
);
AMDIS_TEST_EQ
(
m
[
1
][
2
],
1.0
);
for
(
std
::
size_t
i
=
0
;
i
<
m
.
rows
();
++
i
)
for
(
std
::
size_t
j
=
0
;
j
<
m
.
cols
();
++
j
)
m
[
i
][
j
]
=
2.0
;
// access matrix entries
for
(
std
::
size_t
i
=
0
;
i
<
m
.
rows
();
++
i
)
for
(
std
::
size_t
j
=
0
;
j
<
m
.
cols
();
++
j
)
AMDIS_TEST_EQ
(
m
[
i
][
j
],
2.0
);
// test iterators
for
(
auto
&
mij
:
m
)
mij
=
3.0
;
for
(
auto
const
&
mij
:
m
)
AMDIS_TEST_EQ
(
mij
,
3.0
);
// test data array
m
=
4.0
;
double
const
*
data
=
m
.
data
();
for
(
std
::
size_t
i
=
0
;
i
<
m
.
size
();
++
i
)
AMDIS_TEST_EQ
(
data
[
i
],
4.0
);
}
int
main
()
{
test0
();
test1
();
return
report_errors
();
}
Write
Preview
Supports
Markdown
0%
Try again
or
attach a new file
.
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment