mumechtest.cpp

Go to the documentation of this file.

//********************************************************************************************************
// code:                          ###  ###  #####   ####  ##  ##
//                       ##  ##   ########  ##     ##  ## ##  ##
//                       ##  ##   ## ## ##  ###    ##     ######
//                       ##  ##   ##    ##  ##     ##  ## ##  ##
//                       #####    ##    ##  #####   ####  ##  ##
//                       ##
//
// name:           mumechtest.h
// author(s):      Ladislav Svoboda
// language:       C, C++
// license:        This program is free software; you can redistribute it and/or modify
//                 it under the terms of the GNU Lesser General Public License as published by
//                 the Free Software Foundation; either version 2 of the License, or
//                 (at your option) any later version.
//
//                 This program 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 Lesser General Public License for more details.
//
//                 You should have received a copy of the GNU Lesser General Public License
//                 along with this program; if not, write to the Free Software
//                 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
//********************************************************************************************************
#include "types.h"

#include <string.h>
#include "problem.h"
#include "tests.h"
#include "macros.h"

#include "librw.h"


using namespace mumech;

enum mainBoolOpt {
  MBO_Tests_Verif,             // verified tests
  MBO_Tests_Tools,             // tools
  
  MBO_Tests_Tom,               // Tom's tests will be run
  MBO_Tests_Termit,            // Termit's tests will be run
  MBO_Tests_Standa,            // Standa's tests will be run
  MBO_Tests_Honza,             // Honza's tests will be run
  MBO_Tests_Lukas,             // Lukas's tests will be run
  MBO_Tests_Vorel,             // Vorlas'ojc tests will be run
  
  cMBO                         // count of ...
};

void help (void);
bool parameters (int argc, char *argv[], bool MBO[]);


int main (int argc, char *argv[])
{
  // version
  if (AP_find_option (argc, argv, "--version"))
    { fprintf (stdout, "%.2f\n", VERSION); return 0; }
  
  bool MBO[cMBO];                       // array with main Boolean Options
  memset(MBO, 0, cMBO*sizeof(bool));
  
  // detection of paramaters
  if (parameters (argc, argv, MBO) == false)
    help();
  
  
  if (MBO[MBO_Tests_Verif])  tests_verified();  // verified tests
  if (MBO[MBO_Tests_Tools])  tests_tools();     // tools
  
  if (MBO[MBO_Tests_Tom])    tests_tom();       // Tom's custom tests.
  if (MBO[MBO_Tests_Termit]) tests_termit();    // Termit's custom tests.
  if (MBO[MBO_Tests_Standa]) tests_standa();    // Standa's custom tests.
  if (MBO[MBO_Tests_Honza])  tests_honza();     // Honza's custom tests.
  if (MBO[MBO_Tests_Lukas])  tests_lukas();     // Lukas's custom tests.
  if (MBO[MBO_Tests_Vorel])  tests_vorel();     // Vorlas's custom tests.
  
  return 0;
}
// ***  END OF MAIN  ***


void help (void)
{
  fprintf (stdout,
"                                                          \n"
"                      ************                        \n"
"                         MuMECH                           \n"
"                      ************                        \n"
"    An open source C++ library of analytical solutions    \n"
"               to micromechanical problems                \n"
"            Copyright (C) 2013-2014 Jan Novák             \n"
"                                                          \n"
" SYNTAX   mumech [--help|--version]                       \n"
"          mumech -main_tests_*                            \n"
"                                                          \n"
" DESCRIPTION                          \n"
"                              \n"
"  --help    ... print this help                           \n"
"  --version ... print this help                           \n"
"                              \n"
"  -main_tests_verified                                    \n"
"  -main_tests_tools                                       \n"
"                              \n"
"  -main_tests_tom                                         \n"
"  -main_tests_termit                                      \n"
"  -main_tests_standa                                      \n"
"  -main_tests_honza                                       \n"
"  -main_tests_lukas                                       \n"
"  -main_tests_vorel                                       \n"
"                                                          \n\n");
}


// *****************************************************************************************
// ***   ***   ***   ***   ***      DETECTION OF PARAMETRES      ***   ***   ***   ***   ***
// *****************************************************************************************
bool parameters (int argc, char *argv[], bool MBO[])
{
  // ***
  // ***  HELP PARAMETER
  // ***
  if (argc==1 || AP_find_option (argc,argv,"--help"))  return false;
  
  // ***
  // ***  find file with PARAMETERS
  // ***
  long cmdl_argc = 0;
  if (long pos = AP_find_option (argc, argv, "-f")) {
    FILE *par = _openFileN ("r", "File with options", argv[pos+1]);
    
    cmdl_argc = argc;
    long file_argc = FP_number_of_words (par);   rewind(par);
    
    if (file_argc) {
      char **cmdl_argv = argv;
      argv = new char*[cmdl_argc + file_argc];
      
      for (argc=0; argc<cmdl_argc; argc++)
    argv[argc] = cmdl_argv[argc];
      
      for (; argc<cmdl_argc + file_argc; argc++) {
    FP_skip_nonword (par);
    FP_skip_line_commented (par);
    if (!FP_skip_nonword (par)) break;
    argv[argc] = new char[1023];
    FP_scan_word (par, argv[argc]);
      }
    }
    fclose (par);
  }
  
  
  printf ("Detection of command line parameters\n");
  
  char commpar1[1023]; commpar1[0] = '\0';
  char commpar2[1023]; commpar2[0] = '\0';

  //double auxd;
  //char auxs[1023];
  
  for (int i=1; i<argc; i++) {
    if      (!_STRCMP("-f",                  argv[i])) i++;
    // ***
    // ***   tests
    // ***
    else if (!_STRCMP("-main_tests_verified",  argv[i])) {  MBO[MBO_Tests_Verif]  = true;   sprint_param (commpar1, argv+i, 1); }
    else if (!_STRCMP("-main_tests_tools",     argv[i])) {  MBO[MBO_Tests_Tools]  = true;   sprint_param (commpar1, argv+i, 1); }
    else if (!_STRCMP("-main_tests_tom",       argv[i])) {  MBO[MBO_Tests_Tom]    = true;   sprint_param (commpar1, argv+i, 1); }
    else if (!_STRCMP("-main_tests_termit",    argv[i])) {  MBO[MBO_Tests_Termit] = true;   sprint_param (commpar1, argv+i, 1); }
    else if (!_STRCMP("-main_tests_standa",    argv[i])) {  MBO[MBO_Tests_Standa] = true;   sprint_param (commpar1, argv+i, 1); }
    else if (!_STRCMP("-main_tests_honza",     argv[i])) {  MBO[MBO_Tests_Honza]  = true;   sprint_param (commpar1, argv+i, 1); }
    else if (!_STRCMP("-main_tests_lukas",     argv[i])) {  MBO[MBO_Tests_Lukas]  = true;   sprint_param (commpar1, argv+i, 1); }
    else if (!_STRCMP("-main_tests_vorel",     argv[i])) {  MBO[MBO_Tests_Vorel]  = true;   sprint_param (commpar1, argv+i, 1); }
    
    // ***
    // ***
    // ***
    //else if (!_STRCMP("-min_axes_diff",        argv[i])) {  Pd->set_semiaxes_min_difference(atof(argv[++i]));  sprint_param (commpar2, argv+i, 2);  if (Pd->give_semiaxes_min_difference() == _MIN_AXES_DIFF) _errorr2("Please, set the -min_axes_diff value different from %lf", _MIN_AXES_DIFF); }  ///
    //else if (!_STRCMP("-max_axes_diff",        argv[i])) {  Pd->set_semiaxes_max_difference(atof(argv[++i]));  sprint_param (commpar2, argv+i, 2);  if (Pd->give_semiaxes_max_difference() == _MAX_AXES_DIFF) _errorr2("Please, set the -max_axes_diff value different from %lf", _MAX_AXES_DIFF); }  ///
    
    // unknown non-empty parameter
    else if (argv[i][0] != '\0')  _errorr2 ("unknown parameter \"%s\"", argv[i]);
  }
  
  // ***
  // ***  PRINT OF PARAMETERS
  // ***
  fprintf (stdout,"Parameters: %s %s\n\n", commpar1, commpar2);
  
  // deallocation
  if (cmdl_argc) {
    for (int i=cmdl_argc; i<argc; i++)
      delete [] argv[i];
    
    delete [] argv;
  }
  
  return true;
}