.. _program_listing_file_conversions_mean_osc_conversions.cc:

Program Listing for File mean_osc_conversions.cc
================================================

|exhale_lsh| :ref:`Return to documentation for file <file_conversions_mean_osc_conversions.cc>` (``conversions/mean_osc_conversions.cc``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #include "lupnt/conversions/mean_osc_conversions.h"
   
   #include "lupnt/conversions/state_conversions.h"
   
   namespace lupnt {
   
     // Mean and Osculating
     Vec6 MeanToOsculating(const Vec6 &coe_m, Real GM, Real J2) {
       Vec6 coe_o;
   
       if (J2 > 0) {
         // TODO: Implement the transformation from mean to osculating
         // Vec6 meanEquioe = ClassicalToEquinoctial(coe_m, GM);
         Vec6 oscEquioe;  // = MeanOscClosedEqui(meanEquioe, J2);
         coe_o = EquinoctialToClassical(oscEquioe, GM);
       } else {
         coe_o = coe_m;
       }
   
       return coe_o;
     }
   
     ClassicalOE MeanToOsculating(const ClassicalOE &coe_m, Real GM, Real J2) {
       return ClassicalOE(MeanToOsculating(Vec6(coe_m), GM, J2), coe_m.GetFrame());
     }
   
     Vec6 osc2mean_NRiterator(const Vec6 &osc_equi_elem, double tol) {
       Vec6 mean_equi_elem = osc_equi_elem;
       double R = 1.0;
       int niter = 0;
   
       while (std::abs(R) > tol) {
         niter++;
         Vec6 osc_loop;
         // std::tie(std::ignore, osc_loop, std::ignore) =
         // transformationmatrix_osc2mean_equinoctial(mean_equi_elem);
         Vec6 delta = osc_equi_elem - osc_loop;
         // R = delta.norm_inf(); // Assuming the library provides an infinity
         // norm function
         mean_equi_elem = mean_equi_elem + delta;
   
         if (niter > 100) {
           std::cout << "OscTMean iterations > 100" << std::endl;
           break;
         }
       }
   
       return mean_equi_elem;
     }
   
     Vec6 OsculatingToMean(const Vec6 &coe_o, Real GM, Real J2) {
       Vec6 coe_m;
       double tol = 1e-8;
   
       if (J2 > 0) {
         Vec6 eqoe_o = ClassicalToEquinoctial(coe_o, GM);
         Vec6 eqoe_m = osc2mean_NRiterator(eqoe_o, tol);
         coe_m = EquinoctialToClassical(eqoe_m, GM);
       } else {
         coe_m = coe_o;
       }
   
       return coe_m;
     }
   
     ClassicalOE OsculatingToMean(const ClassicalOE &coe_o, Real GM, Real J2) {
       return ClassicalOE(OsculatingToMean(Vec6(coe_o), GM, J2), coe_o.GetFrame());
     }
   
   }  // namespace lupnt