stepper.hh

Go to the documentation of this file.

/*****************************************************************************
*   This program is part of the msbGrid software                            *
*                                                                           *
*   msbGrid stands for multi-structured block Grid generator                *
*                                                                           *
*   msbGrid is a 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.                                     *
*                                                                           *
*   msbGrid 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.                            *
*                                                                           *
*   See the file COPYING for full copying permissions.                      *
*****************************************************************************/
#ifndef _STEPPER_HH_
#define _STEPPER_HH_

namespace msbGrid
{
template< typename GridFactoryT >
class Stepper;
}

template< typename GridFactoryT >
class msbGrid :: Stepper
{
public:
  typedef GridFactoryT GridFactory;

  typedef typename GridFactory :: Scalar Scalar;
  enum { dim = GridFactory :: dim };

  typedef typename GridFactory :: InputData InputData;

  typedef typename GridFactory :: Point Point;
  typedef typename GridFactory :: Edge Edge;
  typedef typename GridFactory :: Cell Cell;

private:
  int Id_;
  int iStepMax_;
  int stepperSize_;

  bool otherStep_;
  bool firstStep_;

  std :: vector< bool > newStep_;
  std :: vector< Scalar > velocity_;

public:
  Stepper(const int &iStepMax0 = 1e4)
  {
    iStepMax_ = iStepMax0;
    init();
  }

  ~Stepper() {}

  void init(const int &blockNumber0 = 0)
  {
    Id_ = 0;

    firstStep_ = true;
    otherStep_ = true;

    stepperSize_ = blockNumber0;

    newStep_.resize(stepperSize_);
    newStep_.assign(stepperSize_, true);

    velocity_.resize(stepperSize_);
    velocity_.assign( stepperSize_, Scalar(1.0) );
  }

  void reset()
  {
    assert(stepperSize_ != 0);

    init(stepperSize_);
  }

  const int &Id() const
  { return Id_; }

  int &Id()
  { return Id_; }

  const int &iStepMax() const
  { return iStepMax_; }

  int &iStepMax()
  { return iStepMax_; }

  const int &stepperSize() const
  { return stepperSize_; }

  int &stepperSize()
  { return stepperSize_; }

  const bool &otherStep() const
  { return otherStep_; }

  bool &otherStep()
  { return otherStep_; }

  const bool &firstStep() const
  { return firstStep_; }

  bool &firstStep()
  { return firstStep_; }

  const std :: vector< bool > &newStep() const
  { return newStep_; }

  std :: vector< bool > &newStep()
  { return newStep_; }

  const std :: vector< Scalar > &velocity() const
  { return velocity_; }

  std :: vector< Scalar > &velocity()
  { return velocity_; }
};

#endif  /* #ifndef _STEPPER_HH_ */