本文整理汇总了C++中GnuplotWindow类的典型用法代码示例。如果您正苦于以下问题：C++ GnuplotWindow类的具体用法？C++ GnuplotWindow怎么用？C++ GnuplotWindow使用的例子？那么, 这里精选的类代码示例或许可以为您提供帮助。
在下文中一共展示了GnuplotWindow类的15个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: main
int main( ){
USING_NAMESPACE_ACADO
// INTRODUCE THE VARIABLES:
// -------------------------
DifferentialState x;
DifferentialState l;
AlgebraicState z;
Control u;
DifferentialEquation f;
const double t_start = 0.0;
const double t_end = 10.0;
// DEFINE A DIFFERENTIAL EQUATION:
// -------------------------------
f << dot(x) == -x + 0.5*x*x + u + 0.5*z;
f << dot(l) == x*x + 3.0*u*u ;
f << 0 == z + exp(z) - 1.0 + x ;
// DEFINE AN OPTIMAL CONTROL PROBLEM:
// ----------------------------------
OCP ocp( t_start, t_end, 10 );
ocp.minimizeMayerTerm( l );
ocp.subjectTo( f );
ocp.subjectTo( AT_START, x == 1.0 );
ocp.subjectTo( AT_START, l == 0.0 );
GnuplotWindow window;
window.addSubplot(x,"DIFFERENTIAL STATE x");
window.addSubplot(z,"ALGEBRAIC STATE z" );
window.addSubplot(u,"CONTROL u" );
// DEFINE AN OPTIMIZATION ALGORITHM AND SOLVE THE OCP:
// ----------------------------------------------------
OptimizationAlgorithm algorithm(ocp);
algorithm.set( ABSOLUTE_TOLERANCE , 1.0e-7 );
algorithm.set( INTEGRATOR_TOLERANCE , 1.0e-7 );
algorithm.set( HESSIAN_APPROXIMATION, EXACT_HESSIAN );
//algorithm.set( GLOBALIZATION_STRATEGY, GS_FULLSTEP );
algorithm << window;
algorithm.solve();
return 0;
}示例2: main
int main( ){
USING_NAMESPACE_ACADO
TIME autotime;
DifferentialState x(2);
AlgebraicState z;
Control u;
DifferentialEquation f1;
IntermediateState setc_is_1(5);
setc_is_1(0) = autotime;
setc_is_1(1) = x(0);
setc_is_1(2) = x(1);
setc_is_1(3) = z;
setc_is_1(4) = u;
CFunction cLinkModel_1( 3, myAcadoDifferentialEquation1 );
f1 << cLinkModel_1(setc_is_1);
double dconstant1 = 0.0;
double dconstant2 = 5.0;
int dconstant3 = 10;
OCP ocp1(dconstant1, dconstant2, dconstant3);
ocp1.minimizeMayerTerm(x(1));
ocp1.subjectTo(f1);
ocp1.subjectTo(AT_START, x(0) == 1.0 );
ocp1.subjectTo(AT_START, x(1) == 0.0 );
GnuplotWindow window;
window.addSubplot(x(0),"DIFFERENTIAL STATE x");
window.addSubplot(z,"ALGEBRAIC STATE z" );
window.addSubplot(u,"CONTROL u" );
OptimizationAlgorithm algo1(ocp1);
algo1.set( KKT_TOLERANCE, 1.000000E-05 );
algo1.set( RELAXATION_PARAMETER, 1.500000E+00 );
// algo1.set( HESSIAN_APPROXIMATION, EXACT_HESSIAN );
//
algo1 << window;
algo1.solve();
return 0;
}示例3: main
int main( ){
USING_NAMESPACE_ACADO
DifferentialState s,v,m ; // the differential states
Control u ; // the control input u
Parameter T ; // the time horizon T
DifferentialEquation f( 0.0, T ); // the differential equation
// -------------------------------------
OCP ocp( 0.0, T ); // time horizon of the OCP: [0,T]
ocp.minimizeMayerTerm( T ); // the time T should be optimized
f << dot(s) == v; // an implementation
f << dot(v) == (u-0.2*v*v)/m; // of the model equations
f << dot(m) == -0.01*u*u; // for the rocket.
ocp.subjectTo( f ); // minimize T s.t. the model,
ocp.subjectTo( AT_START, s == 0.0 ); // the initial values for s,
ocp.subjectTo( AT_START, v == 0.0 ); // v,
ocp.subjectTo( AT_START, m == 1.0 ); // and m,
ocp.subjectTo( AT_END , s == 10.0 ); // the terminal constraints for s
ocp.subjectTo( AT_END , v == 0.0 ); // and v,
ocp.subjectTo( -0.1 <= v <= 1.7 ); // as well as the bounds on v
ocp.subjectTo( -1.1 <= u <= 1.1 ); // the control input u,
ocp.subjectTo( 5.0 <= T <= 15.0 ); // and the time horizon T.
// -------------------------------------
GnuplotWindow window;
window.addSubplot( s, "THE DISTANCE s" );
window.addSubplot( v, "THE VELOCITY v" );
window.addSubplot( m, "THE MASS m" );
window.addSubplot( u, "THE CONTROL INPUT u" );
OptimizationAlgorithm algorithm(ocp); // the optimization algorithm
algorithm << window;
algorithm.solve(); // solves the problem.
return 0;
}示例4: main
int main( ){
USING_NAMESPACE_ACADO
DifferentialState phi, omega; // the states of the pendulum
Parameter l, alpha ; // its length and the friction
const double g = 9.81 ; // the gravitational constant
DifferentialEquation f ; // the model equations
Function h ; // the measurement function
VariablesGrid measurements; // read the measurements
measurements = readFromFile( "data.txt" ); // from a file.
// --------------------------------------
OCP ocp(measurements.getTimePoints()); // construct an OCP
h << phi ; // the state phi is measured
ocp.minimizeLSQ( h, measurements ) ; // fit h to the data
f << dot(phi ) == omega ; // a symbolic implementation
f << dot(omega) == -(g/l) *sin(phi ) // of the model
- alpha*omega ; // equations
ocp.subjectTo( f ); // solve OCP s.t. the model,
ocp.subjectTo( 0.0 <= alpha <= 4.0 ); // the bounds on alpha
ocp.subjectTo( 0.0 <= l <= 2.0 ); // and the bounds on l.
// --------------------------------------
GnuplotWindow window;
window.addSubplot( phi , "The angle phi", "time [s]", "angle [rad]" );
window.addSubplot( omega, "The angular velocity dphi" );
window.addData( 0, measurements(0) );
ParameterEstimationAlgorithm algorithm(ocp); // the parameter estimation
algorithm << window;
algorithm.solve(); // algorithm solves the problem.
return 0;
}示例5: main
/* >>> start tutorial code >>> */
int main( ){
USING_NAMESPACE_ACADO
// DEFINE A VARIABLES GRID:
// ------------------------
Grid dataGrid( 0.0, 5.0, 6 );
VariablesGrid data;
data.init( 2, dataGrid );
data( 0, 0 ) = 0.0; data( 0, 1 ) = 1.0 ;
data( 1, 0 ) = 0.2; data( 1, 1 ) = 0.8 ;
data( 2, 0 ) = 0.4; data( 2, 1 ) = 0.7 ;
data( 3, 0 ) = 0.6; data( 3, 1 ) = 0.65 ;
data( 4, 0 ) = 0.8; data( 4, 1 ) = 0.625;
data( 5, 0 ) = 1.0; data( 5, 1 ) = 0.613;
// CONSTRUCT A CURVE INTERPOLATING THE DATA:
// -----------------------------------------
Curve c1, c2;
c1.add( data, IM_CONSTANT );
c2.add( data, IM_LINEAR );
// PLOT CURVES ON GIVEN GRID:
// --------------------------
GnuplotWindow window;
window.addSubplot( c1, 0.0,5.0, "Constant data Interpolation" );
window.addSubplot( c2, 0.0,5.0, "Linear data Interpolation" );
window.plot();
return 0;
}示例6: main
int main( )
{
USING_NAMESPACE_ACADO
// INTRODUCE THE VARIABLES:
// -------------------------
DifferentialState xB;
DifferentialState xW;
DifferentialState vB;
DifferentialState vW;
Control F;
// DEFINE A DIFFERENTIAL EQUATION:
// -------------------------------
double h = 0.05;
DiscretizedDifferentialEquation f( h );
// f << next(xB) == ( 9.523918456856767e-01*xB - 3.093442425036754e-03*xW + 4.450257887258270e-04*vW - 2.380407715716160e-07*F );
// f << next(xW) == ( -1.780103154903307e+00*xB - 1.005721624707961e+00*xW - 3.093442425036752e-03*vW - 8.900515774516536e-06*F );
// f << next(vB) == ( -5.536210379145256e+00*xB - 2.021981836435758e-01*xW + 1.0*vB + 2.474992857984263e-02*vW + 1.294618052471308e-04*F );
// f << next(vW) == ( 1.237376970014700e+01*xB + 1.183104351525840e+01*xW - 1.005721624707961e+00*vW + 6.186884850073496e-05*F );
f << next(xB) == ( 0.9335*xB + 0.0252*xW + 0.048860*vB + 0.000677*vW + 3.324e-06*F );
f << next(xW) == ( 0.1764*xB - 0.9821*xW + 0.004739*vB - 0.002591*vW - 8.822e-06*F );
f << next(vB) == ( -2.5210*xB - 0.1867*xW + 0.933500*vB + 0.025200*vW + 0.0001261*F );
f << next(vW) == ( -1.3070*xB + 11.670*xW + 0.176400*vB - 0.982100*vW + 6.536e-05*F );
OutputFcn g;
g << xB;
g << 500.0*vB + F;
DynamicSystem dynSys( f,g );
// SETUP THE PROCESS:
// ------------------
Vector mean( 1 ), amplitude( 1 );
mean.setZero( );
amplitude.setAll( 50.0 );
GaussianNoise myNoise( mean,amplitude );
Actuator myActuator( 1 );
myActuator.setControlNoise( myNoise,0.1 );
myActuator.setControlDeadTimes( 0.1 );
mean.setZero( );
amplitude.setAll( 0.001 );
UniformNoise myOutputNoise1( mean,amplitude );
mean.setAll( 20.0 );
amplitude.setAll( 10.0 );
GaussianNoise myOutputNoise2( mean,amplitude );
Sensor mySensor( 2 );
mySensor.setOutputNoise( 0,myOutputNoise1,0.1 );
mySensor.setOutputNoise( 1,myOutputNoise2,0.1 );
mySensor.setOutputDeadTimes( 0.15 );
Process myProcess;
myProcess.setDynamicSystem( dynSys );
myProcess.set( ABSOLUTE_TOLERANCE,1.0e-8 );
myProcess.setActuator( myActuator );
myProcess.setSensor( mySensor );
Vector x0( 4 );
x0.setZero( );
x0( 0 ) = 0.01;
myProcess.initializeStartValues( x0 );
myProcess.set( PLOT_RESOLUTION,HIGH );
// myProcess.set( CONTROL_PLOTTING,PLOT_NOMINAL );
// myProcess.set( PARAMETER_PLOTTING,PLOT_NOMINAL );
myProcess.set( OUTPUT_PLOTTING,PLOT_REAL );
GnuplotWindow window;
window.addSubplot( xB, "Body Position [m]" );
window.addSubplot( xW, "Wheel Position [m]" );
window.addSubplot( vB, "Body Velocity [m/s]" );
window.addSubplot( vW, "Wheel Velocity [m/s]" );
window.addSubplot( F,"Damping Force [N]" );
window.addSubplot( g(0),"Output 1" );
window.addSubplot( g(1),"Output 2" );
myProcess << window;
// SIMULATE AND GET THE RESULTS:
// -----------------------------
//.........这里部分代码省略.........
示例7: main
/* >>> start tutorial code >>> */
int main( ){
USING_NAMESPACE_ACADO
// INTRODUCE THE VARIABLES:
// ------------------------------------
DifferentialState v,s,m;
Control u ;
const double t_start = 0.0;
const double t_end = 10.0;
const double h = 0.01;
DiscretizedDifferentialEquation f(h) ;
// DEFINE A DISCRETE-TIME SYTSEM:
// -------------------------------
f << next(s) == s + h*v;
f << next(v) == v + h*(u-0.02*v*v)/m;
f << next(m) == m - h*0.01*u*u;
Function eta;
eta << u;
// DEFINE AN OPTIMAL CONTROL PROBLEM:
// ----------------------------------
OCP ocp( t_start, t_end, 50 );
//ocp.minimizeLagrangeTerm( u*u );
ocp.minimizeLSQ( eta );
ocp.subjectTo( f );
ocp.subjectTo( AT_START, s == 0.0 );
ocp.subjectTo( AT_START, v == 0.0 );
ocp.subjectTo( AT_START, m == 1.0 );
ocp.subjectTo( AT_END , s == 10.0 );
ocp.subjectTo( AT_END , v == 0.0 );
ocp.subjectTo( -0.01 <= v <= 1.3 );
// DEFINE A PLOT WINDOW:
// ---------------------
GnuplotWindow window;
window.addSubplot( s,"DifferentialState s" );
window.addSubplot( v,"DifferentialState v" );
window.addSubplot( m,"DifferentialState m" );
window.addSubplot( u,"Control u" );
window.addSubplot( PLOT_KKT_TOLERANCE,"KKT Tolerance" );
window.addSubplot( 0.5 * m * v*v,"Kinetic Energy" );
// DEFINE AN OPTIMIZATION ALGORITHM AND SOLVE THE OCP:
// ---------------------------------------------------
OptimizationAlgorithm algorithm(ocp);
algorithm.set( INTEGRATOR_TYPE, INT_DISCRETE );
algorithm.set( HESSIAN_APPROXIMATION, EXACT_HESSIAN );
algorithm.set( KKT_TOLERANCE, 1e-10 );
algorithm << window;
algorithm.solve();
return 0;
}示例8: main
//.........这里部分代码省略.........
VariablesGrid disturbance; disturbance.read( "my_wind_disturbance_controlsfree.txt" );
if (process.setProcessDisturbance( disturbance ) != SUCCESSFUL_RETURN)
exit( EXIT_FAILURE );
// SETUP OF THE ALGORITHM AND THE TUNING OPTIONS:
// ----------------------------------------------
double samplingTime = 1.0;
RealTimeAlgorithm algorithm( ocp, samplingTime );
if (algorithm.initializeDifferentialStates("p_s_ref.txt" ) != SUCCESSFUL_RETURN)
exit( EXIT_FAILURE );
if (algorithm.initializeControls ("p_c_ref.txt" ) != SUCCESSFUL_RETURN)
exit( EXIT_FAILURE );
algorithm.set( MAX_NUM_ITERATIONS, 2 );
algorithm.set( KKT_TOLERANCE , 1e-4 );
algorithm.set( HESSIAN_APPROXIMATION,GAUSS_NEWTON);
algorithm.set( INTEGRATOR_TOLERANCE, 1e-6 );
algorithm.set( GLOBALIZATION_STRATEGY,GS_FULLSTEP );
// algorithm.set( USE_IMMEDIATE_FEEDBACK, YES );
algorithm.set( USE_REALTIME_SHIFTS, YES );
algorithm.set(LEVENBERG_MARQUARDT, 1e-5);
DVector x0(10);
x0(0) = 1.8264164528775887e+03;
x0(1) = -5.1770453309520573e-03;
x0(2) = 1.2706440287266794e+00;
x0(3) = 2.1977888424944396e+00;
x0(4) = 3.1840786108641383e-03;
x0(5) = -3.8281200674676448e-02;
x0(6) = 0.0000000000000000e+00;
x0(7) = -1.0372313936413566e-02;
x0(8) = 1.4999999999999616e+00;
x0(9) = 0.0000000000000000e+00;
// SETTING UP THE NMPC CONTROLLER:
// -------------------------------
Controller controller( algorithm, reference );
// SETTING UP THE SIMULATION ENVIRONMENT, RUN THE EXAMPLE...
// ----------------------------------------------------------
double simulationStart = 0.0;
double simulationEnd = 10.0;
SimulationEnvironment sim( simulationStart, simulationEnd, process, controller );
if (sim.init( x0 ) != SUCCESSFUL_RETURN)
exit( EXIT_FAILURE );
if (sim.run( ) != SUCCESSFUL_RETURN)
exit( EXIT_FAILURE );
// ...AND PLOT THE RESULTS
// ----------------------------------------------------------
VariablesGrid diffStates;
sim.getProcessDifferentialStates( diffStates );
diffStates.print( "diffStates.txt" );
diffStates.print( "diffStates.m","DIFFSTATES",PS_MATLAB );
VariablesGrid interStates;
sim.getProcessIntermediateStates( interStates );
interStates.print( "interStates.txt" );
interStates.print( "interStates.m","INTERSTATES",PS_MATLAB );
VariablesGrid sampledProcessOutput;
sim.getSampledProcessOutput( sampledProcessOutput );
sampledProcessOutput.print( "sampledOut.txt" );
sampledProcessOutput.print( "sampledOut.m","OUT",PS_MATLAB );
VariablesGrid feedbackControl;
sim.getFeedbackControl( feedbackControl );
feedbackControl.print( "controls.txt" );
feedbackControl.print( "controls.m","CONTROL",PS_MATLAB );
GnuplotWindow window;
window.addSubplot( sampledProcessOutput(0), "DIFFERENTIAL STATE: r" );
window.addSubplot( sampledProcessOutput(1), "DIFFERENTIAL STATE: phi" );
window.addSubplot( sampledProcessOutput(2), "DIFFERENTIAL STATE: theta" );
window.addSubplot( sampledProcessOutput(3), "DIFFERENTIAL STATE: dr" );
window.addSubplot( sampledProcessOutput(4), "DIFFERENTIAL STATE: dphi" );
window.addSubplot( sampledProcessOutput(5), "DIFFERENTIAL STATE: dtheta" );
window.addSubplot( sampledProcessOutput(7), "DIFFERENTIAL STATE: Psi" );
window.addSubplot( sampledProcessOutput(8), "DIFFERENTIAL STATE: CL" );
window.addSubplot( sampledProcessOutput(9), "DIFFERENTIAL STATE: W" );
window.addSubplot( feedbackControl(0), "CONTROL 1 DDR0" );
window.addSubplot( feedbackControl(1), "CONTROL 1 DPSI" );
window.addSubplot( feedbackControl(2), "CONTROL 1 DCL" );
window.plot( );
GnuplotWindow window2;
window2.addSubplot( interStates(1) );
window2.plot();
return 0;
}示例9: main
/* >>> start tutorial code >>> */
int main( ){
USING_NAMESPACE_ACADO
// DEFINE VALRIABLES:
// ---------------------------
DifferentialStateVector q(2); // the generalized coordinates of the pendulum
DifferentialStateVector dq(2); // the associated velocities
const double L1 = 1.00; // length of the first pendulum
const double L2 = 1.00; // length of the second pendulum
const double m1 = 1.00; // mass of the first pendulum
const double m2 = 1.00; // mass of the second pendulum
const double g = 9.81; // gravitational constant
const double alpha = 0.10; // a friction constant
const double J_11 = (m1+m2)*L1*L1; // auxiliary variable (inertia comp.)
const double J_22 = m2 *L2*L2; // auxiliary variable (inertia comp.)
const double J_12 = m2 *L1*L2; // auxiliary variable (inertia comp.)
const double E1 = -(m1+m2)*g*L1; // auxiliary variable (pot energy 1)
const double E2 = - m2 *g*L2; // auxiliary variable (pot energy 2)
IntermediateState c1;
IntermediateState c2;
IntermediateState c3;
IntermediateState T;
IntermediateState V;
IntermediateStateVector Q;
// COMPUTE THE KINETIC ENERGY T AND THE POTENTIAL V:
// -------------------------------------------------
c1 = cos(q(0));
c2 = cos(q(1));
c3 = cos(q(0)+q(1));
T = 0.5*J_11*dq(0)*dq(0) + 0.5*J_22*dq(1)*dq(1) + J_12*c3*dq(0)*dq(1);
V = E1*c1 + E2*c2;
Q = (-alpha*dq);
// AUTOMATICALLY DERIVE THE EQUATIONS OF MOTION BASED ON THE LAGRANGIAN FORMALISM:
// -------------------------------------------------------------------------------
DifferentialEquation f;
LagrangianFormalism( f, T - V, Q, q, dq );
// Define an integrator:
// ---------------------
IntegratorBDF integrator( f );
// Define an initial value:
// ------------------------
double x_start[4] = { 0.0, 0.5, 0.0, 0.1 };
double t_start = 0.0;
double t_end = 3.0;
// START THE INTEGRATION
// ----------------------
integrator.set( INTEGRATOR_PRINTLEVEL, MEDIUM );
integrator.set( INTEGRATOR_TOLERANCE, 1e-12 );
integrator.freezeAll();
integrator.integrate( x_start, t_start, t_end );
VariablesGrid xres;
integrator.getTrajectory(&xres,NULL,NULL,NULL,NULL,NULL);
GnuplotWindow window;
window.addSubplot( xres(0), "The excitation angle of pendulum 1" );
window.addSubplot( xres(1), "The excitation angle of pendulum 2" );
window.addSubplot( xres(2), "The angular velocity of pendulum 1" );
window.addSubplot( xres(3), "The angular velocity of pendulum 2" );
window.plot();
return 0;
}示例10: main
//.........这里部分代码省略.........
power = m*ddr*dr ;
// REGULARISATION TERMS :
// ---------------------------------------------------------------
regularisation = 5.0e2 * ddr0 * ddr0
+ 1.0e8 * dPsi * dPsi
+ 1.0e5 * dCL * dCL
+ 2.5e5 * dn * dn
+ 2.5e7 * ddphi * ddphi;
+ 2.5e7 * ddtheta * ddtheta;
+ 2.5e6 * dtheta * dtheta;
// ---------------------------
// THE "RIGHT-HAND-SIDE" OF THE ODE:
// ---------------------------------------------------------------
DifferentialEquation f;
f << dot(r) == dr ;
f << dot(phi) == dphi ;
f << dot(theta) == dtheta ;
f << dot(dr) == ddr0 ;
f << dot(dphi) == ddphi ;
f << dot(dtheta) == ddtheta ;
f << dot(n) == dn ;
f << dot(Psi) == dPsi ;
f << dot(CL) == dCL ;
f << dot(W) == (-power + regularisation)*1.0e-6;
// DEFINE AN OPTIMAL CONTROL PROBLEM:
// ----------------------------------
OCP ocp( 0.0, 18.0, 18 );
ocp.minimizeMayerTerm( W );
ocp.subjectTo( f );
// INITIAL VALUE CONSTRAINTS:
// ---------------------------------
ocp.subjectTo( AT_START, n == 0.0 );
ocp.subjectTo( AT_START, W == 0.0 );
// PERIODIC BOUNDARY CONSTRAINTS:
// ----------------------------------------
ocp.subjectTo( 0.0, r , -r , 0.0 );
ocp.subjectTo( 0.0, phi , -phi , 0.0 );
ocp.subjectTo( 0.0, theta , -theta , 0.0 );
ocp.subjectTo( 0.0, dr , -dr , 0.0 );
ocp.subjectTo( 0.0, dphi , -dphi , 0.0 );
ocp.subjectTo( 0.0, dtheta, -dtheta, 0.0 );
ocp.subjectTo( 0.0, Psi , -Psi , 0.0 );
ocp.subjectTo( 0.0, CL , -CL , 0.0 );
ocp.subjectTo( -0.34 <= phi <= 0.34 );
ocp.subjectTo( 0.85 <= theta <= 1.45 );
ocp.subjectTo( -40.0 <= dr <= 10.0 );
ocp.subjectTo( -0.29 <= Psi <= 0.29 );
ocp.subjectTo( 0.1 <= CL <= 1.50 );
ocp.subjectTo( -0.7 <= n <= 0.90 );
ocp.subjectTo( -25.0 <= ddr0 <= 25.0 );
ocp.subjectTo( -0.065 <= dPsi <= 0.065 );
ocp.subjectTo( -3.5 <= dCL <= 3.5 );
// CREATE A PLOT WINDOW AND VISUALIZE THE RESULT:
// ----------------------------------------------
GnuplotWindow window;
window.addSubplot( r, "CABLE LENGTH r [m]" );
window.addSubplot( phi, "POSITION ANGLE phi [rad]" );
window.addSubplot( theta,"POSITION ANGLE theta [rad]" );
window.addSubplot( Psi, "ROLL ANGLE psi [rad]" );
window.addSubplot( CL, "LIFT COEFFICIENT CL" );
window.addSubplot( W, "ENERGY W [MJ]" );
window.addSubplot( F[0], "FORCE IN CABLE [N]" );
window.addSubplot( phi,theta, "Kite Orbit","theta [rad]","phi [rad]" );
// DEFINE AN OPTIMIZATION ALGORITHM AND SOLVE THE OCP:
// ---------------------------------------------------
OptimizationAlgorithm algorithm(ocp);
algorithm.initializeDifferentialStates("powerkite_states.txt" );
algorithm.initializeControls ("powerkite_controls.txt" );
algorithm.set ( MAX_NUM_ITERATIONS, 100 );
algorithm.set ( KKT_TOLERANCE , 1e-2 );
algorithm << window;
algorithm.set( PRINT_SCP_METHOD_PROFILE, YES );
algorithm.solve();
return 0;
}示例11: main
int main( ){
// Define a Right-Hand-Side:
// -------------------------
DifferentialState x("", 4, 1), P("", 4, 4);
Control u("", 2, 1);
IntermediateState rhs = cstrModel( x, u );
DMatrix Q = zeros<double>(4,4);
Q(0,0) = 0.2;
Q(1,1) = 1.0;
Q(2,2) = 0.5;
Q(3,3) = 0.2;
DMatrix R = zeros<double>(2,2);
R(0,0) = 0.5;
R(1,1) = 5e-7;
DifferentialEquation f;
f << dot(x) == rhs;
f << dot(P) == getRiccatiODE( rhs, x, u, P, Q, R );
// Define an integrator:
// ---------------------
IntegratorRK45 integrator( f );
integrator.set( INTEGRATOR_PRINTLEVEL, MEDIUM );
integrator.set( PRINT_INTEGRATOR_PROFILE, YES );
// Define an initial value:
// ------------------------
//double x_ss[4] = { 2.14, 1.09, 114.2, 112.9 };
double x_start[20] = { 1.0, 0.5, 100.0, 100.0, 1.0, 0.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
0.0, 0.0, 0.0, 1.0 };
double u_start[2] = { 14.19, -1113.5 };
// double u_start[2] = { 10.00, -7000.0 };
Grid timeInterval( 0.0, 5000.0, 100 );
integrator.freezeAll();
integrator.integrate( timeInterval, x_start, 0 ,0, u_start );
// GET THE RESULTS
// ---------------
VariablesGrid differentialStates;
integrator.getX( differentialStates );
DVector PP = differentialStates.getLastVector();
DMatrix PPP(4,4);
for( int i=0; i<4; ++i )
for( int j=0; j<4; ++j )
PPP(i,j) = PP(4+i*4+j);
PPP.print( "P1.txt","",PS_PLAIN );
// PPP.printToFile( "P2.txt","",PS_PLAIN );
GnuplotWindow window;
window.addSubplot( differentialStates(0), "cA [mol/l]" );
window.addSubplot( differentialStates(1), "cB [mol/l]" );
window.addSubplot( differentialStates(2), "theta [C]" );
window.addSubplot( differentialStates(3), "thetaK [C]" );
window.addSubplot( differentialStates(4 ), "P11" );
window.addSubplot( differentialStates(9 ), "P22" );
window.addSubplot( differentialStates(14), "P33" );
window.addSubplot( differentialStates(19), "P44" );
window.plot();
return 0;
}示例12: main
int main( )
{
USING_NAMESPACE_ACADO
// INTRODUCE THE VARIABLES:
// -------------------------
DifferentialState xB; //Body Position
DifferentialState xW; //Wheel Position
DifferentialState vB; //Body Velocity
DifferentialState vW; //Wheel Velocity
Control F;
Disturbance R;
double mB = 350.0;
double mW = 50.0;
double kS = 20000.0;
double kT = 200000.0;
// DEFINE A DIFFERENTIAL EQUATION:
// -------------------------------
DifferentialEquation f;
f << dot(xB) == vB;
f << dot(xW) == vW;
f << dot(vB) == ( -kS*xB + kS*xW + F ) / mB;
f << dot(vW) == ( kS*xB - (kT+kS)*xW + kT*R - F ) / mW;
// DEFINE LEAST SQUARE FUNCTION:
// -----------------------------
Function h;
h << xB;
h << xW;
h << vB;
h << vW;
h << F;
DMatrix Q(5,5); // LSQ coefficient matrix
Q(0,0) = 10.0;
Q(1,1) = 10.0;
Q(2,2) = 1.0;
Q(3,3) = 1.0;
Q(4,4) = 1.0e-8;
DVector r(5); // Reference
r.setAll( 0.0 );
// DEFINE AN OPTIMAL CONTROL PROBLEM:
// ----------------------------------
const double tStart = 0.0;
const double tEnd = 1.0;
OCP ocp( tStart, tEnd, 20 );
ocp.minimizeLSQ( Q, h, r );
ocp.subjectTo( f );
ocp.subjectTo( -200.0 <= F <= 200.0 );
ocp.subjectTo( R == 0.0 );
// SETTING UP THE REAL-TIME ALGORITHM:
// -----------------------------------
RealTimeAlgorithm alg( ocp,0.025 );
alg.set( MAX_NUM_ITERATIONS, 1 );
alg.set( PLOT_RESOLUTION, MEDIUM );
GnuplotWindow window;
window.addSubplot( xB, "Body Position [m]" );
window.addSubplot( xW, "Wheel Position [m]" );
window.addSubplot( vB, "Body Velocity [m/s]" );
window.addSubplot( vW, "Wheel Velocity [m/s]" );
window.addSubplot( F, "Damping Force [N]" );
window.addSubplot( R, "Road Excitation [m]" );
alg << window;
// SETUP CONTROLLER AND PERFORM A STEP:
// ------------------------------------
StaticReferenceTrajectory zeroReference( "ref.txt" );
Controller controller( alg,zeroReference );
DVector y( 4 );
y.setZero( );
y(0) = 0.01;
if (controller.init( 0.0,y ) != SUCCESSFUL_RETURN)
exit( 1 );
if (controller.step( 0.0,y ) != SUCCESSFUL_RETURN)
exit( 1 );
return EXIT_SUCCESS;
//.........这里部分代码省略.........
示例13: main
int main( ){
USING_NAMESPACE_ACADO
// INTRODUCE THE VARIABLES:
// -------------------------
const int N = 2;
DifferentialState x, y("", N, 1);
Control u;
DifferentialEquation f;
const double t_start = 0.0;
const double t_end = 10.0;
// DEFINE A DIFFERENTIAL EQUATION:
// -------------------------------
f << dot(x) == -x + 0.9*x*x + u;
int i;
for( i = 0; i < N; i++ )
f << dot( y(i) ) == -y(i) + 0.5*y(i)*y(i) + u;
// DEFINE LEAST SQUARE FUNCTION:
// -----------------------------
Function h,m;
h << x;
h << 2.0*u;
m << 10.0*x ;
m << 0.1*x*x;
DMatrix S(2,2);
DVector r(2);
S.setIdentity();
r.setAll( 0.1 );
// DEFINE AN OPTIMAL CONTROL PROBLEM:
// ----------------------------------
OCP ocp( t_start, t_end, 5 );
ocp.minimizeLSQ ( S, h, r );
ocp.minimizeLSQEndTerm( S, m, r );
ocp.subjectTo( f );
ocp.subjectTo( AT_START, x == 1.0 );
for( i = 0; i < N; i++ )
ocp.subjectTo( AT_START, y(i) == 1.0 );
// Additionally, flush a plotting object
GnuplotWindow window;
window.addSubplot( x,"DifferentialState x" );
window.addSubplot( u,"Control u" );
// DEFINE AN OPTIMIZATION ALGORITHM AND SOLVE THE OCP:
// ---------------------------------------------------
OptimizationAlgorithm algorithm(ocp);
algorithm << window;
// algorithm.set( PRINT_SCP_METHOD_PROFILE, YES );
// algorithm.set( DYNAMIC_SENSITIVITY, FORWARD_SENSITIVITY_LIFTED );
// algorithm.set( HESSIAN_APPROXIMATION, CONSTANT_HESSIAN );
// algorithm.set( HESSIAN_APPROXIMATION, FULL_BFGS_UPDATE );
// algorithm.set( HESSIAN_APPROXIMATION, BLOCK_BFGS_UPDATE );
algorithm.set( HESSIAN_APPROXIMATION, GAUSS_NEWTON );
// algorithm.set( HESSIAN_APPROXIMATION, GAUSS_NEWTON_WITH_BLOCK_BFGS );
// algorithm.set( HESSIAN_APPROXIMATION, EXACT_HESSIAN );
// Necessary to use with GN Hessian approximation.
algorithm.set( LEVENBERG_MARQUARDT, 1e-10 );
algorithm.solve();
return 0;
}示例14: main
//.........这里部分代码省略.........
// DEFINE A DIFFERENTIAL EQUATION:
// -------------------------------
DifferentialEquation f;
f << dot(xB) == vB;
f << dot(xW) == vW;
f << dot(vB) == ( -kS*xB + kS*xW + F ) / mB;
f << dot(vW) == ( kS*xB - (kT+kS)*xW + kT*R - F ) / mW;
// DEFINE LEAST SQUARE FUNCTION:
// -----------------------------
Function h;
h << xB;
h << xW;
h << vB;
h << vW;
Matrix Q(4,4);
Q.setIdentity();
Q(0,0) = 10.0;
Q(1,1) = 10.0;
Vector r(4);
r.setAll( 0.0 );
// DEFINE AN OPTIMAL CONTROL PROBLEM:
// ----------------------------------
const double t_start = 0.0;
const double t_end = 1.0;
OCP ocp( t_start, t_end, 20 );
ocp.minimizeLSQ( Q, h, r );
ocp.subjectTo( f );
ocp.subjectTo( -500.0 <= F <= 500.0 );
ocp.subjectTo( R == 0.0 );
// SETTING UP THE (SIMULATED) PROCESS:
// -----------------------------------
OutputFcn identity;
DynamicSystem dynamicSystem( f,identity );
Process process( dynamicSystem,INT_RK45 );
VariablesGrid disturbance = readFromFile( "road.txt" );
process.setProcessDisturbance( disturbance );
// SETTING UP THE MPC CONTROLLER:
// ------------------------------
RealTimeAlgorithm alg( ocp,0.05 );
alg.set( MAX_NUM_ITERATIONS, 2 );
StaticReferenceTrajectory zeroReference;
Controller controller( alg,zeroReference );
// SETTING UP THE SIMULATION ENVIRONMENT, RUN THE EXAMPLE...
// ----------------------------------------------------------
SimulationEnvironment sim( 0.0,3.0,process,controller );
Vector x0(4);
x0(0) = 0.01;
x0(1) = 0.0;
x0(2) = 0.0;
x0(3) = 0.0;
sim.init( x0 );
sim.run( );
// ...AND PLOT THE RESULTS
// ----------------------------------------------------------
VariablesGrid sampledProcessOutput;
sim.getSampledProcessOutput( sampledProcessOutput );
VariablesGrid feedbackControl;
sim.getFeedbackControl( feedbackControl );
GnuplotWindow window;
window.addSubplot( sampledProcessOutput(0), "Body Position [m]" );
window.addSubplot( sampledProcessOutput(1), "Wheel Position [m]" );
window.addSubplot( sampledProcessOutput(2), "Body Velocity [m/s]" );
window.addSubplot( sampledProcessOutput(3), "Wheel Velocity [m/s]" );
window.addSubplot( feedbackControl(1), "Damping Force [N]" );
window.addSubplot( feedbackControl(0), "Road Excitation [m]" );
window.plot( );
return 0;
}示例15: main
//.........这里部分代码省略.........
9.3885430857029321E+04, // P_{top} = 939 h Pa
2.5000000000000000E+02, // \Delta P_{strip}= 2.5 h Pa and \Delta P_{rect} = 1.9 h Pa
1.4026000000000000E+01, // F_{vol} = 14.0 l h^{-1}
3.2000000000000001E-01, // X_F = 0.32
7.1054000000000002E+01, // T_F = 71 oC
4.7163089489100003E+01, // T_C = 47.2 oC
4.1833910753991770E+00, // (not in use?)
2.4899344810136301E+00, // (not in use?)
1.8760537088149468E+02 // (not in use?)
};
DVector x0(NXD, xd);
DVector p0(NP, pd);
// DEFINE AN OPTIMAL CONTROL PROBLEM:
// ----------------------------------
OCP ocp( t_start, t_end, intervals );
// LSQ Term on temperature deviations and controls
Function h;
// for( i = 0; i < NXD; i++ )
// h << 0.001*x(i);
h << 0.1 * ( z(94) - 88.0 ); // Temperature tray 14
h << 0.1 * ( z(108) - 70.0 ); // Temperature tray 28
h << 0.01 * ( u(0) - ud[0] ); // L_vol
h << 0.01 * ( u(1) - ud[1] ); // Q
ocp.minimizeLSQ( h );
// W.r.t. differential equation
ocp.subjectTo( f );
// Fix states
ocp.subjectTo( AT_START, x == x0 );
// Fix parameters
ocp.subjectTo( p == p0 );
// Path constraint on controls
ocp.subjectTo( ud[0] - 2.0 <= u(0) <= ud[0] + 2.0 );
ocp.subjectTo( ud[1] - 2.0 <= u(1) <= ud[1] + 2.0 );
// DEFINE AN OPTIMIZATION ALGORITHM AND SOLVE THE OCP:
// ---------------------------------------------------
OptimizationAlgorithm algorithm(ocp);
algorithm.initializeAlgebraicStates("hydroscal_algebraic_states.txt");
algorithm.set( INTEGRATOR_TYPE, INT_BDF );
algorithm.set( MAX_NUM_ITERATIONS, 5 );
algorithm.set( KKT_TOLERANCE, 1e-3 );
algorithm.set( INTEGRATOR_TOLERANCE, 1e-4 );
algorithm.set( ABSOLUTE_TOLERANCE , 1e-6 );
algorithm.set( PRINT_SCP_METHOD_PROFILE, YES );
algorithm.set( LINEAR_ALGEBRA_SOLVER, SPARSE_LU );
algorithm.set( DISCRETIZATION_TYPE, MULTIPLE_SHOOTING );
//algorithm.set( LEVENBERG_MARQUARDT, 1e-3 );
algorithm.set( DYNAMIC_SENSITIVITY, FORWARD_SENSITIVITY_LIFTED );
//algorithm.set( DYNAMIC_SENSITIVITY, FORWARD_SENSITIVITY );
//algorithm.set( CONSTRAINT_SENSITIVITY, FORWARD_SENSITIVITY );
//algorithm.set( ALGEBRAIC_RELAXATION,ART_EXPONENTIAL ); //results in an extra step but steps are quicker
algorithm.solve();
double clock2 = clock();
printf("total computation time = %.16e \n", (clock2-clock1)/CLOCKS_PER_SEC );
// PLOT RESULTS:
// ---------------------------------------------------
VariablesGrid out_states;
algorithm.getDifferentialStates( out_states );
out_states.print( "OUT_states.m","STATES",PS_MATLAB );
VariablesGrid out_controls;
algorithm.getControls( out_controls );
out_controls.print( "OUT_controls.m","CONTROLS",PS_MATLAB );
VariablesGrid out_algstates;
algorithm.getAlgebraicStates( out_algstates );
out_algstates.print( "OUT_algstates.m","ALGSTATES",PS_MATLAB );
GnuplotWindow window;
window.addSubplot( out_algstates(94), "Temperature tray 14" );
window.addSubplot( out_algstates(108), "Temperature tray 28" );
window.addSubplot( out_controls(0), "L_vol" );
window.addSubplot( out_controls(1), "Q" );
window.plot( );
return 0;
}