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
|
/* This file is part of the OpenLB library
*
* Copyright (C) 2017 Adrian Kummerlaender
* E-mail contact: info@openlb.net
* The most recent release of OpenLB can be downloaded at
* <http://www.openlb.net/>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public
* License along with this program; if not, write to the Free
* Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifndef BLOCK_INDICATOR_F_3D_H
#define BLOCK_INDICATOR_F_3D_H
#include "blockIndicatorBaseF3D.h"
#include "geometry/blockGeometryView3D.h"
#include "functors/analytical/indicator/smoothIndicatorBaseF3D.h"
namespace olb {
/// BlockIndicatorF3D from IndicatorF3D
template <typename T>
class BlockIndicatorFfromIndicatorF3D : public BlockIndicatorF3D<T> {
protected:
IndicatorF3D<T>& _indicatorF;
public:
/**
* \param indicatorF Indicator to be reduced to lattice space
* \param blockGeometry Block geometry structure to be used for conversion
* between lattice and physical coordinates.
**/
BlockIndicatorFfromIndicatorF3D(IndicatorF3D<T>& indicatorF,
BlockGeometryStructure3D<T>& blockGeometry);
using BlockIndicatorF3D<T>::operator();
bool operator() (bool output[], const int input[]) override;
/// Returns min lattice position of the indicated domain's bounding box
Vector<int,3> getMin() override;
/// Returns max lattice position of the indicated domain's bounding box
Vector<int,3> getMax() override;
};
/// BlockIndicatorF3D from SmoothIndicatorF3D
template <typename T, bool HLBM>
class BlockIndicatorFfromSmoothIndicatorF3D : public BlockIndicatorF3D<T> {
protected:
SmoothIndicatorF3D<T,T,HLBM>& _indicatorF;
public:
/**
* \param indicatorF Smooth indicator to be reduced to lattice space
* \param blockGeometry Block geometry structure to be used for conversion
* between lattice and physical coordinates.
**/
BlockIndicatorFfromSmoothIndicatorF3D(SmoothIndicatorF3D<T,T,HLBM>& indicatorF,
BlockGeometryStructure3D<T>& blockGeometry);
using BlockIndicatorF3D<T>::operator();
bool operator() (bool output[], const int input[]) override;
/// Returns min lattice position of the indicated domain's bounding box
Vector<int,3> getMin() override;
/// Returns max lattice position of the indicated domain's bounding box
Vector<int,3> getMax() override;
};
/// Block indicator functor from material numbers
template <typename T>
class BlockIndicatorMaterial3D : public BlockIndicatorF3D<T> {
protected:
const std::vector<int> _materials;
public:
/**
* \param blockGeometry Block geometry structure to be queried
* \param materials Material number vector
**/
BlockIndicatorMaterial3D(BlockGeometryStructure3D<T>& blockGeometry,
std::vector<int> materials);
/**
* \param blockGeometry Block geometry structure to be queried
* \param materials Material number list
**/
BlockIndicatorMaterial3D(BlockGeometryStructure3D<T>& blockGeometry,
std::list<int> materials);
/**
* \param blockGeometry Block geometry structure to be queried
* \param material Material number
**/
BlockIndicatorMaterial3D(BlockGeometryStructure3D<T>& blockGeometry,
int material);
using BlockIndicatorF3D<T>::operator();
bool operator() (bool output[], const int input[]) override;
/// Returns true iff indicated domain subset is empty
bool isEmpty() override;
/// Returns min lattice position of the indicated domain's bounding box
Vector<int,3> getMin() override;
/// Returns max lattice position of the indicated domain's bounding box
Vector<int,3> getMax() override;
};
/// Block indicator identity
template <typename T>
class BlockIndicatorIdentity3D : public BlockIndicatorF3D<T> {
protected:
BlockIndicatorF3D<T>& _indicatorF;
public:
/**
* \param indicatorF Block indicator to be proxied
**/
BlockIndicatorIdentity3D(BlockIndicatorF3D<T>& indicatorF);
using BlockIndicatorF3D<T>::operator();
bool operator() (bool output[], const int input[]) override;
/// Returns min lattice position of the indicated domain's bounding box
Vector<int,3> getMin() override;
/// Returns max lattice position of the indicated domain's bounding box
Vector<int,3> getMax() override;
};
} // namespace olb
#endif
|
