Source code for test_oneAxisSolarArrayPoint

#
#  ISC License
#
#  Copyright (c) 2023, Autonomous Vehicle Systems Lab, University of Colorado at Boulder
#
#  Permission to use, copy, modify, and/or distribute this software for any
#  purpose with or without fee is hereby granted, provided that the above
#  copyright notice and this permission notice appear in all copies.
#
#  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
#  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
#  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
#  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
#  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
#  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
#  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#


#
#   Unit Test Script
#   Module Name:        SEPPointing
#   Author:             Riccardo Calaon
#   Creation Date:      February 15, 2023
#

import pytest
import os
import inspect
import numpy as np

filename = inspect.getframeinfo(inspect.currentframe()).filename
path = os.path.dirname(os.path.abspath(filename))
bskName = 'Basilisk'
splitPath = path.split(bskName)


# Import all the modules that we are going to be called in this simulation
from Basilisk.utilities import SimulationBaseClass
from Basilisk.utilities import unitTestSupport
from Basilisk.utilities import RigidBodyKinematics as rbk
from Basilisk.fswAlgorithms import oneAxisSolarArrayPoint
from Basilisk.utilities import macros
from Basilisk.architecture import messaging
from Basilisk.architecture import bskLogging


def computeGamma(alpha, delta):

    if alpha >= 0 and alpha <= np.pi/2:
        if delta < np.pi/2 - alpha:
            gamma = np.pi/2 - alpha - delta
        elif delta > alpha + np.pi/2:
            gamma = - np.pi/2 - alpha + delta
        else:
            gamma = 0
    else:
        if delta < alpha - np.pi/2:
            gamma = - np.pi/2 + alpha - delta 
        elif delta > 3/2*np.pi - alpha:
            gamma = alpha + delta - 3/2*np.pi
        else:
            gamma = 0

    return gamma


# The 'ang' array spans the interval from 0 to pi.  pi is excluded because
# the code is less accurate around this point;
ang = np.linspace(0, np.pi, 5, endpoint=False)
ang = list(ang)

[docs] @pytest.mark.parametrize("alpha", ang) @pytest.mark.parametrize("delta", ang) @pytest.mark.parametrize("bodyAxisInput", [0,1]) @pytest.mark.parametrize("inertialAxisInput", [0,1,2]) @pytest.mark.parametrize("alignmentPriority", [0,1]) @pytest.mark.parametrize("accuracy", [1e-12]) def test_oneAxisSolarArrayPointTestFunction(show_plots, alpha, delta, bodyAxisInput, inertialAxisInput, alignmentPriority, accuracy): r""" **Validation Test Description** This unit test script tests the correctness of the reference attitude computed by :ref:`oneAxisSolarArrayPoint`. The correctness of the output is determined based on whether the reference attitude causes the solar array drive axis :math:`\hat{a}_1` to be at an angle :math:`\gamma` from the Sun direction :math:`\hat{r}_{S/B}`. **Test Parameters** This test generates an array ``ang`` of linearly-spaced points between 0 and :math:`\pi`. Values of :math:`\alpha` and :math:`\delta` are drawn from all possible combinations of such lineaarly spaced values. In the test, values of :math:`\alpha` and :math:`\delta` are used to set the angular distance between the vectors :math:`{}^\mathcal{N}\hat{r}_{S/B}` and :math:`{}^\mathcal{N}\hat{h}_\text{ref}`, and :math:`{}^\mathcal{B}\hat{h}_1` and :math:`{}^\mathcal{B}\hat{a}_1`. All possible inputs are provided to the module, in terms of input parameters and input messages, using the same combinations of inertial and body-fixed direction vectors. Args: alpha (rad): angle between :math:`{}^\mathcal{N}\hat{r}_{S/B}` and :math:`{}^\mathcal{N}\hat{h}_\text{ref}` delta (rad): angle between :math:`{}^\mathcal{B}\hat{h}_1` and :math:`{}^\mathcal{B}\hat{a}_1` bodyAxisInput (int): passes the body axis input as parameter or as input msg inertialAxisInput (int): passes the inertial axis input as parameter, as input msg, or with :ref:`NavTransMsgPayload` and :ref:`EphemerisMsgPayload` alignmentPriority (int): 0 to prioritize body heading alignment, 1 to prioritize solar array power; if 1, correct result is :math:`\gamma = 0`. **Description of Variables Being Tested** The angle :math:`\gamma` is a function of the angles :math:`\alpha` and :math:`\delta`, where :math:`\alpha` is the angle between the Sun direction :math:`{}^\mathcal{N}\hat{r}_{S/B}` and the reference inertial heading :math:`{}^\mathcal{N}\hat{h}_\text{ref}`, whereas :math:`\delta` is the angle between the body-frame heading :math:`{}^\mathcal{B}\hat{h}_1` and the solar array axis drive :math:`{}^\mathcal{B}\hat{a}_1`. The angle :math:`\gamma` is computed from the output reference attitude and compared with the results of a python function that computes the correct output based on the geometry of the problem. For a description of how such correct result is obtained, see R. Calaon, C. Allard and H. Schaub, "Attitude Reference Generation for Spacecraft with Rotating Solar Arrays and Pointing Constraints", in preparation for Journal of Spacecraft and Rockets. **General Documentation Comments** This unit test verifies the correctness of the generated reference attitude. It does not test the correctness of the reference angular rates and accelerations contained in the ``attRefOutMsg``, because this would require to run the module for multiple update calls. To ensure fast execution of the unit test, this is avoided. """ # each test method requires a single assert method to be called [testResults, testMessage] = oneAxisSolarArrayPointTestFunction(show_plots, alpha, delta, bodyAxisInput, inertialAxisInput, alignmentPriority, accuracy) assert testResults < 1, testMessage
def oneAxisSolarArrayPointTestFunction(show_plots, alpha, delta, bodyAxisInput, inertialAxisInput, alignmentPriority, accuracy): gamma_true = computeGamma(alpha, delta) rHat_SB_N = np.array([1, 2, 3]) # Sun direction in inertial coordinates rHat_SB_N = rHat_SB_N / np.linalg.norm(rHat_SB_N) a1Hat_B = np.array([9, 8, 7]) # array axis direction in body frame a1Hat_B = a1Hat_B / np.linalg.norm(a1Hat_B) a = np.cross(rHat_SB_N, [4, 5, 6]) a = a / np.linalg.norm(a) d = np.cross(a1Hat_B, [6, 5, 4]) d = d / np.linalg.norm(d) DCM1 = rbk.PRV2C(a * alpha) DCM2 = rbk.PRV2C(d * delta) hHat_N = np.matmul(DCM1, rHat_SB_N) # required thrust direction in inertial frame, at an angle alpha from rHat_SB_N hHat_B = np.matmul(DCM2, a1Hat_B) # required thrust direction in inertial frame, at an angle alpha from rHat_SB_N testFailCount = 0 # zero unit test result counter testMessages = [] # create empty array to store test log messages unitTaskName = "unitTask" # arbitrary name (don't change) unitProcessName = "TestProcess" # arbitrary name (don't change) bskLogging.setDefaultLogLevel(bskLogging.BSK_WARNING) # Create a sim module as an empty container unitTestSim = SimulationBaseClass.SimBaseClass() # Create test thread testProcessRate = macros.sec2nano(1.1) testProc = unitTestSim.CreateNewProcess(unitProcessName) testProc.addTask(unitTestSim.CreateNewTask(unitTaskName, testProcessRate)) # Construct algorithm and associated C++ container attReferenceCongfig = oneAxisSolarArrayPoint.oneAxisSolarArrayPoint() attReferenceCongfig.ModelTag = "oneAxisSolarArrayPoint" # Add test module to runtime call list unitTestSim.AddModelToTask(unitTaskName, attReferenceCongfig) # Initialize the test module configuration data # These will eventually become input messages attReferenceCongfig.a1Hat_B = a1Hat_B attReferenceCongfig.alignmentPriority = alignmentPriority # Create input navigation message sigma_BN = np.array([0, 0, 0]) BN = rbk.MRP2C(sigma_BN) rS_B = np.matmul(BN, rHat_SB_N) NavAttMessageData = messaging.NavAttMsgPayload() NavAttMessageData.sigma_BN = sigma_BN NavAttMessageData.vehSunPntBdy = rS_B NavAttMsg = messaging.NavAttMsg().write(NavAttMessageData) attReferenceCongfig.attNavInMsg.subscribeTo(NavAttMsg) if bodyAxisInput == 0: attReferenceCongfig.h1Hat_B = hHat_B else: # Create input bodyHeadingMsg bodyHeadingData = messaging.BodyHeadingMsgPayload() bodyHeadingData.rHat_XB_B = hHat_B bodyHeadingMsg = messaging.BodyHeadingMsg().write(bodyHeadingData) attReferenceCongfig.bodyHeadingInMsg.subscribeTo(bodyHeadingMsg) if inertialAxisInput == 0: attReferenceCongfig.hHat_N = hHat_N elif inertialAxisInput == 1: # Create input inertialHeadingMsg inertialHeadingData = messaging.InertialHeadingMsgPayload() inertialHeadingData.rHat_XN_N = hHat_N inertialHeadingMsg = messaging.InertialHeadingMsg().write(inertialHeadingData) attReferenceCongfig.inertialHeadingInMsg.subscribeTo(inertialHeadingMsg) else: # Create input translation navigation transNavData = messaging.NavTransMsgPayload() transNavData.r_BN_N = [0, 0, 0] transNavMsg = messaging.NavTransMsg().write(transNavData) attReferenceCongfig.transNavInMsg.subscribeTo(transNavMsg) ephemerisData = messaging.EphemerisMsgPayload() ephemerisData.r_BdyZero_N = hHat_N ephemerisMsg = messaging.EphemerisMsg().write(ephemerisData) attReferenceCongfig.ephemerisInMsg.subscribeTo(ephemerisMsg) # Setup logging on the test module output message so that we get all the writes to it dataLog = attReferenceCongfig.attRefOutMsg.recorder() unitTestSim.AddModelToTask(unitTaskName, dataLog) # Need to call the self-init and cross-init methods unitTestSim.InitializeSimulation() # Set the simulation time. # NOTE: the total simulation time may be longer than this value. The # simulation is stopped at the next logging event on or after the # simulation end time. unitTestSim.ConfigureStopTime(macros.sec2nano(1.0)) # Begin the simulation time run set above unitTestSim.ExecuteSimulation() moduleOutput = dataLog.sigma_RN sigma_RN = moduleOutput[0] RN = rbk.MRP2C(sigma_RN) NR = RN.transpose() a1Hat_N = np.matmul(NR, a1Hat_B) gamma_sim = np.arcsin( abs( np.clip( np.dot(rHat_SB_N, a1Hat_N), -1, 1 ) ) ) # set the filtered output truth states if alignmentPriority == 0: if not unitTestSupport.isDoubleEqual(gamma_sim, gamma_true, accuracy): testFailCount += 1 testMessages.append("FAILED: " + attReferenceCongfig.ModelTag + " Module failed incidence angle for " "bodyAxisInput = {}, inertialAxisInput = {} and priorityFlag = {}".format( bodyAxisInput, inertialAxisInput, alignmentPriority)) else: if not unitTestSupport.isDoubleEqual(gamma_sim, 0, accuracy): testFailCount += 1 testMessages.append("FAILED: " + attReferenceCongfig.ModelTag + " Module failed incidence angle for " "bodyAxisInput = {}, inertialAxisInput = {} and priorityFlag = {}".format( bodyAxisInput, inertialAxisInput, alignmentPriority)) if testFailCount: print(testMessages) else: print("Unit Test Passed") return [testFailCount, ''.join(testMessages)] # # This statement below ensures that the unitTestScript can be run as a # stand-along python script # if __name__ == "__main__": oneAxisSolarArrayPointTestFunction( False, np.pi, # alpha np.pi, # delta 0, # flagB 1, # flagN 0, # priorityFlag 1e-9 # accuracy )