block.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 _BLOCK_HH_
#define _BLOCK_HH_

namespace msbGrid
{
template< typename EntityT >
class Block;
}

template< typename EntityT >
class msbGrid :: Block
{
public:
  typedef EntityT Entity;
  typedef Block< Entity > ThisT;

  enum { dim = Entity :: dim };
  typedef typename Entity :: Scalar Scalar;
  typedef typename Entity :: Color Color;

private:
  int Id_;
  bool mark_;
  Scalar declination_;

  std :: vector< Entity > vEnt_;

public:
  Block()
  {
    Id_ = 0;
    mark_ = false;
    declination_ = 0.0;

    vEnt_.clear();
  }

  ~Block() {}

  const std :: vector< Entity > &vEnt() const
  { return vEnt_; }

  std :: vector< Entity > &vEnt()
  { return vEnt_; }

  const int size() const
  { return vEnt_.size(); }

  const bool empty() const
  { return ( vEnt_.size() == 0 ); }

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

  int &Id()
  { return Id_; }

  const int putId(const int &Id0 = 1)
  {
    int Id1 = Id0;
    for ( unsigned int iEnt = 0; iEnt < size(); ++iEnt ) {
      if ( !vEnt_ [ iEnt ].mark() ) {
        vEnt_ [ iEnt ].Id() = Id1;
        ++Id1;
      }
    }

    return Id1;
  }

  const int entId(const int &Id0 = 1)
  {
    int Id1 = Id0;
    for ( int iEnt = 0; iEnt < vEnt_.size(); ++iEnt ) {
      if ( !vEnt_ [ iEnt ].marked() ) {
        vEnt_ [ iEnt ].Id() = Id1;
        ++Id1;
      }
    }

    return Id1;
  }

  const bool hasId() const
  { return ( Id_ != 0 ); }

  const bool &mark() const
  { return mark_; }

  bool &mark()
  { return mark_; }

  const Scalar &declination() const
  { return declination_; }

  Scalar &declination()
  { return declination_; }

  void add(const Entity &ent0)
  { vEnt_.push_back(ent0); }

  void add(const std :: vector< Entity > &vEnt0)
  {
    for ( int iEnt = 0; iEnt < vEnt0.size(); ++iEnt ) {
      add(vEnt0 [ iEnt ]);
    }
  }

  void add(const ThisT &bl0)
  { add( bl0.vEnt() ); }

  void cleanUp()       
  {
    std :: vector< Entity > vEnt0;
    vEnt0.clear();
    for ( int iEnt = 0; iEnt < vEnt_.size(); ++iEnt ) {
      if ( !vEnt_ [ iEnt ].mark() ) {
        vEnt0.push_back(vEnt_ [ iEnt ]);
      }
    }

    vEnt_.clear();
    for ( int iEnt = 0; iEnt < vEnt0.size(); ++iEnt ) {
      vEnt_.push_back(vEnt0 [ iEnt ]);
    }
  }

  void clear()
  { vEnt_.clear(); }

  void translate(const std :: vector< Scalar > &dx)
  {
    assert(dx.size() == dim);

    for ( int iEnt = 0; iEnt < vEnt_.size(); ++iEnt ) {
      vEnt_ [ iEnt ].translate(dx);
    }
  }

  template< typename PointT >
  void rotate(const Scalar &_angle, const PointT &mc)
  {
    for ( unsigned int iEnt = 0; iEnt < vEnt_.size(); ++iEnt ) {
      vEnt_ [ iEnt ].rotate(_angle, mc);
    }
  }

  void rotate(const Scalar &_angle)
  {
    for ( int iEnt = 0; iEnt < vEnt_.size(); ++iEnt ) {
      vEnt_ [ iEnt ].rotate( _angle, vEnt_ [ iEnt ].pos() );
    }
  }

  void infos(const std :: string &name0 = "")
  {
    std :: cout << "# block " << name0 << " ";

    std :: cout << ": size = " << size()
                << " , Id = " << Id_
                << " , mark = " << mark_
                << " , declination = " << declination_ << "\n";

    for ( int iEnt = 0; iEnt < vEnt_.size(); ++iEnt ) {
      vEnt_ [ iEnt ].infos();
    }

    std :: cout << "\n";
  }
}; /* class msbGrid::Block */

#endif  /* #ifndef _BLOCK_HH_ */

#ifndef _POINTS_BLOCK_HH_
#define _POINTS_BLOCK_HH_

namespace msbGrid
{
class PointsBlock;
}

class msbGrid :: PointsBlock : public msbGrid :: Block< msbGrid :: Point >
{
public:
  typedef msbGrid :: Block< msbGrid :: Point > ParentT;
  typedef ParentT :: Color Color;

  typedef msbGrid :: Scalar Scalar;

private:
  /* data for *.m output files */
  msbGrid :: Marker marker_;

  /* data for *.geo output files */
  Scalar cl_;       /* Characteristic length */

public:
  PointsBlock() : ParentT()
  {
    marker_.symbol = "'o'";
    marker_.size = 4;
    marker_.edgeColor = Black;
    marker_.faceColor = White;

    cl_ = Scalar(1.0);
  }

  const msbGrid :: Marker &marker() const
  { return marker_; }

  void putMarkerSymbol(const std :: string &value)
  {
    this->marker_.symbol = value;

    for ( int iEnt = 0; iEnt < this->size(); ++iEnt ) {
      this->vEnt() [ iEnt ].marker().symbol = this->marker_.symbol;
    }
  }

  void putMarkerSize(const double &value)
  {
    this->marker_.size = value;

    for ( int iEnt = 0; iEnt < this->size(); ++iEnt ) {
      this->vEnt() [ iEnt ].marker().size = this->marker_.size;
    }
  }

  void putMarkerEdgeColor(const Color &value)
  {
    this->marker_.edgeColor = value;

    for ( int iEnt = 0; iEnt < this->size(); ++iEnt ) {
      this->vEnt() [ iEnt ].marker().edgeColor = this->marker_.edgeColor;
    }
  }

  void putMarkerFaceColor(const Color &value)
  {
    this->marker_.faceColor = value;

    for ( int iEnt = 0; iEnt < this->size(); ++iEnt ) {
      this->vEnt() [ iEnt ].marker().faceColor = this->marker_.faceColor;
    }
  }

  void putMarkerProperties(const std :: string &mSymbol
                           , const double &mSize
                           , const Color &mEdgeColor
                           , const Color &mFaceColor)
  {
    putMarkerSymbol(mSymbol);
    putMarkerSize(mSize);
    putMarkerEdgeColor(mEdgeColor);
    putMarkerFaceColor(mFaceColor);
  }

  const Scalar &cl() const
  { return cl_; }

  Scalar &cl()
  { return cl_; }

  void putCl(const Scalar &cl0)
  {
    for ( int ip = 0; ip < size(); ++ip ) {
      if ( !this->vEnt() [ ip ].mark() ) {
        this->vEnt() [ ip ].cl() = cl0;
      }
    }
  }
}; /* class msbGrid::PointsBlock */

#endif  /* #ifndef _POINTS_BLOCK_HH_ */

#ifndef _EDGES_BLOCK_HH_
#define _EDGES_BLOCK_HH_

namespace msbGrid
{
class EdgesBlock;
}

class msbGrid :: EdgesBlock : public msbGrid :: Block< msbGrid :: Edge >
{
public:
  typedef msbGrid :: Block< msbGrid :: Edge > ParentT;
  typedef ParentT :: Color Color;

private:
  Color color_;

public:
  EdgesBlock() : ParentT()
  {
    color_ = Black;
  }

  ~EdgesBlock() {}

  const Color &color() const
  { return color_; }

  void putColor(const Color &color0)
  {
    color_ = color0;

    for ( int iEnt = 0; iEnt < this->size(); ++iEnt ) {
      this->vEnt() [ iEnt ].color() = color_;
    }
  }
}; /* class msbGrid::EdgesBlock */

#endif  /* #ifndef _EDGES_BLOCK_HH_ */

#ifndef _CELLS_BLOCK_HH_
#define _CELLS_BLOCK_HH_

namespace msbGrid
{
template< typename CellT >
class CellsBlock;
}

template< typename CellT >
class msbGrid :: CellsBlock : public msbGrid :: Block< CellT >
{
public:
  typedef CellT Cell;
  typedef msbGrid :: Block< Cell > ParentT;
  typedef typename ParentT :: Color Color;

private:
  Color color_;

public:
  CellsBlock() : ParentT()
  {
    color_ = Black;
  }

  ~CellsBlock() {}

  const Color &color() const
  { return color_; }

  void putColor(const Color &color0)
  {
    color_ = color0;

    for ( int iEnt = 0; iEnt < this->size(); ++iEnt ) {
      this->vEnt() [ iEnt ].color() = color_;
    }
  }
}; /* class msbGrid::CellsBlock */

#endif  /* #ifndef _CELLS_BLOCK_HH_ */

#include <growthcohesion.hh>

#ifndef _POINTS_MULTI_BLOCK_HH_
#define _POINTS_MULTI_BLOCK_HH_

namespace msbGrid
{
class PointsMultiBlock;
}

class msbGrid :: PointsMultiBlock : public std :: vector< msbGrid :: PointsBlock >
{
public:
  typedef std :: vector< msbGrid :: PointsBlock > ParentT;

  typedef msbGrid :: InputData InputData;
  typedef msbGrid :: Color Color;

private:
  const InputData *inData_;
  Color color_;

public:
  PointsMultiBlock() : ParentT()
  {}

  ~PointsMultiBlock() {}

  void init(const InputData *inData0, const Color &color0)
  {
    inData_ = inData0;
    color_ = color0;
    ( * this ).resize( inData_->blockNumber() );
  }

  const Color &color() const
  { return color_; }

  template< typename StepperT >
  void fill(StepperT &stepper)
  {
    for ( int iStep = 0; iStep < stepper.iStepMax(); ++iStep ) {
      if ( !stepper.otherStep() ) {
        continue;
      }

 #if VERBOSE_LEVEL >= 1
      std :: cout << "## step = " << ( iStep + 1 ) << "\n";
 #endif
      step2_(stepper);
    }
  }

private:
  template< typename StepperT >
  const bool step_(StepperT &stepper)
  {
    Scalar distRef = inData_->dr() / sqrt(2.0);

    std :: vector< PointsBlock > mpscNew;
    stepper.otherStep() = false;
    int Jnd = 0;
    for ( int Ind = 0; Ind < size(); ++Ind ) {
      if ( stepper.newStep() [ Ind ] ) {
        Point ptRef( ( * this ) [ Ind ].vEnt() [ 0 ] );
        PointsBlock ps( msbGrid :: growth(ptRef, inData_, & stepper, Ind) );
        if ( !ps.empty() ) {
          mpscNew.push_back(ps);
          stepper.newStep() [ Ind ] = update_(mpscNew, Jnd, Ind);
          ++Jnd;
          ( * this ) [ Ind ].add(mpscNew [ Jnd - 1 ]);

          if ( stepper.newStep() [ Ind ] == true ) {
            stepper.otherStep() = true;
          }
        }
      }
    }

    stepper.Id() += 1;
    stepper.firstStep() = false;
    return stepper.otherStep();
  }

  template< typename StepperT >
  const bool step2_(StepperT &stepper)
  {
    Scalar distRef = inData_->dr() / sqrt(2.0);

    std :: vector< PointsBlock > mpscNew;
    mpscNew.clear();
    stepper.otherStep() = false;
    int jBl1 = 0;
    for ( int iBl1 = 0; iBl1 < inData_->blockNumber(); ++iBl1 ) {
      if ( stepper.newStep() [ iBl1 ] ) {
        const Point ptRef(inData_->blockCenter() [ iBl1 ].first, inData_->blockCenter() [ iBl1 ].second);
        PointsBlock ps( msbGrid :: growth2( ptRef, inData_, & stepper, iBl1, ( * this ).color() ) );
        if ( !ps.empty() ) {
          mpscNew.push_back(ps);
          stepper.newStep() [ iBl1 ] = update2_(mpscNew, jBl1, iBl1);
          ( * this ) [ iBl1 ].add(mpscNew [ jBl1 ]);
          ++jBl1;

          if ( stepper.newStep() [ iBl1 ] == true ) {
            stepper.otherStep() = true;
          }
        }
      }
    }

    stepper.Id() += 1;
    stepper.firstStep() = false;
    return stepper.otherStep();
  }

  const bool update_(std :: vector< PointsBlock > &mpscNew, const int &Jnd, const int &Ind)
  {
    for ( int iBl1 = 0; iBl1 < size(); ++iBl1 ) {
      if ( iBl1 != Ind ) {
        msbGrid :: cohesion(mpscNew [ Jnd ], ( * this ) [ iBl1 ], inData_);
      }

      if ( size() == 1 ) {
        msbGrid :: cohesion(mpscNew [ Jnd ], ( * this ) [ iBl1 ], inData_);
      }
    }

    mpscNew [ Jnd ].cleanUp();
    return ( mpscNew [ Jnd ].size() != 0 );
  }

  const bool update2_(std :: vector< PointsBlock > &mpscNew, const int &Jnd, const int &Ind)
  {
    if ( size() == 1 ) {
      msbGrid :: cohesion(mpscNew [ Jnd ], inData_);
    }

    for ( int iBl1 = 0; iBl1 < size(); ++iBl1 ) {
      if ( iBl1 != Ind ) {
        msbGrid :: cohesion(mpscNew [ Jnd ], ( * this ) [ iBl1 ], inData_);
      }
    }

    mpscNew [ Jnd ].cleanUp();
    return ( mpscNew [ Jnd ].size() != 0 );
  }
}; /* class msbGrid::PointsMultiBlock */

#endif  /* #ifndef _POINTS_MULTI_BLOCK_HH_ */