ASL  0.1.7
Advanced Simulation Library
aslDataWithGhostNodes.h
Go to the documentation of this file.
1 /*
2  * Advanced Simulation Library <http://asl.org.il>
3  *
4  * Copyright 2015 Avtech Scientific <http://avtechscientific.com>
5  *
6  *
7  * This file is part of Advanced Simulation Library (ASL).
8  *
9  * ASL is free software: you can redistribute it and/or modify it
10  * under the terms of the GNU Affero General Public License as
11  * published by the Free Software Foundation, version 3 of the License.
12  *
13  * ASL is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  * GNU Affero General Public License for more details.
17  *
18  * You should have received a copy of the GNU Affero General Public License
19  * along with ASL. If not, see <http://www.gnu.org/licenses/>.
20  *
21  */
22 
23 
24 #ifndef ASLDATAWITHGHOSTNODES_H
25 #define ASLDATAWITHGHOSTNODES_H
26 
27 #include "aslDataWrapper.h"
28 #include <iostream>
29 #include <fstream>
30 
31 using namespace std;
32 
33 namespace asl
34 {
35 
38  class AbstractDataWithGhostNodes: public AbstractData
39  {
40  protected:
41  Block internalBlock;
43  unsigned int ghostBorder;
45  bool bordersDataAcces;
47  inline AbstractDataWithGhostNodes(const Block & b, int nGN = 1, bool bDA = true);
48  public:
49  inline int getSubContainerOffset() const;
50  inline unsigned int getSubContainerSize() const;
51  inline const Block & getInternalBlock() const;
52  inline const unsigned int getGhostBorder() const;
54  };
55 
57  template <typename V> class DataWithGhostNodes: public AbstractDataWithGhostNodes
58  {
59  private:
60  DataWrapper<V> dw;
61  public:
63  inline DataWithGhostNodes(const Block & b, int nGN = 1, bool bDA = true);
64  inline DataWithGhostNodes(DataWrapper<V> & d, int nGN = 1);
67  virtual const acl::VectorOfElementsData getDContainer() const;
68  inline void setContainer(const V & cont);
69  inline V & getContainer();
70  };
71 
74 // typedef DataWithGhostNodes<vector<MemElement> > DataWithGhostNodesMem;
75 
76  typedef shared_ptr<DataWithGhostNodesACL> SPDataWithGhostNodesACL;
77  typedef shared_ptr<DataWithGhostNodesACLData> SPDataWithGhostNodesACLData;
78  typedef shared_ptr<AbstractDataWithGhostNodes> SPAbstractDataWithGhostNodes;
79 
83 
87 
88  template <typename V> inline std::shared_ptr<DataWithGhostNodes<V>>
89  resizeGhostNodes(std::shared_ptr<DataWithGhostNodes<V>> d, unsigned int newGN);
90 
91 //--------------------------- Implementation --------------------------
92 
93  AbstractDataWithGhostNodes::AbstractDataWithGhostNodes()
94  {
95  }
96 
97  AbstractDataWithGhostNodes::AbstractDataWithGhostNodes(const Block & b, int nGN,bool bDA):
98  AbstractData (offset(b, nGN)),
99  internalBlock(b),
100  ghostBorder(nGN),
101  bordersDataAcces(bDA)
102  {
103  }
104 
105 
106  template <typename V> DataWithGhostNodes<V>::DataWithGhostNodes()
107  {
108  }
109 
110  template <typename V> DataWithGhostNodes<V>::DataWithGhostNodes(const Block & b, int nGN,bool bDA):
111  AbstractDataWithGhostNodes (b,nGN,bDA),
112  dw(offset(b, nGN))
113  {
114  }
115 
116  template <typename V> DataWithGhostNodes<V>::DataWithGhostNodes(DataWrapper<V> & d, int nGN):
117  AbstractDataWithGhostNodes (offset(d.getBlock(), -nGN), nGN, true),
118  dw(d)
119  {
120  }
121 
123  {
124  return internalBlock;
125  }
126 
127  const unsigned int AbstractDataWithGhostNodes::getGhostBorder() const
128  {
129  return ghostBorder;
130  }
131 
133  {
134  Block b(offset(internalBlock, ghostBorder));
135  int nD(b.getSize().getSize());
136  return b.c2i(AVec<int>(nD,ghostBorder));
137  }
138 
139  inline unsigned int AbstractDataWithGhostNodes::getSubContainerSize() const
140  {
141  const Block b(offset(internalBlock, ghostBorder));
142  int nD(b.getSize().getSize());
143  int s(b.c2i(b.getSize()-AVec<int>(nD,ghostBorder+1)) - b.c2i(AVec<int>(nD,ghostBorder))+1);
144  return s>0?s:0;
145  }
146 
147  template <class V > inline void DataWithGhostNodes<V>::setContainer(const V & cont)
148  {
149  dw.setContainer (cont);
150  }
151 
152  template <class V > inline V & DataWithGhostNodes<V>::getContainer()
153  {
154  return dw.getContainer();
155  }
156 
157  template <typename V> inline std::shared_ptr<DataWithGhostNodes<V>>
158  resizeGhostNodes(std::shared_ptr<DataWithGhostNodes<V>> d, unsigned int newGN)
159  {
160  Block b(offset(d->getBlock(),newGN));
161  std::shared_ptr<DataWithGhostNodes<V>>
162  nd(new DataWithGhostNodes<V>(b, 0));
163  nd->setContainer(d->getContainer());
164  return nd;
165  }
166 
167 
168 } //asl
169 
170 #endif // ASLDATAWITHGHOSTNODES_H
171 
asl::DataWithGhostNodesACL
DataWithGhostNodes< acl::VectorOfElements > DataWithGhostNodesACL
Definition: aslGenerators.h:48
asl::DataWrapper
Class defines a folding rule into a 1D/2D/3D bulk.
Definition: aslDataWrapper.h:77
asl::AbstractDataWithGhostNodes::AbstractDataWithGhostNodes
AbstractDataWithGhostNodes(const Block &b, int nGN=1, bool bDA=true)
asl::AbstractDataWithGhostNodes::getInternalBlock
const Block & getInternalBlock() const
aslDataWrapper.h
acl::VectorOfElementsData
The class represents several ElementData.
Definition: aclVectorOfElementsDef.h:57
asl::resizeGhostNodes
std::shared_ptr< DataWithGhostNodes< V > > resizeGhostNodes(std::shared_ptr< DataWithGhostNodes< V >> d, unsigned int newGN)
Definition: aslDataWithGhostNodes.h:158
asl::SPDataWithGhostNodesACLData
std::shared_ptr< DataWithGhostNodesACLData > SPDataWithGhostNodesACLData
Definition: aslGenerators.h:47
asl::DataWithGhostNodes::DataWithGhostNodes
DataWithGhostNodes(const Block &b, int nGN=1, bool bDA=true)
asl::AbstractDataWithGhostNodes::getGhostBorder
const unsigned int getGhostBorder() const
asl::DataWithGhostNodes::setContainer
void setContainer(const V &cont)
asl::nD
const unsigned int nD(const Block &b)
Definition: aslBlocks.h:220
asl::DataWithGhostNodesACLData
DataWithGhostNodes< acl::VectorOfElementsData > DataWithGhostNodesACLData
Definition: aslGenerators.h:45
asl::AbstractDataWithGhostNodes::getInternalBlock
const Block & getInternalBlock() const
Definition: aslDataWithGhostNodes.h:122
asl::DataWithGhostNodes
Definition: aslDataWithGhostNodes.h:58
acl::VectorOfElements
The class represents several Element.
Definition: aclVectorOfElementsDef.h:92
asl::Block
Definition: aslBlocks.h:57
asl::offset
const Block offset(const Block &bl, int a=1)
asl::AbstractDataWithGhostNodes::ghostBorder
unsigned int ghostBorder
num of cells within the border
Definition: aslDataWithGhostNodes.h:43
asl::AbstractDataWithGhostNodes::getSubContainerOffset
int getSubContainerOffset() const
asl::DataWithGhostNodes::getContainer
V & getContainer()
asl::DataWithGhostNodes::getSubContainer
virtual acl::VectorOfElements getSubContainer()
asl::clone
SPDataWithGhostNodesACLData clone(SPDataWithGhostNodesACLData d, unsigned int n)
asl::DataWithGhostNodes::getDContainer
virtual const acl::VectorOfElementsData getDContainer() const
asl::AbstractDataWithGhostNodes::getSubContainer
virtual acl::VectorOfElements getSubContainer()=0
asl::DataWithGhostNodes::DataWithGhostNodes
DataWithGhostNodes()
asl::DataWithGhostNodes::getEContainer
virtual const acl::VectorOfElements getEContainer()
asl::AbstractDataWithGhostNodes::internalBlock
Block internalBlock
Definition: aslDataWithGhostNodes.h:41
asl::AbstractDataWithGhostNodes::getSubContainerSize
unsigned int getSubContainerSize() const
asl::DataWithGhostNodes::DataWithGhostNodes
DataWithGhostNodes(DataWrapper< V > &d, int nGN=1)
asl::AbstractDataWithGhostNodes::AbstractDataWithGhostNodes
AbstractDataWithGhostNodes()
asl::SPDataWithGhostNodesACL
std::shared_ptr< DataWithGhostNodesACL > SPDataWithGhostNodesACL
Definition: aslGenerators.h:49
asl::DataWithGhostNodes::getContainer
V & getContainer()
Definition: aslDataWithGhostNodes.h:152
asl::AbstractDataWithGhostNodes
Definition: aslDataWithGhostNodes.h:39
asl
Advanced Simulation Library.
Definition: aslDataInc.h:31
asl::SPAbstractDataWithGhostNodes
std::shared_ptr< AbstractDataWithGhostNodes > SPAbstractDataWithGhostNodes
Definition: aslGenerators.h:50