← Back to branch summary

~esys-p-dev/esys-particle/trunk

« back to all changes in this revision

Viewing changes to Tools/StressCalculator/CartesianGrid.h

  • Committer: slatham
  • Date: 2004-12-08 07:29:43 UTC
  • Revision ID: svn-v4:1ddc92f8-1f06-0410-a909-b11019f1b28a:lsmtrunk:553
Added copy-constructor and assignment operator for VertexBox. Removed std-deviation parameter and removed redundant computations from the raw2tostress converter.

Show diffs side-by-side

added added

removed removed

Lines of Context:
Tools/StressCalculator/CartesianGrid.h
38
38
    class CartesianGrid
39
39
    {
40
40
    public:
41
 
      typedef TmplValue value_type;
42
 
      typedef value_type& reference;
 
41
      typedef TmplValue         value_type;
 
42
      typedef value_type&       reference;
43
43
      typedef const value_type& const_reference;
44
 
      typedef value_type* pointer;
 
44
      typedef value_type*       pointer;
45
45
 
46
46
      class Cell
47
47
      {
135
135
          return m_pointerVector.size();
136
136
        }
137
137
 
 
138
        /**
 
139
         * Clears all elements from this cell.
 
140
         */
 
141
        void clear()
 
142
        {
 
143
          m_pointerVector.clear();
 
144
        }
 
145
 
138
146
        ConstIterator getIterator() const
139
147
        {
140
148
          return ConstIterator(m_pointerVector);
208
216
            m_pGrid(pGrid)
209
217
        {
210
218
        }
211
 
        
 
219
 
212
220
        bool hasNext() const
213
221
        {
214
222
          return m_idxIt.hasNext();
226
234
      typedef TCellIterator<CartesianGrid *, Cell &, Cell>             CellIterator;
227
235
      typedef TCellIterator<const CartesianGrid *, const Cell &, Cell> CellConstIterator;
228
236
 
 
237
      typedef std::vector<pointer> ValueVector;
 
238
      class ValueIterator : public ForwardIterator<ValueVector>
 
239
      {
 
240
      public:
 
241
        ValueIterator(ValueVector &v) : ForwardIterator<ValueVector>(v)
 
242
        {
 
243
        }
 
244
        
 
245
        CartesianGrid::reference next()
 
246
        {
 
247
          return *(ForwardIterator<ValueVector>::next());
 
248
        }
 
249
      };
 
250
      
 
251
      class ValueConstIterator : public ForwardConstIterator<ValueVector>
 
252
      {
 
253
      public:
 
254
        ValueConstIterator(const ValueVector &v) : ForwardConstIterator<ValueVector>(v)
 
255
        {
 
256
        }
 
257
 
 
258
        CartesianGrid::const_reference next()
 
259
        {
 
260
          return *(ForwardConstIterator<ValueVector>::next());
 
261
        }
 
262
      };
 
263
 
229
264
      CartesianGrid(const BoundingBox &bBox, double gridSpacing)
230
265
        : m_bBox(bBox),
231
266
          m_gridSpacing(gridSpacing),
233
268
          m_minIndex(),
234
269
          m_maxIndex(),
235
270
          m_cellVector(),
236
 
          m_valuePoolPtr(new Pool(1024))
 
271
          m_valuePoolPtr(new Pool(1024)),
 
272
          m_valueVector()
237
273
      {
238
274
        initialise(bBox, gridSpacing);
239
275
      }
375
411
          );
376
412
      }
377
413
 
 
414
      ValueIterator getValueIterator()
 
415
      {
 
416
        return ValueIterator(m_valueVector);
 
417
      }
 
418
 
 
419
      ValueConstIterator getValueIterator() const
 
420
      {
 
421
        return ValueConstIterator(m_valueVector);
 
422
      }
 
423
 
 
424
      size_t size() const
 
425
      {
 
426
        return m_valueVector.size();
 
427
      }
 
428
 
 
429
      double getGridSpacing() const
 
430
      {
 
431
        return m_gridSpacing;
 
432
      }
 
433
 
 
434
      void clear()
 
435
      {
 
436
        CellIterator cellIt = getCellIterator();
 
437
        while (cellIt.hasNext())
 
438
        {
 
439
          cellIt.next().clear();
 
440
        }
 
441
        m_valuePoolPtr = PoolPtr(new Pool(1024));
 
442
        m_valueVector.clear();
 
443
      }
 
444
 
378
445
    protected:
379
446
      void insertRef(const Vec3 &pos, reference data)
380
447
      {
381
448
        getCell(pos).insertRef(pos, data);
 
449
        m_valueVector.push_back(&data);
382
450
      }
383
451
 
384
452
      void initialise(const BoundingBox &bBox, double gridSpacing)
396
464
          m_dimensions.X()*m_dimensions.Y()*m_dimensions.Z(),
397
465
          Cell()
398
466
        );
 
467
 
 
468
        m_valueVector.clear();
 
469
        m_valueVector.reserve(m_cellVector.size());
 
470
 
399
471
        m_minIndex = Vec3L(0, 0, 0);
400
472
        m_maxIndex = (m_dimensions - 1);
401
473
 
423
495
        }
424
496
      }
425
497
 
426
 
      double getGridSpacing() const
427
 
      {
428
 
        return m_gridSpacing;
429
 
      }
430
 
 
431
498
    private:
432
 
      typedef std::vector<Cell>              CellVector;    
 
499
      typedef std::vector<Cell>              CellVector;
433
500
      typedef boost::object_pool<value_type> Pool;
434
501
      typedef boost::shared_ptr<Pool>        PoolPtr;
435
502
 
440
507
      Vec3L       m_maxIndex;
441
508
      CellVector  m_cellVector;      
442
509
      PoolPtr     m_valuePoolPtr;
 
510
      ValueVector m_valueVector;
443
511
    };
444
512
  }
445
513
}