applyed CppStyle Format

mission/controller/AcsController.cpp

@@ -125,19 +125,17 @@ void AcsController::performControlOperation() {
   bool magMomMtqValid = false;
   if (validMekf == returnvalue::OK) {
     safeCtrl.safeMekf(now, mekfData.quatMekf.value, mekfData.quatMekf.isValid(),
-                        mgmDataProcessed.magIgrfModel.value,
-                        mgmDataProcessed.magIgrfModel.isValid(), susDataProcessed.sunIjkModel.value,
-                        susDataProcessed.isValid(), mekfData.satRotRateMekf.value,
-                        mekfData.satRotRateMekf.isValid(), sunTargetDir, satRateSafe, &errAng,
-                        magMomMtq, &magMomMtqValid);
+                      mgmDataProcessed.magIgrfModel.value, mgmDataProcessed.magIgrfModel.isValid(),
+                      susDataProcessed.sunIjkModel.value, susDataProcessed.isValid(),
+                      mekfData.satRotRateMekf.value, mekfData.satRotRateMekf.isValid(),
+                      sunTargetDir, satRateSafe, &errAng, magMomMtq, &magMomMtqValid);
   } else {
     safeCtrl.safeNoMekf(
         now, susDataProcessed.susVecTot.value, susDataProcessed.susVecTot.isValid(),
-          susDataProcessed.susVecTotDerivative.value,
-          susDataProcessed.susVecTotDerivative.isValid(), mgmDataProcessed.mgmVecTot.value,
-          mgmDataProcessed.mgmVecTot.isValid(), mgmDataProcessed.mgmVecTotDerivative.value,
-          mgmDataProcessed.mgmVecTotDerivative.isValid(), sunTargetDir, satRateSafe, &errAng,
-          magMomMtq, &magMomMtqValid);
+        susDataProcessed.susVecTotDerivative.value, susDataProcessed.susVecTotDerivative.isValid(),
+        mgmDataProcessed.mgmVecTot.value, mgmDataProcessed.mgmVecTot.isValid(),
+        mgmDataProcessed.mgmVecTotDerivative.value, mgmDataProcessed.mgmVecTotDerivative.isValid(),
+        sunTargetDir, satRateSafe, &errAng, magMomMtq, &magMomMtqValid);
   }
 
   double dipolCmdUnits[3] = {0, 0, 0};
@@ -209,9 +207,9 @@ void AcsController::performControlOperation() {
                      &mekfData, &validMekf);
 
   double magMomMtq[3] = {0, 0, 0};
-    detumble.bDotLaw(
-        mgmDataProcessed.mgmVecTotDerivative.value, mgmDataProcessed.mgmVecTotDerivative.isValid(),
-        mgmDataProcessed.mgmVecTot.value, mgmDataProcessed.mgmVecTot.isValid(), magMomMtq);
+  detumble.bDotLaw(mgmDataProcessed.mgmVecTotDerivative.value,
+                   mgmDataProcessed.mgmVecTotDerivative.isValid(), mgmDataProcessed.mgmVecTot.value,
+                   mgmDataProcessed.mgmVecTot.isValid(), magMomMtq);
   double dipolCmdUnits[3] = {0, 0, 0};
   actuatorCmd.cmdDipolMtq(magMomMtq, dipolCmdUnits);
 
@@ -284,16 +282,21 @@ void AcsController::performControlOperation() {
     case SUBMODE_IDLE:
       guidance.sunQuatPtg(&sensorValues, &mekfData, &susDataProcessed, &gpsDataProcessed, now,
                           targetQuat, refSatRate);
-        std::memcpy(quatRef, acsParameters.targetModeControllerParameters.quatRef, 4 * sizeof(double));
+      std::memcpy(quatRef, acsParameters.targetModeControllerParameters.quatRef,
+                  4 * sizeof(double));
       enableAntiStiction = acsParameters.targetModeControllerParameters.enableAntiStiction;
-        guidance.comparePtg(targetQuat, &mekfData, quatRef, refSatRate, quatErrorComplete, quatError, deltaRate);
-        ptgCtrl.ptgLaw(&acsParameters.targetModeControllerParameters, quatError, deltaRate, *rwPseudoInv, torquePtgRws);
-        ptgCtrl.ptgNullspace(&acsParameters.targetModeControllerParameters,
-                    &(sensorValues.rw1Set.currSpeed.value), &(sensorValues.rw2Set.currSpeed.value),
-                    &(sensorValues.rw3Set.currSpeed.value), &(sensorValues.rw4Set.currSpeed.value), rwTrqNs);
+      guidance.comparePtg(targetQuat, &mekfData, quatRef, refSatRate, quatErrorComplete, quatError,
+                          deltaRate);
+      ptgCtrl.ptgLaw(&acsParameters.targetModeControllerParameters, quatError, deltaRate,
+                     *rwPseudoInv, torquePtgRws);
+      ptgCtrl.ptgNullspace(
+          &acsParameters.targetModeControllerParameters, &(sensorValues.rw1Set.currSpeed.value),
+          &(sensorValues.rw2Set.currSpeed.value), &(sensorValues.rw3Set.currSpeed.value),
+          &(sensorValues.rw4Set.currSpeed.value), rwTrqNs);
       VectorOperations<double>::add(torquePtgRws, rwTrqNs, torqueRws, 4);
       actuatorCmd.scalingTorqueRws(torqueRws, torqueRwsScaled);
-        ptgCtrl.ptgDesaturation(&acsParameters.targetModeControllerParameters, mgmDataProcessed.mgmVecTot.value,
+      ptgCtrl.ptgDesaturation(
+          &acsParameters.targetModeControllerParameters, mgmDataProcessed.mgmVecTot.value,
           mgmDataProcessed.mgmVecTot.isValid(), mekfData.satRotRateMekf.value,
           &(sensorValues.rw1Set.currSpeed.value), &(sensorValues.rw2Set.currSpeed.value),
           &(sensorValues.rw3Set.currSpeed.value), &(sensorValues.rw4Set.currSpeed.value), mgtDpDes);
@@ -301,36 +304,46 @@ void AcsController::performControlOperation() {
       break;
 
     case SUBMODE_PTG_TARGET:
-        guidance.targetQuatPtgThreeAxes(&sensorValues, &gpsDataProcessed, &mekfData, now,
-                                        targetQuat, refSatRate);
-        std::memcpy(quatRef, acsParameters.targetModeControllerParameters.quatRef, 4 * sizeof(double));
+      guidance.targetQuatPtgThreeAxes(&sensorValues, &gpsDataProcessed, &mekfData, now, targetQuat,
+                                      refSatRate);
+      std::memcpy(quatRef, acsParameters.targetModeControllerParameters.quatRef,
+                  4 * sizeof(double));
       enableAntiStiction = acsParameters.targetModeControllerParameters.enableAntiStiction;
-        guidance.comparePtg(targetQuat, &mekfData, quatRef, refSatRate, quatErrorComplete, quatError, deltaRate);
-        ptgCtrl.ptgLaw(&acsParameters.targetModeControllerParameters, quatError, deltaRate, *rwPseudoInv, torquePtgRws);
-        ptgCtrl.ptgNullspace(&acsParameters.targetModeControllerParameters,
-                    &(sensorValues.rw1Set.currSpeed.value), &(sensorValues.rw2Set.currSpeed.value),
-                    &(sensorValues.rw3Set.currSpeed.value), &(sensorValues.rw4Set.currSpeed.value), rwTrqNs);
+      guidance.comparePtg(targetQuat, &mekfData, quatRef, refSatRate, quatErrorComplete, quatError,
+                          deltaRate);
+      ptgCtrl.ptgLaw(&acsParameters.targetModeControllerParameters, quatError, deltaRate,
+                     *rwPseudoInv, torquePtgRws);
+      ptgCtrl.ptgNullspace(
+          &acsParameters.targetModeControllerParameters, &(sensorValues.rw1Set.currSpeed.value),
+          &(sensorValues.rw2Set.currSpeed.value), &(sensorValues.rw3Set.currSpeed.value),
+          &(sensorValues.rw4Set.currSpeed.value), rwTrqNs);
       VectorOperations<double>::add(torquePtgRws, rwTrqNs, torqueRws, 4);
       actuatorCmd.scalingTorqueRws(torqueRws, torqueRwsScaled);
-        ptgCtrl.ptgDesaturation(&acsParameters.targetModeControllerParameters, mgmDataProcessed.mgmVecTot.value,
+      ptgCtrl.ptgDesaturation(
+          &acsParameters.targetModeControllerParameters, mgmDataProcessed.mgmVecTot.value,
           mgmDataProcessed.mgmVecTot.isValid(), mekfData.satRotRateMekf.value,
           &(sensorValues.rw1Set.currSpeed.value), &(sensorValues.rw2Set.currSpeed.value),
           &(sensorValues.rw3Set.currSpeed.value), &(sensorValues.rw4Set.currSpeed.value), mgtDpDes);
       break;
 
     case SUBMODE_PTG_TARGET_GS:
-        guidance.targetQuatPtgGs(&sensorValues, &mekfData, &susDataProcessed, &gpsDataProcessed,
-                                 now, targetQuat, refSatRate);
-        std::memcpy(quatRef, acsParameters.targetModeControllerParameters.quatRef, 4 * sizeof(double));
+      guidance.targetQuatPtgGs(&sensorValues, &mekfData, &susDataProcessed, &gpsDataProcessed, now,
+                               targetQuat, refSatRate);
+      std::memcpy(quatRef, acsParameters.targetModeControllerParameters.quatRef,
+                  4 * sizeof(double));
       enableAntiStiction = acsParameters.targetModeControllerParameters.enableAntiStiction;
-        guidance.comparePtg(targetQuat, &mekfData, quatRef, refSatRate, quatErrorComplete, quatError, deltaRate);
-        ptgCtrl.ptgLaw(&acsParameters.targetModeControllerParameters, quatError, deltaRate, *rwPseudoInv, torquePtgRws);
-        ptgCtrl.ptgNullspace(&acsParameters.targetModeControllerParameters,
-                    &(sensorValues.rw1Set.currSpeed.value), &(sensorValues.rw2Set.currSpeed.value),
-                    &(sensorValues.rw3Set.currSpeed.value), &(sensorValues.rw4Set.currSpeed.value), rwTrqNs);
+      guidance.comparePtg(targetQuat, &mekfData, quatRef, refSatRate, quatErrorComplete, quatError,
+                          deltaRate);
+      ptgCtrl.ptgLaw(&acsParameters.targetModeControllerParameters, quatError, deltaRate,
+                     *rwPseudoInv, torquePtgRws);
+      ptgCtrl.ptgNullspace(
+          &acsParameters.targetModeControllerParameters, &(sensorValues.rw1Set.currSpeed.value),
+          &(sensorValues.rw2Set.currSpeed.value), &(sensorValues.rw3Set.currSpeed.value),
+          &(sensorValues.rw4Set.currSpeed.value), rwTrqNs);
       VectorOperations<double>::add(torquePtgRws, rwTrqNs, torqueRws, 4);
       actuatorCmd.scalingTorqueRws(torqueRws, torqueRwsScaled);
-        ptgCtrl.ptgDesaturation(&acsParameters.targetModeControllerParameters, mgmDataProcessed.mgmVecTot.value,
+      ptgCtrl.ptgDesaturation(
+          &acsParameters.targetModeControllerParameters, mgmDataProcessed.mgmVecTot.value,
           mgmDataProcessed.mgmVecTot.isValid(), mekfData.satRotRateMekf.value,
           &(sensorValues.rw1Set.currSpeed.value), &(sensorValues.rw2Set.currSpeed.value),
           &(sensorValues.rw3Set.currSpeed.value), &(sensorValues.rw4Set.currSpeed.value), mgtDpDes);
@@ -341,14 +354,18 @@ void AcsController::performControlOperation() {
                                      refSatRate);
       std::memcpy(quatRef, acsParameters.nadirModeControllerParameters.quatRef, 4 * sizeof(double));
       enableAntiStiction = acsParameters.nadirModeControllerParameters.enableAntiStiction;
-        guidance.comparePtg(targetQuat, &mekfData, quatRef, refSatRate, quatErrorComplete, quatError, deltaRate);
-        ptgCtrl.ptgLaw(&acsParameters.nadirModeControllerParameters, quatError, deltaRate, *rwPseudoInv, torquePtgRws);
-        ptgCtrl.ptgNullspace(&acsParameters.nadirModeControllerParameters,
-            &(sensorValues.rw1Set.currSpeed.value), &(sensorValues.rw2Set.currSpeed.value),
-            &(sensorValues.rw3Set.currSpeed.value), &(sensorValues.rw4Set.currSpeed.value), rwTrqNs);
+      guidance.comparePtg(targetQuat, &mekfData, quatRef, refSatRate, quatErrorComplete, quatError,
+                          deltaRate);
+      ptgCtrl.ptgLaw(&acsParameters.nadirModeControllerParameters, quatError, deltaRate,
+                     *rwPseudoInv, torquePtgRws);
+      ptgCtrl.ptgNullspace(
+          &acsParameters.nadirModeControllerParameters, &(sensorValues.rw1Set.currSpeed.value),
+          &(sensorValues.rw2Set.currSpeed.value), &(sensorValues.rw3Set.currSpeed.value),
+          &(sensorValues.rw4Set.currSpeed.value), rwTrqNs);
       VectorOperations<double>::add(torquePtgRws, rwTrqNs, torqueRws, 4);
       actuatorCmd.scalingTorqueRws(torqueRws, torqueRwsScaled);
-        ptgCtrl.ptgDesaturation(&acsParameters.nadirModeControllerParameters, mgmDataProcessed.mgmVecTot.value,
+      ptgCtrl.ptgDesaturation(
+          &acsParameters.nadirModeControllerParameters, mgmDataProcessed.mgmVecTot.value,
           mgmDataProcessed.mgmVecTot.isValid(), mekfData.satRotRateMekf.value,
           &(sensorValues.rw1Set.currSpeed.value), &(sensorValues.rw2Set.currSpeed.value),
           &(sensorValues.rw3Set.currSpeed.value), &(sensorValues.rw4Set.currSpeed.value), mgtDpDes);
@@ -356,16 +373,21 @@ void AcsController::performControlOperation() {
 
     case SUBMODE_PTG_INERTIAL:
       guidance.inertialQuatPtg(targetQuat, refSatRate);
-        std::memcpy(quatRef, acsParameters.inertialModeControllerParameters.quatRef, 4 * sizeof(double));
+      std::memcpy(quatRef, acsParameters.inertialModeControllerParameters.quatRef,
+                  4 * sizeof(double));
       enableAntiStiction = acsParameters.inertialModeControllerParameters.enableAntiStiction;
-        guidance.comparePtg(targetQuat, &mekfData, quatRef, refSatRate, quatErrorComplete, quatError, deltaRate);
-        ptgCtrl.ptgLaw(&acsParameters.inertialModeControllerParameters, quatError, deltaRate, *rwPseudoInv, torquePtgRws);
-        ptgCtrl.ptgNullspace(&acsParameters.inertialModeControllerParameters,
-            &(sensorValues.rw1Set.currSpeed.value), &(sensorValues.rw2Set.currSpeed.value),
-            &(sensorValues.rw3Set.currSpeed.value), &(sensorValues.rw4Set.currSpeed.value), rwTrqNs);
+      guidance.comparePtg(targetQuat, &mekfData, quatRef, refSatRate, quatErrorComplete, quatError,
+                          deltaRate);
+      ptgCtrl.ptgLaw(&acsParameters.inertialModeControllerParameters, quatError, deltaRate,
+                     *rwPseudoInv, torquePtgRws);
+      ptgCtrl.ptgNullspace(
+          &acsParameters.inertialModeControllerParameters, &(sensorValues.rw1Set.currSpeed.value),
+          &(sensorValues.rw2Set.currSpeed.value), &(sensorValues.rw3Set.currSpeed.value),
+          &(sensorValues.rw4Set.currSpeed.value), rwTrqNs);
       VectorOperations<double>::add(torquePtgRws, rwTrqNs, torqueRws, 4);
       actuatorCmd.scalingTorqueRws(torqueRws, torqueRwsScaled);
-        ptgCtrl.ptgDesaturation(&acsParameters.inertialModeControllerParameters, mgmDataProcessed.mgmVecTot.value,
+      ptgCtrl.ptgDesaturation(
+          &acsParameters.inertialModeControllerParameters, mgmDataProcessed.mgmVecTot.value,
           mgmDataProcessed.mgmVecTot.isValid(), mekfData.satRotRateMekf.value,
           &(sensorValues.rw1Set.currSpeed.value), &(sensorValues.rw2Set.currSpeed.value),
           &(sensorValues.rw3Set.currSpeed.value), &(sensorValues.rw4Set.currSpeed.value), mgtDpDes);
@@ -380,8 +402,7 @@ void AcsController::performControlOperation() {
     ptgCtrl.rwAntistiction(rwAvailable, rwSpeed, torqueRwsScaled);
   }
 
-    double cmdSpeedRws[4] = {0, 0, 0,
-                             0};  // Should be given to the actuator reaction wheel as input
+  double cmdSpeedRws[4] = {0, 0, 0, 0};  // Should be given to the actuator reaction wheel as input
   actuatorCmd.cmdSpeedToRws(&(sensorValues.rw1Set.currSpeed.value),
                             &(sensorValues.rw2Set.currSpeed.value),
                             &(sensorValues.rw3Set.currSpeed.value),
@@ -589,8 +610,7 @@ void AcsController::performControlOperation() {
                   3 * sizeof(float));
       mgmDataRaw.imtqRaw.setValid(sensorValues.imtqMgmSet.mtmRawNt.isValid());
       mgmDataRaw.actuationCalStatus.value = sensorValues.imtqMgmSet.coilActuationStatus.value;
-        mgmDataRaw.actuationCalStatus.setValid(
-            sensorValues.imtqMgmSet.coilActuationStatus.isValid());
+      mgmDataRaw.actuationCalStatus.setValid(sensorValues.imtqMgmSet.coilActuationStatus.isValid());
     }
   }
 }

mission/controller/acs/AcsParameters.h

@@ -816,7 +816,6 @@ class AcsParameters : public HasParametersIF {
   } safeModeControllerParameters;
 
   struct PointingLawParameters {
-
     double zeta = 0.3;
     double om = 0.3;
     double omMax = 1 * M_PI / 180;

mission/controller/acs/Guidance.cpp

@@ -42,7 +42,8 @@ void Guidance::targetQuatPtgSingleAxis(ACS::SensorValues *sensorValues, acsctrl:
   double targetCart[3] = {0, 0, 0};
 
   MathOperations<double>::cartesianFromLatLongAlt(
-      acsParameters.targetModeControllerParameters.latitudeTgt, acsParameters.targetModeControllerParameters.longitudeTgt,
+      acsParameters.targetModeControllerParameters.latitudeTgt,
+      acsParameters.targetModeControllerParameters.longitudeTgt,
       acsParameters.targetModeControllerParameters.altitudeTgt, targetCart);
 
   //	Position of the satellite in the earth/fixed frame via GPS
@@ -172,12 +173,12 @@ void Guidance::targetQuatPtgSingleAxis(ACS::SensorValues *sensorValues, acsctrl:
   }
 }
 
-void Guidance::refRotationRate(int8_t timeElapsedMax, timeval now, double quatInertialTarget[4], double *refSatRate) {
+void Guidance::refRotationRate(int8_t timeElapsedMax, timeval now, double quatInertialTarget[4],
+                               double *refSatRate) {
   //-------------------------------------------------------------------------------------
   //	Calculation of reference rotation rate
   //-------------------------------------------------------------------------------------
-  double timeElapsed =
-      now.tv_sec + now.tv_usec * pow(10, -6) -
+  double timeElapsed = now.tv_sec + now.tv_usec * pow(10, -6) -
                        (timeSavedQuaternion.tv_sec +
                         timeSavedQuaternion.tv_usec * pow((double)timeSavedQuaternion.tv_usec, -6));
   if (timeElapsed < timeElapsedMax) {
@@ -226,7 +227,8 @@ void Guidance::targetQuatPtgThreeAxes(ACS::SensorValues *sensorValues,
   double targetCart[3] = {0, 0, 0};
 
   MathOperations<double>::cartesianFromLatLongAlt(
-      acsParameters.targetModeControllerParameters.latitudeTgt, acsParameters.targetModeControllerParameters.longitudeTgt,
+      acsParameters.targetModeControllerParameters.latitudeTgt,
+      acsParameters.targetModeControllerParameters.longitudeTgt,
       acsParameters.targetModeControllerParameters.altitudeTgt, targetCart);
   //	Position of the satellite in the earth/fixed frame via GPS
   double posSatE[3] = {0, 0, 0};
@@ -307,7 +309,8 @@ void Guidance::targetQuatPtgGs(ACS::SensorValues *sensorValues, acsctrl::MekfDat
   double groundStationCart[3] = {0, 0, 0};
 
   MathOperations<double>::cartesianFromLatLongAlt(
-      acsParameters.targetModeControllerParameters.latitudeTgt, acsParameters.targetModeControllerParameters.longitudeTgt,
+      acsParameters.targetModeControllerParameters.latitudeTgt,
+      acsParameters.targetModeControllerParameters.longitudeTgt,
       acsParameters.targetModeControllerParameters.altitudeTgt, groundStationCart);
   //	Position of the satellite in the earth/fixed frame via GPS
   double posSatE[3] = {0, 0, 0};
@@ -588,13 +591,15 @@ void Guidance::quatNadirPtgThreeAxes(ACS::SensorValues *sensorValues,
 }
 
 void Guidance::inertialQuatPtg(double targetQuat[4], double refSatRate[3]) {
-  std::memcpy(targetQuat, acsParameters.inertialModeControllerParameters.tgtQuat, 4 * sizeof(double));
-  std::memcpy(refSatRate, acsParameters.inertialModeControllerParameters.refRotRate, 3 * sizeof(double));
+  std::memcpy(targetQuat, acsParameters.inertialModeControllerParameters.tgtQuat,
+              4 * sizeof(double));
+  std::memcpy(refSatRate, acsParameters.inertialModeControllerParameters.refRotRate,
+              3 * sizeof(double));
 }
 
-void Guidance::comparePtg(double targetQuat[4], acsctrl::MekfData *mekfData, double quatRef[4], double refSatRate[3],
-                          double quatErrorComplete[4], double quatError[3], double deltaRate[3]) {
-
+void Guidance::comparePtg(double targetQuat[4], acsctrl::MekfData *mekfData, double quatRef[4],
+                          double refSatRate[3], double quatErrorComplete[4], double quatError[3],
+                          double deltaRate[3]) {
   double satRate[3] = {0, 0, 0};
   std::memcpy(satRate, mekfData->satRotRateMekf.value, 3 * sizeof(double));
   VectorOperations<double>::subtract(satRate, refSatRate, deltaRate, 3);

mission/controller/acs/Guidance.h

@@ -58,10 +58,12 @@ class Guidance {
 
   // @note: compares target Quaternion and reference quaternion, also actual satellite rate and
   // desired
-  void comparePtg(double targetQuat[4], acsctrl::MekfData *mekfData, double quatRef[4], double refSatRate[3],
-                  double quatErrorComplete[4], double quatError[3], double deltaRate[3]);
+  void comparePtg(double targetQuat[4], acsctrl::MekfData *mekfData, double quatRef[4],
+                  double refSatRate[3], double quatErrorComplete[4], double quatError[3],
+                  double deltaRate[3]);
 
-  void refRotationRate(int8_t timeElapsedMax, timeval now, double quatInertialTarget[4], double *refSatRate);
+  void refRotationRate(int8_t timeElapsedMax, timeval now, double quatInertialTarget[4],
+                       double *refSatRate);
 
   //	@note: will give back the pseudoinverse matrix for the reaction wheel depending on the valid
   // reation wheel 	maybe can be done in "commanding.h"

mission/controller/acs/control/PtgCtrl.cpp

@@ -26,8 +26,9 @@ void PtgCtrl::loadAcsParameters(AcsParameters *acsParameters_) {
   rwMatrices = &(acsParameters_->rwMatrices);
 }
 
-void PtgCtrl::ptgLaw(AcsParameters::PointingLawParameters * pointingLawParameters, const double *qError, const double *deltaRate,
-                     const double *rwPseudoInv, double *torqueRws) {
+void PtgCtrl::ptgLaw(AcsParameters::PointingLawParameters *pointingLawParameters,
+                     const double *qError, const double *deltaRate, const double *rwPseudoInv,
+                     double *torqueRws) {
   //------------------------------------------------------------------------------------------------
   // Compute gain matrix K and P matrix
   //------------------------------------------------------------------------------------------------
@@ -106,7 +107,8 @@ void PtgCtrl::ptgLaw(AcsParameters::PointingLawParameters * pointingLawParameter
   VectorOperations<double>::mulScalar(torqueRws, -1, torqueRws, 4);
 }
 
-void PtgCtrl::ptgDesaturation(AcsParameters::PointingLawParameters * pointingLawParameters, double *magFieldEst, bool magFieldEstValid, double *satRate,
+void PtgCtrl::ptgDesaturation(AcsParameters::PointingLawParameters *pointingLawParameters,
+                              double *magFieldEst, bool magFieldEstValid, double *satRate,
                               int32_t *speedRw0, int32_t *speedRw1, int32_t *speedRw2,
                               int32_t *speedRw3, double *mgtDpDes) {
   if (!(magFieldEstValid) || !(pointingLawParameters->desatOn)) {
@@ -127,8 +129,8 @@ void PtgCtrl::ptgDesaturation(AcsParameters::PointingLawParameters * pointingLaw
   VectorOperations<double>::add(momentumSat, momentumRw, momentumTotal, 3);
   //	calculating momentum error
   double deltaMomentum[3] = {0, 0, 0};
-  VectorOperations<double>::subtract(
-      momentumTotal, pointingLawParameters->desatMomentumRef, deltaMomentum, 3);
+  VectorOperations<double>::subtract(momentumTotal, pointingLawParameters->desatMomentumRef,
+                                     deltaMomentum, 3);
   //	resulting magnetic dipole command
   double crossMomentumMagField[3] = {0, 0, 0};
   VectorOperations<double>::cross(deltaMomentum, magFieldEst, crossMomentumMagField);
@@ -137,7 +139,8 @@ void PtgCtrl::ptgDesaturation(AcsParameters::PointingLawParameters * pointingLaw
   VectorOperations<double>::mulScalar(crossMomentumMagField, factor, mgtDpDes, 3);
 }
 
-void PtgCtrl::ptgNullspace(AcsParameters::PointingLawParameters * pointingLawParameters, const int32_t *speedRw0, const int32_t *speedRw1,
+void PtgCtrl::ptgNullspace(AcsParameters::PointingLawParameters *pointingLawParameters,
+                           const int32_t *speedRw0, const int32_t *speedRw1,
                            const int32_t *speedRw2, const int32_t *speedRw3, double *rwTrqNs) {
   double speedRws[4] = {(double)*speedRw0, (double)*speedRw1, (double)*speedRw2, (double)*speedRw3};
   double wheelMomentum[4] = {0, 0, 0, 0};

mission/controller/acs/control/PtgCtrl.h

@@ -41,14 +41,16 @@ class PtgCtrl {
   /* @brief: Calculates the needed torque for the pointing control mechanism
    * @param: acsParameters_ Pointer to object which defines the ACS configuration parameters
    */
-  void ptgLaw(AcsParameters::PointingLawParameters * pointingLawParameters, const double *qError, const double *deltaRate,
-              const double *rwPseudoInv, double *torqueRws);
+  void ptgLaw(AcsParameters::PointingLawParameters *pointingLawParameters, const double *qError,
+              const double *deltaRate, const double *rwPseudoInv, double *torqueRws);
 
-  void ptgDesaturation(AcsParameters::PointingLawParameters * pointingLawParameters, double *magFieldEst,
-		  	  	  	   bool magFieldEstValid, double *satRate, int32_t *speedRw0, int32_t *speedRw1,
-					   int32_t *speedRw2, int32_t *speedRw3, double *mgtDpDes);
+  void ptgDesaturation(AcsParameters::PointingLawParameters *pointingLawParameters,
+                       double *magFieldEst, bool magFieldEstValid, double *satRate,
+                       int32_t *speedRw0, int32_t *speedRw1, int32_t *speedRw2, int32_t *speedRw3,
+                       double *mgtDpDes);
 
-  void ptgNullspace(AcsParameters::PointingLawParameters * pointingLawParameters, const int32_t *speedRw0, const int32_t *speedRw1, const int32_t *speedRw2,
+  void ptgNullspace(AcsParameters::PointingLawParameters *pointingLawParameters,
+                    const int32_t *speedRw0, const int32_t *speedRw1, const int32_t *speedRw2,
                     const int32_t *speedRw3, double *rwTrqNs);
 
   /* @brief: Commands the stiction torque in case wheel speed is to low