initialdistribution.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 _INITIAL_DISTRIBUTION_HH_
#define _INITIAL_DISTRIBUTION_HH_

#include <cstdlib>
#include <cmath>
#include <algorithm>

namespace msbGrid
{
class InitialDistribution
{
public:
  typedef msbGrid :: InputData InputData;

private:
  InputData *inData_;
  std :: vector< std :: pair< Scalar, Scalar > > blockCenter_;
  std :: vector< Scalar > blockAngle_;

public:
  InitialDistribution(InputData * inData0)
  {
    inData_ = inData0;
  }

  const InputData &inData() const
  {
    return * inData_;
  }

  InputData &inData()
  {
    return * inData_;
  }

  void periodicDist()
  {
    Scalar xMin = inData_->xMin(), xMax = inData_->xMax();
    const Scalar yMin = inData_->yMin(xMin), yMax = inData_->yMax(xMax);
    Scalar dx = Scalar(1.0) / inData_->blockNumberController() [ 0 ], dy = Scalar(1.0) / inData_->blockNumberController() [ 1 ];

    const Scalar xBegin = xMin + dx / Scalar(2.0), yBegin = yMin + dy / Scalar(2.0);
    for ( Scalar x = xBegin; x <= xMax; x += dx ) {
      for ( Scalar y = yBegin; y <= yMax; y += dy ) {
        const std :: pair< Scalar, Scalar > p0(x, y);
        blockCenter_.push_back(p0);
      }
    }
  }

  void randomDist()
  {
    std :: vector< std :: pair< Scalar, Scalar > > refBlockCenter;
    Scalar xMin = inData_->xMin(), xMax = inData_->xMax();
    const Scalar yMin = inData_->yMin(xMin), yMax = inData_->yMax(xMax);
    Scalar dx = Scalar(1.0) / inData_->blockNumberController() [ 0 ], dy = Scalar(1.0) / inData_->blockNumberController() [ 1 ];

    const Scalar xBegin = xMin + dx / Scalar(2.0), yBegin = yMin + dy / Scalar(2.0);
    for ( Scalar x = xBegin; x <= xMax; x += dx ) {
      for ( Scalar y = yBegin; y <= yMax; y += dy ) {
        const std :: pair< Scalar, Scalar > p0(x, y);
        refBlockCenter.push_back(p0);
      }
    }

    std :: srand( inData_->blockCenterRandSeqId() );
    const Scalar R = inData_->blockCenterPertCoeff() * inData_->dr();

    for ( unsigned int ib = 0; ib < refBlockCenter.size(); ++ib ) {
      const Scalar _alpha = randomAngle();
      const Scalar alpha = deg2Rad(_alpha);
      const Scalar dx = R * std :: cos(alpha), dy = R * std :: sin(alpha);

      const Scalar x_new = ( refBlockCenter [ ib ].first + dx ), y_new = ( refBlockCenter [ ib ].second + dy );
      const std :: pair< Scalar, Scalar > p0(x_new, y_new);
      blockCenter_.push_back(p0);
#if VERBOSE_LEVEL >= 1
      std :: cout << "block : " << ( ib + 1 )
                  << " , x_ref = " << refBlockCenter [ ib ].first
                  << " , y_ref = " << refBlockCenter [ ib ].second
                  << " , R = " << R
                  << " , alpha [deg] = " << _alpha
                  << " , dx = R * std::cos(alpha) = " << dx
                  << " , dy = R * std::sin(alpha) = " << dy
                  << " , x_new = " << x_new
                  << " , y_new = " << y_new
                  << "\n";
#endif
    }

#if VERBOSE_LEVEL >= 1
    std :: cout << "\n";
#endif
  }

  void randomAng()
  {
    std :: srand( inData_->blockAngleRandSeqId() );

    for ( int ib = 0; ib < blockCenter_.size(); ++ib ) {
      blockAngle_.push_back( msbGrid :: randomAngle() );
    }
  }

  void predefinedDist()
  {
    std :: cerr << "predefinedDist() : is not implemented here!!\n";
  }

  void predefinedAng()
  {
    std :: cerr << "predefinedAng() : is not implemented here!!\n";
  }

  const std :: vector< std :: pair< Scalar, Scalar > > &blockCenter() const
  {
    return blockCenter_;
  }

  std :: vector< std :: pair< Scalar, Scalar > > &blockCenter()
  {
    return blockCenter_;
  }

  const std :: vector< Scalar > &blockAngle() const
  {
    return blockAngle_;
  }

  std :: vector< Scalar > &blockAngle()
  {
    return blockAngle_;
  }
}; /*class InitialDistribution*/
} /*namespace msbGrid*/

#endif  /* #ifndef _INITIAL_DISTRIBUTION_HH_ */