The Pennsylvania State University
The Graduate School
College of Engineering
RIGID BODY SATELLITE TIME-OPTIMAL ATTITUDE CONTROL USING
INVERSION
A Dissertation in
Aerospace Engineering
by
Kaushik Basu
© 2018 Kaushik Basu
Submitted in Partial Fulfillment
of the Requirements
for the Degree of
Doctor of Philosophy
December 2018
The dissertation of Kaushik Basu was reviewed and approved∗ by the following:
Robert G. Melton
Professor of Aerospace Engineering
Dissertation Advisor, Chair of Committee
David B. Spencer
Professor of Aerospace Engineering
Joseph P.Cusumano
Professor of Engineering Science and Mechanics
Joseph F.Horn
Professor of Aerospace Engineering
Jack W. Langelaan
Associate Professor and Graduate Studies Advisor
∗Signatures are on file in the Graduate School.
ii
Abstract
Spacecraft missions with requirements for tighter tolerances and that take advantage of improving
computational technology, and having more stringent control requirements,including time optimal
solutions are required.
An inverse-dynamics method is used in conjunction with a particle swarm algorithm to find
near-minimum time reorientation maneuvers in the presence of path constraints. The method
employs a quaternion formulation of the kinematics, using B-splines to represent the quaternions.
The inverse particle swarm optimization provides a method to determine an initial starting point for
a more accurate algorithm that uses a gradient-based method. The inverse method provides certain
advantages in this problem over other methods such as enforcement of boundary conditions and the
increase of computational efficiency by avoiding the use of numerical integrators.
Once the technique is established, parallelization of the algorithm demonstrates the potential for
flight hardware to be implemented that will aid in performing near real-time solutions. In total the
superior terminating kinematic results and speed up of computing time from hours to just several
seconds will allow the implementation using space hardened Graphic Processor Units and Field
Programmable Gate Arrays to perform autonomous guidance and navigation.
iii
Table of Contents
List of Figures vi
List of Tables viii
List of Symbols ix
Acknowledgments xi
Chapter 1Introduction 1
Chapter 2Literature Review 4
Chapter 3Problem Formulation and Method of Solution 173.1 Kinematic Formulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173.2 Particle Swarm Optimization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233.3 The B-Spline . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273.4 Overall Flowchart . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Chapter 4Application 304.1 Application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304.2 Problem Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314.3 Penalty Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334.4 Inverse Dynamics Formulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354.5 Solution Method . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374.6 Interesting Cases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434.7 Summary of PSO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 644.8 PSO Verification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
Chapter 5Parallelization 67
iv
Chapter 6Pseudospectral Solutions 716.1 Optimal Control Theory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 716.2 Pseudospectral . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 726.3 Pseudospectral Results . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
Chapter 7Conclusions and Recommendations 837.1 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 837.2 Recommendations for Future Work . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
Appendix AParticle Swarm Code 85A.1 Matlab Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
Appendix BInversion Dynamics Code and Cost Function 95B.1 Matlab Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
Appendix CPseudospectral 103C.1 Matlab Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
Appendix DiPSO Runs 108D.1 PSU run tables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
Appendix EBSpline Implementation 112E.1 BSplines by Shene . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112E.2 Matlab Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
Appendix FParallelization Code 120F.1 C++ Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
References 152
v
List of Figures
1.1 Swift Instruments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.2 Path Constraint Cones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.1 History of Time Optimal Attitude Problems. . . . . . . . . . . . . . . . . . . . . . . 52.2 Unconstrained Path and Body Rate Solutions. . . . . . . . . . . . . . . . . . . . . . 72.3 Unconstrained Torque Solutions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82.4 Precessional components per axis. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.1 B-Spline Formulation with PSO update. . . . . . . . . . . . . . . . . . . . . . . . . 283.2 Overall Flowchart . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
4.1 Particle Swarm Variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374.2 Kinematics for Direct PSO. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 414.3 Body Rates for Direct PSO. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424.4 Torques for Direct PSO. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434.5 Kinematics for Case A. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 444.6 Body Rates for Case A. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 454.7 Torques for Case A. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464.8 Sensor-Axis Path for Case B. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 474.9 Kinematics for Case B. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 484.10 Body Rates for Case B. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 494.11 Torques for Case B. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 504.12 Sensor-Axis Path for Case C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 514.13 Kinematics for Case C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 524.14 Body Rates for Case C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 534.15 Torques for Case C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 544.16 Sensor-Axis Path for Case C (additional 9000 generations). . . . . . . . . . . . . . . 554.17 Kinematics for Case C. (additional 9000 generations) . . . . . . . . . . . . . . . . . 564.18 Body Rates for Case C. (additional 9000 generations) . . . . . . . . . . . . . . . . . 574.19 Torques for Case C. (additional 9000 generations) . . . . . . . . . . . . . . . . . . . 584.20 Path for Case D. (Splitting the Keep Out Cones) . . . . . . . . . . . . . . . . . . . 594.21 Torques for Case D. (Splitting the Keep Out Cones) . . . . . . . . . . . . . . . . . . 604.22 Path for Case E. (Looping Path) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 614.23 Torques for Case E. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 624.24 Time relaxation Case E. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 634.25 Reproduction of Body Rates using PSO Torque Values . . . . . . . . . . . . . . . . 66
vi
5.1 Run Time vs Number of Processors . . . . . . . . . . . . . . . . . . . . . . . . . . . 695.2 Controller implementation of Parallelization . . . . . . . . . . . . . . . . . . . . . . 695.3 Rigid Body Attitude System . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
6.1 Constrained time-optimal path of the sensor axis . . . . . . . . . . . . . . . . . . . 756.2 Solutions Generated by DIDO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 766.3 Case F without PSO guess . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 776.4 Case F without PSO guess . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 786.5 Case G with PSO guess . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 796.6 Case G with PSO guess . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 806.7 Case F without PSO guess . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 816.8 Case G with PSO guess . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
vii
List of Tables
4.1 Direct PSO Unconstrained Results . . . . . . . . . . . . . . . . . . . . . . . . . . . 404.2 Inverse PSO Unconstrained Results . . . . . . . . . . . . . . . . . . . . . . . . . . . 414.3 Summary of PSO Runs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 644.4 Summary of Minor Violations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
5.1 lxcluster.tlt.psu.edu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 685.2 arcaca.aero.psu cluster . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 685.3 iPSO 30 Particles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
D.1 (30 Particles, 3000 Iterations) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108D.2 (500 Particles, 3000 Iterations) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109D.3 (1000 Particles, 3000 Iterations) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110D.4 (1500 Particles, 3000 Iterations) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
viii
List of Symbols
α azimuth component of rotation vector (kinematic variable represented by B-Spline generatedby P1 to Pnk )(eg. for nk=6 P1 to P6)
β elevation component of rotation vector (kinematic variable represented by B-Spline generatedby Pnk+1 to P2nk )(eg. for nk=6 P7 to P12)
BL,P k particle position lower bound
BU,P k particle position upper bound
BL,V k particle velocity lower bound
BU,V k particle velocity upper bound
C DCM (Direction Cosine Matrix)
cC cognitive weighting coefficient
cI inertial weighting coefficient
cS social weighting coefficient
εi Euler parameters (i=1, . . . , 4)
gBest global best particle
GG J value associated with global best particle
I Satellite inertia tensor
J objective (or cost) function
J objective function with penalty terms, also referred to as the performance index or fitnessfunction
λi rotation vector component (i=1, . . . , 3)
Mmax maximum torque constraint
ix
Mi torque component (i=1, . . . , 3)
nk number of kinematic points used to evaluate B-Spline. (eg. nk=6)
N number of particles
NIT number of iterations
θ rotation about rotation vector (kinematic variable represented by B-Spline generated byP2nk+1 to P3nk )(eg. for nk=6, P13 to P18)
pBest particle’s best position
Pn(N) swarm where (n=1, . . . , 19 when nk=6) and (N=1, . . . , 30 when N=30)
Pn single particle containing n elements(n=1, . . . , 19 when nk=6)
σi satellite sensor orientation vector component (σ is aligned with b1-axis and used to measureits orientation with the inertial axis)
tf final time of maneuver (Generated by P3nk+1)(eg. for nk=6, P19)
ui control torque (i=1, . . . , 3)
Vn single particle’s velocity containing n elements(n=1, . . . , 19 when nk=6)
ωi body rate (i=1, . . . , 3)
x
Acknowledgments
I would like to acknowledge people who made contribution to writing my dissertation. First of
all, I would like to thank my adviser, Dr. Robert G. Melton, for his continuous help and support
throughout my graduate studies. This dissertation research was an enjoyable process because of his
guidance and advice. Dr Melton was also my teaching mentor during my teaching fellowship at the
Pennsylvania State University. I would also like to thank Dr. David B. Spencer as my secondary
adviser helping me tremendously with this subject material. Drs. Joseph P. Cusumano, and Joseph
F. Horn have taught me some great courses as well as allowing me to audit other courses that have
provided a firm foundation for my research endeavors.
Additionally, acknowledgments have to be given to Vidullan Surendran and Ghanghoon Paik
who have made numerous contributions during my studies and have also been good friends. Vidullan
Surrendran was invaluable with programming related issues and was a great teaching instructor for
his subject as well other areas within the field. Ghanghoon Paik has been great to collaborate with
and has been very helpful during my research work. Kirk Heller assisted with access to the high
performance computing cluster facility with the associated guidance.
Finally, I would like to thank my parents and brother who have done more than enough. This
work could never be finished without their support. My studies to this date would not be possible
without their help and assistance.
xi
Chapter 1 |
Introduction
The subject of interest in this dissertation is the time-optimal reorientation of a rigid body
spacecraft with path constraints. There is a class of problems in satellite attitude dynamics that
deals with a combination of time and fuel optimization. There are other problems that deal with fuel
optimization alone, including a zero-propellant maneuver of the ISS (International Space Station)
conducted in 2006 by NASA [1]. The first set of time optimal maneuvers conducted for a spacecraft
was part of the TRACE Mission in August 10th,2010 [2]. The objective was to acquire telemetry
data (i.e snapshots at numerous terrestrial locations) in a series of attitude maneuvers over the
shortest possible time. This resulted in a similar result to the classical Brachistochrone problem
where a longer path was taken to achieve the time-optimal solution. In this case, the path length
was characterized by the accumulated arc lengths of each angular rotation.
The time optimal solution in the TRACE mission was conducted offline [3]. That is, the problem
was prescribed and solved using ground-based computing facilities and resources and then uploaded
to the spacecraft via a datalink for a future slew operation. The reason for this is that these time
optimal solutions are difficult to find, even approximately, and require significant time to solve
completely. Required solution times were greater than 20 minutes during this milestone of the first
time optimal maneuver. Feasible solutions, that is local optimal solutions, can be obtained faster
but looking through the entire control space for global optimal solutions requires more time and a
1
different approach than what was used for the TRACE mission.
The spacecraft mission that inspired this research is the Swift Gamma Burst spacecraft mission
[4].The purpose of this mission is to detect GRBs (gamma-ray bursts) which are powerful explosions
in the universe. They occur usually once a day and are brief, with Swift detecting about 100 bursts a
year. The BAT (Burst Alert Telescope) detects the GRB using a wide field of view. The instruments
are shown in Figs (1.1) [3]. With the position detected the spacecraft swiftly slews the spacecraft to
align the XRT (X-Ray Telescope) and the UVOT (Ultra-Violet/Optical Telescope) within 90-180
seconds. All three telescopes acquire critical data from the rapidly fading afterglow from the GRB.
Figure 1.1: Swift Instruments
An example of a maneuver for Swift is shown in Fig (1.2) where the initial orientation of the
telescope axis as represented by a dashed green line. It has to terminate its re-orientation in the
direction of the solid red line,the next GRB target, while avoiding the bright yellow sun cone, blue
Earth cone and the grey moon cone as those optical sources could damage the delicate light-sensitive
telescope. Presently, Swift computes a slewing maneuver primarily designed to make the telescope
axis avoid entering the “keep-out” cones, but without trying to minimize the slew time.
The focus of this dissertation is to develop techniques that can aide in obtaining possible global
2
21
0
Path Constraint Cones
-11
0.50
-0.5
0
-0.5
-1
0.5
1
Earth Keep Out Cone
Moon KeepOut Cone
Sun KeepOut Cone
Inital Starting Sensor Orientation
Final Sensor Orientation
Figure 1.2: Path Constraint Cones
minimum-time solutions and reduce the computation time such that the computing can be conducted
on-board the spacecraft in real-time, that is RTOC (Real Time Optimal Control). In order to seek a
global solution the research employs the method of PSO (Particle Swarm Optimization). The heart
of the research examines techniques to speed up the computation time, including the development
of the Inversion Method. Once this method has been demonstrated, the PSO utilizing the inversion
method is then parallelized to speed up the calculation. A discussion of an architecture of a near
real time control system for attitude control of a spacecraft is considered.
3
Chapter 2 |
Literature Review
This chapter seeks to provide a broad survey of the literature pertaining to optimal attitude
maneuvers of rigid bodies. This chapter was presented at the AAS/AIAA Space Flight Mechanics
Conference in Williamsburg, Virginia, 2015 [5]. It is rather limited in breadth, given that papers
addressing flexibility effects or modeling multibody dynamics (e.g. gyroscopic devices) are not
included. Those constitute a vast body of work and, although clearly important to theoretical and
practical issues in spacecraft dynamics, lie beyond the manageable scope of this dissertation. An
earlier survey by Scrivener and Thompson [6] considers a variety of dynamical models, all pertaining
to the time-optimal reorientation maneuvers but it pre-dates the development of global search
methods, such as the one used in this dissertation.
The papers surveyed here could be divided by problem type or method of solution, with many
combinations of categories. Instead, we begin with a discussion of features that are common to
nearly all of the work, and focus later on specific aspects of current interest. Nearly all of the papers
surveyed here employ some method of optimal control theory, using either a classical indirect method
(calculus of variations and Pontryagin’s Minimum Principle) or a direct method. A concise history
of the problem is shown in Fig.(2.1).
4
Figure 2.1: History of Time Optimal Attitude Problems.
Unconstrained Paths
All of the papers surveyed here include some constraints on the initial and final states, with the
rest-to-rest maneuver being most commonly addressed. Problems that include path constraints, i.e.,
restrictions on the orientation of one or more body axes during the maneuver, will be addressed in a
later section.
5
The earliest work in the open literature, by Dixon et al [7], examines the problem of minimizing
fuel usage when only two impulsive control torques are employed. The kinematic formulation uses
Euler angles, and although large-angle maneuvers are considered, the potential for encountering a
singularity is not addressed. D’Amario and Stubbs [8] develop a closed-loop controller that executes
an eigenaxis maneuver (rotation about a single axis that is fixed in both the inertial and body fixed
frames) between two rest states of a spacecraft.
Bilimoria and Wie’s seminal paper [9] considers the time-optimal rest-to-rest maneuver of a
spherically symmetric1 spacecraft, with independent control torques of equal maximum authority
for each axis. The problem requiring a time optimal 180 deg. rotation about the z-axis with no
path constraints is shown in Fig.(2.2) [9] with the path traversed and body rates of the optimal
solution. The solution is bang-bang2, with the number of control switches between extreme torque
values depending upon the magnitude of the reorientation angle. For cases where the equivalent
eigenaxis rotation would have been less than or equal to 72 deg, seven switches are required; for
reorientations greater than 72 deg., only five switches are required. These results are shown in
Fig.(2.3) [9]. Interestingly, the time-optimal solution is not a simple eigenaxis maneuver. The
optimal solution makes use of the fact that not all directions have the same maximum control torque
available, and the dynamics can include precessional motion to reach the final specified attitude
more rapidly than if a single axis were employed. These precessional components are resolved in in
Fig.(2.4) [9]. It can be seen in the uz component of the figure that the area A is greater than area B
which results in a greater net torque over the eigenaxis torque shown in dotted lines. The ux and uy1The symmetry refers to the mass distribution. In fact, the significant property is that all three principal moments
of inertia are equal.2Bang-bang has torque at either fully maximum or minimum.
6
component show a similarity between the two torque profiles. The authors use an indirect method,
solved numerically via a multiple shooting method.
Bilimorie and Wie 1993
Constrained Time-Optimal Slewing Maneuvers for Rigid Spacecraft
Figure 2.2: Unconstrained Path and Body Rate Solutions.
Seywald and Kumar [10] consider the possibility of singular control (with independent three-axis
controls) for spherically symmetric mass distributions, and for a variety of initial and final states.
They show that all three controls cannot be singular, i.e., one control torque must always be
saturated, that is fully maximum or minimum. In this thrust control,minimum control means
maximum thrust in the opposite direction. It is possible for one or two controls to be singular, with
finite or infinite order. Subsequently, Byers [11] showed that no singular control is possible for the
7
Time-Optimal Three-Axis Reorientation of a Rigid Spacecraft
Bilimorie and Wie 1993
Control Input for ø = 180 (5 switches) Control Input for ø = 30 (7 switches)
Figure 2.3: Unconstrained Torque Solutions.
case of a rest-to-rest maneuver for this problem.
Byers [12] developed an approximate analytic solution to the problem of time-optimal, rest-to-rest
maneuvers for asymmetric spacecraft. The solution uses a truncated Taylor series to represent the
state transition matrix, with the coefficients in the series generated recursively.
Shen and Tsiotras [13] consider an axisymmetric body with only two control torques available.
The vehicle is spin-stabilized about its unique symmetry axis, which must be reoriented to a specified
direction in minimum time. A special set of kinematic variables [14], valid only for axisymmetric
8
Bilimorie and Wie 1993
Time-Optimal Three-Axis Reorientation of a Rigid Spacecraft
Figure 2.4: Precessional components per axis.
bodies, is used.
Bai and Junkins [15] revisited the problem first considered by Bilimoria and Wie, and found that
there are multiple local minima, with some having six control switches when the reorientation is less
than or equal to 72 deg. They also found that if the total control torque magnitude is bounded, the
time-optimal solution is the eigenaxis maneuver. This is entirely consistent with the fact that such
a system is degenerate – every orientation of the body axes in the physical object will lead to the
same dynamics in a given problem, and the same maximum control torque is available about any
direction.
A different problem, considered by Molodenkov and Sapunkov [16] uses a performance index
9
that is a linear combination of time and control effort
J =∫ T
0(α1 + α2|u|) dt (2.1)
where α1, α2 are constant weighting factors, and the final time T is unspecified. The body has a
spherically-symmetric mass distribution and the components of the control torque u are independent
and bounded.
Li et al [17] examine the global stabilization problem (i.e., how to control a spacecraft from an
arbitrary set of initial conditions to some specified equilibrium point). They treat the problem in
terms of optimum tracking, with the performance index for the kinematics being quadratic in the
states (quaternions 3 and angular velocities); the controller then tracks the resulting optimal state
trajectories. The method can achieve global stability in the absence of external disturbances, and
can converge to a neighborhood of the desired equilibrium if disturbances are present.
The papers by Crassidis and Markley [18] and Crassidis et al [19] involve tracking problems,
wherein an optimal trajectory is first computed and then the controller must force the spacecraft to
follow it. Such requirements arise typically in spacecraft mission designs where a particular event
must be anticipated, for example, a high-speed planetary flyby in which the spacecraft must execute
a defined attitude maneuver in order to capture visual details of the planet’s surface. Other papers,
by Sharma and Tewari [20], Kim and Kim [21], and Krstic and Tsiotras [22] also treat the problem
as a tracking task.
Ioslovich [23] and Ioslovich et al [24] both consider asymmetric spacecraft maneuvering with3See Chapter 3 for an explanation of quaternions.
10
performance index of∫
Σ|ui| and∫|u| respectively, with tf unspecified. Liu and Singh [25] solve the
problem of combined time and fuel, assuming that the solution has bang-bang control structure.
They use a switching-time optimization algorithm to determine the optimum switching times that
satisfy the first-order necessary conditions.
Geometric control methods take advantage of known properties of the solution space – in the
case of attitude maneuvers, the motion from initial to final attitudes is an orthogonal transformation
that can be represented as motion on the manifold defined by the group SO(3). SO(3) is the group
of all rotations in the Euclidean space of dimension order of 3. Two papers that use geometric
control for this advantage are Spindler [26], which considers a rest-to-rest maneuver, using a system
that minimizes the kinetic energy of rotation over a fixed time-interval. The problem is formulated
in a way that avoids the use of costates, but instead introduces differential equations for the controls.
Biggs and Horri [27] use geometric control in the problem of a spin-stabilized spacecraft that must
be reoriented in a fixed time-interval, using a performance index that is quadratic in the control
torque.
In practice, attitude regulators generally operate in conditions where attitude errors resulting
from small disturbances must be corrected; however, in the event of a large disturbance or if initial
conditions place the spacecraft in an unanticipated attitude state, a regulator may need to perform a
large-angle maneuver. Tewari [28] develops a nonlinear feedback control for an attitude regulator for
an asymmetric spacecraft. The formulation uses Modified Rodriguez Parameters (MRP’s) for the
kinimatics 4 and a performance index that is quadratic in the control torques, but higher-order in the
states due to cross-coupling in the dynamics. Global stability is proven via Lyapunov analysis and4See Chapter 3 for an explanation of MRP’s.
11
the simulated performance shows rapid convergence. Tsiotras [29] examines the regulator problem for
an axisymmetric spacecraft. The performance index is quadratic in the states, and the formulation
uses the special kinematics [14] noted earlier for axisymmetric bodies. Mazenc and Akella [30]
consider the problem of attitude regulation when there is a delay in the input (e.g., a transport
delay due to signal propagation time from ground control to the spacecraft). For an asymmetric
spacecraft, they show that arbitrarily large reorientation maneuvers can be controlled without a
limit on the time delay.
Path Constraints
Path constraints, such as restrictions on the permissible direction that one or more axes of the
spacecraft can have during the maneuver, pose additional challenges. These constraints typically
arise from operational concerns, such as preventing intense sunlight from damaging an optical sensor.
These so-called keep-out constraints maintain a minimum angular distance αx between some specified
axis σ fixed in the spacecraft and the direction σX to the object X to be avoided.
Cx = σ · σx − cos(αx) ≤ 0 (2.2)
In the classical indirect method, one then augments the Hamiltonian with the term µxCx, where
the multiplier µx ≥ 0 if the constraint is active and µx = 0 otherwise. Furthermore, the so-called
tangency conditions [31] must also be applied (i.e., for any part of the trajectory on the boundary,
not only C, but also its first and second time derivatives must be zero).
12
Hablani [32] develops a control algorithm that prevents the boresight of an onboard telescope
from entering the keep-out cone of a bright object. The controller uses pitch and yaw commands to
execute the maneuver, and roll commands to maintain communication with a ground station. In the
event that the boresight encounters a keep-out cone boundary, the controller forces the spacecraft
to move such that the boresight slides along the constraint boundary until an exclusion-free zone
with a path to the target becomes available. Spindler [33] uses geometric control theory to solve
the path-constrained problem with a performance index that is quadratic in the angular velocities.
Such a formulation has practical merit for missions where structural considerations preclude the
use of high angular rates in the maneuver. Mengali and Quarta [34] also consider the problem of
reorientation when keep-out cones are present. Although their formulation is not cast as an optimal
control problem, the solution encompasses the use of both high-level control torques (e.g., from gas
jets) using discrete control laws, as well as low-thrust (field-effect electric propulsion) devices with
continuous control laws that can achieve high-precision attitude targeting. Melton [35] examines
the time-optimal problem for a spherically symmetric spacecraft where multiple keep-out cones are
present. Later work [36] shows that the time-optimal solutions do not include any trajectories that
cause the sensor axis to intersect the exclusion boundary either along a finite arc or at a point.
While keep-out cones and allowable sensor paths are easily visualized in physical space, the
permissible paths of the attitude parameters and how their relation to physical space pose an
interesting challenge. Recent work by Tanygin [37] combines a graph-search technique with a
mapping transformation that allows one to determine the minimum angular-length path and to
visualize that along with the alternative feasible solutions. Weiss et al [38] also use a graph-search
13
algorithm and then implement a controller that follows the minimum-angle path. Although these
methods are interesting, it must be remembered that the minimum-angle path is generally not the
time-optimal solution.
Use of Direct Methods
Unlike the classical approach to optimal control, the so-called direct methods do not make explicit
use of the necessary conditions [see Eqs (6.3)], but instead directly minimize the performance index,
subject to whatever state, control, and/or path constraints are present, plus other constraints that
are peculiar to the method. The more accurate direct methods use nonlinear programming to
calculate values of a finite set of parameters that are being used to model the control.
Direct collocation with nonlinear programming (DCNLP) became popular for use in orbital
trajectory optimization after Enright and Conway [39] demonstrated its efficacy in that type of
problem. DCNLP is characterized as a local method, since the solution is constructed piecewise
between discrete times (nodes) in the maneuver. Between any pair of nodes, each state is modeled
as a polynomial in time. At each node, the state value and its time-derivative are continuous.
An equality constraint is added for each state: the defect (the difference between the state’s time
derivative as calculated from the polynomial model and as calculated from the state equations) at
one or more collocation points between the nodes must equal zero. The result is an implicit solution
to each state equation. Scrivener and Thompson [40] employed DCNLP to solve the time-optimal
reorientation problem, showing that good approximations are possible by minimizing the magnitudes
of the defects but without requiring them to be identically zero.
14
Pseudospectral (PS) methods have grown in popularity, again with the initial applications being
in orbital trajectory optimization problems. Unlike DCNLP, the PS methods solve the collocation
problem globally, using a sum of orthogonal polynomials for each state and control that is valid
over the entire time-span of the motion. The collocation points are the nodes, which are required to
be the locations where the finite polynomial expansion exactly represents the function value (state
or control). In general, many fewer nodes are required for PS solutions (compared to DCNLP),
greatly reducing the computational burden. Fahroo and Ross [41] first developed a practical PS
method based upon Chebyshev polynomials, later implemented in the Dido software package [42]
using Legendre polynomials. Two other software implementations of PS methods, PSOPT [43] and
GPOPS-II [44], have found use in attitude maneuver problems [45,46].
Proulx and Ross [47] apply a Legendre PS method to solve the time-optimal reorientation
problem for an asymmetric spacecraft. Their hybrid method uses a genetic algorithm (GA) to
provide a coarse initial estimate of the states and controls as inputs to the PS algorithm; however,
the GA sometimes finds local minima that are far from optimal. Melton [48] compares two heuristic
algorithms known for their global search performance, particle swarm optimization (PSO) and
bacteria foraging optimization (BFO), for use as first-stage estimators for input to a Legendre PS
method. For either first-stage estimator, the overall computation time is significantly reduced as
compared to using just the PS method. Zhuang and Huang [49] use a hybrid PSO-PS method to
study the problem of time-optimal reorientation for an underactuated spacecraft (e.g., when one
control thruster pair has failed), finding superior computational performance to either the PSO or
PS method used individually.
15
Fleming et al [50] apply a PS method to the time-optimal maneuver for an asymmetric spacecraft
and then demonstrates high-fidelity performance when the control is implemented (in simulation) as
closed-loop. Such implementation is possible, in part, due to the rapid calculation that PS methods
afford. An example of optimal attitude control being implemented in an actual spacecraft is given
by Karpenko et al [51], which describes the first flight demonstration of a time-optimal maneuver,
performed in 2010 onboard NASA’s TRACE Space Telescope.
With the literature review, including the optimal time path unconstrained problem and the
preliminary path constraint problem, it is possible to now provide a formulation and method solution
in the next chapter to further investigate this problem.
16
Chapter 3 |
Problem Formulation and Method of Solution
3.1 Kinematic Formulation
For practical reasons, the dynamics are almost always modeled using Euler’s equations of rigid
body motion
I1ω1 + ω2ω3(I3 − I2) = u1
I2ω2 + ω3ω1(I1 − I3) = u2 (3.1)
I3ω3 + ω1ω2(I2 − I1) = u3
where the Ii are the principal moments of inertia, the ωi are the angular velocities (body rates)
about the principal axes, and the ui are the control torques. Onboard controllers generally use
inputs from sensors that directly measure (or estimate) the angular velocities ωi. Generally, some
additional representation of the spacecraft’s instantaneous attitude is needed, along with a way to
relate the body rates with how the attitude is changing, which is addressed in the next section.
17
Kinematic Formulations
For practical implementation where a controller needs only to regulate a spacecraft’s attitude in
some fixed orientation, it may be reasonable to employ Euler angles [52] to specify instantaneous
attitude; however, for large-angle reorientation maneuvers (so-called slew maneuvers), the transfor-
mation between body rates and Euler rates (time-derivatives of the Euler angles) will likely encounter
a singularity. Two other formulations, Euler parameters and Modified Rodrigues Parameters, avoid
that difficulty and are commonly used in attitude dynamics and control problems.
Euler Parameters (Quaternions)
If a = [a1, a2, a3]T and b = [b1, b2, b3]T are dextral, orthonormal basis vectors that define the
orientations of two coordinate systems A and B, the relationship between them can be defined
using a direction cosine matrix (DCM) CAB such that b = CABa. Each element Cij = bi · aj is the
cosine of the angle between the two corresponding unit vectors. The DCM can be generated via a
sequence of, at most, three simple rotations about unique directions (i.e., the standard Euler-angle
representation). Because a DCM is an orthogonal matrix, there must exist one eigenvector with unit
eigenvalue: CABλ = λ. Geometrically, rotating the set a about the direction λ through an angle
θ will bring system A into alignment with system B. Thus, a single rotation, called the eigenaxis
rotation describes the orientation of B with respect to A, replacing the sequence of Euler-angle
rotations. The information embodied in the set (λ, θ) is more practically represented in the Euler
18
parameters
ε1 = λ1 sin θ2 (3.2a)
ε2 = λ2 sin θ2 (3.2b)
ε3 = λ3 sin θ2 (3.2c)
ε4 = cos θ2 (3.2d)
The Euler parameters are frequently, and incorrectly, referred to as quaternions. Although the
two are closely related, quaternions obey the algebra of hyperimaginary numbers, a property that has
important benefits for reducing computation in systems where orientations are changing rapidly [53].
In fact, Euler parameters and quaternions embody identical information. The two names are used
interchangeably in the literature, and this dissertation follows that practice. Conversion between
Euler parameters and the related DCM is given by
C =
1− 2(ε22 + ε2
3) 2(ε1ε2 + ε3ε4) 2(ε1ε3 − ε2ε4)
2(ε2ε1 − ε3ε4) 1− 2(ε21 + ε2
3) 2(ε2ε3 + ε1ε4)
2(ε3ε1 + ε2ε4) 2(ε3ε2 − ε1ε4) 1− 2(ε21 + ε2
2)
(3.3)
ε4 = 12 (1 + trC)1/2 for 0 ≤ θ < π (3.4)
19
ε = 1ε4
C23 − C32
C31 − C13
C12 − C21
if ε4 6= 0 (3.5)
where ε = [ε1, ε2, ε3]T . The case of θ = π presents a practical problem for numerical calculations,
but Markley [54] provides an algorithm to address this. Unlike the kinematic relation between body
rates and Euler rates, the conversion [55] between body rates and Euler-parameter rates does not
contain any singularities
ε1
ε2
ε3
ε4
=
ε4 −ε3 ε2 ε1
ε3 ε4 −ε1 ε2
−ε4 ε1 ε4 ε3
−ε1 −ε2 −ε3 ε4
ω1
ω2
ω3
0
(3.6)
Modified Rodrigues Parameters
A more compact expression for the single-axis rotation simply divides each of the εi; i = 1 . . . 3
by ε4, giving
ρ = λ tan θ2 (3.7)
where ρ is called the Gibbs vector, and its components ρ1, ρ2, ρ3 the Rodrigues parameters [52].
There is still a singularity at θ = π. A modification that moves the singularity to θ = 2π is
σ = λ tan θ4 (3.8)
20
and the components σ1, σ2, σ3 are known as the Modified Rodrigues Parameters (MRP’s) [56]. The
relations between the MRP’s and the corresponding DCM are
σ = 1ζ(ζ + 2)
C23 − C32
C31 − C13
C12 − C21
(3.9)
C = I + 8σ2 − 4(1− σ2)σ(1 + σ2)2 (3.10)
where I is the identity matrix, σ = |σ|, ζ =√trC + 1 and
σ = CT −Cζ(ζ + 2) (3.11)
And the kinematic differential equation, also singularity-free, is
σ = 14[(1− σ2)I + 2σ + 2σσT
]ω (3.12)
Alternative Kinematic Forms
While these two preceding methods provide elegant and compact means for representing attitude,
they both suffer from a property of vector geometry, namely that a rotation specified by (λ, θ) is
physically equivalent to the pair (−λ, 2π − θ). This is particularly troublesome for attitude position
controllers, where a small rotation angle δ might suffice to correct an attitude error, but instead
the controller commands the larger rotation 2π − δ. This phenomenon, known as unwinding, can
21
be avoided in one of two ways. Sanyal [57], Lee et al [58] and Bloch et al [59] use a Lie-algebraic
formulation and rotation matrices (a general form of a DCM’s) that does not require specifying
coordinate systems and which is singularity free. They also make use of a geometric integrator,
which preserves the geometry of the flow, leading to greater numerical accuracy than the more
commonly used Runge-Kutta schemes.
Yet another method is to retain the use of Euler parameters or MRP’s for propagating the
attitude kinematics, but specify the desired final state in a form independent of the eigenaxis
direction. Following Melton [35], where only one axis (aligned with a telescope) has a specified final
orientation, one could employ the same method to specify the orientations of two of the body axes,
e.g., b1 and b2. A required final attitude b1 = b1,f , b2 = b2,f becomes b1 · b1,f = 1 and b2 · b2,f = 1.
Using Eq. (3.3) to represent the instantaneous orientation of the bi (denoted by superscript B) and
the desired final orientation of bj,f (denoted by superscript F ) in terms of an inertial frame N
b1 · b1,f = 1 =[1− 2
(εB2
2 + εB32)] [1− 2
(εF2
2 + εF32)]
+[2(εB1 ε
B2 + εB3 ε
B4
)] [2(εF1 ε
F2 + εF3 ε
F4
)](3.13)
+[2(εB1 ε
B3 − εB2 εB4
)] [2(εF1 ε
F3 − εF2 εF4
)]
which is invariant in the direction of the λ rotation. A similar expression can be written for the dot
product b2 · b2,f = 1. Schaub et al [60] present a universal attitude penalty function for use as part
of the performance index (see the next section) that is independent of the attitude representation.
22
3.2 Particle Swarm Optimization
Particle Swarm Optimization (PSO) is considered a heuristic computational method that mimics
the behavior of swarm of birds or insects as it searches for food. A swarm consists of k particles
each of which represents a possible candidate solution.Each particle consists of a set of n unknown
parameters that define the solution. The particles are initially assigned randomly generated values
within the range of the upper and lower bound B.:
BL,P k ≤ Pk ≤ BU,P k (k = 1, . . . , n) (3.14)
The current value of the i-th particle is called its position P(i), referring to its location in the
n-dimensional solution space. The swarm is represented by the matrix P.
P (i) , [P1(i) . . . Pn(i)]T (i = 1, . . . , N) (3.15)
Here N is the number of particles. Each particle has a velocity (rate of change over the iteration).
Each velocity vector component Vk(i) has bounds that are derived from the limits of position vector
components in Eq. (3.14). The range of the velocity vector components are defined as:
−(BU,P k −BL,P k) ≤ Vk ≤ (BU,P k −BL,P k) (3.16)
BL,V k ≤ Vk ≤ BU,V k (3.17)
23
In each iteration, the new position of a particle P (j+1)k (i) is determined by adding its velocity
(times one iteration) to its current position:
P(j+1)k = P
(j)k + V
(j)k (j = 1, . . . , NIT ) (3.18)
If an updated position exceeds the bounds of Eq. (3.14), the iterated position is set to that bound.
That is, it is set to the lower bound if a value is smaller than the lower limit, or upper bound if a
value is greater than the upper limit . In these extreme cases the velocity of the iteration is set to 0
as [61]:
P(j+1)k =
BL,Pk
if P(j+1)k < BL,Pk
BL,Pkif P
(j+1)k > BU,Pk
and V(j+1)k (i) = 0.
Each particle is evaluated to determine the corresponding values of the cost function J. Each
particle of the swarm has a particle best position (pBest) recorded throughout its own solution
history in terms of the cost function J.There is also a global best position (gBest) amongst all
particles. The global best position of the swarm is shared amongst all the particles in the swarm [62].
The objective function J (j)(i) for pBest of particle i at the j-th iteration is:
J (j)(i) = min J (1,...,j)(i) (3.19)
where (i=1, . . . , N ) then, pBest is determined as:
pBest(j)(i) = P (l)(i)(l = arg minp=1,...,j J
(p)(i))
(3.20)
24
Similarly, the globally best J among all the swarm is:
J(j)Best(i) = min J (1,...,j)(i) (3.21)
and the gBest is:
gBest(j) = pBest(j)(q)(q = arg mini=1,...,N J
(j)Best(i)
)(3.22)
The velocity vector is calculated as follows :
V(j+1)k (i) = cIV
(j)k (i) + cC
[pBest
(j)k (i)− P (j)
k (i)]
+ cS[gBest
(j)k − P
(j)k (i)
](3.23)
where the coefficients of the various components of the vectors are given by :
cI = 1 + r1(0, 1)2 cC = 1.49445r2(0, 1) cs = 1.49445r3(0, 1) (3.24)
where r1(0,1), r2(0,1), and r3(0,1) are random numbers uniformly distributed between 0 and 1. The
numerical values used are commonly used weightings that were determined experimentally by early
researchers to give the best performance for a wide class of problems. The subscripts I, C and S
stand for inertial, cognitive and social. The value of cI determines how much the new velocity for
the i-th particle continues in the same direction as the current velocity. The value of cC determines
how much the new velocity is directed toward the best position ever reached by that particle. And
the value of cS determines how much the new velocity is directed toward the best posiiton ever
25
reached by any particle in the swarm.
A well known problem with PSO (and other heuristic methods as well) is that of stagnation,
in which the swarm collects at some point in the n-dimensional solution space and does not move
for many iterations. In order to help avoid stagnation, the PSO algorithm (shown below) contains
a unique modification for this research. An additional step is added after each iteration to check
the progress of the value of J for the global-best particle. If J has not decreased by a specified
percentage over the previous nr iterations (a value chosen by the user), then some specified fraction
of the particles is reset: those particles are assigned random values within the allowed bounds and
the iterative process continues; however, the value of gBest is retained. This has proven to work
very well in preventing stagnation, although it sometimes requires a number of resets to move the
swarm away from the stagnation point.
Algorithm 1 Particle Swarm OptimizationInitialize a population of particles with random values positions and velocities from n dimensionsin the search spacefor Number of Iterations NIT do
for Each particle i doAdapt velocity of the particle using Equation 3.23Update the position of the particle using Equation 3.18Evaluate the Cost Function J((P )i)Update pBest using Equation 3.20Update gBest using Equation3.22
end forend for
26
3.3 The B-Spline
The kinematic variables (quaternions) can be represented by B-Splines. The particle parameters
of the PSO provide the control points of the B-Splines in the algorithms used in this dissertation.
The B-splines generated will represent the variable α, β and θ as defined by Fig.(4.1) and their
associated derivatives are shown to be used in equations (4.16) and (4.23), that is, the first derivatives
and the second derivatives of the B-splines.
The use of Bezier curves are sufficient approximations for the kinematics variable α, β and θ, but
the more general B-Spline was used in this implementation. Bezier curves use Bernstein polynomials
whose algorithm implementations are much simpler to implement and have a global property where
a single change in a control point affects the entire curve. The Berstein polynomials generate the
basis functions which are then affected by control points. The more general B-Spline has a local
property in that, depending on the degree of the polynomial fit, only the local region is affected
by any changes in a control point and as such only the basis functions around the control point of
interest have to be recalculated. The algorithm used in the dissertation calculates the entire B-Spline
each time a particle is updated. Fig.(3.1) shows an update of the α kinematic spline being updated
by a PSO iteration. Similarly the β and θ kinematic splines would be updated in a similar manner
with the goal of minimizing the tf (the final element of the particle) which is shared amongst all
three kinematic splines.
The α kinematic component shown in Fig.(3.1) is the B-spline and is defined in terms of control
points Pi and coefficients Ni,p. which are determined by the basis functions hence the name B-spline.
27
Figure 3.1: B-Spline Formulation with PSO update.
The α in terms of some parameter τ is
α(τ) =n+1∑i=1
Ni,p(τ)Pi (3.25)
Shene [63] provides the mathematical background to the B-Spline implementation and Melton
provides a Matlab implementation in Appendix E.
28
3.4 Overall Flowchart
Fig.(3.2) shows a flowchart that implements the methods already described in this dissertation,
that is the workflow between Sections 3-6. The workflow shown in Fig.(3.2) between (Section
3.2)Update Particle connected to Operate on Single Particle connected to (Section 3.3) Generate
B-Spline, represents Fig.(3.1).
α, β, and θ
α β θ
Figure 3.2: Overall Flowchart
29
Chapter 4 |
Application
4.1 Application
This chapter looks at the indirect Particle Swarm Optimization, that is, via inverse dynamics,
and compares it to that of direct Particle Swarm Optimization. With the inverse dynamics method
the PSO is applied to the kinematics as opposed to the control torques. This chapter, originally
presented at the AAS/AIAA Astrodynamics Specialist Conference in Vail Colorado, 2015 [64],
has been expanded for completeness. Use of MRPs in [65] made it possible to convert between
the kinematic variables (MRPs) and the angular velocity components, however,quaternions and
not MRPs are the standard kinematic representation used in satellite attitude control systems.
Conversion between quaternion and angular velocity components is accomplished analytically,avoiding
numerical matrix inversion proposed by the the author in [65]. Although this now permits the use
of quaternions in the inverse dynamic formulation, the additional constraint of quaternion normality
(ε21 + ε2
2 + ε23 + ε2
4 = 1) must be exactly incorporated, as explained later in this chapter. The inversion
method has previously been applied to the kinematics using Modified Rodrigues Parameters (MRPs)
by Spiller et al, [65] however the formulation used here makes use of quaternions. In the inverse
dynamics solution, each candidate solution consists of a history of a rotation axis vector and an
associated rotation which is then converted to a quaternion history q(t) and its associated final
30
time tf . The rotation axis vector orientation prescribed by α and β and an associated rotation θ are
approximated by a set of basis splines (B-splines) such that the constraints at the initial and final
times are exactly satisfied. A PSO is then employed to determine coefficients of the B-splines such
that a rotational path satisfies the path and torque magnitude constraints, and which minimizes
tf . The inverse dynamics can then evaluate the body rates and required torque history from the
kinematics and Euler’s equations of motion.
A major consequence of the inverse dynamics is that no integration is required of the governing
equations of motion. The path q(t) and angular velocity ω(t) are found in terms of the B-spline
solutions. As with previous optimization using heuristic methods, the path and control constraints
are included via penalty functions.
4.2 Problem Statement
The physical problem is to minimize the final time tf , so the performance index
J = tf (4.1)
The boundary constraints for the example presented here are
ω1(0) = ω2(0) = ω3(0) = 0
ε1(0) = ε2(0) = ε3(0) = 0, ε4(0) = 1
ω1(tf ) = ω2(tf ) = ω3(tf ) = 0 (4.2)
ε1(tf ) = ε2(tf ) = 0, ε3(tf ) = ε3f ε4(tf ) = ε4f
31
The control constraints are
Mi ≤Mmax (4.3)
The spacecraft being modeled has one or more sensors that are fixed to the spacecraft bus; these
sensors all have the same central axis for their fields of view and this axis is designated here with
the unit vector σ and referred to as the sensor axis. This axis must be kept at least a minimum
angular distance αx from each of several high-intensity light sources. Denoting the directions to
these sources as σx , where the subscript x can be S (Sun), E (Earth), or M (Moon), the so-called
keep-out constraints are then written as
σ · σx ≤ cos(αx) (4.4)
The dynamic constraints are
M1 = I1ω1 + ω2ω3 (I3 − I2)
M2 = I2ω2 + ω3ω1 (I1 − I3) (4.5)
M3 = I3ω3 + ω1ω2 (I2 − I1)
The kinematic constraints are
ω1
ω2
ω3
0
= 2
ε4 ε3 −ε2 −ε1
−ε3 ε4 ε1 −ε2
ε2 −ε1 ε4 −ε3
ε1 ε2 ε3 ε4
ε1
ε2
ε3
ε4
(4.6)
ω = 2E ε
32
ω = 2Eε+ 2Eε (4.7)
4.3 Penalty Functions
Regardless of how the problem is formulated (direct or inverse-dynamics), various types of
constraints have been presented in the previous section and these will be formally stated in this
section as a general optimal control problem constraint and formulated as a penalty function. That
is if any type of constraint is violated in will incure a penalty in the cost function. As stated, the
satellite must reach a specified orientation at the final time of the maneuver and its body rates
(angular velocity components) must be zero; these are equality constraints. Similarly, there are
limits on the control-torque magnitudes and restrictions on how close a particular satellite axis can
be to a bright optical source; these are inequality constraints. In each case, the constraint can be
handled by use of a penalty function. In all cases, the constraints can be written in terms of the
vector of unknowns x (which corresponds to the elements of each particle in the swarm).
For equality constraints of the form
gi(x) = 0 (4.8)
the penalty function is
Gi(x) = keq,i |gi(x)| (4.9)
33
For inequality constraints of the form
hj(x) ≤ 0 (4.10)
the penalty function is
Hj(x) = kineq,j max {0, hj(x)} (4.11)
where the keq,i and kineq,j are weights whose values determine the relative importance the corre-
sponding constraints.
The resulting modified cost function is then
J = tf +Neq∑i=1
Gi +Nineq∑j=1
Hj (4.12)
where Neq and Nineq are the number of equality and inequality constraints, respectively.
Penalty functions are relatively easy to implement, but they do not permit rigorous enforcement of
constraints. Choosing appropriate values of the weighting factors requires some trial and error: if
the weighting is too small, the penalty has little effect on the solution and the constraint may be
violated by a large amount; if the weighting is too large, the penalty dominates the value of the cost
function, resulting in a solution that satisfies that constraint, but which gives a large value of tf
(the true quantity that needs to be minimized).
34
4.4 Inverse Dynamics Formulation
In the inverse-dynamics formulation, it is required that the quaternion trajectory be consistent
with quaternion properties, in that all four quaternions are not independent of one another. That is
ε21 + ε2
2 + ε23 + ε2
4 = 1 (4.13)
Enforcing this constraint in a direct-dynamics formulation, where the kinematic and dynamic
equation of motion are being numerically integrated, is relatively straight forward: the quaternion
is simply re-normalized during each integration step via the assignment statement The following
formulation ensures that this property is satisfied.
εi = εiε21+ε22+ε23+ε24
(i = 1, . . . , 4) (4.14)
which removes any accumulating numerical error in the εi. But in the inverse-dynamics formulation,
such a re-normalization is not possible because each εi is modeled by a time-varying function (e.g a
spline) over the entire time span of the physical motion. A geometric interpretation of the quaternion
makes it possible to incorporate the normality constraint exactly. The body-fixed axes have an
orientation with respect to the inertial axes that can be represented by a single rotation of the body
axes about an axis defined the unit vector λ, with rotation angle (in a right handed sense) of θ, as
seen in Fig. (4.1). This so called λ rotation has the well known relationship with the quaternion
elements.
ε1 = λ1 sin θ2
35
ε2 = λ2 sin θ2
ε3 = λ3 sin θ2 (4.15)
ε4 = cos θ2
While the λ rotation form exactly satisfies the normality constraint, it still uses 4 parameters
(λ1, λ2, λ3, θ). A further geometric transformation reduces the number of parameters to 3 and exactly
satisfies the normality constraint Eq.(4.16) where α, β, θ are defined as in Eq.(4.1).
λ1 = cos(β) cos(α)
λ2 = cos(β) sin(α) (4.16)
λ3 = sin(β)
where α, β, and θ are defined in Fig. (4.1). The problem to be considered is a rest-to-rest
maneuver, consisting of a rotation about an initial axis through an angle with boundary conditions.
In the numerical calculations, time is scaled by the factor√I/Mmax and the control torques are
scaled by the factor Mmax.
Without loss of generality, σ is assumed to lie along the body-fixed b1-axis and its orientation
with respect to the inertial frame is then determined as [52]
σ1 = 1− 2(ε22 + ε2
3)
σ2 = 2(ε1ε2 + ε3ε4) (4.17)
σ3 = 2(ε3ε1 − ε2ε4)
It is further assumed that the reorientation maneuver can occur quickly enough that the spacecraft’s
36
\U+03B#1
for
upper
case
delta
\U+09B#4
don't
use
#
symbol
Figure 4.1: Particle Swarm Variables.
orbital position remains essentially unchanged, and that therefore, the inertial directions to the
high-intensity sources also remain constant during the slew maneuver.
4.5 Solution Method
The first method used is the direct PSO. That is each particle consists of the control points of the
B-splines that represent torque profiles as well as a final time tf . In order to determine the body rates
as well as the quaternions, numerical integration is required. This numerical integration significantly
increases computational time as well as the possibility of introducing numerical integration errors.
The complete set of system equations consists of the Euler’s equation of rigid body motion:
ω1 = [M1 − ω2ω3 (I3 − I2)] /I1
ω2 = [M2 − ω3ω1 (I1 − I3)] /I2 (4.18)
ω3 = [M3 − ω1ω2 (I2 − I1)] /I3
37
and the transformation from the angular velocity components(also called body rates) to the
quaternion rates:
ε1
ε2
ε3
ε4
=
ε4 −ε3 ε2 ε1
ε3 ε4 −ε1 ε2
−ε2 ε1 ε4 ε3
−ε1 −ε2 −ε3 ε4
ω1
ω2
ω3
0
(4.19)
The second method, the inverse-dynamics PSO method (iPSO), has each particle consisting of
the coefficients for the B-splines that represent the kinematics, that is α, β, and θ time histories,
(which in turn are translated to the quaternion time histories) as well as the final time tf . As the
quaternions are established via B-spline representations, the body rates are calculated using Eq.
(4.6) and subsequently the control torques are calculated using Eq. (4.5)
In order to evaluate Eqs.(4.6) and (4.7) in the iPSO method, it is required to calculate both ε
and ε from Eq. (4.15)
εi = λi sin θ2 + θ
2λi cos θ2
ε4 = − θ2 sin θ
2 (4.20)
εi = λi sin θ2 + 2 θ2 λi cos θ
2 + θ2λi cos θ
2 −θ2
4 λi sinθ2
ε4 = − θ2 sin θ
2 −θ2
4 cos θ2 (4.21)
where i = (1,2,3)
38
From Eq. (4.16)
λ1 = −β sin(β) cos(α)− α cos(β) sin(α)
λ2 = −β sin(β) sin(α) + α cos(α) cos(β) (4.22)
λ3 = β cos(β)
λ1 = −β sin(β) cos(α)− β2 cos(β) cos(α) + 2αβ sin(β) sin(α)− α2 cos(β) cos(α)− α sin(α) cos(β)
λ2 = −β sin(β) sin(α)− β2 cos(β) sin(α)− 2αβ sin(β) cos(α)− α2 cos(β) sin(α) + α cos(α) cos(β)
λ3 = β cos(β)− β2 sin(β)
(4.23)
Direct PSO Unconstrained Motion Results
This case uses the direct-PSO method applied to a problem with no path constraints. The
spacecraft is originally orientated with its body axes parallel to the respective inertial axes and it
must rotate to achieve a final orientation equivalent to an eigenaxis maneuver of 3π4 radians about
the b3 axis (same as the inertial Z axis). The direct PSO results in this section can be compared
to the inverse PSO results in the subsequent section. The direct PSO final results are as follows
at tf ; ε1 = -0.001, ε2 = -0.0155, ε3 = 0.6989, and ε4 = 0.7151, which corresponds to θf = 2.354
rad. compared to the required value of 3π4 an error of 0.13◦. The values for αf = 2.342 rad. and
βf = 1.5693 rad., where βf is required to be π2 corresponding to an error of 0.08◦. The final body
39
Table 4.1: Direct PSO Unconstrained Results
initial(rads) final(rads) required(rads) error(deg)α 0 2.342 0* NAβ 0 1.5693 π/2 0.08◦
θ 0 2.354 3π/4 0.13◦
rates which are required to be at rest are as follows; ω1f=-0.0271 rad/s, ω2f=0.0199 rad/s, and
ω3f=0.0126 rad/s. An interesting result is the final spike for the αf value near tf , this is a result
of βf approaching π2 . At β = π
2 , because of the formulation of Eq.(4.16) α is free to take on any
value and this is indicated as 0* in table 4.1 (having no effect on the body rates or control torques).
The kinematics, body rates and torques are shown in Figs. (4.2) - (4.4). As expected, most of the
motion is about the b3 axis, with some precession seen as small oscillations about b1 and b2. The
principal problem with the direct method is that the final conditions are not met. A summary of
the unconstrained problem results can be seen in tables 4.1 and 4.2.
Indirect PSO Motion Results
Applying the inverse-dynamics method (iPSO), several cases are presented, including problems
with and without path constraints.
Case A: (no keep-out cones) The kinematics and body rates exactly meet the final conditions
as shown in Figs. (4.5) and (4.6), and the torques, shown in Fig. (4.7), approximate the optimal
bang-bang solution. Note that the body rates indicate a slight precessional motion as expected. This
solution used 3000 swarm generations and required 2 hours of CPU time (all cases were computed
using an Intel Core i3, 2.27 Ghz processor.)
40
0 0.5 1 1.5 2 2.5 3 3.5 4−3
−2
−1
0
1
2
3
time
Kinematics
αβθ
Figure 4.2: Kinematics for Direct PSO.
Table 4.2: Inverse PSO Unconstrained Results
initial(rads) final(rads) required(rads) error(deg)α 0 0 0* 0β 0 π/2 π/2 0θ 0 3π/4 3π/4 0
Case B: (keep-out cones included as shown in Fig. (4.8)). The iPSO algorithm found a solution
that takes the sensor axis around the Earth cone going the “long way,” which results in a final time
tf = 5, using 3000 swarm generations. This solution meets all the path constraints, but represents a
local-minimum solution. The kinematics, body rates and torques are shown in Figs. (4.9)-(4.11)
respectively.
Case C: (keep-out cones included, same as Case B). This solution also meets the kinematic
41
0 0.5 1 1.5 2 2.5 3 3.5 4−0.4
−0.2
0
0.2
0.4
0.6
0.8
1
1.2
1.4Body Rates
time
ω
1
ω2
ω3
Figure 4.3: Body Rates for Direct PSO.
constraints, but reveals a different sensor-axis path that goes between the Earth and Sun cones,
with a final time tf = 4.8. The sensor-axis path is shown in Fig. (4.12), and the kinematics and
body rates in Figs. (4.13) and (4.14), respectively. As seen in Fig. (4.15), the torques violate the
torque-limit constraint. This incomplete solution required 2.5 hours of CPU time, using 3000 swarm
generations. Continuing this computation for an additional 9000 generations (6 hours of additional
CPU time) led to the results shown in Figs. (4.16) - (4.19). This complete solution has final time
tf = 4.3 and satisfies all of the constraints.
42
0 0.5 1 1.5 2 2.5 3 3.5 4−1
−0.8
−0.6
−0.4
−0.2
0
0.2
0.4
0.6
0.8
1Torques
time
M
1
M2
M3
Figure 4.4: Torques for Direct PSO.
4.6 Interesting Cases
In Case D we see a path in which the particle swarm cost function is particularly low compared
to other feasible solutions and the result is a PSO solution attempting a path that splits the keep out
cones region minimally. This solution actually appears fairly frequently among all of the simulations
conducted in this research. The reason is that the Earth and Sun cones overlap by only 1.5 deg. A
solution with the sensor axis passing through this narrow intersecting zone results in a small penalty
function value. As a practical matter, this solution would be acceptable since the keep-out cones are
specified by the mission designers to be somewhat larger than necessary to provide a safety margin
43
0 0.5 1 1.5 2 2.5 30
0.5
1
1.5
2
2.5
3
3.5Kinematics
time
αβθ
Figure 4.5: Kinematics for Case A.
for the sensors. Increasing the penalty weight for the cone constraints tends to drive the solutions
toward feasible paths that are not minimum-time (for example, a path such as in Case B).
In Case E we see a PSO infeasible solution that is path-feasible but has torque violations and
initially performs a strange loop. With subsequent iterations the loop is eliminated, with the torque
violations getting minimized as more iterations take place. The presence of the unnecessary loop
in the early iterations is a useful reminder that the inverse-dynamics method always produces a
kinematically and dynamically feasible solution, but that the realistic constraints on the path and
control torques must be enforced by additional means. As seen in Fig. (4.22), that even after 12000
iterations the PSO has not found a path that is constrained to an upper time limit on tf = 5 with
44
0 0.5 1 1.5 2 2.5 3−0.2
0
0.2
0.4
0.6
0.8
1
1.2
time
Body Rates
ω
1
ω2
ω3
Figure 4.6: Body Rates for Case A.
satisfactory torque requirements. If we relax the PSO to allow an upper limit on tf = 6, then the
PSO swarms in on a solution to tf = 5.8528 as shown in Fig. (4.24), and the resulting torques are
within the limits of ±1DU.
45
0 0.5 1 1.5 2 2.5 3−1.5
−1
−0.5
0
0.5
1
1.5Torques
time
M
1
M2
M3
Figure 4.7: Torques for Case A.
46
Figure 4.8: Sensor-Axis Path for Case B.
47
0 1 2 3 4 5−0.5
0
0.5
1
1.5
2
2.5
3
3.5Kinematics
time
αβθ
Figure 4.9: Kinematics for Case B.
48
0 1 2 3 4 5−3
−2.5
−2
−1.5
−1
−0.5
0
0.5
1
1.5
time
Body Rates
ω
1
ω2
ω3
Figure 4.10: Body Rates for Case B.
49
0 1 2 3 4 5−4
−3
−2
−1
0
1
2
3
4
5
6Torques
time
M
1
M2
M3
Figure 4.11: Torques for Case B.
50
Figure 4.12: Sensor-Axis Path for Case C.
51
0 1 2 3 4 50
0.5
1
1.5
2
2.5
3
3.5Kinematics
time
αβθ
Figure 4.13: Kinematics for Case C.
52
0 1 2 3 4 5−1.5
−1
−0.5
0
0.5
1
1.5
time
Body Rates
ω
1
ω2
ω3
Figure 4.14: Body Rates for Case C.
53
0 1 2 3 4 5−3
−2.5
−2
−1.5
−1
−0.5
0
0.5
1
1.5
2Torques
time
M
1
M2
M3
Figure 4.15: Torques for Case C.
54
Figure 4.16: Sensor-Axis Path for Case C (additional 9000 generations).
55
0 0.5 1 1.5 2 2.5 3 3.5 4 4.5−0.5
0
0.5
1
1.5
2
2.5Kinematics
time
αβθ
Figure 4.17: Kinematics for Case C. (additional 9000 generations)
56
0 0.5 1 1.5 2 2.5 3 3.5 4 4.5−0.8
−0.6
−0.4
−0.2
0
0.2
0.4
0.6
0.8
1
1.2
time
Body Rates
ω
1
ω2
ω3
Figure 4.18: Body Rates for Case C. (additional 9000 generations)
57
0 0.5 1 1.5 2 2.5 3 3.5 4 4.5−1.5
−1
−0.5
0
0.5
1
1.5Torques
time
M1
M2
M3
Figure 4.19: Torques for Case C. (additional 9000 generations)
58
Figure 4.20: Path for Case D. (Splitting the Keep Out Cones)59
time0 0.5 1 1.5 2 2.5 3 3.5 4 4.5
-1.5
-1
-0.5
0
0.5
1
1.5Torques
M1
M2
M3
Figure 4.21: Torques for Case D. (Splitting the Keep Out Cones)
60
3000 Iterations 6000 Iterations
9000 Iterations 12000 Iterations
Figure 4.22: Path for Case E. (Looping Path)
61
3000 Iterations 6000 Iterations
9000 Iterations 12000 Iterations
Figure 4.23: Torques for Case E.
62
1.51
0.50
-0.5-1-1
0
1
0.5
1
1.5
-1.5
-1
-0.5
0
2
(a)time
0 1 2 3 4 5 6-1.5
-1
-0.5
0
0.5
1
1.5Torques
M1
M2
M3
(b)
time0 1 2 3 4 5 6
-1
-0.5
0
0.5
1
1.5
2
2.5
3Kinematics
α
β
θ
(c)time
0 1 2 3 4 5 6-1.5
-1
-0.5
0
0.5
1Body Rates
ω1
ω2
ω3
(d)
Figure 4.24: Time relaxation Case E.
63
Table 4.3: Summary of PSO Runs
Num. of Particles Average Run Time No Viol. Minor Viol. Major Viol.30* 2.5 hrs 1/20 19/20 0/20500 68 secs 2/20 16/20 2/201000 134 secs 4/20 14/20 2/201500 197 secs 6/20 12/20 2/20
Table 4.4: Summary of Minor Violations
Num. of Part. Tot. Min. Viol. Torq. Viol. Path Viol. Combined Viol.30 19/20 2long path,0short path 4M and S Cone Split 13500 16/20 1long path,5short path 3M and S Cone Split 71000 14/20 2long path,3short path 3M and S Cone Split 61500 12/20 1long path,2short path 6M and S Cone Split 3
4.7 Summary of PSO
A summary of the PSO runs is given in Table 4.3. The individual run details can be found in
Appendix D. The values in Appendix D that are listed correct to two decimal places are runs that
had no violations, and as such the GG value (which represents the cost function(J ) associated with
the global best gBest value) (3.22) can be divided by 100 to obtain the time-optimal duration. Table
4.4 shows the break up of the minor violations column in Table 4.3. The M and S Cone Split means
that the path violates both the Moon and Sun keep out cones, an example of this scenario is shown
in Case D, Fig.(4.20) and as such is categorized under a path violation. A long path violation results
in a torque violation which is shown in Case E, Fig.(4.22) and Fig.(4.23).
64
4.8 PSO Verification
Fig.(4.25)(a) is an example of the PSO obtained body rate, while the PSO obtained torque
is shown in Fig.(4.25)(b). The PSO obtained torques are used as inputs into MATLAB® using
the ode45 Runga Kutta integrator to integrate Eq.(3.1) to obtain the body rates. When using an
absolute and relative tolerance of 1E-6 for the ode45 integrator we get body rates at the terminal
boundary orientation of a magnitude of the order 2.7E-3 (instead of the complete stop value of zero).
However when we use absolute and relative tolerance of 1E-12 we have an end condition for the
body rate at a much reduced magnitude of 6E-9. The reproduced integrated body rates for this
case are shown in Fig.(4.25)(c). The body rates as determined by inverse dynamics and by direct
integration of Eulers equations are identical, thus verifying the accuracy of the inverse PSO method.
65
time0 1 2 3 4 5 6
-1.5
-1
-0.5
0
0.5
1Body Rates
ω1
ω2
ω3
(a)time
0 1 2 3 4 5 6-1.5
-1
-0.5
0
0.5
1
1.5Torques
M1
M2
M3
(b)
time0 1 2 3 4 5 6
-1.5
-1
-0.5
0
0.5
1REPRODUCED body rates
ω 1ω 2ω 3
(c)
Figure 4.25: Reproduction of Body Rates using PSO Torque Values
66
Chapter 5 |
Parallelization
The goal of performing real time computations for this optimal control problem can be aided
by the parallelizing of operations within calculations. Once a process can be performed in parallel
this can be embedded in a control system using parallel processors. The goal is to achieve real
time satellite maneuvers without the aide of ground control. A process that can be performed
in parallel is the PSO. The particle swarm is broken up into approximately even batches and
the expensive computational cost of evaluating the cost function is performed in parallel amongst
different processors. The issue of the global best particle, which is used as part of the velocity vector
amongst all particles, dictates the structure and nature of parallelization. In parallel computing the
concept of synchronization is an important concept and this needs to be considered when exchanging
values amongst particles.
The initial PSO calculation was conducted in Matlab. For 10000 iterations and 100 particles,
the calculation took 8 hrs on an Intel Core i3 2.27GHz processor. The serial code was converted
to C code in a structure that was suitable for parallel processor operations. For a single processor
operation on the Pennsylvania State University lxcluster.tlt.psu.edu cluster it took 78 seconds to
execute and on the lionxf.cluster.psu.edu it took an average of 58.65 seconds. The complete table
for the lionxf cluster can be seen in Table 5.1.
Table 5.2 shows the result of the aracna.aero.psu.edu cluster, showing just the run-time vs the
67
Table 5.1: lxcluster.tlt.psu.edu
# of processors computerrun time#1
computerrun time#2
computerrun time#3
AverageRun
Time (ART)
gBestrun#1
gBestrun#2
gBestrun#3
1 58.65 58.58 58.98 58.74 495 58831 9152 32.40 32.52 32.44 32.45 2850 49.29 48.414 16.25 16.40 16.22 16.29 59122 42.29 2625.24
Table 5.2: arcaca.aero.psu cluster
# of proc. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15ART 131.04 74.91 50.43 37.28 30.21 24.89 21.65 19.21 17.03 15.69 14.26 13.44 12.46 11.53 10.90
number of processors. Fig. (5.1) shows the corresponding graph which is consistent with Amdahl’s
law which shows the diminishing return for the increase in the number of processors. Both Table
5.1 and Table 5.3 show the random nature of a PSO solution and that many runs are required to
provide an good approximate initial solution.
The C code that implements the parallel code can be found in Appendix F. A conceptual design
for a parallelized attitude control system is shown in Fig (5.2) and resides in the GPUs of the
accelerator subsystem.The controller is part of the entire attitude control system shown in Fig. (5.3).
The controller and thrusters can be found in both in Fig. (5.2)and (5.3).
Table 5.3: iPSO 30 Particles
#Run 1 2 3 4 5 6 7 8 9 10GG 994 1180 1626 493.6 646 598 1124 749 576 1130
#Run 11 12 13 14 15 16 17 18 19 20GG 765 4186 3316 1619 1549 3382 563 869 3709 2279
68
0
20
40
60
80
100
120
140
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Ru
n T
ime
(sec
)
# of processors
Run Time vs # of Processors
Figure 5.1: Run Time vs Number of Processors
Figure 5.2: Controller implementation of Parallelization
69
Figure 5.3: Rigid Body Attitude System
70
Chapter 6 |
Pseudospectral Solutions
6.1 Optimal Control Theory
In the classical formulation, one seeks to minimize a performance index
J =∫ tf
t0g(x,u, t)dt (6.1)
subject to the constraints given by Eq. (3.1) and (usually) either Eq. (4.19) or (3.12), and where
x are the states (usually the angular velocities and orientation parameters) and u are the control
torques. The form of g depends upon the physical goal, i.e., if it is a minimum-time problem, then
g = 1.
The Hamiltonian consists of the integrand of J , with the constraint equations adjoined via the
costate vector λ
H = g + λT f(x,u, t) (6.2)
where f is the array of system equations – Eq. (3.1) and either Eq. (4.19) or (3.12). The necessary
conditions for the extremal solution are
x = ∂H∂λ
= f(x,u, t)
λ = −∂H∂x
=[∂f∂x
]Tλ (6.3)
71
H(x∗,u∗,λ∗) ≤ H(x∗,u,λ∗)
where (∗) denotes the optimal solution. Eqs. (6.3) constitute a two-point boundary-value problem
for which there is generally no analytic solution; numerical techniques using shooting methods
(sometimes preceded by a nonlinear programming step to estimate the costates) are required when
the indirect method is used.
In all solutions, the condition for optimality Eqs. (6.4)is such that
∂H∂u
= 0 (6.4)
6.2 Pseudospectral
In this time-optimal attitude control problem we use a pseudospectral (PS) method to refine the
solution provided by the PSO. A brief overview of PS will follow. The pseudospectral discretization
of the nonlinear problem such that the cost function is the discretized form of a Bolza cost function
is
J [XN , UN , τ0, τf ] = E(x0, xNτ0, τf ) + τf − τ0
2
N∑k=0
F (xk, uk)wk (6.5)
The Legendre pseudospectral method is derived by interpolating functions on Legendre-Gauss-
Lobatto (LGL) quadrature nodes. The time bounds of the original cost function equation [τ0, τf ] are
converted to a range from [−1, 1] using the affine transformation found in
τ(t) = (τf − τ0)t+ (τf + τ0)2 (6.6)
72
The interpolating functions are the Lagrange polynomials of order N.
φl(t) = 1N(N + 1)LN(tl)
(t2 − 1)LN(t)t− tl
(6.7)
The state variables and controls are discretized as equation (6.8) and (6.9) respectively.
x(τ(t)) ≈ xN(τ(t)) =N∑l=0
xlφl(t) (6.8)
u(τ(t)) ≈ uN(τ(t)) =N∑l=0
ulφl(t) (6.9)
The dynamic, terminal and path constraints are discretized as
τf − τ0
2 f(xk, uk)−N∑k=0
Dklxl = 0 dynamic (6.10)
where D is the differentiation matrix that allows rapid calculation of the state derivatives at the
nodes,
e(x0, xN , τ0, τf ) = 0 terminal (6.11)
h(xk, uk) ≤ 0 path (6.12)
The continuous problem is thus transformed into a nonlinear programming problem (NLP) with
unknowns Xi and Ui (the states and controls at the nodes). A Legendre PS method has been
implemented in commercial software DIDO which employs a gradient-based method to solve the
73
NLP. An important feature of PS method is their ability to reconstruct the costates once an optimal
solution is obtained. These costates values can then be used to calculate the Hamiltonian and
demonstrate graphically that the solution meets the necessary conditions.
6.3 Pseudospectral Results
A key motivation in the present work is to find an approximate solution that satisfies the
kinematic constraints and which could serve as a good starting point for a gradient based method,
leading to less computational time overall.
We see that a PS method improves the quality of the solution with the aid of a good starting
point, that is one given by the PSO. Fig. (6.1) shows the time-optimal sensor path generated by
the DIDO software [66], and Fig. (6.2) shows the corresponding body rates, Euler parameters and
control torques for this maneuver. This solution required approximately 12 hours of CPU time using
Dido Version 7.20. Appendix-C provides a script used by DIDO to implement the optimal control
problem.
A different case was tried with the same cone directions but with a smaller cone angle without
an initial PSO guess Case F . This can be seen in Fig. (6.3).The kinematic results are given in Fig
(6.4).
It can be seen that the maneuver time is shorter with ts = 2.98 seconds and the control torque
looks closer to the bang-bang solution of an unconstrained problem. We will next use a guess given
by the PSO initial guess to the Dido software. Theses result will be considered Case G. This path is
seen in Fig (6.5). We can see in this path that the maneuver has gone in the alternate direction
74
Figure 6.1: Constrained time-optimal path of the sensor axis
around the sun cone and has reduced the maneuver time to 2.80 seconds. The convergence and as
such the run-time of the solution was also improved.
The kinematic results are given in Fig.(6.6).
75
0 0.5 1 1.5 2 2.5 3 3.5 4 4.5−2
0
2Angular Velocity
time
ωi
ω1
ω2
ω3
0 0.5 1 1.5 2 2.5 3 3.5 4 4.5−1
0
1
2Euler Parameters
time
ε i
ε1
ε2
ε3
ε4
0 0.5 1 1.5 2 2.5 3 3.5 4 4.5−1
0
1
Control Torques
time
Mi
M1
M2
M3
Figure 6.2: Solutions Generated by DIDO
The unconstrained time-optimal problem has a constant H given by (6.4). With that in mind
we see that this is not the case for a path constrained problem as it can be seen in Fig.(6.7) and
Fig.(6.8). It can be seen from the Hamiltonian value that the solution has improved in Case G from
Case F. Dido uses a covector mapping procedure to extract the Hamiltonian Values and the costate
vectors λ introduced in (6.2).
76
1.51
0.50
-0.510.5
0-0.5
-1-1.5
1
0.5
0
-0.5
-1
Figure 6.3: Case F without PSO guess
77
time0 0.5 1 1.5 2 2.5 3
wi
-2
0
2Angular Velocity
w1w2w3
time0 0.5 1 1.5 2 2.5 3
qi
-2
0
2Euler Parameters
01
02
03
04
time0 0.5 1 1.5 2 2.5 3
Mi
-1
0
1Control Torques
m1m2m3
Figure 6.4: Case F without PSO guess
78
1.51
0.50
-0.510.5
0-0.5
-1
-1
1
-1.5
0.5
0
-0.5
Figure 6.5: Case G with PSO guess
79
time0 0.5 1 1.5 2 2.5 3
wi
-1
0
1
2Angular Velocity
w1w2w3
time0 0.5 1 1.5 2 2.5 3
qi
-0.5
0
0.5
1Euler Parameters
01
02
03
04
time0 0.5 1 1.5 2 2.5 3
Mi
-1
0
1Control Torques
M1M2M3
Figure 6.6: Case G with PSO guess
80
time0 0.5 1 1.5 2 2.5 3
Ham
ilton
ian
Val
ue
-1.05
-1
-0.95
-0.9
-0.85Hamiltonian Evolution
H
time0 0.5 1 1.5 2 2.5 3
cost
ates
-3
-2
-1
0
1Costates
6w
1
6w
2
6w
3
6q1
6q2
6q3
6q4
Figure 6.7: Case F without PSO guess
81
time0 0.5 1 1.5 2 2.5 3
Ham
ilton
ian
Val
ue
-1.01
-1
-0.99
-0.98
-0.97Hamiltonian Evolution
H
time0 0.5 1 1.5 2 2.5 3
cost
ates
-1.5
-1
-0.5
0
0.5
1Costates
6w
1
6w
2
6w
3
6q1
6q2
6q3
6q4
Figure 6.8: Case G with PSO guess
82
Chapter 7 |
Conclusions and Recommendations
7.1 Conclusion
The study has examined the use of the PSO method for both the direct method and inverse
dynamics method. The PSO solutions are potentially of important use as initial solutions for further
gradient based methods. It was seen that the inversion method produced much more favorable
results without the use of numerical integration. The direct method produced final results that
violated the boundary conditions slightly. The inversion method did not have this problem but did
have violation of torque constraints. However by increasing the number of generations it could be
seen that these violations were then nearly eliminated, furthermore the final time tf was reduced as
well.
This study looked into use of these solutions as initial conditions into pseudospectral optimization
to determine if performance is increased. It was determined that these solutions indeed improved the
quality of the solution and were conducted in less computing time with at least a 10% improvement.
Also parallelization of the PSO was examined, showing that the computation times where significantly
reduced. One of the biggest motivations for this study was to achieve methods that would eventually
allow RTOC (Real Time Optimial Control). This could allow the satellite or spacecraft to operate
autonomously and allowing the attitude control system to be non-reliant on the Ground Support
83
System.
7.2 Recommendations for Future Work
Future studies can look into methods that can reduce the swarm particle candidates to limited
regions in the solution space based on past learnt optimized control paths. This can be implemented
with some neural network method [67], where past simulations and lessons learned may give a pattern
of where to target the particle swarm population. A development of a scheme to make the swarming
more robust is an area of further research. The use of Bezier curves instead of B-Splines is an area
of investigation to see if there is an improvement in speed. The parallelization was successfully
implemented, with significant speed up. The implementation of these computer algorithms into
dedicated components such as GPUs or FPGAs would be of interest for future work. This use of
dedicated components would be a step in realizing the research into flight hardware and as such
would be able to confirm and quantify significant further speed up. A more difficult problem to would
involve flexible structure spacecraft. Added modes and degrees of freedom of this problem would
involve many more unknown parameters and a parallelized method would certainly be required.
84
Appendix A|
Particle Swarm Code
A.1 Matlab Code
%% Particle Swarm Optimization
% Inverse Dynamics Using a Quaternion Formulation
% Ko Basu July 24th 2016
clc;
clear all;
close all;
format long
global P J JBest PBest GBest GG N_particles N_elements V BLv BUv BLp BUp
global N_iterations t0 tf x0 N_kin_vals q1targ q2targ q3targ q4targ
global k1 k3 korder
global caS caE caM beta_S beta_E beta_M k_cones
global alpha0 alphaf beta0 betaf theta0 thetaf
time0=cputime;
85
%%%%%%%%%%%
% Optimal Control Problem Constraints
%%%%%%%%%%%
%Boundary Conditions
t0 = 0;
q1targ = 0.0;
q2targ = 0.0;
q3targ = sin(pi/4);
q4targ = cos(pi/4);
alpha0 = 0;
alphaf = 0;
beta0 = 0;
betaf = pi/2;
theta0 = 0.0;
thetaf = 3*pi/4.
%Path Constraints
alpha_S = 47*pi/180;
alpha_E = 33*pi/180;
alpha_M = 23*pi/180;
caS = cos(alpha_S);
caE = cos(alpha_E);
caM = cos(alpha_M);
86
beta_S = [0.5, sqrt(3)/2, 0];
beta_E = [0, 0, −1];
beta_M = [0.1795, 0.3109, 0.9333];
%Particle Swarm Variables
N_kin_vals = 6;
N_elements = 3*N_kin_vals + 1;
N_particles = 30;
N_iterations = 3000;
tL = 1.0;
tU = 5.0;
GGStar = zeros(N_iterations,1);
%%%%%%%%%%%%%%
% Initialize the random population
%%%%%%%%%%%%%%
BLalpha = −pi;
BUalpha = pi;
BLbeta = −pi/2;
BUbeta = pi/2;
BLtheta = −pi;
BUtheta = pi;
P = zeros(N_particles, N_elements);
P(:,1:N_kin_vals) = BLalpha*ones(N_particles,N_kin_vals) ...
87
+ 2*(BUalpha−BLalpha)*rand(N_particles,N_kin_vals);
P(:,N_kin_vals+1:2*N_kin_vals) = BLbeta*ones(N_particles,N_kin_vals) ...
+ 2*(BUbeta−BLbeta)*rand(N_particles,N_kin_vals);
P(:,2*N_kin_vals+1:3*N_kin_vals) = BLtheta*ones(N_particles,N_kin_vals) ...
+ 2*(BUtheta−BLtheta)*rand(N_particles,N_kin_vals);
P(:,N_elements) = tL + (tU−tL) * rand(N_particles,1);
PBest = zeros(N_particles,N_elements);
J = 50*ones(N_particles,1); JBest = zeros(N_particles,1);
V = zeros(N_particles,N_elements);
%% set lower and upper bounds on unknowns (particle elements)
%% changed to set separate lower and upper bounds for alpha, beta, theta
ones_row = ones(1,N_kin_vals);
BLp = [BLalpha*ones_row,BLbeta*ones_row,BLtheta*ones_row, tL];
BUp = [BUalpha*ones_row,BUbeta*ones_row,BUtheta*ones_row, tU];
k1 = 100;
k3 = 100;
k_cones = 100000;
%% determine velocity bounds
BUv = BUp − BLp;
BLv = −BUv;
for i = 1:N_particles
88
JBest(i) = inf;
end
GG = inf;
x0 = [0 0 0 0 0 0 1];
%% Output Diagnostics
jshow = 20
reset_count = 0;
for j = 1:N_iterations
if (mod(j,jshow) == 0)
fprintf('iteration = %i\n',j)
end
%%%%%%%%%%%
% PSO Implementation
%%%%%%%%%%%
EvaliPSOJ_v3;
EvalPGBest;
UpdateV(j);
UpdateP;
GGstar(j) = GG;
%PSO reset implementation
reset_count = reset_count + 1;
if (j >= 0.1*N_iterations && reset_count >= 20)
89
sum_G = 0.0;
for kk=j−9:j
sum_G = sum_G + GGstar(kk);
end
avg_G = sum_G/10;
if abs(avg_G − GG)/GG < 0.01
N_fraction = 0.5*N_particles;
P(1:N_fraction,1:N_kin_vals) = ...
BLalpha*ones(N_fraction,N_kin_vals) ...
+ 2*(BUalpha−BLalpha)*rand(N_fraction,N_kin_vals);
P(1:N_fraction,N_kin_vals+1:2*N_kin_vals) = ...
BLbeta*ones(N_fraction,N_kin_vals) ...
+ 2*(BUbeta−BLbeta)*rand(N_fraction,N_kin_vals);
P(1:N_fraction,2*N_kin_vals+1:3*N_kin_vals) = ...
BLtheta*ones(N_fraction,N_kin_vals) ...
+ 2*(BUtheta−BLtheta)*rand(N_fraction,N_kin_vals);
P(1:N_fraction,N_elements) = tL + (tU−tL)*rand(N_fraction,1);
fprintf('***** reset %i of %i particles\n', N_fraction, N_particles)
reset_count = 0;
end
end
end
%%%%%%%%%%%
% PSO Output Results
90
%%%%%%%%%%%
timef = cputime;
run_time = timef − time0
save 'results_3000_iter_6elem_v3code_k1100k3100k_cones100000_tU5_run2'
genkin_Bsplines_v2
%% EvalPGBest
% EvalP&GBest determines the best position visited by particle i % up through the current iteration
% R.G Melton
function EvalPGBest()
global P J JBest PBest GG GBest N_particles
for i = 1:N_particles
if J(i) < JBest(i)
PBest(i,:) = P(i,:);
JBest(i) = J(i);
end
end
for i = 1:N_particles
if J(i) < GG
GG = J(i);
fprintf('GG = %10.6f \n', GG)
GBest = P(i,:);
91
end
end
%% UpdateP
% UpdateP updates the position vector
% R.G Melton
function UpdateP()
global P N_particles N_elements V BLp BUp
for i =1:N_particles
P(i,:) = P(i,:) + V(i,:);
for k = 1:N_elements
if P(i,k) < BLp(k)
P(i,k) = BLp(k);
V(i,k) = 0;
end
if P(i,k) > BUp(k)
P(i,k) = BUp(k);
V(i,k) = 0;
end
end
end
92
%% UpdateV
% updates the velocity vector V
% R.G Melton
function UpdateV(j_iter)
global P PBest GBest N_particles N_elements V BLv BUv
global N_iterations
for i =1:N_particles
% unused alternatives to velocity updates
% c_I = (1 + rand)/2;
% c_C = 0.01 + 1.49445*rand*j_iter/N_iterations;
% c_S = 0.01 + 1.49445*rand*j_iter/N_iterations;
% c_I decreases linearly with j
% c_S & c_C are stationary
c_I_max = 1.0;
c_I_min = 0.1;
c_I = c_I_max − (c_I_max − c_I_min)*j_iter/N_iterations;
c_C = 1.49445*rand;
c_S = 1.49445*rand;
V(i,:) = c_I*V(i,:) + c_C*(PBest(i,:) − P(i,:)) + c_S*(GBest − P(i,:));
for k = 1:N_elements
93
if V(i,k) < BLv(k)
V(i,k) = BLv(k);
end
if V(i,k) > BUv(k)
V(i,k) = BUv(k);
end
end
end
94
Appendix B|
Inversion Dynamics Code and Cost Function
B.1 Matlab Code
%% J−Eval
% Inversion Dynamics and Cost Function
% Ko Basu July 24th 2016
global P J N_particles N_elements N_kin_vals
global k1 k3 t0 tf
global alphasp betasp thetasp korder
global alpha0 alphaf beta0 betaf theta0 thetaf
%%%%%%%%%%%%%%%%%%%%%%%
%%%%% added global vars for keep−out cone constraints
global caS caE caM beta_S beta_E beta_M k_cones
for i=1:N_particles
tf = P(i,N_elements);
n_timesteps = 25;
95
%%%%%%%%%%%%%%%%%%%%%%%%
% Building Knot Vector
%
% knots = [t0,t0, t0, t0:tf/(N_torq_vals+1):tf, tf, tf, tf];
% eg knots = [0 0 0 0 0 1 2 3 4 5 5 5 5 5] if tf=5;
%(produces N_torq_vals + 8) knots
% knot sequence for clamped spline
korder = 4; % Hence Cubic Polynimial
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% changed definition of n
% 4 of the ctrl pts are determined by b.c.
% (first 2 and last 2 for each spline)
% So make n = N_kin_vals −1 + 4 = N_kin_vals + 3
% This will now use all of the values calc by the PSO
n = N_kin_vals + 3;
knots = zeros(1,n+korder+1);
for j = 1:korder
knots(j) = t0;
end
for j = korder+1 : n+1
knots(j) = (j−korder)/(n−korder+2)*tf;
end
for j = n+2 : n+korder+1
knots(j) = tf;
end
96
%%%%%%%%%%%%%%%%%%%%%%%
% Building ControlVector
alpha_vals = [alpha0, alpha0, P(i,1:N_kin_vals), alphaf, alphaf];
beta_vals = [beta0, beta0, P(i,N_kin_vals+1:2*N_kin_vals), betaf, betaf];
theta_vals = [theta0, theta0,P(i,2*N_kin_vals+1:3*N_kin_vals), thetaf, thetaf];
% Making B−Splines
alphasp = spmak(knots, alpha_vals);
betasp = spmak(knots, beta_vals);
thetasp = spmak(knots, theta_vals);
% Making 1st derivative of B−Splines
alphaspd = fnder(alphasp,1);
betaspd = fnder(betasp,1);
thetaspd = fnder(thetasp,1);
% Making 2nd derivative of B−Splines
alphaspdd = fnder(alphasp,2);
betaspdd = fnder(betasp,2);
thetaspdd = fnder(thetasp,2);
tmatrix = linspace(0,tf,n_timesteps);
con1 = 0;
97
con2 = 0;
con3 = 0;
pen_cones = 0;
MMax =1;
I1 = 1; I2 = 1; I3 = 1;
for k = 1 : n_timesteps
t = tmatrix(k);
alpha = fnval(alphasp,t);
beta = fnval(betasp,t);
theta = fnval (thetasp,t);
alphad = fnval(alphaspd,t);
betad = fnval(betaspd,t);
thetad = fnval (thetaspd,t);
alphadd = fnval(alphaspdd,t);
betadd = fnval(betaspdd,t);
thetadd = fnval (thetaspdd,t);
sa = sin(alpha);
ca = cos(alpha);
sb = sin(beta);
cb = cos(beta);
98
lambda1 = cb*ca;
lambda2 = cb*sa;
lambda3 = sb;
lambda1d = − betad*sb*ca − alphad*cb*sa;
lambda2d = − betad*sb*sa + alphad*cb*ca;
lambda3d = betad*cb;
%%%%%%%%%%%%%%%%%
% Inversion Formulation
lambda1dd = − betadd*sb*ca − betad^2*cb*ca...
+betad*sb*alphad*sa + betad*sb*alphad*sa...
−alphadd*cb*sa − alphad^2*cb*ca;
lambda2dd = − betadd*sb*sa − betad^2*cb*sa...
−betad*sb*alphad*ca − betad*sb*alphad*ca...
+alphadd*cb*ca − alphad^2*sa*cb;
lambda3dd = betadd*cb − betad^2 * sb;
st2 = sin(theta/2);
ct2 = cos(theta/2);
e1 = lambda1 * st2;
99
e2 = lambda2 * st2;
e3 = lambda3 * st2;
e4 = ct2;
e1d = lambda1d * st2 + thetad/2*lambda1*ct2;
e2d = lambda2d * st2 + thetad/2*lambda2*ct2;
e3d = lambda3d * st2 + thetad/2*lambda3*ct2;
e4d = −thetad/2*st2;
e1dd = lambda1dd * st2 + thetadd/2*lambda1*ct2 ...
+ 2*lambda1d*thetad/2*ct2−(thetad/2)^2*lambda1*st2;
e2dd = lambda2dd * st2 + thetadd/2*lambda2*ct2 ...
+ 2*lambda2d*thetad/2*ct2−(thetad/2)^2*lambda2*st2;
e3dd = lambda3dd * st2 + thetadd/2*lambda3*ct2 ...
+ 2*lambda3d*thetad/2*ct2−(thetad/2)^2*lambda3*st2;
e4dd = −thetadd/2*st2 − (thetad/2)^2*ct2;
E = [e4 e3 −e2 −e1;
−e3 e4 e1 −e2;
e2 −e1 e4 −e3;
e1 e2 e3 e4];
ed = [e1d;e2d;e3d;e4d];
100
Ed = [e4d e3d −e2d −e1d;
−e3d e4d e1d −e2d;
e2d −e1d e4d −e3d;
e1d e2d e3d e4d];
edd = [e1dd;e2dd;e3dd;e4dd];
w = 2 * E * ed;
wd = 2 * Ed*ed + 2 * E * edd;
M1= I1 * wd(1) + w(2)* w(3) * (I3−I2);
M2= I2 * wd(2) + w(3)* w(1) * (I1−I3);
M3= I3 * wd(3) + w(1)* w(2) * (I2−I1);
con1 = con1 + max(0,abs(M1)−MMax);
con2 = con2 + max(0,abs(M2)−MMax);
con3 = con3 + max(0,abs(M3)−MMax);
sigma = [1−2*(e2^2 + e3^2), 2*(e1*e2 + e3*e4), 2*(e3*e1 − e2*e4)];
c_S = dot(sigma, beta_S);
c_E = dot(sigma, beta_E);
c_M = dot(sigma, beta_M);
pen_cones = pen_cones + max(0, c_S−caS) + max(0,c_E−caE) + max(0,c_M−caM);
101
end
%%%%%%%%%%%%%%%%%%%%%%
% J Cost Function
J_constraints = k1*(con1 + con2 + con3) + k_cones*pen_cones;
J_time = k3*abs(tf);
J(i) = J_constraints + J_time;
end
return
102
Appendix C|
Pseudospectral
C.1 Matlab Code
%% Psuedospectral Optimal Control (Dido File)
% By Ko Basu
% November 15th 2016
clear all
close all
clc
%==============================================================
%%%%%%%%%%%
% Define the problem function files:
%%%%%%%%%%%
conoptslew.cost = 'ConSlewCost';
conoptslew.dynamics = 'ConSlewDynamics';
conoptslew.events = 'ConSlewEvents';
conoptslew.path = 'ConSlewPath';
103
%%%%%%%%%%%
% Set up the problem bounds in SCALED units
%%%%%%%%%%%
tfMax = 20;
bounds.lower.time = [0 eps];
bounds.upper.time = [0 tfMax];
w1o = 0; w2o = 0; w3o = 0;
q1o = 0; q2o = 0; q3o = 0; q4o = 1;
w1f = 0.0; w2f = 0.0; w3f = 0.0;
%% define final orientation
theta = 3*pi/4;
lambda = [0; 0; 1];
q1f = lambda(1)*sin(theta/2.);
q2f = lambda(2)*sin(theta/2.);
q3f = lambda(3)*sin(theta/2.);
q4f = cos(theta/2.);
bounds.lower.states = [−pi; −pi; −pi; −1; −1; −1; −1];
bounds.upper.states = [pi; pi; pi; 1; 1; 1; 1];
104
bounds.lower.controls = [−1; −1; −1];
bounds.upper.controls = [1; 1; 1];
bounds.lower.events = [w1o; w2o; w3o; q1o; q2o; q3o; q4o; w1f; w2f; w3f; q1f; q2f; q3f; q4f];
bounds.upper.events = bounds.lower.events;
alpha_S = 17*pi/180; % min angle between sensor and Sun line
alpha_M = 17*pi/180; % min angle between sensor and Moon line
alpha_neg_z = 33*pi/180; % min angle between sensor and neg. z−axis
bounds.lower.path = [alpha_S; alpha_M; alpha_neg_z];
bounds.upper.path = [pi; pi; pi];
%%%%%%%%%%%
% Tell DIDO the bounds on the problem
%%%%%%%%%%%
conoptslew.bounds = bounds;
%%%%%%%%%%%
% Select the number of nodes for the spectral algorithm
%%%%%%%%%%%
algorithm.nodes = [50];
%%%%%%%%%%%
% call DIDO:
%%%%%%%%%%%
105
%−−−−−−−−−−−−
% generate guess
−−−−−−−−−−−−
d = [1 1 2];
d = d/sqrt(dot(d,d));
alpha = 1;
alpha1 = alpha*d(1);
alpha2 = alpha*d(2);
alpha3 = alpha*d(3);
delta_theta = pi;
delta_t = 2*pi;
M1_0 = 0;
M1_c = 0;
M1_f = 0;
M2_0 = −0.1;
M2_c = 0.01;
M2_f = 0;
M3_0 = 0;
M3_c = 0.1;
M3_f = −0.01;
%%
%% Here is where you could insert your own guesses for the controls, states, and node−times
%%
% algorithm.guess.controls = [M1_0 M1_c M1_f; M2_0 M2_c M2_f; M3_0 M3_c M3_f];
106
% algorithm.guess.states = [0 0 0; 0 −0.1 0; 0 0.1 0;
% 0 0 0; 0 −1/sqrt(2) 0; 0 0 1/sqrt(2); 1 1/sqrt(2) 1/sqrt(2)];
% algorithm.guess.time = [0 delta_t/2 delta_t];
%%
startTimeGuess = cputime;
display('begin DIDO')
%% Use the following call to start DIDO if you are providing initial guesses
% in the algorithm structure
[cost, primal, dual] = dido(conoptslew, algorithm);
%%
% Otherwise, use this call
%[cost, primal, dual] = dido(conoptslew);
display('finished DIDO')
GuessRunTime = cputime − startTimeGuess
%%%%%%%%%%%
%−−− save data −−−−
%%%%%%%%%%%
save 'rrun_50nodes'
107
Appendix D|
iPSO Runs
D.1 PSU run tables
Table D.1: (30 Particles, 3000 Iterations)
Run# GG Comment1 2279 short2 3709 between moon and sun cone3 869 short4 563 short5 3383 infeasible M & S cone6 1549 short7 1619 short8 3316 long path containing a loop9 4186 infeasible M & S cone10 765 short11 1130 short12 576 short13 749 short14 1124 short15 598 short16 646 short17 493.6 short18 1626 long path19 1180 infeasible M & S cone20 994 short
108
Table D.2: (500 Particles, 3000 Iterations)
Run# GG Comment1 57766 infeasible2 2628 between moon and sun cone cone3 495.91 short4 2353 short5 472.39 long path6 499.93 between moon and sun cone7 457.86 short8 1049 short loop9 1113 short10 2289 short11 554 short12 989 short13 2657 short14 466.61 short15 823 short16 57848 infeasible17 2288 short18 436.23 short19 489.19 between moon and sun cone20 60783 infeasible
109
Table D.3: (1000 Particles, 3000 Iterations)
Run# GG Comment1 425.11 short2 1191 short cone3 1060 short4 2053 short5 935 long path6 496.06 between moon and sun cone7 533 short8 1313 short loop9 431.94 short10 560 short11 476.42 between moon and sun cone12 30777 infeasible13 13762 short14 2120 long path15 840 between moon and sun cone16 57825 infeasible17 1470 short18 415.71 short19 2733 short20 670 short
110
Table D.4: (1500 Particles, 3000 Iterations)
Run# GG Comment1 2629 short2 57851 infeasible cone3 447.97 between moon and sun cone4 475.09 between moon and sun cone5 1101 short6 1342 long path7 494.37 between moon and sun cone8 6618 short loop9 422.94 short10 482.55 between moon and sun cone11 473.31 short12 57792 infeasible13 772 short14 437.41 short15 436.09 short16 1977 short17 491.36 between moon and sun cone18 42407 short19 494.16 between moon and sun cone20 1140 short
111
Appendix E|
BSpline Implementation
E.1 BSplines by Shene
B-splines are defined in terms of control points Pi and coefficients Ni,p. The basic definition for
a function Z in terms of some parameter τ is
Z(τ) =n+1∑i=1
Ni,p(τ)Pi
The n+ 1 control points are 2-dimensional, with the 1-axis usually corresponding to time t (or
some other independent variable), and the 2-axis corresponding to some dependent variable, such as
a kinematic variable or a control input. Note that t and τ are not the same; this distinction leads to
a complication later when we need to compute derivatives of Z.
The parameter p defines the order of the spline, which is composed of a linear combination
of polynomials in τ , with the highest-power given by p. Construction of the spline begins with
a knot-string composed of non-descending values of τ : τ1, τ2, . . . , τm+1, where m = n + p + 1. In
most treatments of B-splines, the knot-string is defined to lie on the domain [0, 1]; however, larger
upper values are possible so long as numerical values for the higher powers in the polynomials do
not become a problem. For inverse-dynamics problems, where the initial and final values of the
kinematic variables are fixed, it is useful to employ a clamped B-spline, which requires a special
112
structure of the knot-string. In this case, the values of the knots are given by
τi =
0, 1 ≤ i ≤ p+ 1
(i−p−1n−p+1
)tf , p+ 2 ≤ i ≤ n+ 1
tf , n+ 2 ≤ i ≤ m+ 1
For a clamped B-spline, making the ordinate values of the first two control points equal, and doing
the same for the last two control points, forces the first derivative of the ordinate variable to be
zero at the end points. (This is not required in every problem, but for the rest-to-rest time-optimal
reorientation problem, we know that the initial and final derivatives of the kinematic variables are
all zero; this will also make the body rates zero at the end points.)
Shene gives a useful algorithm for calculating the values of the coefficients for a given value of τ
and given control points Pi. The following triangle algorithm is taken from Shene, with the indices
modified to start at 1 rather than 0.
Triangle Algorithm:
Shene notes that this algorithm is not efficient; however, in practice, it is sufficiently fast.
Computing derivatives of Z(τ) with respect to τ is fairly straightforward, but remember that τ
and t are different! For the derivative dZ/dτ , one forms a new knot-string τ (1) by deleting the first
113
Algorithm 2 B-SplineInput: n, p,m, u, and m+1 clamped knots [ τ1, ..., τm+1 ]
Output: Coefficients N1,p(τ), N2,p(τ), . . . , Nn+1,p(τ) in N [1], N [2], . . . , N [n+ 1]
Initialize N [1 . . . n+ 1] to 0;if τ = τ1 then // rule out special cases
N [1] = 1.0;return
elseif τ = τm+1 then
N[n+1] = 1.0;return
end ifend if// now τ is between τ1 and τm+1Let τ be in knot-span [τk, τk+1);N [k] := 1.0 // degree 0 coefficientfor d :=1 to p do // degree d goes from 1 to p
N [k − d] = τk+1−ττk+1−τ(k−d)+1
N [(k − d) + 1]; // right (south-west corner) term onlyfor i := k − d+ 1 to k − 1 do // compute internal terms
N [i] := τ−τi
τi+d−τiN [i] + τi+d+1−τ
τi+d+1−τi+1N [i+ 1];
end forN [k] = τ−τk
τk+d−τkN [k]; // left (north-west corner) term only
end for// array N [1 . . . n+ 1] has the coefficients.
and last knots from the original string, resulting in
τ (1) = (τ2, . . . , τm)
One also forms a new set of n control points Qi defined by
Qi = p
τ(1)i+p − τ
(1)i
(Pi+1 − Pi), i = 1 . . . n (E.1)
The derivative with respect to τ isdZdτ
=n∑i=1
Ni,p−1(τ)Qi (E.2)
114
where the coefficients Ni,p−1 are computed using the knot-string τ (1) and the value p− 1 in place of
p in the triangle algorithm.
For the second-derivative, d2Z/dτ 2, the above steps are repeated, with a new knot-string τ (2)
formed by deleting the first and last knots in the string τ (1), resulting in a new knot-string
τ (2) = (τ (1)2 , . . . , τ
(1)m−1)
and a new set of control points
Ri = p− 1τ
(2)i+p−1 − τ
(2)i
(Qi+1 −Qi), i = 1 . . . n− 1
and the second-derivative with respect to τ is then
d2Zdτ 2 =
n−1∑i=1
Ni,p−2(τ)Ri (E.3)
where the coefficients Ni,p−2 are computed using the knot-string τ (2) and the value p− 2 in place of
p in the triangle algorithm.
Recall that each spline Z consists of two coordinates. Let the first coordinate g represent time
t, and let the second coordinate f represent the variable being modeled (for example, a kinematic
variable). The spline curve Z(τ) can now be written as Z = (g(τ), f(τ)) or equivalently Z = (x, y)
where x = g(τ) is the actual time t, plotted on the abscissa axis, and y = f(τ) is the variable being
modeled, plotted on the ordinate axis. To determine the derivatives of Z with respect to time t, use
the rules for differentiation:dy
dt= df
dτ
dτ
dt= df/dτ
dg/dτ
and the values of df/dτ and dg/dτ are the components of the derivative dZ/dτ calculated using Eq
115
(E.2), i.e., dZ/dτ is the vector [dg/dτ, df/dτ ]
Calculation of the second-derivative again requires application of the rules for differentiation:
d2y
dt2= d
dt
(dy
dt
)= d
dt
(df/dτ
dg/dτ
)= d
dτ
(df/dτ
dg/dτ
)dτ
dt
=dgdτ
d2fdτ2 − df
dτd2gdτ2(
dgdτ
)2dτdg
=dgdτ
d2fdτ2 − df
dτd2gdτ2(
dgdτ
)3 (E.4)
and the second-derivatives with respect to τ are calculated using Eq. (E.3), i.e. d2Z/dτ 2 =
[d2g/dτ 2, d2f/dτ 2].
E.2 Matlab Code
%% B_Spline Implementation
% By Robert Melton
% May 10th 2016
function [f,f_dot,f_ddot,tx] = B_spline(CP,knots,t)
% inputs are the control points (CP), knots, time
% outputs are the approxiimated function's value f, and it's derivatives
% f_dot, f_ddot
%% CP is a 2D array, with each row containing 2 elements (time, f)
[nctrl,~] = size (CP);
n = nctrl−1;
116
nknots = length(knots);
knots1 = knots(2:end−1);
knots2 = knots1(2:end−1);
m = nknots−1;
p = m−n−1;
n1 = n−1;
n2 = n−2;
m1 = m−2;
m2 = m−4;
Q = zeros(n,2);
R = zeros(n1,2);
for i=1:n
Q(i,:) = p/(knots1(i+p) − knots1(i))*(CP(i+1,:) − CP(i,:));
end
for i=1:n1;
R(i,:) = (p−1)/(knots2(i+p−1) − knots2(i))*(Q(i+1,:) − Q(i,:));
end
N = bspline_triangle(n,m,t,knots);
N1 = bspline_triangle(n1,m1,t,knots1);
N2 = bspline_triangle(n2,m2,t,knots2);
Y_approx = N'*CP; % dot product of N with each column of P
Y_dot_approx = N1'*Q;
Y_ddot_approx = N2'*R;
f = Y_approx(1,2);
tx = Y_approx(1,1);
117
f1 = Y_dot_approx(1,2);
g1 = Y_dot_approx(1,1);
f_dot = f1/g1;
f2 = Y_ddot_approx(1,2);
g2 = Y_ddot_approx(1,1);
f_ddot = (f2*g1 − g2*f1)/g1^3;
end
function N = bspline_triangle(n,m,t,knots)
% implements the triangular form of B−spline generation
%
p = m − n − 1;
N = zeros(n+1,1);
%%% special cases %%%
if t == knots(1)
N(1) = 1.0;
return
else if t == knots(m+1)
N(n+1) = 1.0;
return
end
%%%%%%%%%%%%%%%%%%%%%
%%% determine which knots bound t %%%
k = 1;
118
for jj = 1:m
if (t < knots(jj+1))
%% if(knots(jj) <= t) && (t < knots(jj+1))
k = jj;
break
end
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%
N(k) = 1.0;
for d = 1:p
N(k−d) = (knots(k+1) − t)/(knots(k+1) − knots(k−d+1))*N(k−d+1); % right (south−west
... corner) term only
for i = k−d+1:k−1
N(i) = (t−knots(i))/(knots(i+d) − knots(i))*N(i)+
(knots(i+d+1) − t)/(knots(i+d+1) − knots(i+1))*N(i+1);% computer internal terms
end
N(k) = (t−knots(k))/(knots(k+d) − knots(k))*N(k); % (north−west corner) term only
end
end
119
Appendix F|
Parallelization Code
F.1 C++ Code
//PSO Pa r a l l e l i z a t i o n C++ Implementation
//by Ko Basu
//Dec 14 th 2016
#inc lude <s td i o . h>
#inc lude <s t d l i b . h>
#inc lude <iostream>
#inc lude <math . h>
#inc lude <c f l o a t >
#inc lude <s t d l i b . h>
#inc lude <omp . h>
#inc lude <sys / time . h>
#inc lude <cs t r i ng >
#inc lude <g s l / g s l_bsp l i n e . h>
120
#de f i n e PI 3.14159265358979323846
//Time Optimal Search Space
#de f i n e tL 1
#de f i n e tU 5
//Penalty Weightings f o r Cost Function
#de f i n e k1 1000
#de f i n e k2 100
#de f i n e k3 10
#de f i n e k_cones 100000
//Mass Moment o f I n e r t i a s
#de f i n e I1 1
#de f i n e I2 1
#de f i n e I3 1
us ing namespace std ;
// Pa r t i c l e (C implementation Var iab l e s )
s t r u c t Pa r t i c l e
{
f l o a t ∗ e lements ;
f l o a t ∗PBest ;
121
f l o a t J ;
f l o a t JBest ;
f l o a t ∗V;
} ;
//Function De f i n i t i o n s used in Main Function
void EvalJ ( Pa r t i c l e ∗a , i n t num_particles , i n t num_elements , i n t num_kin_vals , i n t
nBreak , i n t k , double ∗bounds , i n t dt ) ;
void d i s p l a yPa r t i c l e ( Pa r t i c l e ∗a , i n t num_particles , i n t num_elements ) ;
void EvalPGBest ( Pa r t i c l e ∗a , i n t num_particles , i n t num_elements , f l o a t &GG, f l o a t
∗GBest ) ;
void updateV ( Pa r t i c l e ∗a , i n t num_particles , i n t num_elements , f l o a t GG, f l o a t ∗
GBest , \
f l o a t ∗BLv , f l o a t ∗BUv, i n t i t e r , i n t t o t a l_ i t e r ) ;
void updateP ( Pa r t i c l e ∗a , i n t num_particles , i n t num_elements , f l o a t GG, f l o a t ∗
GBest , \
f l o a t ∗BLp, f l o a t ∗BUp) ;
void c t r lPt sGenera te ( Pa r t i c l e ∗a , i n t num_kin_vals , double ∗bounds , double ∗ c t r l P t s )
;
void bSpl ineGenerate ( i n t nBreak , i n t k , gs l_bspl ine_workspace ∗∗bw, gs l_vector ∗∗B,\
double ∗ c t r lP t s , i n t nCtrlPts , double lBound , double uBound) ;
void bSpl ineEval ( double x , i n t nDeriv , double ∗ r e su l t , gs l_bspl ine_workspace ∗bw,\
gs l_vector ∗B, double ∗ c t r lP t s , i n t nCtr lPts ) ;
122
void swapPart i c l e ( Pa r t i c l e &a , Pa r t i c l e &b , i n t num_elements ) {
Pa r t i c l e temp ;
temp . e lements=new f l o a t [ num_elements ] ;
temp . PBest=new f l o a t [ num_elements ] ;
temp .V=new f l o a t [ num_elements ] ;
f o r ( i n t i =0; i<num_elements ; i++){
temp . e lements [ i ]=b . e lements [ i ] ;
temp . PBest [ i ]=b . PBest [ i ] ;
temp .V[ i ]=b .V[ i ] ;
b . e lements [ i ]=a . e lements [ i ] ;
b . PBest [ i ]=a . PBest [ i ] ;
b .V[ i ]=a .V[ i ] ;
a . e lements [ i ]=temp . e lements [ i ] ;
a . PBest [ i ]=temp . PBest [ i ] ;
a .V[ i ]=temp .V[ i ] ;
}
temp . J=b . J ;
temp . JBest=b . JBest ;
b . J=a . J ;
b . JBest=a . JBest ;
123
a . J=temp . J ;
a . JBest=temp . JBest ;
}
// s o r t i n g p a r t i c l e s f o r r e s e t t i n g opera t i on o f PSO
void s o r t P a r t i c l e s ( Pa r t i c l e ∗a , i n t num_particles , i n t num_elements ) {
f o r ( i n t i = 0 ; i < ( num_partic les − 1 ) ; i++)
{
f o r ( i n t j = 0 ; j < ( num_partic les − i − 1) ; j++)
{
i f ( a [ j ] . J > a [ j +1] . J ) /∗ For dec r ea s ing order use < ∗/
{
swapPart i c l e ( a [ j +1] , a [ j ] , num_elements ) ;
}
}
}
}
// Main Function
i n t main ( )
{
s t r u c t t imeva l sTime , eTime ;
124
// PSO Cha r a c t e r i s t i c s
i n t N_part ic l e s =2000 , N_elements , N_iterat ions =3000 ,N_kin_vals=6;
cout <<" \n # of P a r t i c l e s "<<N_part ic l e s ;
gett imeofday(&sTime ,NULL) ;
N_elements = 3∗N_kin_vals+1;
f l o a t GG=FLT_MAX;
f l o a t ∗GBest ;
GBest = new f l o a t [ N_elements ] ;
P a r t i c l e ∗pSwarm ;
pSwarm=new Pa r t i c l e [ N_part ic l e s ] ;
i f (pSwarm==NULL)
{
cout <<" \n Error cannot a l l o c a t e memory" ;
}
f o r ( i n t i =0; i<N_part ic l e s ; i++)
{
pSwarm [ i ] . e lements=new f l o a t [ N_elements ] ;
pSwarm [ i ] . PBest=new f l o a t [ N_elements ] ;
125
pSwarm [ i ] .V=new f l o a t [ N_elements ] ;
}
f l o a t ∗BLp ;
f l o a t ∗BUp;
f l o a t ∗BLv,∗BUv;
BLp = new f l o a t [ N_elements ] ;
BUp = new f l o a t [ N_elements ] ;
BLv = new f l o a t [ N_elements ] ;
BUv = new f l o a t [ N_elements ] ;
f o r ( i n t i =0; i<N_elements−1; i++)
{
i f ( i <6)
{
BLp [ i ]=−PI ;
BUp[ i ]=PI ;
BUv[ i ]=BUp[ i ]−BLp [ i ] ;
BLv [ i ]=−BUv[ i ] ;
}
e l s e i f ( i <12)
{
BLp [ i ]=−PI /2 ;
126
BUp[ i ]=PI /2 ;
BUv[ i ]=BUp[ i ]−BLp [ i ] ;
BLv [ i ]=−BUv[ i ] ;
}
e l s e
{
BLp [ i ]=−PI ;
BUp[ i ]=PI ;
BUv[ i ]=BUp[ i ]−BLp [ i ] ;
BLv [ i ]=−BUv[ i ] ;
}
}
BLp [ N_elements−1]=tL ;
BUp[ N_elements−1]=tU ;
BUv[ N_elements−1]=tU−tL ;
BLv [ N_elements−1]=−BUv[ N_elements−1] ;
srand ( time (NULL) ) ;
// { I n i t i a l Or i t en ta t i on (0 , 0 , 0 ) , F ina l Or i enta t i on (PI /2 ,0 ,3∗PI /4) }
double b [ ]= {0 ,0 ,0 , PI /2 ,0 ,3∗PI /4} ;
// Pa r t i c l e Random I n i t i a l i z a t i o n
127
f o r ( i n t i =0; i<N_part ic l e s ; i++)
{
// Implementing Equation ( 3 . 1 5 )
f o r ( i n t j =0; j<N_elements ; j++)
{
pSwarm [ i ] . e lements [ j ]=−PI + 2∗PI ∗( rand ( ) %10001) ∗0 . 0001 ;
}
pSwarm [ i ] . e lements [ N_elements−1]= tL + (tU−tL ) ∗( rand ( ) %10001) ∗0 . 0001 ;
pSwarm [ i ] . JBest= FLT_MAX;
pSwarm [ i ] . J= FLT_MAX;
}
f o r ( i n t i =0; i<N_iterat ions ; i++, dispCnt++, resetCnt++)
{
EvalJ (pSwarm , N_part ic les , N_elements , N_kin_vals , 8 , 4 , b , 2 5 ) ;
EvalPGBest (pSwarm , N_part ic les , N_elements , GG, GBest ) ;
updateV (pSwarm , N_part ic les , N_elements , GG, GBest , BLv , BUv, i ,
N_iterat ions ) ;
updateP (pSwarm , N_part ic les , N_elements , GG, GBest , BLp, BUp) ;
128
i f ( dispCnt==100){
cout<<" \nGG: "<<GG<<" \tGGAvg : "<<GGAvg/ resetCnt<<" \ t I t e r : "<<i<<endl ;
dispCnt=0;
}
// PSO Reset
GGAvg+=GG;
i f ( resetCnt >20)
{
GGAvg/=resetCnt ;
i f ( f abs (GGAvg−GG) <0.1)
{
// cout<<"\nResett ing : "<<GGAvg−GG;
// s o r t P a r t i c l e s (pSwarm , N_part ic les , N_elements ) ;
f o r ( i n t j =0; j<N_part ic l e s /2 ; j++)
{
f o r ( i n t k=0; k<N_elements−1; k++)
{
pSwarm [ j ] . e lements [ k]=−PI + 2∗PI ∗( rand ( ) %10001) ∗0 . 0001 ;
129
}
pSwarm [ j ] . e lements [ N_elements−1]= tL + (tU−tL ) ∗( rand ( ) %10001)
∗0 . 0001 ;
pSwarm [ j ] . JBest= FLT_MAX;
pSwarm [ j ] . J= FLT_MAX;
}
}
GGAvg=0;
resetCnt=0;
}
}
//Used to c a l c u l a t e runtime
gett imeofday(&eTime ,NULL) ;
cout<<" \n\nGBEST\n" ;
f o r ( i n t i =0; i<N_elements ; i++)
{
cout<<GBest [ i ]<<" " ;
}
cout<<" \n\n" ;
130
//Output B−Sp l ine Coordinates
double ∗ptr=new double [ ( N_kin_vals+4) ∗ 3 ] ;
i n t y=0,z=0;
// Ctr l po in t s f o r alpha
ptr [ y++]=b [ 0 ] ;
ptr [ y++]=b [ 0 ] ;
f o r ( z=0; z<N_kin_vals ; z++)
{
ptr [ y++]=GBest [ z ] ;
}
ptr [ y++]=b [ 1 ] ;
ptr [ y++]=b [ 1 ] ;
// Ctr l po in t s f o r beta
ptr [ y++]=b [ 2 ] ;
ptr [ y++]=b [ 2 ] ;
f o r ( ; z<N_kin_vals ∗2 ; z++)
{
ptr [ y++]=GBest [ z ] ;
131
}
ptr [ y++]=b [ 3 ] ;
ptr [ y++]=b [ 3 ] ;
// Ctr l po in t s f o r alpha
ptr [ y++]=b [ 4 ] ;
ptr [ y++]=b [ 4 ] ;
f o r ( ; z<N_kin_vals ∗3 ; z++)
{
ptr [ y++]=GBest [ z ] ;
}
ptr [ y++]=b [ 5 ] ;
ptr [ y++]=b [ 5 ] ;
gs l_bspl ine_workspace ∗ a lphaSpl ine , ∗ betaSpl ine , ∗ th e taSp l i n e ;
g s l_vector ∗aVec ;
double r e s [ 3 ] ;
bSpl ineGenerate (8 , 4 , &alphaSpl ine , &aVec , ptr , 10 , 0 , GBest [ N_elements−1]) ;
bSpl ineGenerate (8 , 4 , &betaSpl ine , &aVec , ptr+10, 10 , 0 , GBest [ N_elements−1]) ;
bSpl ineGenerate (8 , 4 , &thetaSp l ine , &aVec , ptr+20, 10 , 0 , GBest [ N_elements−1]) ;
132
f o r ( double x i =0; xi<=GBest [ N_elements−1] ; x i +=0.1)
{
bSpl ineEval ( xi , 2 , res , a lphaSpl ine , aVec , ptr , 1 0 ) ;
p r i n t f ( " \n%f %f " , xi , r e s [ 0 ] ) ;
bSpl ineEval ( xi , 2 , res , betaSpl ine , aVec , ptr +10 ,10) ;
p r i n t f ( " %f " , r e s [ 0 ] ) ;
bSpl ineEval ( xi , 2 , res , the taSp l ine , aVec , ptr +20 ,10) ;
p r i n t f ( " %f " , r e s [ 0 ] ) ;
}
g s l_bsp l i n e_f r e e ( a lphaSp l ine ) ;
g s l_bsp l i n e_f r e e ( be taSp l ine ) ;
g s l_bsp l i n e_f r e e ( the taSp l i n e ) ;
g s l_vector_f ree ( aVec ) ;
d e l e t e [ ] ptr ;
// Dea l l o ca t i on r ou t i n e s
f o r ( i n t i =0; i<N_part ic l e s ; i++)
{
133
de l e t e [ ] pSwarm [ i ] . e lements ;
d e l e t e [ ] pSwarm [ i ] . PBest ;
d e l e t e [ ] pSwarm [ i ] .V;
}
d e l e t e [ ] pSwarm ;
d e l e t e [ ] GBest ;
d e l e t e [ ] BLp ;
d e l e t e [ ] BUp;
d e l e t e [ ] BLv ;
d e l e t e [ ] BUv;
std : : cout <<" \n\nRuntime : "<< ( eTime . tv_sec−sTime . tv_sec )+\
( eTime . tv_usec−sTime . tv_usec ) /1e6<<" seconds " ;
s td : : cout<<" \n" ;
r e turn 0 ;
}
// d i sp l ay pa r t c l e e lements ( alpha , beta , theta c on t r o l po ints , f i n a l time )
void d i s p l a yPa r t i c l e ( Pa r t i c l e ∗a , i n t num_particles , i n t num_elements )
{
134
i n t i , j ;
f o r ( i =0; i<num_partic les ; i++)
{
cout<<" \n\n\ nPa r t i c l e "<<i<<" \n" ;
cout<<" \nKin Vals : " ;
f o r ( j =0; j<num_elements−1; j++)
{
cout<<a [ i ] . e lements [ j ]<<" " ;
}
cout<<" \nTime : "<<a [ i ] . e lements [ j ] ;
cout<<" \nJ : "<<a [ i ] . J ;
cout<<" \nJBest : "<<a [ i ] . JBest ;
}
}
// Update Pa r t i c l e Personal Best and Global Best
void EvalPGBest ( Pa r t i c l e ∗a , i n t num_particles , i n t num_elements , f l o a t &GG, f l o a t
∗GBest )
{
f o r ( i n t i =0; i<num_partic les ; i++)
{
i f ( a [ i ] . J < a [ i ] . JBest )
{
f o r ( i n t j =0; j<num_elements ; j++)
{
135
// Implementing Equation ( 3 . 2 0 )
a [ i ] . PBest [ j ] = a [ i ] . e lements [ j ] ;
}
a [ i ] . JBest = a [ i ] . J ;
}
i f ( a [ i ] . J < GG)
{
f o r ( i n t j =0; j<num_elements ; j++)
{
// Implementing Equation ( 3 . 2 2 )
GBest [ j ] = a [ i ] . e lements [ j ] ;
}
GG = a [ i ] . J ;
}
}
}
// Update Ve loc i ty Vector
void updateV ( Pa r t i c l e ∗a , i n t num_particles , i n t num_elements , f l o a t GG, f l o a t ∗
GBest , \
f l o a t ∗BLv , f l o a t ∗BUv, i n t i t e r , i n t t o t a l_ i t e r )
{
// Implementing Equation ( 3 . 2 4 )
f l o a t c I =1−(1−0.1)∗ i t e r / t o t a l_ i t e r ;
f l o a t cC=1.49445∗( rand ( ) %10001) ∗0 . 0001 ;
136
f l o a t cS=1.49445∗( rand ( ) %10001) ∗0 . 0001 ;
f o r ( i n t i =0; i<num_partic les ; i++)
{
f o r ( i n t j =0; j<num_elements ; j++)
{
// Implementing Equation ( 3 . 2 3 )
a [ i ] .V[ j ] =c I ∗a [ i ] .V[ j ]+cC∗( a [ i ] . PBest [ j ]−a [ i ] . e lements [ j ] )+cS ∗(GBest [ j
]−a [ i ] . e lements [ j ] ) ;
}
f o r ( i n t j =0; j<num_elements ; j++)
{
i f ( a [ i ] .V[ j ] < BLv [ j ] )
a [ i ] .V[ j ]=BLv [ j ] ;
i f ( a [ i ] .V[ j ] > BUv[ j ] )
a [ i ] .V[ j ]=BUv[ j ] ;
}
}
}
//Update Pa r t i c l e ( Previous + Ve loc i ty )
void updateP ( Pa r t i c l e ∗a , i n t num_particles , i n t num_elements , f l o a t GG, f l o a t ∗
137
GBest , \
f l o a t ∗BLp, f l o a t ∗BUp)
{
f o r ( i n t i =0; i<num_partic les ; i++)
{
f o r ( i n t j =0; j<num_elements ; j++)
{
a [ i ] . e lements [ j ] =a [ i ] . e lements [ j ]+a [ i ] .V[ j ] ;
}
f o r ( i n t j =0; j<num_elements ; j++)
{
i f ( a [ i ] . e lements [ j ] < BLp [ j ] )
{
a [ i ] . e lements [ j ]=BLp [ j ] ;
a [ i ] .V[ j ]=0;
}
i f ( a [ i ] . e lements [ j ] > BUp[ j ] )
{
a [ i ] . e lements [ j ]=BUp[ j ] ;
a [ i ] .V[ j ]=0;
}
}
138
}
}
//Create an array conta in ing con t r o l po int va lue s and re tu rn s the po in t e r to
i t .
void c t r lPt sGenera te ( Pa r t i c l e ∗a , i n t num_kin_vals , double ∗bounds , double ∗ptr )
{
i n t i =0, j =0;
// Ctr l po in t s f o r alpha
ptr [ i++]=bounds [ 0 ] ;
ptr [ i++]=bounds [ 0 ] ;
f o r ( j =0; j<num_kin_vals ; j++)
{
ptr [ i++]=a−>elements [ j ] ;
}
ptr [ i++]=bounds [ 1 ] ;
ptr [ i++]=bounds [ 1 ] ;
// Ctr l po in t s f o r beta
ptr [ i++]=bounds [ 2 ] ;
139
ptr [ i++]=bounds [ 2 ] ;
f o r ( ; j<num_kin_vals ∗2 ; j++)
{
ptr [ i++]=a−>elements [ j ] ;
}
ptr [ i++]=bounds [ 3 ] ;
ptr [ i++]=bounds [ 3 ] ;
// Ctr l po in t s f o r theta
ptr [ i++]=bounds [ 4 ] ;
ptr [ i++]=bounds [ 4 ] ;
f o r ( ; j<num_kin_vals ∗3 ; j++)
{
ptr [ i++]=a−>elements [ j ] ;
}
ptr [ i++]=bounds [ 5 ] ;
ptr [ i ]=bounds [ 5 ] ;
}
void EvalJ ( Pa r t i c l e ∗a , i n t num_particles , i n t num_elements , i n t num_kin_vals , i n t
140
nBreak , i n t k , double ∗bounds , i n t nTSteps )
{
// i n t t i d ;
// PARALLELIZATION
#pragma omp p a r a l l e l f o r
f o r ( i n t zz=0; zz<num_partic les ; zz++)
{
double ∗ a r rCt r lPt s=new double [ ( num_kin_vals+4) ∗ 3 ] ; // Ctr l po in t s f o r a l l 3
s p l i n e s
gs l_bspl ine_workspace ∗ a lphaSpl ine , ∗ betaSpl ine , ∗ th e taSp l i n e ;
g s l_vector ∗aVec ,∗ bVec ,∗ cVec ;
double x i ;
double alphaRes [ 3 ] , betaRes [ 3 ] , thetaRes [ 3 ] ;
// Dea l l o ca t e prev ious c on t r o l vec to r f i r s t
c t r lPt sGenera te ( a+zz , num_kin_vals , bounds , a r rCt r lPt s ) ;
bSpl ineGenerate ( nBreak , k , &alphaSpl ine , &aVec , ar rCtr lPts , 10 , 0 , a [ zz ] .
e lements [ num_elements−1]) ;
bSpl ineGenerate ( nBreak , k , &betaSpl ine , &bVec , a r rCt r lPt s +10, 10 , 0 , a [ zz ] .
e lements [ num_elements−1]) ;
141
bSpl ineGenerate ( nBreak , k , &thetaSp l ine , &cVec , a r rCt r lPt s +20, 10 , 0 , a [ zz ] .
e lements [ num_elements−1]) ;
double con1=0,con2=0,con3=0,pen_cones=0,MMax=1;
//Cone Axes Or i enta t i on (Keep Out Cones )
double beta_S [3 ]= {0 . 5 , pow ( 3 , 0 . 5 ) /2 ,0} ;
double beta_E [3 ]= {0 ,0 ,−1};
double beta_M[3]= {0 . 1795 , 0 . 3 109 , 0 . 9 333} ;
//Cone Angles (Keep Out Cones )
double caS=cos (47∗PI /180) , caE=cos (33∗PI /180) ,caM=cos (23∗PI /180) ;
double dt=a [ zz ] . e lements [ num_elements−1]/( nTSteps−1) ;
f o r ( x i =0; xi<=a [ zz ] . e lements [ num_elements−1] ; x i+=dt )
{
bSpl ineEval ( xi , 2 , alphaRes , a lphaSpl ine , aVec , ar rCtr lPts , 1 0 ) ;
bSpl ineEval ( xi , 2 , betaRes , betaSpl ine , aVec , a r rCt r lPt s +10 ,10) ;
bSpl ineEval ( xi , 2 , thetaRes , the taSp l ine , aVec , a r rCt r lPt s +20 ,10) ;
double sa , ca , sb , cb ;
double lambda1 , lambda2 , lambda3 ;
double lambda1d , lambda2d , lambda3d ;
double lambda1dd , lambda2dd , lambda3dd ;
142
double st2 , ct2 ;
double e1 , e2 , e3 , e4 ;
double e1d , e2d , e3d , e4d ;
double e1dd , e2dd , e3dd , e4dd ;
double E [ 4 ] [ 4 ] ;
double Ed [ 4 ] [ 4 ] ;
sa = s i n ( alphaRes [ 0 ] ) ;
ca = cos ( alphaRes [ 0 ] ) ;
sb = s i n ( betaRes [ 0 ] ) ;
cb = cos ( betaRes [ 0 ] ) ;
// INVERSION DYNAMICS
lambda1 = cb∗ ca ;
lambda2 = cb∗ sa ;
lambda3 = sb ;
lambda1d = −betaRes [ 1 ] ∗ sb∗ ca − alphaRes [ 1 ] ∗ cb∗ sa ;
lambda2d = − betaRes [ 1 ] ∗ sb∗ sa + alphaRes [ 1 ] ∗ cb∗ ca ;
lambda3d = betaRes [ 1 ] ∗ cb ;
lambda1dd = − betaRes [ 2 ] ∗ sb∗ ca − pow( betaRes [ 1 ] , 2 ) ∗cb∗ ca\
143
+betaRes [ 1 ] ∗ sb∗alphaRes [ 1 ] ∗ sa + betaRes [ 1 ] ∗ sb∗alphaRes [ 1 ] ∗ sa
\
−alphaRes [ 2 ] ∗ cb∗ sa − pow( alphaRes [ 1 ] , 2 ) ∗cb∗ ca ;
lambda2dd = − betaRes [ 2 ] ∗ sb∗ sa − pow( betaRes [ 1 ] , 2 ) ∗cb∗ sa \
−betaRes [ 1 ] ∗ sb∗alphaRes [ 1 ] ∗ ca − betaRes [ 1 ] ∗ sb∗alphaRes [ 1 ] ∗ ca
\
+alphaRes [ 2 ] ∗ cb∗ ca − pow( alphaRes [ 1 ] , 2 ) ∗ sa ∗cb ;
lambda3dd = betaRes [ 2 ] ∗ cb − pow( betaRes [ 1 ] , 2 ) ∗ sb ;
s t2 = s i n ( thetaRes [ 0 ] / 2 ) ;
ct2 = cos ( thetaRes [ 0 ] / 2 ) ;
e1 = lambda1 ∗ s t2 ;
e2 = lambda2 ∗ s t2 ;
e3 = lambda3 ∗ s t2 ;
e4 = ct2 ;
e1d = lambda1d ∗ s t2 + thetaRes [ 1 ] / 2∗ lambda1∗ ct2 ;
e2d = lambda2d ∗ s t2 + thetaRes [ 1 ] / 2∗ lambda2∗ ct2 ;
e3d = lambda3d ∗ s t2 + thetaRes [ 1 ] / 2∗ lambda3∗ ct2 ;
e4d = −thetaRes [ 1 ] / 2∗ s t2 ;
e1dd = lambda1dd ∗ s t2 + thetaRes [ 2 ] / 2∗ lambda1∗ ct2
+ 2∗ lambda1d∗ thetaRes [ 1 ] / 2∗ ct2−pow( ( thetaRes [ 1 ] / 2 ) ,2 ) ∗ lambda1∗ s t2
144
;
e2dd = lambda2dd ∗ s t2 + thetaRes [ 2 ] / 2∗ lambda2∗ ct2 \
+ 2∗ lambda2d∗ thetaRes [ 1 ] / 2∗ ct2−pow( ( thetaRes [ 1 ] / 2 ) ,2 ) ∗ lambda2∗ s t2
;
e3dd = lambda3dd ∗ s t2 + thetaRes [ 2 ] / 2∗ lambda3∗ ct2 \
+ 2∗ lambda3d∗ thetaRes [ 1 ] / 2∗ ct2−pow( ( thetaRes [ 1 ] / 2 ) ,2 ) ∗ lambda3∗ s t2
;
e4dd = −thetaRes [ 2 ] / 2∗ s t2 − pow( ( thetaRes [ 1 ] / 2 ) ,2 ) ∗ ct2 ;
E [ 0 ] [ 0 ] = e4 ;
E [ 0 ] [ 1 ] = e3 ;
E [ 0 ] [ 2 ] = −e2 ;
E [ 0 ] [ 3 ] = −e1 ;
E [ 1 ] [ 0 ] = −e3 ;
E [ 1 ] [ 1 ] = e4 ;
E [ 1 ] [ 2 ] = e1 ;
E [ 1 ] [ 3 ] = −e2 ;
E [ 2 ] [ 0 ] = e2 ;
E [ 2 ] [ 1 ] = −e1 ;
E [ 2 ] [ 2 ] = e4 ;
145
E [ 2 ] [ 3 ] = −e3 ;
E [ 3 ] [ 0 ] = e1 ;
E [ 3 ] [ 1 ] = e2 ;
E [ 3 ] [ 2 ] = e3 ;
E [ 3 ] [ 3 ] = e4 ;
double ed [ ] = {e1d , e2d , e3d , e4d } ;
Ed [ 0 ] [ 0 ] = e4d ;
Ed [ 0 ] [ 1 ] = e3d ;
Ed [ 0 ] [ 2 ] = −e2d ;
Ed [ 0 ] [ 3 ] = −e1d ;
Ed [ 1 ] [ 0 ] = −e3d ;
Ed [ 1 ] [ 1 ] = e4d ;
Ed [ 1 ] [ 2 ] = e1d ;
Ed [ 1 ] [ 3 ] = −e2d ;
Ed [ 2 ] [ 0 ] = e2d ;
Ed [ 2 ] [ 1 ] = −e1d ;
Ed [ 2 ] [ 2 ] = e4d ;
Ed [ 2 ] [ 3 ] = −e3d ;
146
Ed [ 3 ] [ 0 ] = e1d ;
Ed [ 3 ] [ 1 ] = e2d ;
Ed [ 3 ] [ 2 ] = e3d ;
Ed [ 3 ] [ 3 ] = e4d ;
double edd [ ] = {e1dd , e2dd , e3dd , e4dd } ;
double w[4 ]= {0 ,0 , 0 , 0} ;
f o r ( i n t i i =0; i i <4; i i ++)
{
f o r ( i n t j j =0; j j <4; j j++)
{
w[ i i ]+=( E[ i i ] [ j j ]∗ ed [ j j ] ) ;
}
w[ i i ]∗=2;
}
double wd[4 ]= {0 , 0 , 0 , 0} ;
f o r ( i n t i i =0; i i <4; i i ++)
{
f o r ( i n t j j =0; j j <4; j j++)
{
wd [ i i ]=wd [ i i ]+2∗( Ed [ i i ] [ j j ]∗ ed [ j j ] ) +2∗E[ i i ] [ j j ]∗ edd [ j j ] ;
147
}
}
double M1= I1 ∗ wd [ 0 ] + w[ 1 ] ∗ w[ 2 ] ∗ ( I3−I2 ) ;
double M2= I2 ∗ wd [ 1 ] + w[ 2 ] ∗ w[ 0 ] ∗ ( I1−I3 ) ;
double M3= I3 ∗ wd [ 2 ] + w[ 0 ] ∗ w[ 1 ] ∗ ( I2−I1 ) ;
con1 = con1 + fmax (0 , f abs (M1)−MMax) ;
con2 = con2 + fmax (0 , f abs (M2)−MMax) ;
con3 = con3 + fmax (0 , f abs (M3)−MMax) ;
double sigma [3 ]= {1−2∗(pow( e2 , 2 ) + pow( e3 , 2 ) ) , 2∗( e1∗ e2 + e3∗ e4 ) , 2∗(
e3∗ e1 − e2∗ e4 ) } ;
double c_S = sigma [ 0 ] ∗ beta_S [0 ]+ sigma [ 1 ] ∗ beta_S [1 ]+ sigma [ 2 ] ∗ beta_S [ 2 ] ;
double c_E = sigma [ 0 ] ∗ beta_E [0]+ sigma [ 1 ] ∗ beta_E [1]+ sigma [ 2 ] ∗ beta_E [ 2 ] ;
double c_M = sigma [ 0 ] ∗ beta_M[0]+ sigma [ 1 ] ∗ beta_M[1]+ sigma [ 2 ] ∗ beta_M [ 2 ] ;
pen_cones = pen_cones + fmax (0 , c_S−caS ) + fmax (0 ,c_E−caE ) + fmax (0 ,c_M−
caM) ;
}
double J_const ra int s = k1 ∗( con1 + con2 + con3 )+ k_cones∗pen_cones ;
double J_time = k3∗ f abs ( a [ zz ] . e lements [ num_elements−1]) ;
148
// PENALTY FUNCTION
a [ zz ] . J = J_const ra int s + J_time ;
// Memory Dea l l o ca t e
g s l_bsp l i n e_f r e e ( a lphaSp l ine ) ;
g s l_bsp l i n e_f r e e ( be taSp l ine ) ;
g s l_bsp l i n e_f r e e ( the taSp l i n e ) ;
g s l_vector_f ree ( aVec ) ;
g s l_vector_f ree ( bVec ) ;
g s l_vector_f ree ( cVec ) ;
d e l e t e [ ] a r rCt r lPt s ;
}
}
void bSpl ineGenerate ( i n t nBreak , i n t k , gs l_bspl ine_workspace ∗∗bw, gs l_vector ∗∗B,
double ∗ c t r lP t s , i n t nCtrlPts , double lBound , double uBound)
{
}
void bSpl ineEval ( double x , i n t nDeriv , double ∗ r e su l t , gs l_bspl ine_workspace ∗bw,
gs l_vector ∗B, double ∗ c t r lP t s , i n t nCtr lPts )
{
149
i n t i , j ;
gs l_matrix ∗X = gsl_matr ix_al loc ( nCtrlPts , nDeriv+1) ;
//Zero a l l va lue s o f r e s u l t . Length o f r e s u l t = Order o f d e r i v a t e s + 1 f o r eva l
o f s p l i n e
f o r ( i =0; i<nDeriv+1; i++)
{
r e s u l t [ i ]=0;
}
gs l_bsp l ine_eva l (x ,B,bw) ;
//Evaluate b−s p l i n e at x
f o r ( i =0; i<nCtr lPts ; i++)
{
r e s u l t [0]+= c t r lP t s [ i ]∗ gs l_vector_get (B, i ) ;
}
//Evaluate d e r i v a t e s
gs l_bsp l ine_der iv_eva l (x , nDeriv ,X,bw) ;
f o r ( i =1; i<nDeriv+1; i++)
{
f o r ( j =0; j<nCtr lPts ; j++)
150
{
r e s u l t [ i ]+=c t r lP t s [ j ]∗ gsl_matrix_get (X, j , i ) ;
}
}
gs l_matr ix_free (X) ;
}
151
References
[1] Bedrossian, N., S. Bhatt, M. Lammers, L. Nguyen, and Y. Zhang (2007) “First everflight demonstration of zero propellant manueverTM attitude control concept,” in Guidance,Navigation, and Control Conference, vol. AIAA-2007-6734,(Hilton Head, South Carolina), pp.1–12.
[2] Karpenko, M., S. Bhatt, N. Bedrossian, A. Fleming, and I. Ross (2012) “First flightresults on time-optimal spacecraft slews,” Journal of Guidance, Control, and Dynamics, 35(2),pp. 367–376.
[3] Aeronautics, N. and S. Administration (1998-2010), “TRACE,” .URL http://www.swift.gsfc.nasa.gov
[4] Center, G. S. F. (2004-2016), “The Swift Gamma-Ray Burst Mission,” .URL http://www.swift.gsfc.nasa.gov
[5] Basu, K. and R. G. Melton (2015) “Survey of Optimal Rigid Body Attitude Maneuvers,”Advances in the Astronautical Sciences, 411, pp. 1–11.
[6] Scrivener, S. L. and R. C. Thompson (1994) “Survey of time-optimal attitude maneuvers,”Journal of Guidance, Control, and Dynamics, 17(2), pp. 225–233.
[7] Dixon, M., T. Edelbaum, J. Potter, and W. Vandervelde (1970) “Fuel optimalreorientation of axisymmetric spacecraft,” Journal of Spacecraft and Rockets, 7(11), pp. 1345–1351.
[8] D’Amario, L. and G. Stubbs (1979) “A New Single-Rotation-Axis Autopilot for RapidSpacecraft Attitude Maneuvers,” Journal of Guidance and Control, 2(4), pp. 339–346.
[9] Bilimoria, K. D. and B. Wie (1993) “Time-Optimal Three-Axis Reorientation of a RigidSpacecraft,” Journal of Guidance, Control, and Dynamics, 16(3), pp. 446–452.
[10] Seywald, H. and R. R. Kumar (1993) “Singular control in minimum time spacecraftreorientation,” Journal of Guidance, Control, and Dynamics, 16(4), pp. 686–694.
[11] Byers, R. M. (1995) “On singular controls in time optimal rigid body reorientation,” Advancesin the Astronautical Sciences, 89, pp. 603 – 603.
[12] Byers, R. (1996) “Time Optimal Attitude Control of Asymmetric Rigid Spacecraft,” Journalof Vibration and Control, 2(1), pp. 17–32.
[13] Shen, H. and P. Tsiotras (1999) “Time-optimal control of axisymmetric rigid spacecraftusing two controls,” Journal of Guidance, Control, and Dynamics, 22(5), pp. 682–694.
152
[14] Tsiotras, P. and J. M. Longuski (1995) “New parameterization of the attitude kinematics,”Journal of the Astronautical Sciences, 43(3), pp. 243 – 262.
[15] Bai, X. and J. L. Junkins (2009) “New results for time-optimal three-axis reorientation of arigid spacecraft,” Journal of Guidance, Control, and Dynamics, 32(4), pp. 1071–1076.
[16] Molodenkov, A. and Y. G. Sapunkov (2012) “A new class of analytic solutions in theoptimal turn problem for a spherically symmetric body,” Mechanics of Solids, 47(2), pp.167–177.
[17] Li, S., S. Ding, and Q. Li (2010) “Global set stabilization of the spacecraft attitude controlproblem based on quaternion,” International Journal of Robust and Nonlinear Control, 20(1),pp. 84–105.
[18] Crassidis, J. L. and F. L. Markley (1996) “Sliding mode control using modified Rodriguesparameters,” Journal of Guidance, Control, and Dynamics, 19(6), pp. 1381–1383.
[19] Crassidis, J. L., F. L. Markley, T. C. Anthony, and S. F. Andrews (1997) “Nonlinearpredictive control of spacecraft,” Journal of Guidance, Control, and Dynamics, 20(6), pp.1096–1103.
[20] Sharma, R. and A. Tewari (2004) “Optimal nonlinear tracking of spacecraft attitudemaneuvers,” Control Systems Technology, IEEE Transactions on, 12(5), pp. 677–682.
[21] Kim, K.-S. and Y. Kim (2003) “Robust backstepping control for slew maneuver using nonlineartracking function,” Control Systems Technology, IEEE Transactions on, 11(6), pp. 822–829.
[22] Krstic, M. and P. Tsiotras (1999) “Inverse optimal stabilization of a rigid spacecraft,”Automatic Control, IEEE Transactions on, 44(5), pp. 1042–1049.
[23] Ioslovich, I. (2003) “Arbitrary fuel-optimal attitude maneuvering of a non-symmetric spacevehicle in a vehicle-fixed coordinate frame,” Automatica, 39(3), pp. 557–562.
[24] Ioslovich, I., M. Borshchevsky, and P.-O. Gutman (2009) “Long time missions and thefuel-optimal attitude maneuvering in a swinging mode,” Mathematical Programming, 120(1),pp. 49–66.
[25] Liu, S.-W. and T. Singh (1997) “Fuel/time optimal control of spacecraft maneuvers,” Journalof Guidance, Control, and Dynamics, 20(2), pp. 394–397.
[26] Spindler, K. (1996) “Optimal attitude control of a rigid body,” Applied Mathematics andOptimization, 34(1), pp. 79–90.
[27] Biggs, J. D. and N. Horri (2012) “Optimal geometric motion planning for a spin-stabilizedspacecraft,” Systems & Control Letters, 61(4), pp. 609–616.
153
[28] Tewari, A. (2002) “Optimal nonlinear spacecraft attitude control through Hamilton-Jacobiformulation,” The Journal of the Astronautical Sciences, 50(1), pp. 99–112.
[29] Tsiotras, P. (1997) “Optimal Regulation and Passivity Results for Axisymmetric RigidBodies Using Two Controls,” Journal of Guidance, Control, and Dynamics, 20(3), pp. 457–463.
[30] Mazenc, F. and M. R. Akella (2014) “Quaternion-based stabilization of attitude dynamicssubject to pointwise delay in the input,” in Proceedings of the American Control Conference,pp. 4877 – 4882.
[31] Bryson, A. E. and Y.-C. Ho (1975) Applied Optimal Control: Optimization, Estimation andControl, Hemisphere Publishing Corp., New York, pp. 100-119.
[32] Hablani, H. B. (1999) “Attitude commands avoiding bright objects and maintaining com-munication with ground station,” Journal of Guidance, Control, and Dynamics, 22(6), pp.759–767.
[33] Spindler, K. (2002) “Attitude maneuvers which avoid a forbidden direction,” Journal ofDynamical and Control Systems, 8(1), pp. 1–22.
[34] Mengali, G. and A. A. Quarta (2004) “Spacecraft control with constrained fast reorientationand accurate pointing,” Aeronautical Journal, 108(1080), pp. 85–91.
[35] Melton, R. G. (2010) “Constrained Time-Optimal Slewing Maneuvers for Rigid Spacecraft,”Advances in the Astronautical Sciences, 135, pp. 107–126.
[36] Melton, R. (2010) “Boundary Points and Arcs in Constrained, Time-Optimal SatelliteReorientation Maneuvers,” in AIAA/AAS Astrodynamics Specialist Conference, AIAA, paperAIAA 2010-8376.
[37] Tanygin, S. (2014) “Three-Axis Constrained Attitude Pathfinding and Visualization: Chartinga Course on Higher-Dimensional Maps,” in AIAA/AAS Astrodynamics Specialist Conference,AIAA/AAS, paper AIAA 2014-4101.
[38] Weiss, A., F. Leve, M. Baldwin, J. R. Forbes, and I. Kolmanovsky (2014) “Spacecraftconstrained attitude control using positively invariant constraint admissible sets on SO (3)×R3,”in American Control Conference (ACC), 2014, IEEE, pp. 4955–4960.
[39] Enright, P. J. and B. A. Conway (1991) “Optimal Finite-Thrust Spacecraft TrajectoriesUsing Collocation and Nonlinear Programming,” Journal of Guidance, Control, and Dynamics,14(5), pp. 981–985.
[40] Scrivener, S. L. and R. C. Thompson (1994) “Time-Optimal Reorientation of a RigidSpacecraft Using Collocation and Nonlinear Programming,” Advances in the AstronauticalSciences, 85, pp. 1905–1924.
154
[41] Fahroo, F. and I. M. Ross (2002) “Direct Trajectory Optimization by a Chebyshev Pseu-dospectral Method,” Journal of Guidance, Control, and Dynamics, 25(1), pp. 160–166.
[42] Ross, I. M. (2007) A Beginner’s Guide to DIDO: A MATLAB Application Package for SolvingOptimal Control Problems, Elissar Global, Carmel, CA, rept. TR-711.
[43] Becerra, V. M. (2011) PSOPT: Optimal Control Solver User Manual, http://www.psopt.org.
[44] Patterson, M. A. and A. V. Rao (2014) GPOPS-II, Ver. 2.0, A General-Purpose MATLABSoftware for Solving Multiple-Phase Optimal Control Problems, http://www.gpops2.com.
[45] Caubet, A. and J. D. Biggs (2013) “Optimal Attitude Motion Planner for Large Slew Ma-neuvers Using a Shape-Based Method,” in AIAA Guidance, Navigation and Control Conference.
[46] Shang, M., T. Zhang, and J. Song (2013) “Optimal torque control constraint rigid spacecraftattitude maneuver with constraints,” in Control and Decision Conference (CCDC), 2013 25thChinese, IEEE, pp. 363–367.
[47] Proulx, R. J. and I. M. Ross (2002) “Time-Optimal Reorientation of Asymmetric RigidBodies,” Advances in the Astronautical Sciences, 109, part II, pp. 1207–1227.
[48] Melton, R. G. (2014) “Hybrid methods for determining time-optimal, constrained spacecraftreorientation maneuvers,” Acta Astronautica, 94(1), pp. 294–301.
[49] Zhuang, Y. and H. Huang (2014) “Time-optimal trajectory planning for underactuatedspacecraft using a hybrid particle swarm optimization algorithm,” Acta Astronautica, 94(2), pp.690 – 698.URL http://dx.doi.org/10.1016/j.actaastro.2013.06.023
[50] Fleming, A., P. Sekhavat, and I. M. Ross (2010) “Minimum-time reorientation of a rigidbody,” Journal of Guidance, Control, and Dynamics, 33(1), pp. 160–170.
[51] Karpenko, M., S. Bhatt, N. Bedrossian, and I. M. Ross (2014) “Flight Implementation ofShortest-Time Maneuvers for Imaging Satellites,” Journal of Guidance, Control, and Dynamics,pp. 1–11.
[52] Kane, T. R., P. W. Likins, and D. A. Levinson (1983) Spacecraft Dynamics, McGraw-Hill,New York, ch. 1.
[53] Wertz, J. R. (ed.) (1978) Spacecraft Attitude Determination and Control, Kluwer AcademicPublishers, Dordrecht, The Netherlands, app. D.
[54] Markley, F. (2008) “Unit quaternion from rotation matrix,” Journal of Guidance, Control,and Dynamics, 31(2), pp. 440 – 442.
[55] Wie, B. (1998) Space Vehicle Dynamics and Control, American Institute of Aeronautics andAstronautics, ch. 5.
155
[56] Schaub, H. and J. L. Junkins (2009) Analytical Mechanics for Spacecraft Systems, 2nd ed.,American Institute of Aerosnautics and Astronautics, Reston, VA, ch. 3.
[57] Sanyal, A., A. Fosbury, N. Chaturvedi, and D. S. Bernstein (2009) “Inertia-freespacecraft attitude trajectory tracking with internal-model-based disturbance rejection andalmost global stabilization,” in American Control Conference, 2009. ACC’09., IEEE, pp. 4830–4835.
[58] Lee, T., M. Leok, and N. H. McClamroch (2008) “Time optimal attitude control for arigid body,” in American Control Conference, 2008, IEEE, pp. 5210–5215.
[59] Bloch, A. M., I. I. Hussein, M. Leok, and A. K. Sanyal (2009) “Geometric structure-preserving optimal control of a rigid body,” Journal of Dynamical and Control Systems, 15(3),pp. 307–330.
[60] Schaub, H., J. Junkins, and R. Robinett (1997) “New Penalty Functions and OptimalControl Formulation for Spacecraft Attitude Control Problems,” Journal of Guidance, Control,and Dynamics, 20(3), pp. 428 – 434.
[61] Pontani, M. and B. A. Conway (2010) “Particle Swarm Optimization Applied to SpaceTrajectories,” Journal of Guidance, Control, and Dynamics, 33, pp. 1429 – 1441.
[62] Kennedy, J. and R. Eberhart (1995) “Particle Swarm Optimization,” in Proceedings ofICNN’95 - International Conference on Neural Networks, vol. 4, pp. 1942 – 1948.
[63] Shene, D. C.-K. (1997-2004), “CS3621 Introduction to Computing with Geometry Notes,” .URL http://www.cs.mtu.edu/ shene/COURSES/cs3621/NOTES/
[64] Basu, K. and R. G. Melton (2015) “Time-Optimal Reorientation via Inverse Dynamics: AQuaternion and Particle Swarm Formulation,” Advances in the Astronautical Sciences, 762, pp.1–14.
[65] Spiller, D., L. Ansalone, and F. Curti (2015) “Particle Swarm Optimization for Time-Optimal Spacecraft Reorientation with Keep-Out Cones,” Journal of Guidance, Control, andDynamics, 39(2), pp. 312–325.
[66] Ross, I. M. (2004) “User manual for DIDO: A MATLAB application package for solvingoptimal control problems,” Tomlab Optimization, Sweden.
[67] Basu, K., R. G. Melton, and S. Aguasvivas-Manzano (2017) “Time-Optimal Reorienta-tion using Neural Network and Particle Swarm Formulation,” Advances in the AstronauticalSciences, 816, pp. 1–20.
156
VitaKaushik Basu
EDUCATIONBA/MA Mathematics, West Chester University of Pennsylvania 2009ME Aerospace Engineering, Pennsylvania State University 2010Teaching Certificate, Pennsylvania State University 2016
PUBLICATIONS AND TECHNICAL PRESENTATIONSBasu,K.(FA), Fisher,Z., Bresler,J., Bender,B., Cowan,S., Young,L., and Newhart,T. A New
Beginning: Human Class Mars EDL; RASCAL-NIANET 2015 Forum @NASA/KSC, June 15-17,2015
Paik,G. and Basu,K. Thermal Modelling of Avionics Vault on Jupiter Orbiter ; TWAS 2015(Thermal and Fluids Analysis Workshop) @NASA/GSFC, August 3-7, 2015
Basu,K. and Melton,R.G. Survey of Optimal Rigid-Body Attitude Maneuvers; AAS/AIAA 15-411@ Williamsburg, Virginia. January 11-15, 2015
Basu,K. and Melton,R.G. Time-Optimal Reorientation via Inverse Dynamics: A Quaternionand Particle Swarm Formulaton; AAS/AIAA 15-762 @ Vail, Colorado, August 9-13, 2015
Marcucci,E.C., Hays,L., Holstein-Rathlou,C., Keane,J.T., Becerra,P., Basu,K. Davis,B., Fox,V.,Herman,J., Hughes,A., Mendez Ramos,E., Nelessen,A., Neveu,M., Parrish,N., Scheinberg,A., Wro-bel,J.S. Argus: An Io observer mission concept study from the 2014 NASA/JPL Planetary ScienceSummer School; LPI 2015(Lunar Planetary Institute) @The Woodlands, Texas. March 16-20.
Basu,K., Shaw,M. and Melton,R.G. Satellite Attitude Control Technology; DST 2017 (Directorateof Science and Technology) Summer Symposium @ CIA/Langley, Virginia June 5-6, 2017
Spiller,D. and Basu,K. Optimal Passive Formation Reconfiguration using Attitude Control andPerturbing Forces; IWSCFF 17-37 (International Workshop on Satellite Constellations and FormationFlying) @ UC Boulder, Colorado. June 21-24, 2017
Basu,K., Melton,R.G. and Aguasvivas-Manzano,S. Time-Optimal Reorientation using NeuralNetwork and Particle Swarm Formulation; AAS/AIAA 17-816 @ Stevenson, Washington August21-24, 2017
Spiller.D, and Basu,K. On the Optimal Passive Formation Reconfiguration by using AttitudeControl; Journal Acta Astronautica @ AA-2017-1167,Elsevier Dec, 2017