Line data Source code
1 : /*
2 : * Copyright (c) 2007-2015: Sebastian Reiter
3 : * Author: Sebastian Reiter
4 : *
5 : * This file is part of UG4.
6 : *
7 : * UG4 is free software: you can redistribute it and/or modify it under the
8 : * terms of the GNU Lesser General Public License version 3 (as published by the
9 : * Free Software Foundation) with the following additional attribution
10 : * requirements (according to LGPL/GPL v3 §7):
11 : *
12 : * (1) The following notice must be displayed in the Appropriate Legal Notices
13 : * of covered and combined works: "Based on UG4 (www.ug4.org/license)".
14 : *
15 : * (2) The following notice must be displayed at a prominent place in the
16 : * terminal output of covered works: "Based on UG4 (www.ug4.org/license)".
17 : *
18 : * (3) The following bibliography is recommended for citation and must be
19 : * preserved in all covered files:
20 : * "Reiter, S., Vogel, A., Heppner, I., Rupp, M., and Wittum, G. A massively
21 : * parallel geometric multigrid solver on hierarchically distributed grids.
22 : * Computing and visualization in science 16, 4 (2013), 151-164"
23 : * "Vogel, A., Reiter, S., Rupp, M., Nägel, A., and Wittum, G. UG4 -- a novel
24 : * flexible software system for simulating pde based models on high performance
25 : * computers. Computing and visualization in science 16, 4 (2013), 165-179"
26 : *
27 : * This program is distributed in the hope that it will be useful,
28 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
29 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
30 : * GNU Lesser General Public License for more details.
31 : */
32 :
33 : #include "collision_edges_node.h"
34 :
35 : namespace ug{
36 : namespace node_tree
37 : {
38 :
39 : ////////////////////////////////////////////////////////////////////////
40 0 : SPCollisionEdgesNode CollisionEdgesNode::create()
41 : {
42 0 : CollisionEdgesNode* node = new CollisionEdgesNode;
43 0 : node->m_objectCode = OC_COLLISION_EDGES_NODE;
44 0 : return SPCollisionEdgesNode(node);
45 : }
46 :
47 : ////////////////////////////////////////////////////////////////////////
48 0 : CollisionEdgesNode::CollisionEdgesNode()
49 : {
50 0 : m_bEdgeIDsSupplied = false;
51 0 : }
52 :
53 : ////////////////////////////////////////////////////////////////////////
54 0 : CollisionEdgesNode::~CollisionEdgesNode()
55 : {
56 0 : }
57 :
58 : ////////////////////////////////////////////////////////////////////////
59 0 : void CollisionEdgesNode::add_edge(int ind1, int ind2)
60 : {
61 0 : if(m_bEdgeIDsSupplied)
62 : {
63 0 : add_edge(ind1, ind2, CollisionElementID());
64 : }
65 : else
66 : {
67 0 : m_vEdges.push_back(ind1);
68 0 : m_vEdges.push_back(ind2);
69 : }
70 0 : }
71 :
72 : ////////////////////////////////////////////////////////////////////////
73 0 : void CollisionEdgesNode::
74 : add_edge(int ind1, int ind2, CollisionElementID edgeID)
75 : {
76 0 : if(!m_bEdgeIDsSupplied)
77 : {
78 0 : m_bEdgeIDsSupplied = true;
79 0 : if(num_edges() > 0)
80 0 : m_vEdgeIDs.resize(num_edges());
81 : }
82 :
83 0 : m_vEdges.push_back(ind1);
84 0 : m_vEdges.push_back(ind2);
85 0 : m_vEdgeIDs.push_back(edgeID);
86 0 : }
87 :
88 : ////////////////////////////////////////////////////////////////////////
89 0 : void CollisionEdgesNode::add_edges(int* pIndices, int numEdges)
90 : {
91 0 : int maxEdge = m_vEdges.size() / 2;
92 :
93 0 : if(m_bEdgeIDsSupplied)
94 0 : m_vEdgeIDs.resize(maxEdge + numEdges);
95 :
96 0 : int startEdge = m_vEdges.size();
97 : // resize m_vEdges
98 0 : m_vEdges.resize(m_vEdges.size() + numEdges * 2);
99 :
100 : int upperBorder = numEdges*2;
101 0 : for(int i = 0; i < upperBorder; ++i)
102 0 : m_vEdges[startEdge + i] = pIndices[i];
103 0 : }
104 :
105 : ////////////////////////////////////////////////////////////////////////
106 0 : void CollisionEdgesNode::
107 : add_edges(int* pIndices, CollisionElementID* pEdgeIDs, int numEdges)
108 : {
109 0 : int maxEdge = m_vEdges.size() / 2;
110 :
111 0 : if(m_bEdgeIDsSupplied)
112 0 : m_vEdgeIDs.resize(maxEdge + numEdges);
113 : else
114 : {
115 0 : m_vEdgeIDs.resize(maxEdge + numEdges);
116 0 : m_bEdgeIDsSupplied = true;
117 : }
118 :
119 :
120 : // fill the ids
121 : {
122 0 : for(int i = 0; i <numEdges; ++i)
123 0 : m_vEdgeIDs[maxEdge + i] = pEdgeIDs[i];
124 : }
125 :
126 0 : int startEdge = m_vEdges.size();
127 : // resize m_vEdges
128 0 : m_vEdges.resize(m_vEdges.size() + numEdges * 2);
129 :
130 : // fill m_vEdges
131 : {
132 : int upperBorder = numEdges*2;
133 0 : for(int i = 0; i < upperBorder; ++i)
134 0 : m_vEdges[startEdge + i] = pIndices[i];
135 : }
136 :
137 0 : }
138 :
139 : ////////////////////////////////////////////////////////////////////////
140 0 : int CollisionEdgesNode::num_edges() const
141 : {
142 0 : return(m_vEdges.size() / 2);
143 : }
144 :
145 : ////////////////////////////////////////////////////////////////////////
146 0 : void CollisionEdgesNode::get_edge(int index, int& ind1Out, int& ind2Out) const
147 : {
148 0 : index *= 2;
149 0 : ind1Out = m_vEdges[index++];
150 0 : ind2Out = m_vEdges[index];
151 0 : }
152 :
153 : ////////////////////////////////////////////////////////////////////////
154 0 : const int* CollisionEdgesNode::get_edges() const
155 : {
156 0 : return &m_vEdges.front();
157 : }
158 :
159 : ////////////////////////////////////////////////////////////////////////
160 0 : void CollisionEdgesNode::
161 : set_edge_id(int edgeIndex, CollisionElementID edgeID)
162 : {
163 0 : if(!m_bEdgeIDsSupplied)
164 : {
165 0 : m_bEdgeIDsSupplied = true;
166 0 : if(num_edges() > 0)
167 0 : m_vEdgeIDs.resize(num_edges());
168 : }
169 :
170 0 : m_vEdgeIDs[edgeIndex] = edgeID;
171 0 : }
172 :
173 : ////////////////////////////////////////////////////////////////////////
174 0 : CollisionElementID CollisionEdgesNode::
175 : get_edge_id(int edgeIndex)
176 : {
177 0 : if(m_bEdgeIDsSupplied)
178 0 : return m_vEdgeIDs[edgeIndex];
179 :
180 0 : return CollisionElementID();
181 : }
182 :
183 : }// end of namespace node_tree
184 : }// end of namespace ug
185 :
|
