def _createOptimizer(self):
'''
Reads the Optimization.ParticleSwarm dictionary and creates a pyswarms.GlobalBestPSO object
Returns the Optimizer, the user's desired number of iterations, and showConvergence (bool)
'''
pathToParticleSwarmDict = self.optimizationReader.simDefDictPathToReadFrom + '.ParticleSwarm'
pSwarmReader = SubDictReader(pathToParticleSwarmDict, self.optimizationReader.simDefinition)
nParticles = pSwarmReader.tryGetInt("nParticles", defaultValue=20)
nIterations = pSwarmReader.tryGetInt("nIterations", defaultValue=50)
c1 = pSwarmReader.tryGetFloat("cognitiveParam", defaultValue=0.5)
c2 = pSwarmReader.tryGetFloat("socialParam", defaultValue=0.6)
w = pSwarmReader.tryGetFloat("inertiaParam", defaultValue=0.9)
pySwarmOptions = { 'c1':c1, 'c2':c2, 'w':w }
nVars = len(self.varNames)
varBounds = (self.minVals, self.maxVals)
from pyswarms.single import \
GlobalBestPSO # Import here because for most sims it's not required
optimizer = GlobalBestPSO(nParticles, nVars, pySwarmOptions, bounds=varBounds, init_pos=self.initPositions)
if self.bestPosition != None and self.bestCost != None:
optimizer.swarm.best_pos = self.bestPosition
optimizer.swarm.best_cost = self.bestCost
showConvergence = self.optimizationReader.tryGetBool("showConvergencePlot", defaultValue=False)
if not self.silent:
print("Optimization Parameters:")
print("{} Particles".format(nParticles))
print("{} Iterations".format(nIterations))
print("c1 = {}, c2 = {}, w = {}\n".format(c1, c2, w))
costFunctionDefinition = self.optimizationReader.getString("costFunction")
print("Cost Function:")
print(costFunctionDefinition + "\n")
return optimizer, nIterations, showConvergence
def __init__(self, simDefinition=None, silent=False):
''' Sets up the Wind, Atmospheric, and Earth models requested in the Sim Definition file '''
self.launchRail = None
if simDefinition != None:
# Whenever we're running a real simulation, should always end up here
envDictReader = SubDictReader("Environment", simDefinition)
self.meanWindModel = meanWindModelFactory(envDictReader, silent=silent)
self.turbulenceModel = turbulenceModelFactory(envDictReader, silent=silent)
self.atmosphericModel = atmosphericModelFactory(envDictReader=envDictReader)
self.earthModel = earthModelFactory(envDictReader)
self.launchSiteElevation = envDictReader.tryGetFloat("LaunchSite.elevation")
self.launchSiteLatitude = envDictReader.tryGetFloat("LaunchSite.latitude")
self.launchSiteLongitude = envDictReader.tryGetFloat("LaunchSite.longitude")
# Check if being launched from a launch rail
launchRailLength = envDictReader.getFloat("LaunchSite.railLength")
if launchRailLength > 0:
# Initialize a launch rail, aligned with the rocket's initial direction
initialRocketPosition_towerFrame = envDictReader.getVector("Rocket.position")
# Check whether precise initial orientation has been specified
rotationAxis = envDictReader.tryGetVector("Rocket.rotationAxis", defaultValue=None)
if rotationAxis != None:
rotationAngle = math.radians(envDictReader.getFloat("Rocket.rotationAngle"))
initOrientation = Quaternion(rotationAxis, rotationAngle)
else:
# Calculate initial orientation quaternion in launch tower frame
rotationAxis = envDictReader.tryGetVector("Rocket.rotationAxis", defaultValue=None)
if rotationAxis != None:
rotationAngle = math.radians(self.rocketDictReader.getFloat("Rocket.rotationAngle"))
initOrientation = Quaternion(rotationAxis, rotationAngle)
else:
# Calculate initial orientation quaternion in launch tower frame
initialDirection = envDictReader.getVector("Rocket.initialDirection").normalize()
angleFromVertical = Vector(0,0,1).angle(initialDirection)
rotationAxis = Vector(0,0,1).crossProduct(initialDirection)
initOrientation = Quaternion(rotationAxis, angleFromVertical)
# TODO: Get from rocket, or calculate the same way - so that it works with rotationAxis + Angle
initialDirection = envDictReader.getVector("Rocket.initialDirection").normalize()
angleFromVertical = Vector(0,0,1).angle(initialDirection)
rotationAxis = Vector(0,0,1).crossProduct(initialDirection)
initOrientation = Quaternion(rotationAxis, angleFromVertical)
initPosition_seaLevelENUFrame = initialRocketPosition_towerFrame + Vector(0, 0, self.launchSiteElevation)
launchTowerState_local = RigidBodyState(position=initPosition_seaLevelENUFrame, orientation=initOrientation)
launchTowerState_global = self.earthModel.convertIntoGlobalFrame(launchTowerState_local, self.launchSiteLatitude, self.launchSiteLongitude)
towerDirection_global = launchTowerState_global.orientation.rotate(Vector(0, 0, 1))
self.launchRail = LaunchRail(launchTowerState_global.position, towerDirection_global, launchRailLength, earthRotationRate=self.earthModel.rotationRate)
else:
# Construct default environment from default parameters when no sim definition is passed in
# Need additional default value here in case a SimDefinition is not passed in (otherwise SimDefinition takes care of default values)
self.meanWindModel = meanWindModelFactory()
self.turbulenceModel = None
self.atmosphericModel = atmosphericModelFactory()
self.earthModel = earthModelFactory()
self.launchSiteElevation = float(defaultConfigValues["Environment.LaunchSite.elevation"])
self.launchSiteLatitude = float(defaultConfigValues["Environment.LaunchSite.latitude"])
self.launchSiteLongitude = float(defaultConfigValues["Environment.LaunchSite.longitude"])
