gridcreator.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.                      *
*****************************************************************************/
#include <inputdata.hh>
#include <gridfactory.hh>
#include <commandlinereader.hh>

#ifndef _GRID_CREATOR_HH_
#define _GRID_CREATOR_HH_

namespace msbGrid
{
template< typename CellT, typename InitialDistributionT >
int makeGrid( int argc,
              char **argv,
              void (*usage)(const char *, const std :: string &) );

std :: string usageTextBlock()
{
  return "Options usually are parameters given to the simulation, \n"
         "and have to be specified with this syntax: \n"
         "\t--ParameterName=VALUE, for example --xMin=\"0\"\n"
         "Parameters specified on the command line have priority over those in the parameter file.\n"
         "If no parameter file name is given, './<programname>.input' is chosen as default.\n"
         "\n"
         "Important options include:\n"
         "\t-h, --help                        Print this usage message and exit\n"
         "\t-PrintParameters [true|false]     Print the run-time modifiable parameters _after_ \n"
         "\t                                  the simulation [default: true]\n"
         "\t-PrintProperties [true|false]     Print the compile-time parameters _before_ \n"
         "\t                                  the simulation [default: false]\n"
         "\t-ParameterFile FILENAME           File with parameter definitions\n"
         "\n";
}
}

template< typename CellT, typename InitialDistributionT >
int msbGrid :: makeGrid( int argc,
                         char **argv,
                         void (*usage)(const char *, const std :: string &) )
{
  typedef CellT Cell;
  enum { dim = Cell :: dim };

  typedef InitialDistributionT InitialDistribution;

  typedef typename msbGrid :: GridFactory< Cell > GridFactory;
  typedef msbGrid :: Scalar Scalar;
  typedef msbGrid :: InputData InputData;
  typedef msbGrid :: Point Point;
  typedef msbGrid :: Edge Edge;

  try
  {
    // parse the command line arguments

    // check whether the user did not specify any parameter.
    // in this case print the usage message
    if ( argc == 1 ) {
      std :: cout << "No parameter file given. Defaulting to '"
                  << argv [ 0 ]
                  << ".input' for input file.\n";
      std :: ifstream parameterFile;
      // check whether the parameter file exists.
      std :: string defaultName = argv [ 0 ];
      defaultName += ".input";
      parameterFile.open( defaultName.c_str() );
      if ( !parameterFile.is_open() ) {
        std :: cout << " -> Could not open file '"
                    << defaultName
                    << "'. <- \n\n";
        usage( argv [ 0 ], msbGrid :: usageTextBlock() );
        return 1;
      }

      parameterFile.close();
    }

    // check whether the user wanted to see the help message
    for ( int i = 1; i < argc; ++i ) {
      if ( std :: string("--help") == argv [ i ] || std :: string("-h") == argv [ i ] ) {
        usage( argv [ 0 ], msbGrid :: usageTextBlock() );
        return 0;
      }
    }

    // check whether the user wanted to see the package version
    for ( int i = 1; i < argc; ++i ) {
      if ( std :: string("--version") == argv [ i ] || std :: string("-v") == argv [ i ] ) {
        std :: cout << PACKAGE_STRING << "\n";
        return 0;
      }
    }

    // fill the parameters tree with the options from the command line
    std :: string s = msbGrid :: readCommandLineOptions( argc, argv, msbGrid :: ParameterTree :: tree() );
 #if VERBOSE_LEVEL >= 2
    std :: cout << "command line options are:\n";
    msbGrid :: ParameterTree :: tree().report();
 #endif

    if ( !s.empty() ) {
      std :: cerr << s;
      std :: string usageMessage = msbGrid :: usageTextBlock();
      usage(argv [ 0 ], usageMessage);
      return 1;
    }

    // obtain the name of the parameter file
    std :: string defaultName = argv [ 0 ];
    defaultName += ".input";
    std :: string parameterFileName = msbGrid :: ParameterTree :: tree().get("ParameterFile", defaultName);

    // open and check whether the parameter file exists.
    std :: ifstream parameterFile( parameterFileName.c_str() );
    if ( !parameterFile.is_open() ) {
      // if the name of the file has been specified,
      // this must be an error. Otherwise proceed.
      if ( ParameterTree :: tree().hasKey("ParameterFile") ) {
        std :: cout << "\n\t -> Could not open file '"
                    << parameterFileName
                    << "'. <- \n\n";
        usage( argv [ 0 ], usageTextBlock() );
        return 1;
      }
    } else {
      // read parameters from the file without overwriting
      msbGrid :: ParameterTreeParser :: readINITree(parameterFileName,
                                                    msbGrid :: ParameterTree :: tree(),
                                                    /*overwrite=*/ false);
    }

    parameterFile.close();

    // read primary input data
    std :: string outputPath = msbGrid :: ParameterTree :: tree().get("OutputPath", "../../output/");
    std :: string outputDirName = msbGrid :: ParameterTree :: tree().get("OutputDirName", "");
    const Scalar xMin = msbGrid :: ParameterTree :: tree().get("XMin", 0.0);
    const Scalar xMax = msbGrid :: ParameterTree :: tree().get("XMax", 1.0);
    std :: vector< Scalar > blockNumberCoeff;
    blockNumberCoeff.clear();
    blockNumberCoeff.push_back( msbGrid :: ParameterTree :: tree().get("BnCx", 1.0) ); // x axis
    blockNumberCoeff.push_back( msbGrid :: ParameterTree :: tree().get("BnCy", 1.0) ); // y axis
    const Scalar dr = msbGrid :: ParameterTree :: tree().get("Dr", 0.1);
    const Scalar rafCoeff = msbGrid :: ParameterTree :: tree().get("RafC", 1.0);
    // read secondary input data
    const std :: string blockCenterDistribution = msbGrid :: ParameterTree :: tree().get("BCDistType", "random");
    const std :: string blockAngleDistribution = msbGrid :: ParameterTree :: tree().get("BADistType", "random");
    const int blockCenterRandSeqIdDefault = 0 /*(unsigned)time(0)*/;
    const int blockAngleRandSeqIdDefault = 0 /*(unsigned)time(0)*/;
    const int blockCenterRandSeqId = msbGrid :: ParameterTree :: tree().get("BCId", blockCenterRandSeqIdDefault);
    const int blockAngleRandSeqId = msbGrid :: ParameterTree :: tree().get("BAId", blockAngleRandSeqIdDefault);
    const Scalar blockCenterPertCoeff = msbGrid :: ParameterTree :: tree().get("BCPC", 0.0);
    const Scalar dist2BoundCoeff = msbGrid :: ParameterTree :: tree().get("D2bC", 1.0);
    const Scalar interBlockDistCoeff = msbGrid :: ParameterTree :: tree().get("IntbC", 1.0);

 #if VERBOSE_LEVEL >= 2
    std :: cout << "\n//*** primary input data ***//\n";
    std :: cout << "outputPath = " << outputPath << "\n";
    std :: cout << "xMin = " << xMin << ( xMin == 0 ? " (default value)" : "" ) << "\n";
    std :: cout << "xMax = " << xMax << ( xMax == 1 ? " (default value)" : "" ) << "\n";
    std :: cout << "blockNumberCoeffx = " << blockNumberCoeff [ 0 ] << ( blockNumberCoeff [ 0 ] == 1 ? " (default value)" : "" ) << "\n";
    std :: cout << "blockNumberCoeffy = " << blockNumberCoeff [ 1 ] << ( blockNumberCoeff [ 1 ] == 1 ? " (default value)" : "" ) << "\n";
    std :: cout << "dr = " << dr << ( dr == 0.1 ? " (default value)" : "" ) << "\n";
    std :: cout << "rafCoeff = " << rafCoeff << ( rafCoeff == 1 ? " (default value)" : "" ) << "\n";

    std :: cout << "\n//*** secondary input data ***//\n";
    std :: cout << "blockCenterDistribution = " << blockCenterDistribution << ( blockCenterDistribution == "periodic" ? " (default value)" : "" ) << "\n";
    std :: cout << "blockAngleDistribution = " << blockAngleDistribution << ( blockAngleDistribution == "random" ? " (default value)" : "" ) << "\n";
    std :: cout << "blockCenterRandSeqId = " << blockCenterRandSeqId << ( blockCenterRandSeqId == blockCenterRandSeqIdDefault ? " ( = (unsigned)time(0))" : "" ) << "\n";
    std :: cout << "blockAngleRandSeqId = " << blockAngleRandSeqId << ( blockAngleRandSeqId == blockAngleRandSeqIdDefault ? " ( = (unsigned)time(0))" : "" ) << "\n";
    std :: cout << "blockCenterPertCoeff = " << blockCenterPertCoeff << ( blockCenterPertCoeff == 0 ? " (default value)" : "" ) << "\n";
    std :: cout << "dist2BoundCoeff = " << dist2BoundCoeff << ( dist2BoundCoeff == 1 ? " (default value)" : "" ) << "\n";
    std :: cout << "interBlockDistCoeff = " << interBlockDistCoeff << ( interBlockDistCoeff == 1 ? " (default value)" : "" ) << "\n";
 #endif

    InputData inputDataTmp(xMin, xMax, blockNumberCoeff, dr, rafCoeff, dist2BoundCoeff, interBlockDistCoeff, outputPath, outputDirName);
    inputDataTmp.setSecondaryInputData(blockCenterDistribution, blockAngleDistribution, blockCenterRandSeqId, blockAngleRandSeqId, blockCenterPertCoeff);

    InitialDistribution initialDist( &inputDataTmp);

    if ( blockCenterDistribution == "periodic" ) {
      initialDist.periodicDist();
    }

    if ( blockCenterDistribution == "random" ) {
      initialDist.randomDist();
    }

    if ( blockCenterDistribution == "predefined" ) {
      initialDist.predefinedDist();
    }

    if ( blockAngleDistribution == "random" ) {
      initialDist.randomAng();
    }

    if ( blockAngleDistribution == "predefined" ) {
      initialDist.predefinedAng();
    }

    /* input data */
    InputData inputData( xMin, xMax, blockNumberCoeff, dr, rafCoeff, dist2BoundCoeff, interBlockDistCoeff
                         , outputPath, outputDirName, initialDist.blockCenter(), initialDist.blockAngle() );

    if ( blockCenterDistribution == "predefined" ) {
      inputData.xMin() = initialDist.inData().xMin();
      inputData.xMax() = initialDist.inData().xMax();
    }

    inputData.setSecondaryInputData(blockCenterDistribution
                                    , blockAngleDistribution
                                    , blockCenterRandSeqId
                                    , blockAngleRandSeqId
                                    , blockCenterPertCoeff);

    /* make the grid */
    GridFactory gridFactory1( &inputData);

    return 0;
  }

  catch(int x)
  {
    return 1;
  }
}

#endif /* _GRID_CREATOR_HH_ */