Example #1
0
void ModelManager::loadList()
{
	fs::path ModelPath(L"./Data/Models/"), CacheFilePath(L"./Data/ModelCache.dat");
	if (!fs::exists(ModelPath)) throw std::ios_base::failure("Model directory not found");

	if (loadFromCache(CacheFilePath, ModelPath))
		return;

	// Rebuild the cache file, since it is invalid
	loadInternal(ModelPath);
	saveToCache(CacheFilePath, ModelPath);
}
Example #2
0
int main( int ac, char* av[] ) {

  try {

    std::cout << "FE analysis of Ducati steel trellis frame using FELyX\n";
   
    // PROGRAM OPTIONS
    // ---------------
    // Declare a group of options that will be allowed only on command line
    po::options_description generic( "Generic options" );
    unsigned noise;
    generic.add_options()
    ( "version,v", "Print version string" )
    ( "help,h", "Produce help message" )
    ( "noise,n", po::value<unsigned>( &noise ) ->default_value( 2 ), "Verbosity level (0-2)" )
    ;

    // Declare groups of options that will be allowed both on command line and in config file
    po::options_description solution( "Solution strategies" );
    std::string bwalgo, solver;
    solution.add_options()
#ifdef HAVE_PARDISO
    ( "bwalgo", po::value<std::string>( &bwalgo ) ->default_value( "mmd" ),
      "Bandwidth algorithm (mmd, sloan, reverse_sloan, cuthill_mckee, reverse_cuthill_mckee)" )
    ( "solver", po::value<std::string>( &solver ) ->default_value( "pardiso" ), "Solver (pardiso, skyline)" )
#else
    ( "bwalgo", po::value<std::string>( &bwalgo ) ->default_value( "sloan" ),
      "Bandwidth algorithm (sloan, reverse_sloan, cuthill_mckee, reverse_cuthill_mckee)" )
    ( "solver", po::value<std::string>( &solver ) ->default_value( "skyline" ), "Solver (pardiso, skyline)" )
#endif
    ;

    // Files to manage
    po::options_description files( "Files" );
    files.add_options()
    ( "model-path", po::value<std::string>() ->default_value( "DucatiFrameFEModel.ansys" ),
      "Finite Element model to be used" )
    ( "res-path", po::value<std::string>() ->default_value( "DucatiFrame.objectives" ),
      "Path to result file where objective values are stored" )
    ( "param-format", po::value<std::string>() ->default_value( "DoubleList" ),
      "Format of param file to read" )
    ( "param-path", po::value<std::string>() ->default_value( "DoubleList.params" ),
      "Path to parameter file")
    ;

    // Put the different option containers together
    po::options_description options( "\nFELyX usage: program [options] model_path \nAllowed options" );
    options.add( generic ).add( solution ).add( files );

    // Store options in variables_map
    po::variables_map vm;
    store( po::parse_command_line( ac, av, options ), vm );
    notify( vm );

    // Define reactions for the different options
    if ( vm.count( "help" ) ) {
      std::cout << options << "\n";
      return 0;
    }

    if ( vm.count( "version" ) ) {
      std::cout << "\nFELyX " << VERSION << " - The Finite Element LibrarY eXperiment \n\n";
      return 0;
    }

    fs::path ModelPath( vm[ "model-path" ].as<std::string>(), fs::native );
    fs::path ResPath  ( vm[ "res-path"   ].as<std::string>(), fs::native );
    std::string ParamFormat = vm[ "param-format"   ].as<std::string>();
    fs::path ParamPath( vm[ "param-path"   ].as<std::string>(), fs::native );

    
    // RUN FEA ANALYSIS
    //StructObject FEM(ModelPath.leaf(), fs::complete(ModelPath).branch_path().native_file_string(),noise );

    DucFelyxObject FEM( noise, 15, ModelPath );
   
    FEM.NodesReordering( bwalgo );

    FEM.updateTubeProperties(ParamPath,ParamFormat);
    
    // Save new model, if needed
    // FEM.SaveAnsysModel();
    
    FEM.ApplyTorsionLoadcase();

    if ( solver == "skyline" )
      FEM.DirectSolver();
    else if ( solver == "pardiso" )
      FEM.SparseSolver();
    else
      std::cerr << "WARNING: No valid solver type specified, evaluating nothing!\n ";

    double Stiffness= FEM.EvalTorsionStiffness();

    FEM.ApplyBrakingLoadcase();

    if ( solver == "skyline" )
      FEM.DirectSolver();
    else if ( solver == "pardiso" )
      FEM.SparseSolver();
    else
      std::cerr << "WARNING: No valid solver type specified, evaluating nothing!\n ";

    double MaxStress= FEM.EvalMaxStress( 1, 2 ) ;

    double Mass= FEM.EvalMass(1,2);
    
    exportObjectives( ResPath, Mass, Stiffness, MaxStress);
     
  }

  // Catch exceptions
  catch ( std::exception & e ) {
    cerr << e.what() << endl;
    return 1;
  }

  std::cout << "FELyX analysis done\n";

  return 0;
}