Program Listing for File GeneralKModels_Py.cc

↰ Return to documentation for file (doxygen_docs/GeneralKModels/GeneralKModels_Py.cc)

#include"Karana/GeneralKModels/ComputedTorque.h"
#include"Karana/GeneralKModels/DataLogger.h"
#include"Karana/GeneralKModels/GeneralKModels_Py_doc.h"
#include"Karana/GeneralKModels/GraphicalSceneMovie.h"
#include"Karana/GeneralKModels/PID.h"
#include"Karana/GeneralKModels/PinJointLimits.h"
#include"Karana/GeneralKModels/PointMassGravity.h"
#include"Karana/GeneralKModels/ProjectConstraintError.h"
#include"Karana/GeneralKModels/SpringDamper.h"
#include"Karana/GeneralKModels/SubhingeForceLimits.h"
#include"Karana/GeneralKModels/SubhingeSpringDamper.h"
#include"Karana/GeneralKModels/SyncRealTime.h"
#include"Karana/GeneralKModels/TimeDisplay.h"
#include"Karana/GeneralKModels/UniformGravity.h"
#include"Karana/GeneralKModels/UpdateProxyScene.h"
#include"Karana/KCore/pybind11Utils.h"
#include"Karana/KCore/pybind11_chrono_numpy.h"
#include"Karana/Math/Defs.h"
#include"Karana/SOADyn/pybind11KModel.h"
#include<pybind11/eigen.h>
#include<pybind11/functional.h>
#include<pybind11/pybind11.h>
#include<pybind11/stl.h>
#include<pybind11/typing.h>


namespacepy=pybind11;

namespacekc=Karana::Core;
usingnamespaceKarana::Models;

ADD_TO_DS_METHOD_CASTER(SpringDamper,Karana.Models.GeneralKModels_types,SpringDamperDS)
ADD_TO_DS_METHOD_CASTER(PointMassGravity,Karana.Models.GeneralKModels_types,PointMassGravityDS)

PYBIND11_MODULE(_GeneralKModels_Py,m){

py::module::import("Karana.Dynamics._SOADyn_Py");

py::class_<UniformGravityParams,kc::ks_ptr<UniformGravityParams>>(
m,"UniformGravityParams",DOC(Karana,Models,UniformGravityParams))
.def("isFinalized",
&UniformGravityParams::isFinalized,
DOC(Karana,Models,UniformGravityParams,isFinalized))
.def_readwrite("g",&UniformGravityParams::g,DOC(Karana,Models,UniformGravityParams,g));

autoPyKmodelUniformGrav=
KModelPybind11<UniformGravity,UniformGravityParams>("UniformGravityKModel",m);

py::class_<UniformGravity,
KModel<UniformGravity, UniformGravityParams>,
kc::ks_ptr<UniformGravity>>(m,"UniformGravity",DOC(Karana,Models,UniformGravity))
.def(py::init<>(&UniformGravity::create),
py::arg("name"),
py::arg("sp"),
py::arg("st"),
DOC(Karana,Models,UniformGravity,create))
.def_static("create",
&UniformGravity::create,
py::arg("name"),
py::arg("sp"),
py::arg("st"),
DOC(Karana,Models,UniformGravity,create))
.def("preDeriv",
&UniformGravity::preDeriv,
py::arg("t"),
py::arg("x"),
DOC(Karana,Models,UniformGravity,preDeriv));

py::class_<PointMassGravityParams,kc::ks_ptr<PointMassGravityParams>>(
m,"PointMassGravityParams",DOC(Karana,Models,PointMassGravityParams))
.def("isFinalized",
&PointMassGravityParams::isFinalized,
DOC(Karana,Models,PointMassGravityParams,isFinalized))
.def_readwrite(
"mu",&PointMassGravityParams::mu,DOC(Karana,Models,PointMassGravityParams,mu));

autoPyKmodelPointMassGrav=
KModelPybind11<PointMassGravity,PointMassGravityParams>("PointMassGravityKModel",m);

py::class_<PointMassGravity,
KModel<PointMassGravity, PointMassGravityParams>,
kc::ks_ptr<PointMassGravity>>(
m,"PointMassGravity",DOC(Karana,Models,PointMassGravity))
.def(py::init<>(&PointMassGravity::create),
py::arg("name"),
py::arg("sp"),
py::arg("st"),
py::arg("central_body"),
DOC(Karana,Models,PointMassGravity,create))
.def_static("create",
&PointMassGravity::create,
py::arg("name"),
py::arg("sp"),
py::arg("st"),
py::arg("central_body"),
DOC(Karana,Models,PointMassGravity,create))
.def("preDeriv",
&PointMassGravity::preDeriv,
py::arg("t"),
py::arg("x"),
DOC(Karana,Models,PointMassGravity,preDeriv))
.def("getObjIds",
&PointMassGravity::getObjIds,
DOC(Karana,Models,PointMassGravity,getObjIds));

addToDSMethod<PointMassGravity>(PyKmodelPointMassGrav,
"PointMassGravity",
"Karana.Models.GeneralKModels_types",
"PointMassGravityDS");

py::class_<SpringDamperParams,kc::ks_ptr<SpringDamperParams>>(
m,"SpringDamperParams",DOC(Karana,Models,SpringDamperParams))
.def("isFinalized",
&SpringDamperParams::isFinalized,
DOC(Karana,Models,SpringDamperParams,isFinalized))
.def_readwrite("unsprung_length",
&SpringDamperParams::unsprung_length,
DOC(Karana,Models,SpringDamperParams,unsprung_length))
.def_readwrite("d",&SpringDamperParams::d,DOC(Karana,Models,SpringDamperParams,d))
.def_readwrite("k",&SpringDamperParams::k,DOC(Karana,Models,SpringDamperParams,k));

py::class_<SpringDamperScratch,kc::ks_ptr<SpringDamperScratch>>(
m,"SpringDamperScratch",DOC(Karana,Models,SpringDamperScratch))
.def_readwrite("offset",
&SpringDamperScratch::offset,
DOC(Karana,Models,SpringDamperScratch,offset))
.def_readwrite("position_error",
&SpringDamperScratch::position_error,
DOC(Karana,Models,SpringDamperScratch,position_error))
.def_readwrite("velocity_error",
&SpringDamperScratch::velocity_error,
DOC(Karana,Models,SpringDamperScratch,velocity_error))
.def_readwrite("stiffness_force",
&SpringDamperScratch::stiffness_force,
DOC(Karana,Models,SpringDamperScratch,stiffness_force))
.def_readwrite("damping_force",
&SpringDamperScratch::damping_force,
DOC(Karana,Models,SpringDamperScratch,damping_force))
.def_readwrite("total_force",
&SpringDamperScratch::total_force,
DOC(Karana,Models,SpringDamperScratch,total_force));

autoPyKmodelSpringDamper=
KModelPybind11<SpringDamper,SpringDamperParams,SpringDamperScratch>("SpringDamperKModel",
m);

py::class_<SpringDamper,
KModel<SpringDamper, SpringDamperParams, SpringDamperScratch>,
kc::ks_ptr<SpringDamper>>
PySpringDamper(m,"SpringDamper",DOC(Karana,Models,SpringDamper));

PySpringDamper
.def(py::init<>(&SpringDamper::create),
py::arg("name"),
py::arg("sp"),
py::arg("nd1"),
py::arg("nd2"),
DOC(Karana,Models,SpringDamper,create))
.def_static("create",
&SpringDamper::create,
py::arg("name"),
py::arg("sp"),
py::arg("nd1"),
py::arg("nd2"),
DOC(Karana,Models,SpringDamper,create))
.def("preDeriv",
&SpringDamper::preDeriv,
py::arg("t"),
py::arg("x"),
DOC(Karana,Models,SpringDamper,preDeriv))
.def("getNodeIds",&SpringDamper::getNodeIds,DOC(Karana,Models,SpringDamper,getNodeIds))
.def("sourceNode",&SpringDamper::sourceNode,DOC(Karana,Models,SpringDamper,sourceNode))
.def(
"targetNode",&SpringDamper::targetNode,DOC(Karana,Models,SpringDamper,targetNode));

addToDSMethod<SpringDamper>(
PySpringDamper,"SpringDamper","Karana.Models.GeneralKModels_types","SpringDamperDS");

py::class_<PinJointLimitsParams,kc::ks_ptr<PinJointLimitsParams>>(
m,"PinJointLimitsParams",DOC(Karana,Models,PinJointLimitsParams))
.def("isFinalized",
&PinJointLimitsParams::isFinalized,
DOC(Karana,Models,PinJointLimitsParams,isFinalized))
.def_readwrite("upper_limit",
&PinJointLimitsParams::upper_limit,
DOC(Karana,Models,PinJointLimitsParams,upper_limit))
.def_readwrite("lower_limit",
&PinJointLimitsParams::lower_limit,
DOC(Karana,Models,PinJointLimitsParams,lower_limit))
.def_readwrite("d",&PinJointLimitsParams::d,DOC(Karana,Models,PinJointLimitsParams,d))
.def_readwrite("k",&PinJointLimitsParams::k,DOC(Karana,Models,PinJointLimitsParams,k));

autoPyKmodelPinJointLimits=
KModelPybind11<PinJointLimits,PinJointLimitsParams>("PinJointLimitsKModel",m);

py::class_<PinJointLimits,
KModel<PinJointLimits, PinJointLimitsParams>,
kc::ks_ptr<PinJointLimits>>(m,"PinJointLimits",DOC(Karana,Models,PinJointLimits))
.def(py::init<>(&PinJointLimits::create),
py::arg("name"),
py::arg("sp"),
py::arg("pin"),
DOC(Karana,Models,PinJointLimits,create))
.def_static("create",
&PinJointLimits::create,
py::arg("name"),
py::arg("sp"),
py::arg("pin"),
DOC(Karana,Models,PinJointLimits,create))
.def("preDeriv",
&PinJointLimits::preDeriv,
py::arg("t"),
py::arg("x"),
DOC(Karana,Models,PinJointLimits,preDeriv));

py::class_<SubhingeSpringDamperParams,kc::ks_ptr<SubhingeSpringDamperParams>>(
m,"SubhingeSpringDamperParams",DOC(Karana,Models,SubhingeSpringDamperParams))
.def("isFinalized",
&SubhingeSpringDamperParams::isFinalized,
DOC(Karana,Models,SubhingeSpringDamperParams,isFinalized))
.def_readwrite("setpoint",
&SubhingeSpringDamperParams::setpoint,
DOC(Karana,Models,SubhingeSpringDamperParams,setpoint))
.def_readwrite(
"d",&SubhingeSpringDamperParams::d,DOC(Karana,Models,SubhingeSpringDamperParams,d))
.def_readwrite("k",
&SubhingeSpringDamperParams::k,
DOC(Karana,Models,SubhingeSpringDamperParams,k));

autoPyKmodelSubhingeSpringDamper=
KModelPybind11<SubhingeSpringDamper,SubhingeSpringDamperParams>(
"SubhingeSpringDamperKModel",m);

py::class_<SubhingeSpringDamper,
KModel<SubhingeSpringDamper, SubhingeSpringDamperParams>,
kc::ks_ptr<SubhingeSpringDamper>>(
m,"SubhingeSpringDamper",DOC(Karana,Models,SubhingeSpringDamper))
.def(py::init<>(&SubhingeSpringDamper::create),
py::arg("name"),
py::arg("sp"),
py::arg("sh"),
DOC(Karana,Models,SubhingeSpringDamper,create))
.def_static("create",
&SubhingeSpringDamper::create,
py::arg("name"),
py::arg("sp"),
py::arg("sh"),
DOC(Karana,Models,SubhingeSpringDamper,create))
.def("preDeriv",
&SubhingeSpringDamper::preDeriv,
py::arg("t"),
py::arg("x"),
DOC(Karana,Models,SubhingeSpringDamper,preDeriv));

py::class_<SubhingeForceLimitsParams,kc::ks_ptr<SubhingeForceLimitsParams>>(
m,"SubhingeForceLimitsParams",DOC(Karana,Models,SubhingeForceLimitsParams))
.def("isFinalized",
&SubhingeForceLimitsParams::isFinalized,
DOC(Karana,Models,SubhingeForceLimitsParams,isFinalized))
.def_readwrite("lower_limits",
&SubhingeForceLimitsParams::lower_limits,
DOC(Karana,Models,SubhingeForceLimitsParams,lower_limits))
.def_readwrite("upper_limits",
&SubhingeForceLimitsParams::upper_limits,
DOC(Karana,Models,SubhingeForceLimitsParams,upper_limits));

autoPyKmodelSubhingeForceLimits=
KModelPybind11<SubhingeForceLimits,SubhingeForceLimitsParams>("SubhingeForceLimitsKModel",
m);

py::class_<SubhingeForceLimits,
KModel<SubhingeForceLimits, SubhingeForceLimitsParams>,
kc::ks_ptr<SubhingeForceLimits>>(
m,"SubhingeForceLimits",DOC(Karana,Models,SubhingeForceLimits))
.def(py::init<>(&SubhingeForceLimits::create),
py::arg("name"),
py::arg("sp"),
py::arg("sh"),
DOC(Karana,Models,SubhingeForceLimits,create))
.def_static("create",
&SubhingeForceLimits::create,
py::arg("name"),
py::arg("sp"),
py::arg("sh"),
DOC(Karana,Models,SubhingeForceLimits,create))
.def("preDeriv",
&SubhingeForceLimits::preDeriv,
py::arg("t"),
py::arg("x"),
DOC(Karana,Models,SubhingeForceLimits,preDeriv));

py::class_<PIDParams,kc::ks_ptr<PIDParams>>(m,"PIDParams",DOC(Karana,Models,PIDParams))
.def("isFinalized",&PIDParams::isFinalized,DOC(Karana,Models,PIDParams,isFinalized))
.def_readwrite("kp",&PIDParams::kp,DOC(Karana,Models,PIDParams,kp))
.def_readwrite("kd",&PIDParams::kd,DOC(Karana,Models,PIDParams,kd))
.def_readwrite("ki",&PIDParams::ki,DOC(Karana,Models,PIDParams,ki));

autoPyKmodelPID=KModelPybind11<PID,PIDParams>("PIDKModel",m);

py::class_<PID,KModel<PID,PIDParams>,kc::ks_ptr<PID>>(m,"PID",DOC(Karana,Models,PID))
.def(py::init<>(&PID::create),
py::arg("name"),
py::arg("sp"),
py::arg("sh"),
py::arg("q_traj"),
py::arg("u_traj"),
DOC(Karana,Models,PID,create))
.def_static("create",
&PID::create,
py::arg("name"),
py::arg("sp"),
py::arg("sh"),
py::arg("q_traj"),
py::arg("u_traj"),
DOC(Karana,Models,PID,create))
.def("preModelStep",
&PID::preModelStep,
py::arg("t"),
py::arg("x"),
DOC(Karana,Models,PID,preModelStep))
.def("preDeriv",
&PID::preDeriv,
py::arg("t"),
py::arg("x"),
DOC(Karana,Models,PID,preDeriv));

autoPyKmodelUpdateProxyScene=KModelPybind11<UpdateProxyScene>("UpdateProxySceneKModel",m);

py::class_<UpdateProxyScene,KModel<UpdateProxyScene>,kc::ks_ptr<UpdateProxyScene>>(
m,"UpdateProxyScene",DOC(Karana,Models,UpdateProxyScene))
.def(py::init<>(&UpdateProxyScene::create),
py::arg("name"),
py::arg("sp"),
py::arg("scene"),
DOC(Karana,Models,UpdateProxyScene,create))
.def_static("create",
&UpdateProxyScene::create,
py::arg("name"),
py::arg("sp"),
py::arg("scene"),
DOC(Karana,Models,UpdateProxyScene,create))
.def("postHop",
&UpdateProxyScene::postHop,
py::arg("t"),
py::arg("x"),
DOC(Karana,Models,UpdateProxyScene,postHop));

autoPyKmodelSyncRealTime=KModelPybind11<SyncRealTime>("SyncRealTimeKModel",m);

py::class_<SyncRealTime,KModel<SyncRealTime>,kc::ks_ptr<SyncRealTime>>(
m,"SyncRealTime",DOC(Karana,Models,SyncRealTime))
.def(py::init<>(&SyncRealTime::create),
py::arg("name"),
py::arg("sp"),
py::arg("rt_speed")=1.0,
DOC(Karana,Models,SyncRealTime,create))
.def_static("create",
&SyncRealTime::create,
py::arg("name"),
py::arg("sp"),
py::arg("rt_speed")=1.0,
DOC(Karana,Models,SyncRealTime,create))
.def("preHop",
&SyncRealTime::preHop,
py::arg("t"),
py::arg("x"),
DOC(Karana,Models,SyncRealTime,preHop))
.def("postHop",
&SyncRealTime::postHop,
py::arg("t"),
py::arg("x"),
DOC(Karana,Models,SyncRealTime,postHop));

py::class_<TimeDisplayParams,kc::ks_ptr<TimeDisplayParams>>(
m,"TimeDisplayParams",DOC(Karana,Models,TimeDisplayParams))
.def("isFinalized",
&TimeDisplayParams::isFinalized,
DOC(Karana,Models,TimeDisplayParams,isFinalized))
.def_readwrite(
"color",&TimeDisplayParams::color,DOC(Karana,Models,TimeDisplayParams,color));

autoPyKmodelTimeDisplay=
KModelPybind11<TimeDisplay,TimeDisplayParams>("TimeDisplayKModel",m);

py::class_<TimeDisplay,KModel<TimeDisplay,TimeDisplayParams>,kc::ks_ptr<TimeDisplay>>(
m,"TimeDisplay",DOC(Karana,Models,TimeDisplay))
.def(py::init<>(&TimeDisplay::create),
py::arg("name"),
py::arg("sp"),
py::arg("scene"),
DOC(Karana,Models,TimeDisplay,create))
.def_static("create",
&TimeDisplay::create,
py::arg("name"),
py::arg("sp"),
py::arg("scene"),
DOC(Karana,Models,TimeDisplay,create))
.def("postModelStep",
&TimeDisplay::postModelStep,
py::arg("t"),
py::arg("x"),
DOC(Karana,Models,TimeDisplay,postModelStep));

py::class_<GraphicalSceneMovieParams,kc::ks_ptr<GraphicalSceneMovieParams>>(
m,"GraphicalSceneMovieParams",DOC(Karana,Models,GraphicalSceneMovieParams))
.def("isFinalized",
&GraphicalSceneMovieParams::isFinalized,
DOC(Karana,Models,GraphicalSceneMovieParams,isFinalized))
.def_readwrite("dir",
&GraphicalSceneMovieParams::dir,
DOC(Karana,Models,GraphicalSceneMovieParams,dir))
.def_readwrite("filename_prefix",
&GraphicalSceneMovieParams::filename_prefix,
DOC(Karana,Models,GraphicalSceneMovieParams,filename_prefix));

autoPyKmodelGraphicalSceneMovie=
KModelPybind11<GraphicalSceneMovie,GraphicalSceneMovieParams>("GraphicalSceneMovieKModel",
m);

py::class_<GraphicalSceneMovie,
KModel<GraphicalSceneMovie, GraphicalSceneMovieParams>,
kc::ks_ptr<GraphicalSceneMovie>>(
m,"GraphicalSceneMovie",DOC(Karana,Models,GraphicalSceneMovie))
.def(py::init<>(&GraphicalSceneMovie::create),
py::arg("name"),
py::arg("sp"),
py::arg("scene"),
DOC(Karana,Models,GraphicalSceneMovie,create))
.def_static("create",
&GraphicalSceneMovie::create,
py::arg("name"),
py::arg("sp"),
py::arg("scene"),
DOC(Karana,Models,GraphicalSceneMovie,create))
.def("postModelStep",
&GraphicalSceneMovie::postModelStep,
py::arg("t"),
py::arg("x"),
DOC(Karana,Models,GraphicalSceneMovie,postModelStep))
.def("getFfmpegCommand",
&GraphicalSceneMovie::getFfmpegCommand,
DOC(Karana,Models,GraphicalSceneMovie,getFfmpegCommand));

py::class_<ProjectConstraintErrorParams,kc::ks_ptr<ProjectConstraintErrorParams>>(
m,"ProjectConstraintErrorParams",DOC(Karana,Models,ProjectConstraintErrorParams))
.def("isFinalized",
&ProjectConstraintErrorParams::isFinalized,
DOC(Karana,Models,ProjectConstraintErrorParams,isFinalized))
.def_readwrite("tol",
&ProjectConstraintErrorParams::tol,
DOC(Karana,Models,ProjectConstraintErrorParams,tol));

autoPyKmodelProjectConstraintError=
KModelPybind11<ProjectConstraintError,ProjectConstraintErrorParams>(
"ProjectConstraintErrorKModel",m);

py::class_<ProjectConstraintError,
KModel<ProjectConstraintError, ProjectConstraintErrorParams>,
kc::ks_ptr<ProjectConstraintError>>(
m,"ProjectConstraintError",DOC(Karana,Models,ProjectConstraintError))
.def(py::init<>(&ProjectConstraintError::create),
py::arg("name"),
py::arg("sp"),
py::arg("sg"),
py::arg("integrator"),
py::arg("cks"),
DOC(Karana,Models,ProjectConstraintError,create))
.def_static("create",
&ProjectConstraintError::create,
py::arg("name"),
py::arg("sp"),
py::arg("sg"),
py::arg("integrator"),
py::arg("cks"),
DOC(Karana,Models,ProjectConstraintError,create))
.def("postModelStep",
&ProjectConstraintError::postModelStep,
py::arg("t"),
py::arg("x"),
DOC(Karana,Models,ProjectConstraintError,postModelStep));

py::class_<DataLoggerParams,kc::ks_ptr<DataLoggerParams>>(
m,"DataLoggerParams",DOC(Karana,Models,DataLoggerParams))
.def("isFinalized",
&DataLoggerParams::isFinalized,
DOC(Karana,Models,DataLoggerParams,isFinalized))
.def_readwrite("log_first_step",
&DataLoggerParams::log_first_step,
DOC(Karana,Models,DataLoggerParams,log_first_step));

autoPyKmodelDataLogger=KModelPybind11<DataLogger,DataLoggerParams>("DataLoggerKModel",m);

py::class_<DataLogger,KModel<DataLogger,DataLoggerParams>,kc::ks_ptr<DataLogger>>(
m,"DataLogger",DOC(Karana,Models,DataLogger))
.def(py::init<>(&DataLogger::create),
py::arg("name"),
py::arg("sp"),
py::arg("h5_writer"),
DOC(Karana,Models,DataLogger,create))
.def_static("create",
&DataLogger::create,
py::arg("name"),
py::arg("sp"),
py::arg("h5_writer"),
DOC(Karana,Models,DataLogger,create))
.def("postModelStep",
&DataLogger::postModelStep,
py::arg("t"),
py::arg("x"),
DOC(Karana,Models,DataLogger,postModelStep))
.def("getH5Writer",&DataLogger::getH5Writer,DOC(Karana,Models,DataLogger,getH5Writer));

autoPyKmodelComputedTorque=KModelPybind11<ComputedTorque>("ComputedTorqueKModel",m);

py::class_<ComputedTorque,KModel<ComputedTorque>,kc::ks_ptr<ComputedTorque>>(
m,"ComputedTorque",DOC(Karana,Models,ComputedTorque))
.def(py::init<>(&ComputedTorque::create),
py::arg("name"),
py::arg("sp"),
py::arg("st"),
py::arg("set_accels_fn"),
DOC(Karana,Models,ComputedTorque,create))
.def_static("create",
&ComputedTorque::create,
py::arg("name"),
py::arg("sp"),
py::arg("st"),
py::arg("set_accels_fn"),
DOC(Karana,Models,ComputedTorque,create))
.def("preDeriv",
&ComputedTorque::preDeriv,
py::arg("t"),
py::arg("x"),
DOC(Karana,Models,ComputedTorque,preDeriv));
}