inputdata.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 _INPUT_DATA_HH_
#define _INPUT_DATA_HH_

namespace msbGrid
{
class InputData;
}

class msbGrid :: InputData
{
private:
  Scalar xMin_, xMax_, dr_, rafCoeff_, dist2BoundCoeff_, interBlockDistCoeff_;
  std :: vector< Scalar > blockNumberController_;
  std :: string outputPath_, outputDirName_;
  std :: vector< std :: pair< Scalar, Scalar > > blockCenter_;
  std :: vector< Scalar > blockAngle_;
  std :: vector< Color > blockColor_;

  /* secondary input data : needed just to add output comments in *.geo files */

  std :: string blockCenterDistribution_;
  std :: string blockAngleDistribution_;
  int blockCenterRandSeqId_;
  int blockAngleRandSeqId_;
  int blockCenterPertCoeff_;

public:
  InputData(const Scalar & xMin
            , const Scalar & xMax
            , const std :: vector< Scalar > & blockNumberController
            , const Scalar & dr
            , const Scalar & rafCoeff
            , const Scalar & dist2BoundCoeff
            , const Scalar & interBlockDistCoeff
            , const std :: string & outputPath
            , const std :: string & outputDirName)
  {
    xMin_ = xMin;
    xMax_ = xMax;
    blockNumberController_ = blockNumberController;
    dr_ = dr;
    rafCoeff_ = rafCoeff;
    dist2BoundCoeff_ = dist2BoundCoeff;
    interBlockDistCoeff_ = interBlockDistCoeff;
    outputPath_ = outputPath;
    outputDirName_ = outputDirName;

    blockCenterRandSeqId_ = ( unsigned ) time(0);
    blockAngleRandSeqId_ = ( unsigned ) time(0);
    blockCenterPertCoeff_ = 0;
  }

  InputData(const Scalar & xMin
            , const Scalar & xMax
            , const std :: vector< Scalar > & blockNumberController
            , const Scalar & dr
            , const Scalar & rafCoeff
            , const Scalar & dist2BoundCoeff
            , const Scalar & interBlockDistCoeff
            , const std :: string & outputPath
            , const std :: string & outputDirName
            , const std :: vector< std :: pair< Scalar, Scalar > > & blockCenter
            , const std :: vector< Scalar > & blockAngle) : InputData(xMin, xMax, blockNumberController, dr, rafCoeff, dist2BoundCoeff, interBlockDistCoeff, outputPath, outputDirName)
  {
    if ( blockCenter.size() < blockAngle.size() ) {
      std :: cerr << "warning : blockCenter.size() < blockAngle.size() , additional angles will be ignored!!\n";
    }

    if ( blockCenter.size() > blockAngle.size() ) {
      std :: cerr << "warning : blockCenter.size() > blockAngle.size() , additional angles will be randomly generated!!\n";
    }

    blockCenter_.clear();
    blockAngle_.clear();
    blockColor_.clear();
    for ( unsigned int ib = 0; ib < blockCenter.size(); ++ib ) {
      blockCenter_.push_back(blockCenter [ ib ]);
      blockColor_.push_back( randomColor() );
    }

    for ( unsigned int ib = 0; ib < blockCenter.size(); ++ib ) {
      blockAngle_.push_back(blockAngle [ ib ]);
    }

    if ( blockCenter.size() > blockAngle.size() ) {
      for ( unsigned int ib = 0; ib < ( blockCenter.size() - blockAngle.size() ); ++ib ) {
        blockAngle_.push_back( randomAngle() );
      }
    }
  }

  ~InputData() {}

  void setSecondaryInputData(const std :: string &blockCenterDistribution,
                             const std :: string &blockAngleDistribution,
                             const int &blockCenterRandSeqId,
                             const int &blockAngleRandSeqId,
                             const int &blockCenterPertCoeff)
  {
    blockCenterDistribution_ = blockCenterDistribution;
    blockAngleDistribution_ = blockAngleDistribution;
    blockCenterRandSeqId_ = blockCenterRandSeqId;
    blockAngleRandSeqId_ = blockAngleRandSeqId;
    blockCenterPertCoeff_ = blockCenterPertCoeff;
  }

  const Scalar &xMin() const
  { return xMin_; }

  Scalar &xMin()
  { return xMin_; }

  const Scalar &xMax() const
  { return xMax_; }

  Scalar &xMax()
  { return xMax_; }

  const Scalar &dr() const
  { return dr_; }

  Scalar &dr()
  { return dr_; }

  const Scalar &rafCoeff() const
  { return rafCoeff_; }

  Scalar &rafCoeff()
  { return rafCoeff_; }

  const Scalar &dist2BoundCoeff() const
  { return dist2BoundCoeff_; }

  Scalar &dist2BoundCoeff()
  { return dist2BoundCoeff_; }

  const Scalar &interBlockDistCoeff() const
  { return interBlockDistCoeff_; }

  Scalar &interBlockDistCoeff()
  { return interBlockDistCoeff_; }

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

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

  const int blockNumber() const
  { return blockCenter_.size(); }

  const int lastBlockIdx() const
  { return ( blockNumber() - 1 ); }

  const std :: vector< Scalar > blockNumberController() const
  { return blockNumberController_; }

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

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

  const std :: vector< Color > &blockColor() const
  { return blockColor_; }

  std :: vector< Color > &blockColor()
  { return blockColor_; }

  const std :: string &outputPath() const
  { return outputPath_; }

  std :: string &outputPath()
  { return outputPath_; }

  const std :: string &outputDirName() const
  { return outputDirName_; }

  std :: string &outputDirName()
  { return outputDirName_; }

  Scalar yMin(const Scalar &x) const       
  { return xMin_; }

  Scalar yMax(const Scalar &x) const       
  { return xMax_ /*/2.*/; }

  /* to output secondary input data */
  const std :: string &blockCenterDistribution() const
  { return blockCenterDistribution_; }

  const std :: string &blockAngleDistribution() const
  { return blockAngleDistribution_; }

  const int &blockCenterRandSeqId() const
  { return blockCenterRandSeqId_; }

  const int &blockAngleRandSeqId() const
  { return blockAngleRandSeqId_; }

  const int &blockCenterPertCoeff() const
  { return blockCenterPertCoeff_; }
};      /* class InputData */

#endif  /* #ifndef _INPUT_DATA_HH_ */