xc
PtrArray3dBase.h
1 //----------------------------------------------------------------------------
2 // XC program; finite element analysis code
3 // for structural analysis and design.
4 //
5 // Copyright (C) Luis Claudio Pérez Tato
6 //
7 // This program derives from OpenSees <http://opensees.berkeley.edu>
8 // developed by the «Pacific earthquake engineering research center».
9 //
10 // Except for the restrictions that may arise from the copyright
11 // of the original program (see copyright_opensees.txt)
12 // XC is free software: you can redistribute it and/or modify
13 // it under the terms of the GNU General Public License as published by
14 // the Free Software Foundation, either version 3 of the License, or
15 // (at your option) any later version.
16 //
17 // This software is distributed in the hope that it will be useful, but
18 // WITHOUT ANY WARRANTY; without even the implied warranty of
19 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 // GNU General Public License for more details.
21 //
22 //
23 // You should have received a copy of the GNU General Public License
24 // along with this program.
25 // If not, see <http://www.gnu.org/licenses/>.
26 //----------------------------------------------------------------------------
27 //PtrArray3dBase.h
28 //Pointers in an array of matrices
29 
30 #ifndef PTRARRAY3DBASE_H
31 #define PTRARRAY3DBASE_H
32 
33 #include "xc_utils/src/kernel/CommandEntity.h"
34 #include "xc_utils/src/geom/pos_vec/Array3dBoxConstRef.h"
35 #include "xc_utils/src/geom/pos_vec/ConstantILayerConstRef.h"
36 #include "xc_utils/src/geom/pos_vec/ConstantJLayerConstRef.h"
37 #include "xc_utils/src/geom/pos_vec/ConstantKLayerConstRef.h"
38 #include "xc_utils/src/geom/pos_vec/IRowConstRef.h"
39 #include "xc_utils/src/geom/pos_vec/JRowConstRef.h"
40 #include "xc_utils/src/geom/pos_vec/KRowConstRef.h"
41 #include "xc_utils/src/geom/pos_vec/Array3dBoxVarRef.h"
42 #include "xc_utils/src/geom/pos_vec/ConstantILayerVarRef.h"
43 #include "xc_utils/src/geom/pos_vec/ConstantJLayerVarRef.h"
44 #include "xc_utils/src/geom/pos_vec/ConstantKLayerVarRef.h"
45 #include "xc_utils/src/geom/pos_vec/IRowVarRef.h"
46 #include "xc_utils/src/geom/pos_vec/JRowVarRef.h"
47 #include "xc_utils/src/geom/pos_vec/KRowVarRef.h"
48 
49 namespace XC{
50 
54 template <class PtrArray>
55 class PtrArray3dBase: public std::vector<PtrArray>, public CommandEntity
56  {
57  public:
58  typedef typename PtrArray::value_type value_type;
59  typedef typename PtrArray::reference reference;
60  typedef typename PtrArray::const_reference const_reference;
61  typedef typename std::vector<PtrArray>::iterator iterator;
62  typedef typename std::vector<PtrArray>::const_iterator const_iterator;
63 
64  typedef Array3dBoxConstRef<PtrArray3dBase<PtrArray> > box_const_ref;
65  typedef ConstantILayerConstRef<PtrArray3dBase<PtrArray> > constant_i_layer_const_ref;
66  typedef ConstantJLayerConstRef<PtrArray3dBase<PtrArray> > constant_j_layer_const_ref;
67  typedef ConstantKLayerConstRef<PtrArray3dBase<PtrArray> > constant_k_layer_const_ref;
68  typedef IRowConstRef<PtrArray3dBase<PtrArray> > const_ref_i_row;
69  typedef JRowConstRef<PtrArray3dBase<PtrArray> > const_ref_j_row;
70  typedef KRowConstRef<PtrArray3dBase<PtrArray> > const_ref_k_row;
71 
72  typedef Array3dBoxVarRef<PtrArray3dBase<PtrArray> > box_var_ref;
73  typedef ConstantILayerVarRef<PtrArray3dBase<PtrArray> > constant_i_layer_variable_ref;
74  typedef ConstantJLayerVarRef<PtrArray3dBase<PtrArray> > constant_j_layer_variable_ref;
75  typedef ConstantKLayerVarRef<PtrArray3dBase<PtrArray> > constant_k_layer_variable_ref;
76  typedef IRowVarRef<PtrArray3dBase<PtrArray> > var_ref_i_row;
77  typedef JRowVarRef<PtrArray3dBase<PtrArray> > var_ref_j_row;
78  typedef KRowVarRef<PtrArray3dBase<PtrArray> > var_ref_k_row;
79  protected:
80  void set_owner_matrices(void);
81 
82  public:
83  PtrArray3dBase(const size_t &n_layers= 0);
84  PtrArray3dBase(const size_t &n_layers,const PtrArray &);
85  PtrArray3dBase(const size_t &,const size_t &,const size_t &);
86 
87  bool check_range(const size_t &,const size_t &,const size_t &) const;
88  void resize(const size_t &);
89  void resize(const size_t &,const size_t &,const size_t &,const value_type &v= value_type());
90  size_t getNumberOfLayers(void) const;
91  size_t getNumberOfRows(void) const;
92  size_t getNumberOfColumns(void) const;
93  size_t GetDim(void) const;
94  bool isIRow(void) const;
95  bool isJRow(void) const;
96  bool isKRow(void) const;
97  bool isIConstantLayer(void) const;
98  bool isJConstantLayer(void) const;
99  bool isKConstantLayer(void) const;
100  size_t NumPtrs(void) const;
101  bool Null(void) const;
102  bool HasNull(void) const;
103  void clearAll(void);
104 
105  void dim(const size_t &,const size_t &,const size_t &);
106 
107  const PtrArray &operator()(const size_t &layer) const;
108  PtrArray &operator()(const size_t &layer);
109  inline const_reference operator()(const size_t &i,const size_t &j,const size_t &k) const
110  { return ((*this)(i))(j,k); }
111  inline reference operator()(const size_t &i,const size_t &j,const size_t &k)
112  { return ((*this)(i))(j,k); }
113  reference getAtI(const size_t &i);
114  const_reference getAtI(const size_t &) const;
115  reference getAtIJ(const size_t &,const size_t &);
116  const_reference getAtIJ(const size_t &,const size_t &) const;
117  value_type getAtIJK(const size_t &,const size_t &,const size_t &);
118 
119  box_const_ref getBoxConstRef(size_t layer=1,size_t f=1, size_t c=1) const;
120  box_const_ref getBoxConstRef(const Array3dRange &rango) const;
121 
122  constant_i_layer_const_ref getConstantILayerConstRef(size_t layer=1,size_t f=1, size_t c=1) const;
123  constant_i_layer_const_ref getConstantILayerConstRef(size_t layer,const RangoIndice &,const RangoIndice &) const;
124  constant_j_layer_const_ref getConstantJLayerConstRef(size_t f=1,size_t layer=1, size_t c=1) const;
125  constant_j_layer_const_ref getConstantJLayerConstRef(const RangoIndice &,const size_t &f,const RangoIndice &) const;
126  constant_k_layer_const_ref getConstantKLayerConstRef(size_t c=1,size_t layer=1, size_t f=1) const;
127  constant_k_layer_const_ref getConstantKLayerConstRef(const RangoIndice &,const RangoIndice &,const size_t &) const;
128 
129  const_ref_i_row getIRowConstRef(size_t f=1,size_t c=1) const;
130  const_ref_i_row getIRowConstRef(const RangoIndice &,const size_t &f,const size_t &c) const;
131  const_ref_j_row getJRowConstRef(size_t layer=1,size_t c=1) const;
132  const_ref_j_row getJRowConstRef(const size_t &layer,const RangoIndice &,const size_t &c) const;
133  const_ref_k_row getKRowConstRef(size_t layer=1,size_t f=1) const;
134  const_ref_k_row getKRowConstRef(const size_t &layer,const size_t &f,const RangoIndice &) const;
135 
136  box_var_ref getBoxVarRef(size_t layer=1,size_t f=1, size_t c=1);
137  box_var_ref getBoxVarRef(const Array3dRange &);
138 
139  constant_i_layer_variable_ref getConstantILayerVarRef(size_t layer=1,size_t f=1, size_t c=1);
140  constant_i_layer_variable_ref getConstantILayerVarRef(const size_t &layer,const RangoIndice &,const RangoIndice &);
141  constant_j_layer_variable_ref getConstantJLayerVarRef(size_t f=1,size_t layer=1, size_t c=1);
142  constant_j_layer_variable_ref getConstantJLayerVarRef(const RangoIndice &,const size_t &f,const RangoIndice &);
143  constant_k_layer_variable_ref getConstantKLayerVarRef(size_t c=1,size_t layer=1, size_t f=1);
144  constant_k_layer_variable_ref getConstantKLayerVarRef(const RangoIndice &,const RangoIndice &,const size_t &c);
145 
146  var_ref_i_row getVarRefIRow(size_t f=1,size_t c=1);
147  var_ref_i_row getVarRefIRow(const RangoIndice &,const size_t &f,const size_t &c);
148  var_ref_j_row getVarRefJRow(size_t layer=1,size_t c=1);
149  var_ref_j_row getVarRefJRow(const size_t &layer,const RangoIndice &,const size_t &c);
150  var_ref_k_row getVarRefKRow(size_t layer=1,size_t f=1);
151  var_ref_k_row getVarRefKRow(const size_t &layer,const size_t &f,const RangoIndice &);
152 
153  void putBox(size_t layer_offset,size_t row_offset,size_t offset_col,const PtrArray3dBase<PtrArray> &otra);
154 
155  std::vector<int> getLayerObjectsTags(const size_t &);
156  std::vector<int> getRowObjectsTags(const size_t &,const size_t &);
157  std::vector<int> getRowsObjectsTags(const size_t &);
158  std::vector<int> getColumnObjectsTags(const size_t &,const size_t &);
159  std::vector<int> getColumnsObjectsTags(const size_t &);
160  std::vector<int> getLayerInteriorObjectsTags(const size_t &);
161  std::vector<int> getRowInteriorObjectsTags(const size_t &,const size_t &);
162  std::vector<int> getRowsInteriorObjectsTags(const size_t &);
163  std::vector<int> getColumnInteriorObjectsTags(const size_t &,const size_t &);
164  std::vector<int> getColumnsInteriorObjectsTags(const size_t &);
165  std::vector<int> getTagsInteriorObjs(void);
166  };
167 
169 template <class PtrArray>
170 PtrArray3dBase<PtrArray>::PtrArray3dBase(const size_t &n_layers)
171  : std::vector<PtrArray>(n_layers), CommandEntity()
172  { set_owner_matrices(); }
173 
175 template <class PtrArray>
176 PtrArray3dBase<PtrArray>::PtrArray3dBase(const size_t &n_layers,const PtrArray &m)
177  : std::vector<PtrArray>(n_layers,m), CommandEntity()
178  { set_owner_matrices(); }
179 
181 template <class PtrArray>
182 PtrArray3dBase<PtrArray>::PtrArray3dBase(const size_t &n_layers,const size_t &n_rows,const size_t &cols)
183  : std::vector<PtrArray>(n_layers), CommandEntity()
184  {
185  for(size_t i=0;i<n_layers;i++)
186  (*this)[i]= PtrArray(n_rows,cols);
187  set_owner_matrices();
188  }
189 
191 template <class PtrArray>
192 void PtrArray3dBase<PtrArray>::set_owner_matrices(void)
193  {
194  for(iterator i=this->begin();i!=this->end();i++)
195  i->set_owner(this);
196  }
197 
199 template <class T>
200 void XC::PtrArray3dBase<T>::dim(const size_t &nLayers,const size_t &nRows,const size_t &numberOfColumns)
201  { this->resize(nLayers,nRows,numberOfColumns,nullptr); }
202 
204 template <class PtrArray>
205 void PtrArray3dBase<PtrArray>::resize(const size_t &n_layers)
206  {
207  std::vector<PtrArray>::resize(n_layers);
208  set_owner_matrices();
209  }
210 
212 template <class PtrArray>
213 void PtrArray3dBase<PtrArray>::resize(const size_t &n_layers,const size_t &n_rows,const size_t &cols,const value_type &v)
214  {
215  std::vector<PtrArray>::resize(n_layers);
216  for(size_t i= 0;i<n_layers;i++)
217  (*this)[i].resize(n_rows,cols,v);
218  set_owner_matrices();
219  }
220 
221 template <class PtrArray>
222 bool PtrArray3dBase<PtrArray>::check_range(const size_t &layer,const size_t &iRow,const size_t &iCol) const
223  {
224  if(layer<=getNumberOfLayers())
225  return PtrArray3dBase<PtrArray>::operator()(layer).CheckIndices(iRow,iCol);
226  else
227  return false;
228  }
229 
230 
231 template <class PtrArray>
232 size_t PtrArray3dBase<PtrArray>::getNumberOfLayers(void) const
233  { return this->size(); }
234 
235 template <class PtrArray>
236 size_t PtrArray3dBase<PtrArray>::getNumberOfRows(void) const
237  {
238  size_t retval= 0;
239  if(this->size())
240  retval= (*this)[0].getNumberOfRows();
241  return retval;
242  }
243 template <class PtrArray>
244 size_t PtrArray3dBase<PtrArray>::getNumberOfColumns(void) const
245  {
246  size_t retval= 0;
247  if(this->size())
248  retval= (*this)[0].getNumberOfColumns();
249  return retval;
250  }
251 template <class PtrArray>
252 size_t PtrArray3dBase<PtrArray>::GetDim(void) const
253  {
254  size_t retval= 0;
255  if(this->size()>1) retval++;
256  if(this->getNumberOfRows()>1) retval++;
257  if(this->getNumberOfColumns()>1) retval++;
258  return retval;
259  }
260 
262 template <class PtrArray>
263 size_t PtrArray3dBase<PtrArray>::NumPtrs(void) const
264  {
265  const size_t sz= this->size();
266  if(sz<1)
267  return 0;
268  else
269  {
270  const PtrArray &layer= (*this)(1);
271  return sz*layer.getNumberOfRows()*layer.getNumberOfColumns();
272  }
273  }
274 
276 template <class PtrArray>
277 bool PtrArray3dBase<PtrArray>::Null(void) const
278  {
279  if(this->empty())
280  return true;
281  else
282  return (*this)[0].Null();
283  }
284 
286 template <class PtrArray>
287 bool PtrArray3dBase<PtrArray>::HasNull(void) const
288  {
289  bool retval= false;
290  if(this->empty())
291  retval= true;
292  else
293  {
294  const size_t numberOfLayers= this->getNumberOfLayers();
295  for(size_t i=0;i<numberOfLayers;i++)
296  if((*this)[i].Null())
297  {
298  retval= true;
299  break;
300  }
301  }
302  return retval;
303  }
304 
306 template <class PtrArray>
307 void PtrArray3dBase<PtrArray>::clearAll(void)
308  {
309  std::vector<PtrArray>::clear();
310  CommandEntity::clearPyProps();
311  }
312 
313 
315 template <class PtrArray>
316 bool PtrArray3dBase<PtrArray>::isIRow(void) const
317  {
318  if((this->getNumberOfRows()>1) || (this->getNumberOfColumns()>1)) return false;
319  return true;
320  }
321 
323 template <class PtrArray>
324 bool PtrArray3dBase<PtrArray>::isJRow(void) const
325  {
326  if((this->getNumberOfLayers()>1) || (this->getNumberOfColumns()>1)) return false;
327  return true;
328  }
329 
331 template <class PtrArray>
332 bool PtrArray3dBase<PtrArray>::isKRow(void) const
333  {
334  if((this->getNumberOfLayers()>1) || (this->getNumberOfRows()>1)) return false;
335  return true;
336  }
337 
339 template <class PtrArray>
340 bool PtrArray3dBase<PtrArray>::isIConstantLayer(void) const
341  { return (this->getNumberOfLayers()==1); }
342 
344 template <class PtrArray>
345 bool PtrArray3dBase<PtrArray>::isJConstantLayer(void) const
346  { return (this->getNumberOfRows()==1); }
347 
349 template <class PtrArray>
350 bool PtrArray3dBase<PtrArray>::isKConstantLayer(void) const
351  { return (this->getNumberOfColumns()==1); }
352 
354 template <class PtrArray>
355 const PtrArray &PtrArray3dBase<PtrArray>::operator()(const size_t &i) const
356  { return (*this)[i-1]; }
357 
359 template <class PtrArray>
360 PtrArray &PtrArray3dBase<PtrArray>::operator()(const size_t &i)
361  { return (*this)[i-1]; }
362 
363 
364 template <class PtrArray>
365 typename PtrArray3dBase<PtrArray>::reference PtrArray3dBase<PtrArray>::getAtI(const size_t &i)
366  { return const_cast<reference>(static_cast<const PtrArray3dBase<PtrArray> &>(*this).getAtI(i)); }
367 
368 template <class PtrArray>
369 typename PtrArray3dBase<PtrArray>::const_reference PtrArray3dBase<PtrArray>::getAtI(const size_t &i) const
370  {
371  if(isIRow())
372  return operator()(i,1,1);
373  else if(isJRow())
374  return operator()(1,i,1);
375  else if(isKRow())
376  return operator()(1,1,i);
377  else
378  {
379  std::cerr << "PtrArray3dBase::getAtI; the set is not one-dimensional." << std::endl;
380  return operator()(1,1,1);
381  }
382  }
383 
384 template <class PtrArray>
385 typename PtrArray3dBase<PtrArray>::value_type PtrArray3dBase<PtrArray>::getAtIJK(const size_t &i,const size_t &j,const size_t &k)
386  {
387  typename PtrArray3dBase<PtrArray>::value_type retval= nullptr;
388  if(this->check_range(i,j,k))
389  retval= (*this)(i,j,k);
390  return retval;
391  }
392 
393 template <class PtrArray>
394 typename PtrArray3dBase<PtrArray>::reference PtrArray3dBase<PtrArray>::getAtIJ(const size_t &i, const size_t &j)
395  { return const_cast<reference>(static_cast<const PtrArray3dBase<PtrArray> &>(*this).getAtIJ(i)); }
396 
397 template <class PtrArray>
398 typename PtrArray3dBase<PtrArray>::const_reference PtrArray3dBase<PtrArray>::getAtIJ(const size_t &i, const size_t &j) const
399  {
400  //XXX We still need to get the layer
401  // (It will not necessarily be the first one).
402  if(isIConstantLayer())
403  return operator()(1,i,j);
404  else if(isJConstantLayer())
405  return operator()(i,1,j);
406  else if(isKConstantLayer())
407  return operator()(i,j,1);
408  else
409  {
410  std::cerr << getClassName() << "::" << __FUNCTION__
411  << "; the node set is not bidimensional." << std::endl;
412  return nullptr;
413  }
414  }
415 
416 template <class PtrArray>
417 typename PtrArray3dBase<PtrArray>::box_const_ref PtrArray3dBase<PtrArray>::getBoxConstRef(size_t layer,size_t f, size_t c) const
418  { return box_const_ref(*this,layer,f,c); }
419 template <class PtrArray>
420 typename PtrArray3dBase<PtrArray>::box_const_ref PtrArray3dBase<PtrArray>::getBoxConstRef(const Array3dRange &rango) const
421  { return box_const_ref(*this,rango); }
422 
423 template <class PtrArray>
424 typename PtrArray3dBase<PtrArray>::constant_i_layer_const_ref PtrArray3dBase<PtrArray>::getConstantILayerConstRef(size_t layer,size_t f, size_t c) const
425  { return constant_i_layer_const_ref(*this,layer,f,c); }
426 template <class PtrArray>
427 typename PtrArray3dBase<PtrArray>::constant_i_layer_const_ref PtrArray3dBase<PtrArray>::getConstantILayerConstRef(size_t layer,const RangoIndice &row_range,const RangoIndice &column_range) const
428  { return constant_i_layer_const_ref(*this,layer,row_range,column_range); }
429 template <class PtrArray>
430 typename PtrArray3dBase<PtrArray>::constant_j_layer_const_ref PtrArray3dBase<PtrArray>::getConstantJLayerConstRef(size_t f,size_t layer, size_t c) const
431  { return constant_j_layer_const_ref(*this,layer,f,c); }
432 template <class PtrArray>
433 typename PtrArray3dBase<PtrArray>::constant_j_layer_const_ref PtrArray3dBase<PtrArray>::getConstantJLayerConstRef(const RangoIndice &layer_range,const size_t &f,const RangoIndice &column_range) const
434  { return constant_j_layer_const_ref(*this,layer_range,f,column_range); }
435 template <class PtrArray>
436 typename PtrArray3dBase<PtrArray>::constant_k_layer_const_ref PtrArray3dBase<PtrArray>::getConstantKLayerConstRef(size_t c,size_t layer, size_t f) const
437  { return constant_k_layer_const_ref(*this,c,layer,f); }
438 template <class PtrArray>
439 typename PtrArray3dBase<PtrArray>::constant_k_layer_const_ref PtrArray3dBase<PtrArray>::getConstantKLayerConstRef(const RangoIndice &layer_range, const RangoIndice &row_range, const size_t &c) const
440  { return constant_k_layer_const_ref(*this,layer_range,row_range,c); }
441 
442 template <class PtrArray>
443 typename PtrArray3dBase<PtrArray>::const_ref_i_row PtrArray3dBase<PtrArray>::getIRowConstRef(size_t f,size_t c) const
444  { return const_ref_i_row(*this,f,c); }
445 template <class PtrArray>
446 typename PtrArray3dBase<PtrArray>::const_ref_i_row PtrArray3dBase<PtrArray>::getIRowConstRef(const RangoIndice &layer_range,const size_t &f,const size_t &c) const
447  { return const_ref_i_row(*this,layer_range,f,c); }
448 template <class PtrArray>
449 typename PtrArray3dBase<PtrArray>::const_ref_j_row PtrArray3dBase<PtrArray>::getJRowConstRef(size_t layer,size_t c) const
450  { return const_ref_j_row(*this,layer,c); }
451 template <class PtrArray>
452 typename PtrArray3dBase<PtrArray>::const_ref_j_row PtrArray3dBase<PtrArray>::getJRowConstRef(const size_t &layer,const RangoIndice &row_range,const size_t &c) const
453  { return const_ref_j_row(*this,layer,row_range,c); }
454 template <class PtrArray>
455 typename PtrArray3dBase<PtrArray>::const_ref_k_row PtrArray3dBase<PtrArray>::getKRowConstRef(size_t layer,size_t f) const
456  { return const_ref_k_row(*this,layer,f); }
457 template <class PtrArray>
458 typename PtrArray3dBase<PtrArray>::const_ref_k_row PtrArray3dBase<PtrArray>::getKRowConstRef(const size_t &layer,const size_t &f,const RangoIndice &column_range) const
459  { return const_ref_k_row(*this,layer,f,column_range); }
460 
461 template <class PtrArray>
462 typename PtrArray3dBase<PtrArray>::box_var_ref PtrArray3dBase<PtrArray>::getBoxVarRef(size_t layer,size_t f, size_t c)
463  { return box_var_ref(*this,layer,f,c); }
464 template <class PtrArray>
465 typename PtrArray3dBase<PtrArray>::box_var_ref PtrArray3dBase<PtrArray>::getBoxVarRef(const Array3dRange &rango)
466  { return box_var_ref(*this,rango); }
467 
468 template <class PtrArray>
469 typename PtrArray3dBase<PtrArray>::constant_i_layer_variable_ref PtrArray3dBase<PtrArray>::getConstantILayerVarRef(size_t layer,size_t f, size_t c)
470  { return constant_i_layer_variable_ref(*this,layer,f,c); }
471 template <class PtrArray>
472 typename PtrArray3dBase<PtrArray>::constant_i_layer_variable_ref PtrArray3dBase<PtrArray>::getConstantILayerVarRef(const size_t &layer,const RangoIndice &row_range,const RangoIndice &rcols)
473  { return constant_i_layer_variable_ref(*this,layer,row_range,rcols); }
474 template <class PtrArray>
475 typename PtrArray3dBase<PtrArray>::constant_j_layer_variable_ref PtrArray3dBase<PtrArray>::getConstantJLayerVarRef(size_t f,size_t layer, size_t c)
476  { return constant_j_layer_variable_ref(*this,layer,f,c); }
477 template <class PtrArray>
478 typename PtrArray3dBase<PtrArray>::constant_j_layer_variable_ref PtrArray3dBase<PtrArray>::getConstantJLayerVarRef(const RangoIndice &layer_range,const size_t &f,const RangoIndice &rcols)
479  { return constant_j_layer_variable_ref(*this,layer_range,f,rcols); }
480 template <class PtrArray>
481 typename PtrArray3dBase<PtrArray>::constant_k_layer_variable_ref PtrArray3dBase<PtrArray>::getConstantKLayerVarRef(size_t c,size_t layer, size_t f)
482  { return constant_k_layer_variable_ref(*this,c,layer,f); }
483 template <class PtrArray>
484 typename PtrArray3dBase<PtrArray>::constant_k_layer_variable_ref PtrArray3dBase<PtrArray>::getConstantKLayerVarRef(const RangoIndice &layer_range, const RangoIndice &row_range,const size_t &c)
485  { return constant_k_layer_variable_ref(*this,layer_range,row_range,c); }
486 
487 template <class PtrArray>
488 typename PtrArray3dBase<PtrArray>::var_ref_i_row PtrArray3dBase<PtrArray>::getVarRefIRow(size_t f,size_t c)
489  { return var_ref_i_row(*this,f,c); }
490 template <class PtrArray>
491 typename PtrArray3dBase<PtrArray>::var_ref_i_row PtrArray3dBase<PtrArray>::getVarRefIRow(const RangoIndice &layer_range,const size_t &f,const size_t &c)
492  { return var_ref_i_row(*this,layer_range,f,c); }
493 template <class PtrArray>
494 typename PtrArray3dBase<PtrArray>::var_ref_j_row PtrArray3dBase<PtrArray>::getVarRefJRow(size_t layer,size_t c)
495  { return var_ref_j_row(*this,layer,c); }
496 template <class PtrArray>
497 typename PtrArray3dBase<PtrArray>::var_ref_j_row PtrArray3dBase<PtrArray>::getVarRefJRow(const size_t &layer,const RangoIndice &row_range,const size_t &c)
498  { return var_ref_j_row(*this,layer,row_range,c); }
499 template <class PtrArray>
500 typename PtrArray3dBase<PtrArray>::var_ref_k_row PtrArray3dBase<PtrArray>::getVarRefKRow(size_t layer,size_t f)
501  { return var_ref_k_row(*this,layer,f); }
502 template <class PtrArray>
503 typename PtrArray3dBase<PtrArray>::var_ref_k_row PtrArray3dBase<PtrArray>::getVarRefKRow(const size_t &layer,const size_t &f,const RangoIndice &rcols)
504  { return var_ref_k_row(*this,layer,f,rcols); }
505 
507 template <class PtrArray>
508 void PtrArray3dBase<PtrArray>::putBox(size_t layer_offset,size_t row_offset,size_t offset_col,const PtrArray3dBase<PtrArray> &otra)
509  {
510  const size_t numberOfLayers= otra.getNumberOfLayers();
511  const size_t numberOfRows= otra.getNumberOfRows();
512  const size_t numberOfColumns= otra.getNumberOfColumns();
513  if((numberOfLayers+layer_offset)>getNumberOfLayers())
514  {
515  std::cerr << getClassName() << "::" << __FUNCTION__
516  << "; layer index out of range." << std::endl;
517  return;
518  }
519  if((numberOfRows+row_offset)>this->getNumberOfRows())
520  {
521  std::cerr << getClassName() << "::" << __FUNCTION__
522  << "; row index out of range." << std::endl;
523  return;
524  }
525  if((numberOfColumns+offset_col)>this->getNumberOfColumns())
526  {
527  std::cerr << getClassName() << "::" << __FUNCTION__
528  << "; column index out of range." << std::endl;
529  return;
530  }
531  for(size_t i=1;i<=numberOfLayers;i++)
532  for(size_t j=1;j<=numberOfRows;j++)
533  for(size_t k=1;k<=numberOfColumns;k++)
534  (*this)(layer_offset+i,row_offset+j,offset_col+k)= otra(i,j,k);
535  }
536 
537 
539 template <class PtrArray>
540 std::vector<int> PtrArray3dBase<PtrArray>::getLayerObjectsTags(const size_t &c)
541  { return (*this)(c).getTagsObjs(); }
542 
544 template <class PtrArray>
545 std::vector<int> PtrArray3dBase<PtrArray>::getRowObjectsTags(const size_t &c,const size_t &f)
546  {
547  const size_t numCols= this->getNumberOfColumns();
548  std::vector<int> retval;
549  for(size_t k= 1;k<=numCols;k++)
550  retval[k-1]= (*this)(c,f,k)->getTag();
551  return retval;
552  }
553 
555 template <class PtrArray>
556 std::vector<int> PtrArray3dBase<PtrArray>::getRowsObjectsTags(const size_t &f)
557  {
558  const size_t num_layers= this->getNumberOfLayers();
559  const size_t numCols= this->getNumberOfColumns();
560  m_int retval(num_layers,numCols);
561  for(size_t i= 1;i<=num_layers;i++)
562  for(size_t k= 1;k<=numCols;k++)
563  retval(i,k)= (*this)(i,f,k)->getTag();
564  return retval.getVector();
565  }
566 
568 template <class PtrArray>
569 std::vector<int> PtrArray3dBase<PtrArray>::getColumnObjectsTags(const size_t &layer,const size_t &c)
570  {
571  const size_t n_rows= this->getNumberOfRows();
572  std::vector<int> retval(n_rows);
573  for(size_t j= 1;j<=n_rows;j++)
574  retval[j-1]= (*this)(layer,j,c)->getTag();
575  return retval;
576  }
577 
579 template <class PtrArray>
580 std::vector<int> PtrArray3dBase<PtrArray>::getColumnsObjectsTags(const size_t &c)
581  {
582  const size_t num_layers= this->getNumberOfLayers();
583  const size_t n_rows= this->getNumberOfRows();
584  m_int retval(num_layers,n_rows);
585  for(size_t i= 1;i<=num_layers;i++)
586  for(size_t j= 1;j<=n_rows;j++)
587  retval(i,j)= (*this)(i,j,c)->getTag();
588  return retval.getVector();
589  }
590 
592 template <class PtrArray>
593 std::vector<int> PtrArray3dBase<PtrArray>::getLayerInteriorObjectsTags(const size_t &c)
594  { return (*this)(c).getObjsInteriores(); }
595 
597 template <class PtrArray>
598 std::vector<int> PtrArray3dBase<PtrArray>::getRowInteriorObjectsTags(const size_t &c,const size_t &f)
599  {
600  const size_t numCols= this->getNumberOfColumns();
601  std::vector<int> retval(numCols);
602  for(size_t k= 1;k<=numCols;k++)
603  retval[k-1]= (*this)(c,f,k)->getTag();
604  return retval;
605  }
606 
608 template <class PtrArray>
609 std::vector<int> PtrArray3dBase<PtrArray>::getRowsInteriorObjectsTags(const size_t &f)
610  {
611  const size_t num_layers= this->getNumberOfLayers();
612  const size_t numCols= getNumberOfColumns();
613  m_int retval(num_layers-2,numCols-2);
614  for(size_t i= 2;i<num_layers;i++)
615  for(size_t k= 2;k<numCols;k++)
616  retval(i-1,k-1)= (*this)(i,f,k)->getTag();
617  return retval.getVector();
618  }
619 
621 template <class PtrArray>
622 std::vector<int> PtrArray3dBase<PtrArray>::getColumnInteriorObjectsTags(const size_t &layer,const size_t &c)
623  {
624  const size_t n_rows= this->getNumberOfRows();
625  std::vector<int> retval(n_rows-2);
626  for(size_t j= 2;j<n_rows;j++)
627  retval[j-2]= (*this)(layer,j,c)->getTag();
628  return retval;
629  }
630 
632 template <class PtrArray>
633 std::vector<int> PtrArray3dBase<PtrArray>::getColumnsInteriorObjectsTags(const size_t &c)
634  {
635  const size_t num_layers= this->getNumberOfLayers();
636  const size_t n_rows= this->getNumberOfRows();
637  m_int retval(num_layers-2,n_rows-2);
638  for(size_t i= 2;i<num_layers;i++)
639  for(size_t j= 2;j<n_rows;j++)
640  retval(i-1,j-1)= (*this)(i,j,c)->getTag();
641  return retval.getVector();
642  }
643 
645 template <class PtrArray>
646 std::vector<int> PtrArray3dBase<PtrArray>::getTagsInteriorObjs(void)
647  {
648  std::cerr << "deprecated; use python" << std::endl;
649  std::vector<int> retval;
650  const size_t num_layers= this->getNumberOfLayers();
651  if(num_layers==1)
652  retval= (*this)(1).getTagsInteriorObjs();
653  else
654  {
655  const size_t n_rows= this->getNumberOfRows();
656  if(n_rows==1)
657  retval= getRowsInteriorObjectsTags(1);
658  else
659  {
660  const size_t numCols= this->getNumberOfColumns();
661  if(numCols==1)
662  retval= getColumnsInteriorObjectsTags(1);
663  else
664  for(size_t i= 2;i<num_layers;i++)
665  {
666  std::vector<int> tmp= getLayerInteriorObjectsTags(i);
667  retval.insert(retval.end(),tmp.begin(),tmp.end());
668  }
669  }
670  }
671  return retval;
672  }
673 
674 } //end of XC namespace.
675 
676 #endif
XC::PtrArray3dBase::dim
void dim(const size_t &, const size_t &, const size_t &)
Matrix dimensions.
Definition: PtrArray3dBase.h:200
XC::PtrArray3dBase::getColumnObjectsTags
std::vector< int > getColumnObjectsTags(const size_t &, const size_t &)
Return the identifiers of the objects in the column.
Definition: PtrArray3dBase.h:569
XC::PtrArray3dBase::putBox
void putBox(size_t layer_offset, size_t row_offset, size_t offset_col, const PtrArray3dBase< PtrArray > &otra)
Put in the array the array argument.
Definition: PtrArray3dBase.h:508
XC::PtrArray3dBase::getColumnInteriorObjectsTags
std::vector< int > getColumnInteriorObjectsTags(const size_t &, const size_t &)
Return the identifiers of the objects in the c-th column interior.
Definition: PtrArray3dBase.h:622
XC::PtrArray3dBase::isIConstantLayer
bool isIConstantLayer(void) const
Returns true if the indexes that vary are los J y K.
Definition: PtrArray3dBase.h:340
XC::PtrArray3dBase::isJRow
bool isJRow(void) const
Returns true if only index J varies.
Definition: PtrArray3dBase.h:324
XC::PtrArray3dBase::isKConstantLayer
bool isKConstantLayer(void) const
Returns true if the indexes that vary are los I y J.
Definition: PtrArray3dBase.h:350
XC::PtrArray3dBase::Null
bool Null(void) const
Returns true if it&#39;s empty or the pointers are null.
Definition: PtrArray3dBase.h:277
XC::PtrArray3dBase::getRowsInteriorObjectsTags
std::vector< int > getRowsInteriorObjectsTags(const size_t &)
Return the identifiers of the objects in the c-th rows interior.
Definition: PtrArray3dBase.h:609
XC::PtrArray3dBase::resize
void resize(const size_t &)
Resize the array.
Definition: PtrArray3dBase.h:205
XC::PtrArray3dBase::isIRow
bool isIRow(void) const
Returns true if only index I varies.
Definition: PtrArray3dBase.h:316
XC::PtrArray3dBase::getRowObjectsTags
std::vector< int > getRowObjectsTags(const size_t &, const size_t &)
Return the identifiers of the objects in the row.
Definition: PtrArray3dBase.h:545
XC::PtrArray3dBase::getRowInteriorObjectsTags
std::vector< int > getRowInteriorObjectsTags(const size_t &, const size_t &)
Return the identifiers of the objects in the row interior.
Definition: PtrArray3dBase.h:598
XC::PtrArray3dBase::clearAll
void clearAll(void)
Clears all.
Definition: PtrArray3dBase.h:307
XC::PtrArray3dBase::set_owner_matrices
void set_owner_matrices(void)
Sets the owner for the matrices.
Definition: PtrArray3dBase.h:192
XC::PtrArray3dBase::isJConstantLayer
bool isJConstantLayer(void) const
Returns true if the indexes that vary are los I y K.
Definition: PtrArray3dBase.h:345
XC::PtrArray3dBase::getLayerInteriorObjectsTags
std::vector< int > getLayerInteriorObjectsTags(const size_t &)
Return the identifiers of the objects in the layer interior.
Definition: PtrArray3dBase.h:593
XC::PtrArray3dBase::getColumnsInteriorObjectsTags
std::vector< int > getColumnsInteriorObjectsTags(const size_t &)
Return the identifiers of the objects in the c-th columns interior.
Definition: PtrArray3dBase.h:633
XC::PtrArray3dBase::getColumnsObjectsTags
std::vector< int > getColumnsObjectsTags(const size_t &)
Return the identifiers of the objects in the c-th columns.
Definition: PtrArray3dBase.h:580
XC::PtrArray3dBase::HasNull
bool HasNull(void) const
Returns true if it&#39;s empty or some of the pointers are null.
Definition: PtrArray3dBase.h:287
XC::PtrArray3dBase::getRowsObjectsTags
std::vector< int > getRowsObjectsTags(const size_t &)
Return the identifiers of the objects in the f-th rows.
Definition: PtrArray3dBase.h:556
XC::PtrArray3dBase::NumPtrs
size_t NumPtrs(void) const
Return the number of elements of the array.
Definition: PtrArray3dBase.h:263
XC
Open source finite element program for structural analysis.
Definition: ContinuaReprComponent.h:34
XC::PtrArray3dBase::operator()
const PtrArray & operator()(const size_t &layer) const
Return the i-th layer.
Definition: PtrArray3dBase.h:355
XC::PtrArray3dBase::isKRow
bool isKRow(void) const
Returns true if only index K varies.
Definition: PtrArray3dBase.h:332
XC::PtrArray3dBase::getLayerObjectsTags
std::vector< int > getLayerObjectsTags(const size_t &)
Return the identifiers of the objects in the layer.
Definition: PtrArray3dBase.h:540
XC::PtrArray3dBase::getTagsInteriorObjs
std::vector< int > getTagsInteriorObjs(void)
Return the tabs of the inerior elements.
Definition: PtrArray3dBase.h:646
XC::PtrArray3dBase
Three-dimensional array of object pointers.
Definition: PtrArray3dBase.h:55
XC::PtrArray3dBase::PtrArray3dBase
PtrArray3dBase(const size_t &n_layers=0)
Default constructor.
Definition: PtrArray3dBase.h:170
Generated by   doxygen 1.8.12