The script is nothing but the same demo_veh_man.cpp. Anyways let me attach
it here.
I am not sure where should I add this
"*vehicle::SetDataPath(CHRONO_VEHICLE_DATA_DIR);".
Can you advise me on this please? *
*Thanks,*
*Prabanjan*
On Tuesday 27 February 2024 at 15:34:36 UTC [email protected] wrote:
> Prabas,
> please always provide a reference to the script that throws issues, not
> just the error itself.
>
> Second: I wrote to you in the previous post " I think you are also missing
> *vehicle::SetDataPath(CHRONO_VEHICLE_DATA_DIR);"*Did you do it?
>
> Il giorno martedì 27 febbraio 2024 alle 15:50:13 UTC+1 [email protected]
> ha scritto:
>
>> Dear Community,
>>
>> I am able to compile and run the template_project successfully. As a next
>> step I wanted to run the demo_VEH_MAN.cpp as it is. I copied the code to
>> new folder and modified the cmakefile accordingly. I modified nothing in
>> demo_VEH_MAN.cpp except adding SetChronoDataPath(CHRONO_DATA_DIR); next to
>> the main function. I am able to build and get the exe. but running the exe
>> throws the following error as shown in the attached image. I had a look at
>> discussions in this forum, they all suggest adding line
>> SetChronoDataPath(CHRONO_DATA_DIR); in .cpp, which doesn't help in my case.
>> Any help is highly appreciated.
>>
>> Thanks,
>> Prabanjan
>>
>
--
You received this message because you are subscribed to the Google Groups
"ProjectChrono" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
To view this discussion on the web visit
https://groups.google.com/d/msgid/projectchrono/4086e530-d126-48e9-bfda-25e7eaa48632n%40googlegroups.com.
#--------------------------------------------------------------
#
# Example of CMake configuration file to build an external
# project depending on Chrono and on optional Chrono modules.
#
# This minimal sample project can be used as a template for a
# user project. Modify sections 1, 2, and 3 below as appropriate.
#
#--------------------------------------------------------------
cmake_minimum_required(VERSION 3.18)
cmake_policy(SET CMP0091 NEW)
#--------------------------------------------------------------
# === 1 ===
# Set the project name
#--------------------------------------------------------------
project(my_project)
set(Chrono_DIR D:/chrono/chrono/build/cmake)
#--------------------------------------------------------------
# === 2 ===
# Find the Chrono package and any REQUIRED or OPTIONAL modules
# by invoking the find_package function in CONFIG mode:
# find_package(Chrono
# COMPONENTS req_module1 req_module1 ...
# OPTIONAL_COMPONENTS opt_module1 opt_module2 ...
# CONFIG)
# The following Chrono modules can be requested (case insensitive):
# Cascade, Cosimulation, Irrlicht, OpenGL, Matlab, Multicore, Gpu,
# PardisoMKL, PardisoProject, Postprocess, Python, Vehicle,
# VehicleCosimm, VSG.
# A component can be requested either as required or optional
# (see the CMake documentation for find_package).
#
# Note that you will have to set the variable Chrono_DIR to
# specify the location of the chrono-config.cmake script, if
# it is not in its default install location.
# Chrono_DIR can be either a Chrono build tree or a Chrono install tree.
#
# The following variables are set and can be used further down:
# Chrono_FOUND
# set to true if Chrono and all required components were found
# CHRONO_C_FLAGS
# CHRONO_CXX_FLAGS
# C and C++ compilation flags
# CHRONO_INCLUDE_DIRS
# additional paths for included headers
# CHRONO_LIBRARIES
# list of required libraries (with full path)
# CHRONO_LINKER_FLAGS
# additional linker flags
# CHRONO_DATA_DIR
# path to the Chrono data make_directory
#
# In addition, for each requested component [COMPONENT], the
# following variable is set to true (ON) or false (OFF):
# CHRONO_[COMPONENT]_FOUND
#
# In this example, we only request the Irrlicht module (required)
# and, for demonstration purposes, the PardisoMKL module (optional)
#--------------------------------------------------------------
LIST(APPEND CMAKE_PREFIX_PATH "${CMAKE_INSTALL_PREFIX}/../Chrono/lib")
find_package(Chrono
COMPONENTS Irrlicht Vehicle
OPTIONAL_COMPONENTS PardisoMKL
CONFIG)
# Include directories, compiler flags, libraries
set(COMPILER_FLAGS "${CH_CXX_FLAGS}")
set(LINKER_FLAGS "${CH_LINKERFLAG_EXE}")
list(APPEND LIBS "ChronoEngine")
list(APPEND LIBS "ChronoEngine_vehicle")
list(APPEND LIBS "ChronoModels_vehicle")
if(ENABLE_MODULE_IRRLICHT)
include_directories(${CH_IRRLICHT_INCLUDES})
set(COMPILER_FLAGS "${COMPILER_FLAGS} ${CH_IRRLICHT_CXX_FLAGS}")
list(APPEND LIBS "ChronoEngine_irrlicht")
list(APPEND LIBS "ChronoEngine_vehicle_irrlicht")
endif()
if(ENABLE_MODULE_VSG)
include_directories(${CH_VSG_INCLUDES})
list(APPEND LIBS "ChronoEngine_vsg")
list(APPEND LIBS "ChronoEngine_vehicle_vsg")
endif()
if(ENABLE_MODULE_PARDISO_MKL)
include_directories(${CH_MKL_INCLUDES})
set(COMPILER_FLAGS "${COMPILER_FLAGS} ${CH_MKL_CXX_FLAGS}")
set(LINKER_FLAGS "${LINKER_FLAGS} ${CH_MKL_LINK_FLAGS}")
list(APPEND LIBS "ChronoEngine_pardisomkl")
endif()
if(ENABLE_MODULE_MUMPS)
include_directories(${CH_MUMPS_INCLUDES})
list(APPEND LIBS "ChronoEngine_mumps")
endif()
if(ENABLE_MODULE_POSTPROCESS)
list(APPEND LIBS "ChronoEngine_postprocess")
endif()
#--------------------------------------------------------------
# Return now if Chrono or a required component was not found.
#--------------------------------------------------------------
if (NOT Chrono_FOUND)
message("Could not find Chrono or one of its required modules")
return()
endif()
#--------------------------------------------------------------
# Important! To ensure ABI compatibility, use the same C++ standard
# as the one used to build the Chrono libraries.
#--------------------------------------------------------------
set(CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_STANDARD ${CHRONO_CXX_STANDARD})
#--------------------------------------------------------------
# Enable creation of "application bundles" on MacOSX.
#--------------------------------------------------------------
# This is necessary for any Irrlicht-based project (like the example here).
# For OpenGL-based or non-graphics projects, this is optional and the block
# below can be removed (or else explcitly set CMAKE_MACOSX_BUNDLE to 'OFF').
#
# If creating application bundles, the build output will be named 'myexe.app'.
# Use the convenience script 'run_app.sh' available under
'contrib/appbundle-macosx/'
# to run:
# start_demo.sh myexe.app
if(APPLE)
set(CMAKE_MACOSX_BUNDLE ON)
endif()
#--------------------------------------------------------------
# Add path to Chrono headers and to headers of all dependencies
# of the requested modules.
#--------------------------------------------------------------
include_directories(${CHRONO_INCLUDE_DIRS})
#-----------------------------------------------------------------------------
# Fix for VS 2017 15.8 and newer to handle alignment specification with Eigen
#-----------------------------------------------------------------------------
if(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
if(MSVC AND ${MSVC_VERSION} GREATER_EQUAL 1915)
add_definitions( "-D_ENABLE_EXTENDED_ALIGNED_STORAGE" )
endif()
endif()
#--------------------------------------------------------------
# Tweaks to disable some warnings with MSVC
#--------------------------------------------------------------
if(MSVC)
add_definitions("-D_CRT_SECURE_NO_DEPRECATE") # avoids deprecation warnings
add_definitions("-D_SCL_SECURE_NO_DEPRECATE") # avoids deprecation warnings
add_definitions( "-DNOMINMAX" ) # do not use MSVC's min/max
macros
endif()
#--------------------------------------------------------------
# === 3 ===
# Add the executable from your project and specify all C++
# files in your project.
#--------------------------------------------------------------
add_executable(my_demo my_example.cpp)
#--------------------------------------------------------------
# Set properties for your executable target
#
# Note that here we define a macro CHRONO_DATA_DIR which will
# contain the path to the Chrono data directory, either in its
# source tree (if using a build version of Chrono), or in its
# install tree (if using an installed version of Chrono).
#--------------------------------------------------------------
target_compile_definitions(my_demo PUBLIC
"CHRONO_DATA_DIR=\"${CHRONO_DATA_DIR}\"")
target_compile_options(my_demo PUBLIC ${CHRONO_CXX_FLAGS})
target_link_options(my_demo PUBLIC ${CHRONO_LINKER_FLAGS})
#--------------------------------------------------------------
# Link to Chrono libraries and dependency libraries
#--------------------------------------------------------------
target_link_libraries(my_demo ${CHRONO_LIBRARIES})
#--------------------------------------------------------------
# === 4 (OPTIONAL) ===
#
# Optionally, add a custom command for copying all Chrono and
# dependency DLLs to the appropriate binary output folder.
# This function has effect only on Windows.
#
# DLLs will be copied into ${PROJECT_BINARY_DIR}/${config} by default
# or in ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${config} if only
CMAKE_RUNTIME_OUTPUT_DIRECTORY is set
# or to ${CMAKE_RUNTIME_OUTPUT_DIRECTORY_<CONFIG>} if the specific
CMAKE_RUNTIME_OUTPUT_DIRECTORY_<CONFIG> has been set
#--------------------------------------------------------------
# set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/bin")
# set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE "<mycustompathforrelease>")
add_DLL_copy_command()
// =============================================================================
// PROJECT CHRONO - http://projectchrono.org
//
// Copyright (c) 2014 projectchrono.org
// All rights reserved.
//
// Use of this source code is governed by a BSD-style license that can be found
// in the LICENSE file at the top level of the distribution and at
// http://projectchrono.org/license-chrono.txt.
//
// =============================================================================
// Authors: Radu Serban, Rainer Gericke
// =============================================================================
//
// Main driver function for the MAN truck models.
//
// The vehicle reference frame has Z up, X towards the front of the vehicle, and
// Y pointing to the left.
//
// =============================================================================
#include "chrono/core/ChStream.h"
#include "chrono/utils/ChUtilsInputOutput.h"
#include "chrono_vehicle/ChConfigVehicle.h"
#include "chrono_vehicle/ChVehicleModelData.h"
#include "chrono_vehicle/driver/ChDataDriver.h"
#include "chrono_vehicle/driver/ChInteractiveDriverIRR.h"
#include "chrono_vehicle/terrain/RigidTerrain.h"
#include "chrono_vehicle/wheeled_vehicle/ChWheeledVehicleVisualSystemIrrlicht.h"
#include "chrono_models/vehicle/man/MAN_5t.h"
#include "chrono_models/vehicle/man/MAN_7t.h"
#include "chrono_models/vehicle/man/MAN_10t.h"
#include "chrono_thirdparty/filesystem/path.h"
using namespace chrono;
using namespace chrono::irrlicht;
using namespace chrono::vehicle;
using namespace chrono::vehicle::man;
// =============================================================================
// Select one of the MAN truck models (5, 7, or 10)
#define TRUCK 5
// Initial vehicle location and orientation
ChVector<> initLoc(0, 0, 0.7);
ChQuaternion<> initRot(1, 0, 0, 0);
enum DriverMode { DEFAULT, RECORD, PLAYBACK };
DriverMode driver_mode = DEFAULT;
// Visualization type for vehicle parts (PRIMITIVES, MESH, or NONE)
VisualizationType chassis_vis_type = VisualizationType::MESH;
VisualizationType suspension_vis_type = VisualizationType::PRIMITIVES;
VisualizationType steering_vis_type = VisualizationType::PRIMITIVES;
VisualizationType wheel_vis_type = VisualizationType::MESH;
VisualizationType tire_vis_type = VisualizationType::MESH;
// Collision type for chassis (PRIMITIVES, MESH, or NONE)
CollisionType chassis_collision_type = CollisionType::NONE;
// Type of engine model (SHAFTS, SIMPLE, SIMPLE_MAP)
EngineModelType engine_model = EngineModelType::SIMPLE;
// Type of transmission model (SHAFTS, SIMPLE_MAP)
TransmissionModelType transmission_model =
TransmissionModelType::AUTOMATIC_SIMPLE_MAP;
// Type of tire model (TMEASY, TMSIMPLE)
TireModelType tire_model = TireModelType::TMSIMPLE;
// Type of break model (SIMPLE, SHAFTS)
BrakeType brake_model = BrakeType::SHAFTS;
// Rigid terrain
RigidTerrain::PatchType terrain_model = RigidTerrain::PatchType::BOX;
double terrainHeight = 0; // terrain height (FLAT terrain only)
double terrainLength = 200.0; // size in X direction
double terrainWidth = 200.0; // size in Y direction
// Point on chassis tracked by the camera
ChVector<> trackPoint(0.0, 0.0, 1.75);
// Contact method
ChContactMethod contact_method = ChContactMethod::SMC;
bool contact_vis = false;
// Simulation step sizes
double step_size = 1e-3;
double tire_step_size = step_size;
// Simulation end time
double t_end = 1000;
// Time interval between two render frames
double render_step_size = 1.0 / 50; // FPS = 50
// Debug logging
bool debug_output = false;
double debug_step_size = 1.0 / 1; // FPS = 1
// POV-Ray output
bool povray_output = false;
// =============================================================================
int main(int argc, char* argv[]) {
GetLog() << "Copyright (c) 2019 projectchrono.org\nChrono version: " <<
CHRONO_VERSION << "\n\n";
SetChronoDataPath(CHRONO_DATA_DIR);
std::cout << "Data directory: " << CHRONO_DATA_DIR << std::endl;
std::string objPath = "../data/vehicle/MAN_Kat1/meshes/MAN_5t_chassis.obj";
std::cout << "Attempting to load OBJ file from: " << objPath << std::endl;
// --------------
// Create systems
// --------------
#if !defined(TRUCK)
#define TRUCK 5
#endif
#if defined(TRUCK) && (TRUCK == 5)
std::string truck_name = "MAN_5t";
MAN_5t truck;
#endif
#if defined(TRUCK) && (TRUCK == 7)
std::string truck_name = "MAN_7t";
MAN_7t truck;
truck.SetDriveline6WD(false);
#endif
#if defined(TRUCK) && (TRUCK == 10)
std::string truck_name = "MAN_10t";
MAN_10t truck;
truck.SetDriveline8WD(false);
#endif
truck.SetContactMethod(contact_method);
truck.SetChassisCollisionType(chassis_collision_type);
truck.SetChassisFixed(false);
truck.SetInitPosition(ChCoordsys<>(initLoc, initRot));
truck.SetEngineType(engine_model);
truck.SetTransmissionType(transmission_model);
truck.SetTireType(tire_model);
truck.SetBrakeType(brake_model);
truck.SetTireStepSize(tire_step_size);
truck.Initialize();
truck.SetChassisVisualizationType(chassis_vis_type);
truck.SetSuspensionVisualizationType(suspension_vis_type);
truck.SetSteeringVisualizationType(steering_vis_type);
truck.SetWheelVisualizationType(wheel_vis_type);
truck.SetTireVisualizationType(tire_vis_type);
// Associate a collision system
truck.GetSystem()->SetCollisionSystemType(ChCollisionSystem::Type::BULLET);
// Create the terrain
RigidTerrain terrain(truck.GetSystem());
ChContactMaterialData minfo;
minfo.mu = 0.9f;
minfo.cr = 0.01f;
minfo.Y = 2e7f;
auto patch_mat = minfo.CreateMaterial(contact_method);
std::shared_ptr<RigidTerrain::Patch> patch;
switch (terrain_model) {
case RigidTerrain::PatchType::BOX:
patch = terrain.AddPatch(patch_mat, CSYSNORM, terrainLength,
terrainWidth);
patch->SetTexture(vehicle::GetDataFile("terrain/textures/tile4.jpg"), 200, 200);
break;
case RigidTerrain::PatchType::HEIGHT_MAP:
patch = terrain.AddPatch(patch_mat, CSYSNORM,
vehicle::GetDataFile("terrain/height_maps/test64.bmp"), 128,
128, 0, 4);
patch->SetTexture(vehicle::GetDataFile("terrain/textures/grass.jpg"), 16, 16);
break;
case RigidTerrain::PatchType::MESH:
patch = terrain.AddPatch(patch_mat, CSYSNORM,
vehicle::GetDataFile("terrain/meshes/test.obj"));
patch->SetTexture(vehicle::GetDataFile("terrain/textures/grass.jpg"), 100, 100);
break;
}
patch->SetColor(ChColor(0.8f, 0.8f, 0.5f));
terrain.Initialize();
// Create the vehicle Irrlicht interface
auto vis =
chrono_types::make_shared<ChWheeledVehicleVisualSystemIrrlicht>();
vis->SetWindowTitle(truck_name + " Truck Demo");
vis->SetChaseCamera(trackPoint, 10.0, 0.5);
vis->Initialize();
vis->AddLightDirectional();
vis->AddSkyBox();
vis->AddLogo();
vis->AttachVehicle(&truck.GetVehicle());
// -----------------
// Initialize output
// -----------------
const std::string out_dir = GetChronoOutputPath() + truck_name;
const std::string pov_dir = out_dir + "/POVRAY";
if (!filesystem::create_directory(filesystem::path(out_dir))) {
std::cout << "Error creating directory " << out_dir << std::endl;
return 1;
}
if (povray_output) {
if (!filesystem::create_directory(filesystem::path(pov_dir))) {
std::cout << "Error creating directory " << pov_dir << std::endl;
return 1;
}
terrain.ExportMeshPovray(out_dir);
}
std::string driver_file = out_dir + "/driver_inputs.txt";
utils::CSV_writer driver_csv(" ");
// ------------------------
// Create the driver system
// ------------------------
// Create the interactive driver system
ChInteractiveDriverIRR driver(*vis);
// Set the time response for steering and throttle keyboard inputs.
double steering_time = 1.0; // time to go from 0 to +1 (or from 0 to -1)
double throttle_time = 1.0; // time to go from 0 to +1
double braking_time = 0.3; // time to go from 0 to +1
driver.SetSteeringDelta(render_step_size / steering_time);
driver.SetThrottleDelta(render_step_size / throttle_time);
driver.SetBrakingDelta(render_step_size / braking_time);
// If in playback mode, attach the data file to the driver system and
// force it to playback the driver inputs.
if (driver_mode == PLAYBACK) {
driver.SetInputDataFile(driver_file);
driver.SetInputMode(ChInteractiveDriverIRR::InputMode::DATAFILE);
}
driver.Initialize();
// ---------------
// Simulation loop
// ---------------
if (debug_output) {
GetLog() << "\n\n============ System Configuration ============\n";
truck.LogHardpointLocations();
}
truck.GetVehicle().LogSubsystemTypes();
std::cout << "\nVehicle mass: " << truck.GetVehicle().GetMass() <<
std::endl;
// Number of simulation steps between miscellaneous events
int render_steps = (int)std::ceil(render_step_size / step_size);
int debug_steps = (int)std::ceil(debug_step_size / step_size);
// Initialize simulation frame counters
int step_number = 0;
int render_frame = 0;
if (contact_vis) {
vis->SetSymbolScale(1e-4);
vis->EnableContactDrawing(ContactsDrawMode::CONTACT_FORCES);
}
truck.GetVehicle().EnableRealtime(true);
while (vis->Run()) {
double time = truck.GetSystem()->GetChTime();
// End simulation
if (time >= t_end)
break;
// Render scene and output POV-Ray data
if (step_number % render_steps == 0) {
vis->BeginScene();
vis->Render();
vis->EndScene();
if (povray_output) {
// Zero-pad frame numbers in file names for postprocessing
std::ostringstream filename;
filename << pov_dir << "/data_" << std::setw(4) <<
std::setfill('0') << render_frame + 1 << ".dat";
utils::WriteVisualizationAssets(truck.GetSystem(),
filename.str());
}
render_frame++;
}
// Debug logging
if (debug_output && step_number % debug_steps == 0) {
GetLog() << "\n\n============ System Information ============\n";
GetLog() << "Time = " << time << "\n\n";
truck.DebugLog(OUT_SPRINGS | OUT_SHOCKS | OUT_CONSTRAINTS);
}
// Collect output data from modules (for inter-module communication)
DriverInputs driver_inputs = driver.GetInputs();
// Driver output
if (driver_mode == RECORD) {
driver_csv << time << driver_inputs.m_steering <<
driver_inputs.m_throttle << driver_inputs.m_braking
<< std::endl;
}
// Update modules (process inputs from other modules)
driver.Synchronize(time);
terrain.Synchronize(time);
truck.Synchronize(time, driver_inputs, terrain);
vis->Synchronize(time, driver_inputs);
// Advance simulation for one timestep for all modules
driver.Advance(step_size);
terrain.Advance(step_size);
truck.Advance(step_size);
vis->Advance(step_size);
// Increment frame number
step_number++;
}
if (driver_mode == RECORD) {
driver_csv.write_to_file(driver_file);
}
return 0;
}
