bsk 2.8.23__tar.gz → 2.8.25__tar.gz

{bsk-2.8.23/bsk.egg-info → bsk-2.8.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bsk
-Version: 2.8.23
+Version: 2.8.25
 Summary: Basilisk: an Astrodynamics Simulation Framework
 Home-page: https://avslab.github.io/basilisk/
 License: 

{bsk-2.8.23 → bsk-2.8.25/bsk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bsk
-Version: 2.8.23
+Version: 2.8.25
 Summary: Basilisk: an Astrodynamics Simulation Framework
 Home-page: https://avslab.github.io/basilisk/
 License: 

bsk-2.8.25/docs/source/bskVersion.txt

@@ -0,0 +1 @@
+2.8.25

{bsk-2.8.23 → bsk-2.8.25}/src/simulation/dynamics/constraintEffector/constraintDynamicEffector.rst

@@ -69,9 +69,34 @@ This section outlines the steps needed to setup a Constraint Dynamic Effector in
 
    See :ref:`spacecraft` documentation on how to set up a spacecraft object.
 
-#. Add the module to the task list::
+#. Add the spacecraft and module to the task list::
 
-    Sim.AddModelToTask(TaskName, constraintEffector)
+        Sim.AddModelToTask(TaskName, scObject1)
+        Sim.AddModelToTask(TaskName, scObject2)
+        Sim.AddModelToTask(TaskName, constraintEffector)
+
+   .. important::
+
+      The order in which the spacecraft are solved in the task **MUST** compute
+      spacecraft 1 first and spacecraft 2 second. Regardless of what your spacecraft objects are
+      named, the spacecraft considered "1" and "2" are dictated when setting ``R_P1B1_B1``, ``R_P2B2_B2``,
+      and ``R_P2P1_B1Init`` where spacecraft 1 hosts connection point P1 and parent frame B1, and
+      spacecraft 2 hosts connection point P2 and parent frame B2.
+
+      When using the :ref:`SimulationBaseClass` ``AddModelToTask()`` model priority to set the order of execution, ensure that spacecraft 1 is
+      set to be solved before spacecraft 2. Note that model priority execution is from highest
+      value to lowest value, with the default being -1 when unspecified. When using the model
+      priority, the setup could look like::
+
+         Sim.AddModelToTask(TaskName, scObject2, ModelPriority=5) # spacecraft 2 solved second
+         Sim.AddModelToTask(TaskName, scObject1, ModelPriority=10) # spacecraft 1 solved first
+
+      When not setting any model priority, and therefore letting all models default to a -1
+      model priority, models of the same priority are computed in the order that they are added.
+      So if not setting a model priority, the setup MUST look like::
+
+         Sim.AddModelToTask(TaskName, scObject1) # spacecraft 1 solved first
+         Sim.AddModelToTask(TaskName, scObject2) # spacecraft 2 solved second
 
 #. Ensure that the dynamics integration is synced between the connected spacecraft. For best results use a variable timestep integrator::
 

{bsk-2.8.23 → bsk-2.8.25}/src/simulation/dynamics/linearTranslationalBodies/linearTranslationBodiesNDOF/linearTranslationNDOFStateEffector.cpp

@@ -23,7 +23,7 @@
 #include <string>
 
 /*! This is the constructor, setting variables to default values */
-linearTranslationNDOFStateEffector::linearTranslationNDOFStateEffector()
+LinearTranslationNDOFStateEffector::LinearTranslationNDOFStateEffector()
 {
     // Zero the mass props and mass prop rates contributions
     this->effProps.mEff = 0.0;
@@ -32,20 +32,20 @@ linearTranslationNDOFStateEffector::linearTranslationNDOFStateEffector()
     this->effProps.rEffPrime_CB_B.fill(0.0);
     this->effProps.IEffPrimePntB_B.fill(0.0);
 
-    this->nameOfRhoState = "translatingBodyRho" + std::to_string(linearTranslationNDOFStateEffector::effectorID);
-    this->nameOfRhoDotState = "translatingBodyRhoDot" + std::to_string(linearTranslationNDOFStateEffector::effectorID);
-    linearTranslationNDOFStateEffector::effectorID++;
+    this->nameOfRhoState = "translatingBodyRho" + std::to_string(LinearTranslationNDOFStateEffector::effectorID);
+    this->nameOfRhoDotState = "translatingBodyRhoDot" + std::to_string(LinearTranslationNDOFStateEffector::effectorID);
+    LinearTranslationNDOFStateEffector::effectorID++;
 }
 
-uint64_t linearTranslationNDOFStateEffector::effectorID = 1;
+uint64_t LinearTranslationNDOFStateEffector::effectorID = 1;
 
 /*! This is the destructor, nothing to report here */
-linearTranslationNDOFStateEffector::~linearTranslationNDOFStateEffector()
+LinearTranslationNDOFStateEffector::~LinearTranslationNDOFStateEffector()
 {
-    linearTranslationNDOFStateEffector::effectorID --;    /* reset the panel ID*/
+    LinearTranslationNDOFStateEffector::effectorID --;    /* reset the panel ID*/
 }
 
-void translatingBody::setMass(double mass) {
+void TranslatingBody::setMass(double mass) {
     if (mass > 0.0)
         this->mass = mass;
     else {
@@ -53,7 +53,7 @@ void translatingBody::setMass(double mass) {
     }
 }
 
-void translatingBody::setFHat_P(Eigen::Vector3d fHat_P) {
+void TranslatingBody::setFHat_P(Eigen::Vector3d fHat_P) {
     if (fHat_P.norm() > 0.01) {
         this->fHat_P = fHat_P.normalized();
     }
@@ -62,7 +62,7 @@ void translatingBody::setFHat_P(Eigen::Vector3d fHat_P) {
     }
 }
 
-void translatingBody::setK(double k) {
+void TranslatingBody::setK(double k) {
     if (k >= 0.0)
         this->k = k;
     else {
@@ -70,7 +70,7 @@ void translatingBody::setK(double k) {
     }
 }
 
-void translatingBody::setC(double c) {
+void TranslatingBody::setC(double c) {
     if (c >= 0.0)
         this->c = c;
     else {
@@ -79,11 +79,11 @@ void translatingBody::setC(double c) {
 }
 
 /*! This method is used to reset the module. */
-void linearTranslationNDOFStateEffector::Reset(uint64_t CurrentClock)
+void LinearTranslationNDOFStateEffector::Reset(uint64_t CurrentClock)
 {
     for(auto& translatingBody: this->translatingBodyVec) {
-        if (translatingBody.fHat_P.norm() > 0.0) {
-            translatingBody.fHat_P.normalize();
+        if (translatingBody->fHat_P.norm() > 0.0) {
+            translatingBody->fHat_P.normalize();
         }
         else {
             bskLogger.bskLog(BSK_ERROR, "Norm of fHat must be greater than 0. sHat may not have been set by the user.");
@@ -92,7 +92,7 @@ void linearTranslationNDOFStateEffector::Reset(uint64_t CurrentClock)
 }
 
 /*! This method is used to add a translating body. */
-void linearTranslationNDOFStateEffector::addTranslatingBody(const translatingBody& newBody) {
+void LinearTranslationNDOFStateEffector::addTranslatingBody(const std::shared_ptr<TranslatingBody> newBody) {
     // Pushback new body
     translatingBodyVec.push_back(newBody);
     this->N++;
@@ -108,8 +108,15 @@ void linearTranslationNDOFStateEffector::addTranslatingBody(const translatingBod
     this->CRho.conservativeResize(this->CRho.rows()+1);
 }
 
+/*! This method is used to get a translating body. */
+std::shared_ptr<TranslatingBody> LinearTranslationNDOFStateEffector::getTranslatingBody(uint64_t index) {
+    assert(("Index can't be greater than the number of degrees of freedom of the effector", index <= this->numberOfDegreesOfFreedom));
+
+    return this->translatingBodyVec.at(index);
+}
+
 /*! This method reads motor force, lock flag, and reference state messages. */
-void linearTranslationNDOFStateEffector::readInputMessages()
+void LinearTranslationNDOFStateEffector::readInputMessages()
 {
     //! - Read the incoming command array
     if (this->motorForceInMsg.isLinked() && this->motorForceInMsg.isWritten()) {
@@ -117,7 +124,7 @@ void linearTranslationNDOFStateEffector::readInputMessages()
         incomingCmdBuffer = this->motorForceInMsg();
         int i = 0;
         for(auto& translatingBody: this->translatingBodyVec) {
-            translatingBody.u = incomingCmdBuffer.motorForce[i];
+            translatingBody->u = incomingCmdBuffer.motorForce[i];
             i++;
         }
     }
@@ -128,7 +135,7 @@ void linearTranslationNDOFStateEffector::readInputMessages()
         incomingLockBuffer = this->motorLockInMsg();
         int i = 0;
         for(auto& translatingBody: this->translatingBodyVec) {
-            translatingBody.isAxisLocked = incomingLockBuffer.effectorLockFlag[i];
+            translatingBody->isAxisLocked = incomingLockBuffer.effectorLockFlag[i];
             i++;
         }
     }
@@ -138,15 +145,15 @@ void linearTranslationNDOFStateEffector::readInputMessages()
         if (this->translatingBodyRefInMsgs[translatingBodyIndex].isLinked() && this->translatingBodyRefInMsgs[translatingBodyIndex].isWritten()) {
             LinearTranslationRigidBodyMsgPayload incomingRefBuffer;
             incomingRefBuffer = this->translatingBodyRefInMsgs[translatingBodyIndex]();
-            translatingBody.rhoRef = incomingRefBuffer.rho;
-            translatingBody.rhoDotRef = incomingRefBuffer.rhoDot;
+            translatingBody->rhoRef = incomingRefBuffer.rho;
+            translatingBody->rhoDotRef = incomingRefBuffer.rhoDot;
         }
         translatingBodyIndex++;
     }
 }
 
 /*! This method takes the computed rho states and outputs them to the messaging system. */
-void linearTranslationNDOFStateEffector::writeOutputStateMessages(uint64_t CurrentClock)
+void LinearTranslationNDOFStateEffector::writeOutputStateMessages(uint64_t CurrentClock)
 {
     // Write out the translating body output messages
     int i = 0;
@@ -155,8 +162,8 @@ void linearTranslationNDOFStateEffector::writeOutputStateMessages(uint64_t Curre
     for(auto& translatingBody: this->translatingBodyVec) {
         if (this->translatingBodyOutMsgs[i]->isLinked()) {
             translatingBodyBuffer = this->translatingBodyOutMsgs[i]->zeroMsgPayload;
-            translatingBodyBuffer.rho = translatingBody.rho;
-            translatingBodyBuffer.rhoDot = translatingBody.rhoDot;
+            translatingBodyBuffer.rho = translatingBody->rho;
+            translatingBodyBuffer.rhoDot = translatingBody->rhoDot;
             this->translatingBodyOutMsgs[i]->write(&translatingBodyBuffer, this->moduleID, CurrentClock);
         }
 
@@ -164,10 +171,10 @@ void linearTranslationNDOFStateEffector::writeOutputStateMessages(uint64_t Curre
             configLogMsg = this->translatingBodyConfigLogOutMsgs[i]->zeroMsgPayload;
 
             // Logging the F frame is the body frame B of that object
-            eigenVector3d2CArray(translatingBody.r_FcN_N, configLogMsg.r_BN_N);
-            eigenVector3d2CArray(translatingBody.v_FcN_N, configLogMsg.v_BN_N);
-            eigenVector3d2CArray(translatingBody.sigma_FN, configLogMsg.sigma_BN);
-            eigenVector3d2CArray(translatingBody.omega_FN_F, configLogMsg.omega_BN_B);
+            eigenVector3d2CArray(translatingBody->r_FcN_N, configLogMsg.r_BN_N);
+            eigenVector3d2CArray(translatingBody->v_FcN_N, configLogMsg.v_BN_N);
+            eigenVector3d2CArray(translatingBody->sigma_FN, configLogMsg.sigma_BN);
+            eigenVector3d2CArray(translatingBody->omega_FN_F, configLogMsg.omega_BN_B);
             this->translatingBodyConfigLogOutMsgs[i]->write(&configLogMsg, this->moduleID, CurrentClock);
         }
 
@@ -176,21 +183,21 @@ void linearTranslationNDOFStateEffector::writeOutputStateMessages(uint64_t Curre
 }
 
 /*! This method prepends the name of the spacecraft for multi-spacecraft simulations.*/
-void linearTranslationNDOFStateEffector::prependSpacecraftNameToStates()
+void LinearTranslationNDOFStateEffector::prependSpacecraftNameToStates()
 {
     this->nameOfRhoState = this->nameOfSpacecraftAttachedTo + this->nameOfRhoState;
     this->nameOfRhoDotState = this->nameOfSpacecraftAttachedTo + this->nameOfRhoDotState;
 }
 
 /*! This method allows the TB state effector to have access to the hub states and gravity*/
-void linearTranslationNDOFStateEffector::linkInStates(DynParamManager& statesIn)
+void LinearTranslationNDOFStateEffector::linkInStates(DynParamManager& statesIn)
 {
     this->inertialPositionProperty = statesIn.getPropertyReference(this->nameOfSpacecraftAttachedTo + "r_BN_N");
     this->inertialVelocityProperty = statesIn.getPropertyReference(this->nameOfSpacecraftAttachedTo + "v_BN_N");
 }
 
 /*! This method allows the TB state effector to register its states: rho and rhoDot with the dynamic parameter manager */
-void linearTranslationNDOFStateEffector::registerStates(DynParamManager& states)
+void LinearTranslationNDOFStateEffector::registerStates(DynParamManager& states)
 {
     // Register the rho states
     this->rhoState = states.registerState(N, 1, this->nameOfRhoState);
@@ -199,8 +206,8 @@ void linearTranslationNDOFStateEffector::registerStates(DynParamManager& states)
     Eigen::MatrixXd RhoDotInitMatrix(N,1);
     int i = 0;
     for(const auto& translatingBody: this->translatingBodyVec) {
-        RhoInitMatrix(i,0) = translatingBody.rhoInit;
-        RhoDotInitMatrix(i,0) = translatingBody.rhoDotInit;
+        RhoInitMatrix(i,0) = translatingBody->rhoInit;
+        RhoDotInitMatrix(i,0) = translatingBody->rhoDotInit;
         i++;
     }
     this->rhoState->setState(RhoInitMatrix);
@@ -209,7 +216,7 @@ void linearTranslationNDOFStateEffector::registerStates(DynParamManager& states)
 
 /*! This method allows the TB state effector to provide its contributions to the mass props and mass prop rates of the
  spacecraft */
-void linearTranslationNDOFStateEffector::updateEffectorMassProps(double integTime)
+void LinearTranslationNDOFStateEffector::updateEffectorMassProps(double integTime)
 {
     this->effProps.mEff = 0.0;
     this->effProps.rEff_CB_B = Eigen::Vector3d::Zero();
@@ -219,64 +226,64 @@ void linearTranslationNDOFStateEffector::updateEffectorMassProps(double integTim
 
     int i = 0;
     for(auto& translatingBody: this->translatingBodyVec) {
-        if (translatingBody.isAxisLocked) {
+        if (translatingBody->isAxisLocked) {
             auto rhoDotVector = this->rhoDotState->getState();
             rhoDotVector(i) = 0.0;
             this->rhoDotState->setState(rhoDotVector);
         }
         // Give the mass of the translating body to the effProps mass
-        this->effProps.mEff += translatingBody.mass;
+        this->effProps.mEff += translatingBody->mass;
 
         // Grab current states
-        translatingBody.rho = this->rhoState->getState()(i, 0);
-        translatingBody.rhoDot = this->rhoDotState->getState()(i, 0);
+        translatingBody->rho = this->rhoState->getState()(i, 0);
+        translatingBody->rhoDot = this->rhoDotState->getState()(i, 0);
 
         // Write the translating axis in B frame
         if (i == 0) {
-            translatingBody.dcm_FB = translatingBody.dcm_FP;
-            translatingBody.fHat_B = translatingBody.fHat_P;
+            translatingBody->dcm_FB = translatingBody->dcm_FP;
+            translatingBody->fHat_B = translatingBody->fHat_P;
         } else {
-            translatingBody.dcm_FB = translatingBody.dcm_FP * this->translatingBodyVec[i-1].dcm_FB;
-            translatingBody.fHat_B = this->translatingBodyVec[i-1].dcm_FB.transpose() * translatingBody.fHat_P;
+            translatingBody->dcm_FB = translatingBody->dcm_FP * this->translatingBodyVec[i-1]->dcm_FB;
+            translatingBody->fHat_B = this->translatingBodyVec[i-1]->dcm_FB.transpose() * translatingBody->fHat_P;
         }
-        translatingBody.r_FF0_B = translatingBody.rho * translatingBody.fHat_B;
+        translatingBody->r_FF0_B = translatingBody->rho * translatingBody->fHat_B;
 
         // Compute the effector's CoM with respect to point B
-        translatingBody.r_FcF_B = translatingBody.dcm_FB.transpose() * translatingBody.r_FcF_F;
+        translatingBody->r_FcF_B = translatingBody->dcm_FB.transpose() * translatingBody->r_FcF_F;
         if (i == 0) {
             // The parent frame of first body is the B frame
-            translatingBody.r_F0P_B = translatingBody.r_F0P_P;
-            translatingBody.r_FP_B = translatingBody.r_F0P_B + translatingBody.r_FF0_B;
-            translatingBody.r_FB_B = translatingBody.r_FP_B;
+            translatingBody->r_F0P_B = translatingBody->r_F0P_P;
+            translatingBody->r_FP_B = translatingBody->r_F0P_B + translatingBody->r_FF0_B;
+            translatingBody->r_FB_B = translatingBody->r_FP_B;
         } else {
-            translatingBody.r_F0P_B = this->translatingBodyVec[i-1].dcm_FB.transpose() * translatingBody.r_F0P_P;
-            translatingBody.r_FP_B = translatingBody.r_F0P_B + translatingBody.r_FF0_B;
-            translatingBody.r_FB_B = translatingBody.r_FP_B + this->translatingBodyVec[i-1].r_FB_B;
+            translatingBody->r_F0P_B = this->translatingBodyVec[i-1]->dcm_FB.transpose() * translatingBody->r_F0P_P;
+            translatingBody->r_FP_B = translatingBody->r_F0P_B + translatingBody->r_FF0_B;
+            translatingBody->r_FB_B = translatingBody->r_FP_B + this->translatingBodyVec[i-1]->r_FB_B;
         }
-        translatingBody.r_FcB_B = translatingBody.r_FcF_B + translatingBody.r_FB_B;
-        this->effProps.rEff_CB_B += translatingBody.mass * translatingBody.r_FcB_B;
+        translatingBody->r_FcB_B = translatingBody->r_FcF_B + translatingBody->r_FB_B;
+        this->effProps.rEff_CB_B += translatingBody->mass * translatingBody->r_FcB_B;
 
         // Find the inertia of the bodies about point B
-        translatingBody.rTilde_FcB_B = eigenTilde(translatingBody.r_FcB_B);
-        translatingBody.IPntFc_B = translatingBody.dcm_FB.transpose() * translatingBody.IPntFc_F * translatingBody.dcm_FB;
-        this->effProps.IEffPntB_B += translatingBody.IPntFc_B - translatingBody.mass * translatingBody.rTilde_FcB_B * translatingBody.rTilde_FcB_B;
+        translatingBody->rTilde_FcB_B = eigenTilde(translatingBody->r_FcB_B);
+        translatingBody->IPntFc_B = translatingBody->dcm_FB.transpose() * translatingBody->IPntFc_F * translatingBody->dcm_FB;
+        this->effProps.IEffPntB_B += translatingBody->IPntFc_B - translatingBody->mass * translatingBody->rTilde_FcB_B * translatingBody->rTilde_FcB_B;
 
         // Find rPrime_FcB_B
-        translatingBody.rPrime_FcF_B = Eigen::Vector3d::Zero();
-        translatingBody.rPrime_FF0_B = translatingBody.rhoDot * translatingBody.fHat_B;
-        translatingBody.rPrime_FP_B = translatingBody.rPrime_FF0_B;
+        translatingBody->rPrime_FcF_B = Eigen::Vector3d::Zero();
+        translatingBody->rPrime_FF0_B = translatingBody->rhoDot * translatingBody->fHat_B;
+        translatingBody->rPrime_FP_B = translatingBody->rPrime_FF0_B;
         if (i == 0) {
-            translatingBody.rPrime_FB_B = translatingBody.rPrime_FP_B;
+            translatingBody->rPrime_FB_B = translatingBody->rPrime_FP_B;
         } else {
-            translatingBody.rPrime_FB_B = translatingBody.rPrime_FP_B + this->translatingBodyVec[i-1].rPrime_FB_B;
+            translatingBody->rPrime_FB_B = translatingBody->rPrime_FP_B + this->translatingBodyVec[i-1]->rPrime_FB_B;
         }
-        translatingBody.rPrime_FcB_B = translatingBody.rPrime_FcF_B + translatingBody.rPrime_FB_B;
-        this->effProps.rEffPrime_CB_B += translatingBody.mass * translatingBody.rPrime_FcB_B;
+        translatingBody->rPrime_FcB_B = translatingBody->rPrime_FcF_B + translatingBody->rPrime_FB_B;
+        this->effProps.rEffPrime_CB_B += translatingBody->mass * translatingBody->rPrime_FcB_B;
 
         // Find the body-frame time derivative of the inertia of each arm and the entire spacecraft
-        translatingBody.IPrimePntFc_B = Eigen::Matrix3d::Zero();
-        Eigen::Matrix3d rPrimeTilde_FcB_B = eigenTilde(translatingBody.rPrime_FcB_B);
-        this->effProps.IEffPrimePntB_B += translatingBody.IPrimePntFc_B - translatingBody.mass * (rPrimeTilde_FcB_B * translatingBody.rTilde_FcB_B + translatingBody.rTilde_FcB_B * rPrimeTilde_FcB_B);
+        translatingBody->IPrimePntFc_B = Eigen::Matrix3d::Zero();
+        Eigen::Matrix3d rPrimeTilde_FcB_B = eigenTilde(translatingBody->rPrime_FcB_B);
+        this->effProps.IEffPrimePntB_B += translatingBody->IPrimePntFc_B - translatingBody->mass * (rPrimeTilde_FcB_B * translatingBody->rTilde_FcB_B + translatingBody->rTilde_FcB_B * rPrimeTilde_FcB_B);
 
         i++;
     }
@@ -286,7 +293,7 @@ void linearTranslationNDOFStateEffector::updateEffectorMassProps(double integTim
 
 /*! This method allows the TB state effector to give its contributions to the matrices needed for the back-sub
  method */
-void linearTranslationNDOFStateEffector::updateContributions(double integTime, BackSubMatrices & backSubContr, Eigen::Vector3d sigma_BN, Eigen::Vector3d omega_BN_B, Eigen::Vector3d g_N)
+void LinearTranslationNDOFStateEffector::updateContributions(double integTime, BackSubMatrices & backSubContr, Eigen::Vector3d sigma_BN, Eigen::Vector3d omega_BN_B, Eigen::Vector3d g_N)
 {
     // Find the DCM from N to B frames
     this->sigma_BN = sigma_BN;
@@ -311,50 +318,50 @@ void linearTranslationNDOFStateEffector::updateContributions(double integTime, B
 }
 
 /*! This method compute MRho for back-sub */
-void linearTranslationNDOFStateEffector::computeMRho(Eigen::MatrixXd& MRho)
+void LinearTranslationNDOFStateEffector::computeMRho(Eigen::MatrixXd& MRho)
 {
     for (int n = 0; n<this->N; n++) {
         for (int i = 0; i<this->N; i++) {
             MRho(n,i) = 0.0;
-            if ((this->translatingBodyVec[n].isAxisLocked || this->translatingBodyVec[i].isAxisLocked) && n != i)
+            if ((this->translatingBodyVec[n]->isAxisLocked || this->translatingBodyVec[i]->isAxisLocked) && n != i)
                 continue;
             for (int j = (i<=n) ? n : i; j<this->N; j++) {
-                MRho(n,i) += this->translatingBodyVec[n].fHat_B.transpose() * this->translatingBodyVec[j].mass
-                    * this->translatingBodyVec[i].fHat_B;
+                MRho(n,i) += this->translatingBodyVec[n]->fHat_B.transpose() * this->translatingBodyVec[j]->mass
+                    * this->translatingBodyVec[i]->fHat_B;
             }
         }
     }
 }
 
 /*! This method compute ARhoStar for back-sub */
-void linearTranslationNDOFStateEffector::computeARhoStar(Eigen::MatrixXd& ARhoStar)
+void LinearTranslationNDOFStateEffector::computeARhoStar(Eigen::MatrixXd& ARhoStar)
 {
     for (int n = 0; n<this->N; n++) {
-        if (this->translatingBodyVec[n].isAxisLocked)
+        if (this->translatingBodyVec[n]->isAxisLocked)
             continue;
         for (int i = n; i<this->N; i++) {
-            ARhoStar.row(n) -= this->translatingBodyVec[n].fHat_B.transpose() * this->translatingBodyVec[i].mass;
+            ARhoStar.row(n) -= this->translatingBodyVec[n]->fHat_B.transpose() * this->translatingBodyVec[i]->mass;
         }
     }
 }
 
 /*! This method compute BRhoStar for back-sub */
-void linearTranslationNDOFStateEffector::computeBRhoStar(Eigen::MatrixXd& BRhoStar)
+void LinearTranslationNDOFStateEffector::computeBRhoStar(Eigen::MatrixXd& BRhoStar)
 {
     for (int n = 0; n<this->N; n++) {
-        if (this->translatingBodyVec[n].isAxisLocked)
+        if (this->translatingBodyVec[n]->isAxisLocked)
             continue;
         for (int i = n; i<this->N; i++) {
-            Eigen::Vector3d r_FciB_B = this->translatingBodyVec[i].r_FcB_B;
+            Eigen::Vector3d r_FciB_B = this->translatingBodyVec[i]->r_FcB_B;
             Eigen::Matrix3d rTilde_FciB_B = eigenTilde(r_FciB_B);
 
-            BRhoStar.row(n) += this->translatingBodyVec[n].fHat_B.transpose() * this->translatingBodyVec[i].mass * rTilde_FciB_B;
+            BRhoStar.row(n) += this->translatingBodyVec[n]->fHat_B.transpose() * this->translatingBodyVec[i]->mass * rTilde_FciB_B;
         }
     }
 }
 
 /*! This method compute CRhoStar for back-sub */
-void linearTranslationNDOFStateEffector::computeCRhoStar(Eigen::VectorXd& CRhoStar,
+void LinearTranslationNDOFStateEffector::computeCRhoStar(Eigen::VectorXd& CRhoStar,
                                                       const Eigen::Vector3d& g_N)
 {
     Eigen::Matrix3d omegaTilde_BN_B = eigenTilde(this->omega_BN_B);
@@ -365,50 +372,50 @@ void linearTranslationNDOFStateEffector::computeCRhoStar(Eigen::VectorXd& CRhoSt
     Eigen::Vector3d F_g = Eigen::Vector3d::Zero().transpose();
 
     for (int n = 0; n<this->N; n++) {
-        if (this->translatingBodyVec[n].isAxisLocked)
+        if (this->translatingBodyVec[n]->isAxisLocked)
             continue;
-        CRhoStar(n, 0) = this->translatingBodyVec[n].u
-                           - this->translatingBodyVec[n].k * (this->translatingBodyVec[n].rho -
-                           this->translatingBodyVec[n].rhoRef) - this->translatingBodyVec[n].c *
-                           (this->translatingBodyVec[n].rhoDot - this->translatingBodyVec[n].rhoDotRef);
+        CRhoStar(n, 0) = this->translatingBodyVec[n]->u
+                           - this->translatingBodyVec[n]->k * (this->translatingBodyVec[n]->rho -
+                           this->translatingBodyVec[n]->rhoRef) - this->translatingBodyVec[n]->c *
+                           (this->translatingBodyVec[n]->rhoDot - this->translatingBodyVec[n]->rhoDotRef);
         for (int i = n; i<this->N; i++) {
-            Eigen::Vector3d r_FciB_B = this->translatingBodyVec[i].r_FcB_B;
-            Eigen::Vector3d rPrime_FciB_B = this->translatingBodyVec[i].rPrime_FcB_B;
+            Eigen::Vector3d r_FciB_B = this->translatingBodyVec[i]->r_FcB_B;
+            Eigen::Vector3d rPrime_FciB_B = this->translatingBodyVec[i]->rPrime_FcB_B;
 
-            F_g = this->translatingBodyVec[i].mass * g_B;
-            CRhoStar(n, 0) += this->translatingBodyVec[n].fHat_B.transpose() * (F_g - this->translatingBodyVec[i].mass *
+            F_g = this->translatingBodyVec[i]->mass * g_B;
+            CRhoStar(n, 0) += this->translatingBodyVec[n]->fHat_B.transpose() * (F_g - this->translatingBodyVec[i]->mass *
                               (omegaTilde_BN_B * omegaTilde_BN_B * r_FciB_B + 2 * omegaTilde_BN_B * rPrime_FciB_B));
         }
     }
 }
 
 /*! This method computes the back-sub contributions of the system */
-void linearTranslationNDOFStateEffector::computeBackSubContributions(BackSubMatrices& backSubContr) const
+void LinearTranslationNDOFStateEffector::computeBackSubContributions(BackSubMatrices& backSubContr) const
 {
     Eigen::Matrix3d omegaTilde_BN_B = eigenTilde(this->omega_BN_B);
 
     for (int i = 0; i<this->N; i++) {
-    Eigen::Matrix3d rTilde_FciB_B = eigenTilde(this->translatingBodyVec[i].r_FcB_B);
-    Eigen::Vector3d rPrime_FciB_B = this->translatingBodyVec[i].rPrime_FcB_B;
-    backSubContr.vecRot -= this->translatingBodyVec[i].mass * omegaTilde_BN_B * rTilde_FciB_B * rPrime_FciB_B;
+    Eigen::Matrix3d rTilde_FciB_B = eigenTilde(this->translatingBodyVec[i]->r_FcB_B);
+    Eigen::Vector3d rPrime_FciB_B = this->translatingBodyVec[i]->rPrime_FcB_B;
+    backSubContr.vecRot -= this->translatingBodyVec[i]->mass * omegaTilde_BN_B * rTilde_FciB_B * rPrime_FciB_B;
         for (int j = i; j < this->N; j++) {
-            Eigen::Matrix3d rTilde_FcjB_B = eigenTilde(this->translatingBodyVec[j].r_FcB_B);
+            Eigen::Matrix3d rTilde_FcjB_B = eigenTilde(this->translatingBodyVec[j]->r_FcB_B);
 
             // Translation contributions
-            backSubContr.matrixA += this->translatingBodyVec[j].mass *  this->translatingBodyVec[i].fHat_B * this->ARho.row(i);
-            backSubContr.matrixB += this->translatingBodyVec[j].mass *  this->translatingBodyVec[i].fHat_B * this->BRho.row(i);
-            backSubContr.vecTrans -= this->translatingBodyVec[j].mass * this->translatingBodyVec[i].fHat_B * this->CRho.row(i);
+            backSubContr.matrixA += this->translatingBodyVec[j]->mass *  this->translatingBodyVec[i]->fHat_B * this->ARho.row(i);
+            backSubContr.matrixB += this->translatingBodyVec[j]->mass *  this->translatingBodyVec[i]->fHat_B * this->BRho.row(i);
+            backSubContr.vecTrans -= this->translatingBodyVec[j]->mass * this->translatingBodyVec[i]->fHat_B * this->CRho.row(i);
 
             // Rotation contributions
-            backSubContr.matrixC += this->translatingBodyVec[j].mass * rTilde_FcjB_B * this->translatingBodyVec[i].fHat_B * this->ARho.row(i);
-            backSubContr.matrixD += this->translatingBodyVec[j].mass * rTilde_FcjB_B * this->translatingBodyVec[i].fHat_B * this->BRho.row(i);
-            backSubContr.vecRot -= this->translatingBodyVec[j].mass * rTilde_FcjB_B * this->translatingBodyVec[i].fHat_B * this->CRho.row(i);
+            backSubContr.matrixC += this->translatingBodyVec[j]->mass * rTilde_FcjB_B * this->translatingBodyVec[i]->fHat_B * this->ARho.row(i);
+            backSubContr.matrixD += this->translatingBodyVec[j]->mass * rTilde_FcjB_B * this->translatingBodyVec[i]->fHat_B * this->BRho.row(i);
+            backSubContr.vecRot -= this->translatingBodyVec[j]->mass * rTilde_FcjB_B * this->translatingBodyVec[i]->fHat_B * this->CRho.row(i);
         }
     }
 }
 
 /*! This method is used to find the derivatives for the TB stateEffector: rhoDDot and the kinematic derivative */
-void linearTranslationNDOFStateEffector::computeDerivatives(double integTime, Eigen::Vector3d rDDot_BN_N, Eigen::Vector3d omegaDot_BN_B, Eigen::Vector3d sigma_BN)
+void LinearTranslationNDOFStateEffector::computeDerivatives(double integTime, Eigen::Vector3d rDDot_BN_N, Eigen::Vector3d omegaDot_BN_B, Eigen::Vector3d sigma_BN)
 {
     // Find rDDotLoc_BN_B
     const Eigen::Vector3d& rDDotLocal_BN_N = rDDot_BN_N;
@@ -421,7 +428,7 @@ void linearTranslationNDOFStateEffector::computeDerivatives(double integTime, Ei
 }
 
 /*! This method is for calculating the contributions of the TB state effector to the energy and momentum of the spacecraft */
-void linearTranslationNDOFStateEffector::updateEnergyMomContributions(double integTime,
+void LinearTranslationNDOFStateEffector::updateEnergyMomContributions(double integTime,
                                                                       Eigen::Vector3d & rotAngMomPntCContr_B,
                                                                       double & rotEnergyContr,
                                                                       Eigen::Vector3d omega_BN_B)
@@ -434,40 +441,40 @@ void linearTranslationNDOFStateEffector::updateEnergyMomContributions(double int
 
     for(auto& translatingBody: this->translatingBodyVec) {
         // Update omega_FN_B
-        translatingBody.omega_FN_B = this->omega_BN_B;
+        translatingBody->omega_FN_B = this->omega_BN_B;
 
         // Compute rDot_FcB_B
-        translatingBody.rDot_FcB_B = translatingBody.rPrime_FcB_B + omegaTilde_BN_B * translatingBody.r_FcB_B;
+        translatingBody->rDot_FcB_B = translatingBody->rPrime_FcB_B + omegaTilde_BN_B * translatingBody->r_FcB_B;
 
         // Find rotational angular momentum contribution from hub
-        rotAngMomPntCContr_B += translatingBody.IPntFc_B * translatingBody.omega_FN_B + translatingBody.mass * translatingBody.rTilde_FcB_B * translatingBody.rDot_FcB_B;
+        rotAngMomPntCContr_B += translatingBody->IPntFc_B * translatingBody->omega_FN_B + translatingBody->mass * translatingBody->rTilde_FcB_B * translatingBody->rDot_FcB_B;
 
         // Find rotational energy contribution from the hub
-        rotEnergyContr += 1.0 / 2.0 * translatingBody.omega_FN_B.dot(translatingBody.IPntFc_B * translatingBody.omega_FN_B)
-                        + 1.0 / 2.0 * translatingBody.mass * translatingBody.rDot_FcB_B.dot(translatingBody.rDot_FcB_B)
-                        + 1.0 / 2.0 * translatingBody.k * (translatingBody.rho - translatingBody.rhoRef) *
-                        (translatingBody.rho - translatingBody.rhoRef);
+        rotEnergyContr += 1.0 / 2.0 * translatingBody->omega_FN_B.dot(translatingBody->IPntFc_B * translatingBody->omega_FN_B)
+                        + 1.0 / 2.0 * translatingBody->mass * translatingBody->rDot_FcB_B.dot(translatingBody->rDot_FcB_B)
+                        + 1.0 / 2.0 * translatingBody->k * (translatingBody->rho - translatingBody->rhoRef) *
+                        (translatingBody->rho - translatingBody->rhoRef);
     }
 }
 
 /*! This method computes the translating body states relative to the inertial frame */
-void linearTranslationNDOFStateEffector::computeTranslatingBodyInertialStates()
+void LinearTranslationNDOFStateEffector::computeTranslatingBodyInertialStates()
 {
     for(auto& translatingBody: this->translatingBodyVec) {
         // Compute the rotational properties
         Eigen::Matrix3d dcm_FN;
-        dcm_FN = translatingBody.dcm_FB * this->dcm_BN;
-        translatingBody.sigma_FN = eigenMRPd2Vector3d(eigenC2MRP(dcm_FN));
-        translatingBody.omega_FN_F = translatingBody.dcm_FB.transpose().transpose() * translatingBody.omega_FN_B;
+        dcm_FN = translatingBody->dcm_FB * this->dcm_BN;
+        translatingBody->sigma_FN = eigenMRPd2Vector3d(eigenC2MRP(dcm_FN));
+        translatingBody->omega_FN_F = translatingBody->dcm_FB.transpose().transpose() * translatingBody->omega_FN_B;
 
         // Compute the translation properties
-        translatingBody.r_FcN_N = (Eigen::Vector3d)*this->inertialPositionProperty + this->dcm_BN.transpose() * translatingBody.r_FcB_B;
-        translatingBody.v_FcN_N = (Eigen::Vector3d)*this->inertialVelocityProperty + this->dcm_BN.transpose() * translatingBody.rDot_FcB_B;
+        translatingBody->r_FcN_N = (Eigen::Vector3d)*this->inertialPositionProperty + this->dcm_BN.transpose() * translatingBody->r_FcB_B;
+        translatingBody->v_FcN_N = (Eigen::Vector3d)*this->inertialVelocityProperty + this->dcm_BN.transpose() * translatingBody->rDot_FcB_B;
     }
 }
 
 /*! This method is used so that the simulation will ask TB to update messages */
-void linearTranslationNDOFStateEffector::UpdateState(uint64_t CurrentSimNanos)
+void LinearTranslationNDOFStateEffector::UpdateState(uint64_t CurrentSimNanos)
 {
     this->readInputMessages();
     this->computeTranslatingBodyInertialStates();

{bsk-2.8.23 → bsk-2.8.25}/src/simulation/dynamics/linearTranslationalBodies/linearTranslationBodiesNDOF/linearTranslationNDOFStateEffector.h

@@ -34,7 +34,7 @@
 #include "architecture/messaging/messaging.h"
 
 /*! @brief translating body structure */
-struct translatingBody {
+struct TranslatingBody {
 public:
     /** setter for `mass` property */
     void setMass(double mass);
@@ -79,7 +79,7 @@ public:
     Eigen::Matrix3d getDCM_FP() const {return dcm_FP;};
 
 private:
-    friend class linearTranslationNDOFStateEffector;
+    friend class LinearTranslationNDOFStateEffector;
 
     // user-defined properties
     double mass = 0.0;             //!< [kg] mass of translating arm
@@ -135,11 +135,11 @@ private:
 };
 
 /*! @brief translating body state effector class */
-class linearTranslationNDOFStateEffector: public StateEffector, public SysModel {
+class LinearTranslationNDOFStateEffector: public StateEffector, public SysModel {
 public:
 
-    linearTranslationNDOFStateEffector();         //!< -- Constructor
-    ~linearTranslationNDOFStateEffector() final;  //!< -- Destructor
+    LinearTranslationNDOFStateEffector();         //!< -- Constructor
+    ~LinearTranslationNDOFStateEffector() final;  //!< -- Destructor
 
     std::vector<Message<LinearTranslationRigidBodyMsgPayload>*> translatingBodyOutMsgs;       //!< vector of state output messages
     std::vector<Message<SCStatesMsgPayload>*> translatingBodyConfigLogOutMsgs;                //!< vector of translating body state config log messages
@@ -148,7 +148,9 @@ public:
     ReadFunctor<ArrayEffectorLockMsgPayload> motorLockInMsg;          //!< -- (optional) motor lock input message name
 
     /** method for adding a new translating body */
-    void addTranslatingBody(translatingBody const& newBody);
+    void addTranslatingBody(const std::shared_ptr<TranslatingBody> newBody);
+    /** method for getting an indexed translating body */
+    std::shared_ptr<TranslatingBody> getTranslatingBody(uint64_t index);
     /** setter for `nameOfRhoState` property */
     void setNameOfRhoState(const std::string& nameOfRhoState) { this->nameOfRhoState = nameOfRhoState; };
     /** setter for `nameOfRhoDotState` property */
@@ -161,7 +163,7 @@ public:
 private:
     static uint64_t effectorID;    //!< [] ID number of this effector
     int N = 0;    //!< -- number of translating body axes defined in the system
-    std::vector<translatingBody> translatingBodyVec; //!< -- vector of TB effector structs
+    std::vector<std::shared_ptr<TranslatingBody>> translatingBodyVec; //!< -- vector of TB effector structs
 
     // Terms needed for back substitution
     Eigen::MatrixXd ARho;     //!< -- rDDot_BN term for back substitution