diff --git a/mission_analysis/mission_analysis_conf.xml b/mission_analysis/mission_analysis_conf.xml
index 4a0744917d78a960279c8aa8a1ae5d0651933015..3f259e88f9e9bbaa96f2689edc65bb4af382f282 100644
--- a/mission_analysis/mission_analysis_conf.xml
+++ b/mission_analysis/mission_analysis_conf.xml
@@ -39,10 +39,10 @@
         <log_file description="Specify the name of the log file">
 			<value>mission_analysis.log</value>
 		</log_file>
-        <inkscape_path description="Path to the inkscape application ('DEFAULT': Use inkscape from the UNICADO repo structure)">
+        <inkscape_path description="Path to inkscape (only needed if your executable is not part of system paths - otherwise unused)">
 			<value>DEFAULT</value>
 		</inkscape_path>
-        <gnuplot_path description="Path to the gnuplot application ('DEFAULT': Use gnuplot from the UNICADO repo structure)">
+        <gnuplot_path description="Path to gnuplot (only needed if your executable is not part of system paths - otherwise unused)">
 			<value>DEFAULT</value>
 		</gnuplot_path>
     </control_settings>
diff --git a/mission_analysis/src/libs/condition_methods/flight_conditions.cpp b/mission_analysis/src/libs/condition_methods/flight_conditions.cpp
index 234e44399f8efb39ec088d4d200ae5ea450b9642..56f5b01a301300fa122c7e8f17cc93cd9b8213bd 100644
--- a/mission_analysis/src/libs/condition_methods/flight_conditions.cpp
+++ b/mission_analysis/src/libs/condition_methods/flight_conditions.cpp
@@ -1,5 +1,5 @@
 /**
- * \file flight_conditions.cpp
+ * \file Flight_conditions.cpp
  * \author Gerrit Pauls (gerrit.pauls@tuhh.de)
  * \brief
  * \version 0.1
@@ -12,9 +12,9 @@
 
 #include "flight_conditions.h"
 
-/* Initialization of attributes of the flight_conditions object with the constructor */
-flight_conditions::flight_conditions(std::vector<mission_file_data_handler::mission_data_set>* mission_data,
-                                    operating_conditions* oc, aerodynamics* aero,
+/* Initialization of attributes of the Flight_conditions object with the constructor */
+Flight_conditions::Flight_conditions(std::vector<mission_file_data_handler::mission_data_set>* mission_data,
+                                    Operating_conditions* oc, aerodynamics* aero,
                                     atmosphere* atm, Multi_engine_propulsion* engine, const size_t& variable_camber_segment_quantity)
     :
     /* Initialization of mission and operating condition pointer */
@@ -91,15 +91,15 @@ flight_conditions::flight_conditions(std::vector<mission_file_data_handler::miss
 }
 
 /* Destructor of the flight conditions object */
-flight_conditions::~flight_conditions() {
+Flight_conditions::~Flight_conditions() {
 }
 
-void flight_conditions::update_operating_condition(const operating_conditions& oc) {
+void Flight_conditions::update_operating_condition(const Operating_conditions& oc) {
     this->operating_condition = &oc;
 }
 
 /* Set Initial flight conditions */
-void flight_conditions::set_initial_flight_track() {
+void Flight_conditions::set_initial_flight_track() {
     switch (this->mission_data->at(this->operating_condition->mission_step).mode) {
         case ACCELERATE:
         case FLCHANGE:
@@ -111,7 +111,7 @@ void flight_conditions::set_initial_flight_track() {
         case CLIMBCONSTCAS:
         case CLIMBTOCRUISE:
         case CLIMBTOSERVICECEILING:
-        case flight_conditions::DESCENT:
+        case Flight_conditions::DESCENT:
         case FREEFLIGHT: { // use kinetic energy to climb/descent
             this->glidepath_angle = asin((std::min(1., (this->thrust - this->drag) / this->aircraft_mass / G_FORCE)));
             this->ROC = sin(this->glidepath_angle) * this->TAS;
@@ -135,7 +135,7 @@ void flight_conditions::set_initial_flight_track() {
     }
 }
 
-void flight_conditions::set_initial_acceleration_factors(const double& braking_coefficient, const double& friction_coefficient, const double& wing_surface_area) {
+void Flight_conditions::set_initial_acceleration_factors(const double& braking_coefficient, const double& friction_coefficient, const double& wing_surface_area) {
     switch (this->mission_data->at(this->operating_condition->mission_step).mode) {
         case TAKEOFF:
         case LANDING: {
@@ -159,7 +159,7 @@ void flight_conditions::set_initial_acceleration_factors(const double& braking_c
     }
 }
 
-double flight_conditions::get_ground_run_acceleration(const double& thrust, const double& drag, const double& lift,
+double Flight_conditions::get_ground_run_acceleration(const double& thrust, const double& drag, const double& lift,
                                                     const double& weight, const double& minimum_acceleration, const double& friction_coefficient) {
     double acceleration_tmp(G_FORCE * ((thrust / weight - friction_coefficient) + (lift * friction_coefficient - drag) / weight));
     if (!std::isnan(minimum_acceleration) && fabs(acceleration_tmp) < fabs(minimum_acceleration)) {
@@ -168,7 +168,7 @@ double flight_conditions::get_ground_run_acceleration(const double& thrust, cons
     return acceleration_tmp;
 }
 
-void flight_conditions::set_initial_thrust() {
+void Flight_conditions::set_initial_thrust() {
     switch (this->mission_data->at(this->operating_condition->mission_step).mode) {
         case CRUISE:
         case CRUISECI:
@@ -197,8 +197,8 @@ void flight_conditions::set_initial_thrust() {
                             error_message << "Reduce drag.";
                             throwError(__FILE__, __func__, __LINE__, error_message.str());
                         } else {}
-                        const operating_conditions* oc_backup(this->operating_condition);
-                        operating_conditions oc_tmp(*(this->operating_condition));
+                        const Operating_conditions* oc_backup(this->operating_condition);
+                        Operating_conditions oc_tmp(*(this->operating_condition));
                         oc_tmp.rating = new_rating;
                         this->update_operating_condition(oc_tmp);
                         this->set_initial_thrust();
@@ -228,7 +228,7 @@ void flight_conditions::set_initial_thrust() {
                         this->rel_engine_availability * this->thrust_efficiency;
 }
 
-void flight_conditions::set_flight_track() {
+void Flight_conditions::set_flight_track() {
     switch (this->mission_data->at(this->operating_condition->mission_step).mode) {
         case ACCELERATE:
         case FLCHANGE:
@@ -270,7 +270,7 @@ void flight_conditions::set_flight_track() {
 }
 
 /* Update fligh conditions */
-void flight_conditions::set_acceleration_factors(const double& braking_coefficient, const double& friction_coefficient, const double& wing_surface_area) {
+void Flight_conditions::set_acceleration_factors(const double& braking_coefficient, const double& friction_coefficient, const double& wing_surface_area) {
     if ((this->mission_data->at(this->operating_condition->mission_step).mode == TAKEOFF ||
          this->mission_data->at(this->operating_condition->mission_step).mode == LANDING) &&
                 (accuracyCheck(this->delta_h, 0., ACCURACY_HIGH))) { //ground run
@@ -294,7 +294,7 @@ void flight_conditions::set_acceleration_factors(const double& braking_coefficie
     }
 }
 
-void flight_conditions::set_thrust() {
+void Flight_conditions::set_thrust() {
     double required_thrust(sin(this->mean_glidepath_angle) * this->end_aircraft_mass * G_FORCE + this->end_aircraft_mass * this->mean_acceleration + this->end_drag);
     switch (this->mission_data->at(this->operating_condition->mission_step).mode) {
         case CRUISE:
@@ -323,8 +323,8 @@ void flight_conditions::set_thrust() {
                             error_message << "Reduce drag.";
                             throwError(__FILE__, __func__, __LINE__, error_message.str());
                         } else {}
-                        const operating_conditions* oc_backup(this->operating_condition);
-                        operating_conditions oc_tmp(*(this->operating_condition));
+                        const Operating_conditions* oc_backup(this->operating_condition);
+                        Operating_conditions oc_tmp(*(this->operating_condition));
                         oc_tmp.rating = new_rating;
                         this->update_operating_condition(oc_tmp);
                         this->set_thrust();
@@ -354,7 +354,7 @@ void flight_conditions::set_thrust() {
                             this->rel_engine_availability * this->thrust_efficiency;
 }
 
-void flight_conditions::activate_spoilers() {
+void Flight_conditions::activate_spoilers() {
     switch (this->mission_data->at(this->operating_condition->mission_step).mode) {
         case CRUISE:
         case CRUISECI:
@@ -374,7 +374,7 @@ void flight_conditions::activate_spoilers() {
     }
 }
 
-void flight_conditions::update_end_mass(const bool& use_breguet) {
+void Flight_conditions::update_end_mass(const bool& use_breguet) {
     this->end_fuel_mass_flow =
         this->engine->get_aircraft_fuelflow(this->mission_data->at(this->operating_condition->mission_step).energy_carrier_id) * this->rel_engine_availability;
     this->mean_fuel_mass_flow = (this->fuel_mass_flow + this->end_fuel_mass_flow) / 2.;
@@ -388,7 +388,7 @@ void flight_conditions::update_end_mass(const bool& use_breguet) {
     this->end_aircraft_mass = this->aircraft_mass - this->step_fuel_mass;
 }
 
-void flight_conditions::set_way_and_time() {
+void Flight_conditions::set_way_and_time() {
     /* Accelerated motion:
      * NOTE: all velocity vectors are directed in flight direction (and with this also the final flight path vector)
      *       --> in the end the flight path vector must be corrected by track angle to get the range back
diff --git a/mission_analysis/src/libs/condition_methods/flight_conditions.h b/mission_analysis/src/libs/condition_methods/flight_conditions.h
index d6d2c3ee9516b64b6f2bb4e65ffeb2cbc7c9fa42..15ee5cd1769ca83af9e56ab2d91226456283300e 100644
--- a/mission_analysis/src/libs/condition_methods/flight_conditions.h
+++ b/mission_analysis/src/libs/condition_methods/flight_conditions.h
@@ -9,8 +9,8 @@
  *
  */
 
-#ifndef MISSION_ANALYSIS_SRC_LIBS_CONDITION_METHODS_FLIGHT_CONDITIONS_H_
-#define MISSION_ANALYSIS_SRC_LIBS_CONDITION_METHODS_FLIGHT_CONDITIONS_H_
+#ifndef MISSION_ANALYSIS_SRC_LIBS_CONDITION_METHODS_Flight_conditions_H_
+#define MISSION_ANALYSIS_SRC_LIBS_CONDITION_METHODS_Flight_conditions_H_
 
 #include <map>
 #include <memory>
@@ -25,12 +25,12 @@
 #include "../mission_file_data_handler/mission_file_data_handler.h"
 #include "../multi_engine_propulsion/multi_engine_propulsion.h"
 
-class operating_conditions;
+class Operating_conditions;
 class centerOfGravityShift;
 
 /** \brief Class for flight conditions
  */
-class flight_conditions {
+class Flight_conditions {
  public:
     /* Typedefs and Enums */
     enum missionMode {TAKEOFF = 1, ACCELERATE, CLIMBCONSTCAS, CLIMBTOCRUISE, CRUISE, DESCENT, APPROACH, DECELERATE, LANDING,
@@ -41,7 +41,7 @@ class flight_conditions {
 
     /* Objects */
     std::vector<mission_file_data_handler::mission_data_set>* mission_data; /**< reference to the mission data from mission XML */
-    const operating_conditions* operating_condition; /**< Constant pointer to an operating condition */
+    const Operating_conditions* operating_condition; /**< Constant pointer to an operating condition */
 
     atmosphere* atm;    /* pointer to given atmosphere */
     Multi_engine_propulsion* engine;     /* pointer to given engine */
@@ -114,7 +114,7 @@ class flight_conditions {
     bool engine_limit_reached; /**< Switch if the engine upper or lower operation limit is reached [-] */
 
     /* Constructor and destructor */
-    /** \brief Constructor for class flight_conditions
+    /** \brief Constructor for class Flight_conditions
      * \param mission_data: reference to the mission object
      * \param oc: const reference to a certain operating condition
      * \param aero: reference to an aerodnymic object
@@ -122,17 +122,17 @@ class flight_conditions {
      * \param eng: reference to an engine object
      * \param variable_camber_segment_quantity: const reference to the number of segments with variable camber [-]
      */
-    flight_conditions(std::vector<mission_file_data_handler::mission_data_set>* mission_data, operating_conditions* oc,
+    Flight_conditions(std::vector<mission_file_data_handler::mission_data_set>* mission_data, Operating_conditions* oc,
                         aerodynamics* aero, atmosphere* atm, Multi_engine_propulsion* eng, const size_t& variable_camber_segment_quantity);
-    /** \brief Destructor for class flight_conditions
+    /** \brief Destructor for class Flight_conditions
      */
-    virtual ~flight_conditions();
+    virtual ~Flight_conditions();
 
     /* Methods */
     /** \brief Function allows to adapt the engine rating from outside the flightCondition class
-     *  \param oc operating_conditions: const reference to a certain operating condition
+     *  \param oc Operating_conditions: const reference to a certain operating condition
      */
-    void update_operating_condition(const operating_conditions& oc);
+    void update_operating_condition(const Operating_conditions& oc);
     /** \brief Function calculates delta_x and delta_t
      *  \details the equations of constant and accelerated motion are used to get way and time values for the segment
      */
@@ -186,4 +186,4 @@ class flight_conditions {
     void update_end_mass(const bool& use_breguet = false);
 };
 
-#endif // MISSION_ANALYSIS_SRC_LIBS_CONDITION_METHODS_FLIGHT_CONDITIONS_H_
+#endif // MISSION_ANALYSIS_SRC_LIBS_CONDITION_METHODS_Flight_conditions_H_
diff --git a/mission_analysis/src/libs/condition_methods/operating_conditions.cpp b/mission_analysis/src/libs/condition_methods/operating_conditions.cpp
index bcbb8a0743efdf062661c8ea0685d37e1df394a4..9e66f6fbb1d7b2a892f908433655ca707b0666f7 100644
--- a/mission_analysis/src/libs/condition_methods/operating_conditions.cpp
+++ b/mission_analysis/src/libs/condition_methods/operating_conditions.cpp
@@ -1,5 +1,5 @@
 /**
- * \file operating_conditions.cpp
+ * \file Operating_conditions.cpp
  * \author Gerrit Pauls (gerrit.pauls@tuhh.de)
  * \brief
  * \version 0.1
@@ -13,8 +13,8 @@
 
 #include "../mission_file_data_handler/mission_file_data_handler.h"
 
-/* Initialization of attributes for the operating_conditions object with the constructor */
-operating_conditions::operating_conditions(std::vector<mission_file_data_handler::mission_data_set>* mission_data)
+/* Initialization of attributes for the Operating_conditions object with the constructor */
+Operating_conditions::Operating_conditions(std::vector<mission_file_data_handler::mission_data_set>* mission_data)
     :
     mission_step(0),
     rating(""),
@@ -30,11 +30,11 @@ operating_conditions::operating_conditions(std::vector<mission_file_data_handler
     mission_data(mission_data) {
 }
 
-/* Destructor of the operating_conditions object */
-operating_conditions::~operating_conditions() {
+/* Destructor of the Operating_conditions object */
+Operating_conditions::~Operating_conditions() {
 }
 
-void operating_conditions::set_segment_operating_conditions(const uint16_t &i) {
+void Operating_conditions::set_segment_Operating_conditions(const uint16_t &i) {
     this->mission_step = i;
     this->config = (*mission_data).at(i).config;
     this->rating = (*mission_data).at(i).rating;
@@ -56,7 +56,7 @@ void operating_conditions::set_segment_operating_conditions(const uint16_t &i) {
     this->background_shaft_power = (*mission_data).at(i).background_shaft_power;
 }
 
-void operating_conditions::delete_used_bleed_and_shaft_power_offtakes(const double& time_step) {
+void Operating_conditions::delete_used_bleed_and_shaft_power_offtakes(const double& time_step) {
     if (!this->bleed_times.empty()) {
         double time_sum(0.);
         while (!this->bleed_times.empty() && time_sum < time_step) {
diff --git a/mission_analysis/src/libs/condition_methods/operating_conditions.h b/mission_analysis/src/libs/condition_methods/operating_conditions.h
index 6eaf929bf90a2cf72b7dfc8cf9f9a5752233540e..e7a41ccbf24a4e6c54925ced90ac35637ce34627 100644
--- a/mission_analysis/src/libs/condition_methods/operating_conditions.h
+++ b/mission_analysis/src/libs/condition_methods/operating_conditions.h
@@ -12,8 +12,8 @@
 /* List of references
     [1] Airbus customer services, Flight Operations Support & Line Assistance: Getting to grips with the cost index, Issue II, May 1998, p.7
 */
-#ifndef MISSION_ANALYSIS_SRC_LIBS_CONDITION_METHODS_OPERATING_CONDITIONS_H_
-#define MISSION_ANALYSIS_SRC_LIBS_CONDITION_METHODS_OPERATING_CONDITIONS_H_
+#ifndef MISSION_ANALYSIS_SRC_LIBS_CONDITION_METHODS_Operating_conditions_H_
+#define MISSION_ANALYSIS_SRC_LIBS_CONDITION_METHODS_Operating_conditions_H_
 
 #include <string>
 #include <vector>
@@ -22,7 +22,7 @@
 
 /** \brief Class for operating conditions
  */
-class operating_conditions {
+class Operating_conditions {
  public:
     uint16_t mission_step;                  /**< Index of current mission step [-] */
     std::string rating;                     /**< Rating */
@@ -39,23 +39,23 @@ class operating_conditions {
     std::vector<mission_file_data_handler::mission_data_set>* mission_data; /**< reference to the mission data from mission XML */
 
     /* Constructor and destructor */
-    /** \brief Constructor for the class operating_conditions
+    /** \brief Constructor for the class Operating_conditions
      * \param mission_data: reference to the mission data set
      */
-    explicit operating_conditions(std::vector<mission_file_data_handler::mission_data_set>* mission_data);
-    /** \brief Destructor for the class operating_conditions
+    explicit Operating_conditions(std::vector<mission_file_data_handler::mission_data_set>* mission_data);
+    /** \brief Destructor for the class Operating_conditions
      */
-    virtual ~operating_conditions();
+    virtual ~Operating_conditions();
 
     /* Methods */
     /** \brief Function sets segment operating conditions
      * \param i: index parameter of mission step [-]
      */
-    void set_segment_operating_conditions(const uint16_t &i);
+    void set_segment_Operating_conditions(const uint16_t &i);
      /** \brief Function deletes the time step processed values from the bleed- and shaft_power-Offtakes vectors of operationConditions
      * \param time_step constant reference of the overall time step [s]
      */
     void delete_used_bleed_and_shaft_power_offtakes(const double& time_step);
 };
 
-#endif // MISSION_ANALYSIS_SRC_LIBS_CONDITION_METHODS_OPERATING_CONDITIONS_H_
+#endif // MISSION_ANALYSIS_SRC_LIBS_CONDITION_METHODS_Operating_conditions_H_
diff --git a/mission_analysis/src/libs/mission_file_data_handler/mission_file_data_handler.cpp b/mission_analysis/src/libs/mission_file_data_handler/mission_file_data_handler.cpp
index d245551bd8f6d9d0e7dd310ce3ca3d787e9a9c06..3c97066e04a7dd058b93c1b109209d44c69d5a6a 100644
--- a/mission_analysis/src/libs/mission_file_data_handler/mission_file_data_handler.cpp
+++ b/mission_analysis/src/libs/mission_file_data_handler/mission_file_data_handler.cpp
@@ -113,10 +113,10 @@ void mission_file_data_handler::read_departure_steps(const double& max_operating
         }
         /* Mode specific mission parameters */
         if (data.mode_name == "takeoff") {
-            data.mode = flight_conditions::TAKEOFF;
+            data.mode = Flight_conditions::TAKEOFF;
             data.energy_carrier_id = takeoff_id;
         } else if (data.mode_name == "accelerate") {
-            data.mode = flight_conditions::ACCELERATE;
+            data.mode = Flight_conditions::ACCELERATE;
             data.mach_switch = false;
             data.energy_carrier_id = climb_id;
             data.CAS = EndnodeReadOnly<double>(subpath + num2Str(i) + "/calibrated_airspeed").read(mission_xml).value();
@@ -126,7 +126,7 @@ void mission_file_data_handler::read_departure_steps(const double& max_operating
                         subpath + num2Str(i), ceil(data.CAS - max_operating_speed)));
             }
         } else if (data.mode_name == "climb") { // Mode: climb at a constant calibrated airspeed
-            data.mode = flight_conditions::CLIMBCONSTCAS;
+            data.mode = Flight_conditions::CLIMBCONSTCAS;
             data.mach_switch = false;
             data.altitude = EndnodeReadOnly<double>(subpath + num2Str(i) + "/altitude").read(mission_xml).value();
             data.auto_FL_optimum = false;
@@ -243,23 +243,23 @@ void mission_file_data_handler::read_flight_steps(double* average_shaft_bleed, d
 
         /* Identify step mode and adapt data accordingly */
         if (data.mode_name == "change_speed_to_CAS") { // Mode: accelerate, i.e. change speed to calibrated airspeed
-            data.mode = flight_conditions::ACCELERATE;
+            data.mode = Flight_conditions::ACCELERATE;
         } else if (data.mode_name == "climb_to_cruise") { // Mode: climb to cruise altitude
-            data.mode = (data.CI_via_speed_switch) ? flight_conditions::CLIMBTOCRUISECI : flight_conditions::CLIMBTOCRUISE;
+            data.mode = (data.CI_via_speed_switch) ? Flight_conditions::CLIMBTOCRUISECI : Flight_conditions::CLIMBTOCRUISE;
         } else if (data.mode_name == "climb_to_ceiling") { // Mode: climb to ceiling altitude
-            data.mode = flight_conditions::CLIMBTOSERVICECEILING;
+            data.mode = Flight_conditions::CLIMBTOSERVICECEILING;
             if (data.CI_via_speed_switch) { //is flight management system switched on?
                 data.CI = EndnodeReadOnly<bool>(subpath + num2Str(i) + "/flight_management_system/cost_index").read(mission_xml).value();
             }
         } else if (data.mode_name == "change_flight_level" &&
                    !(EndnodeReadOnly<bool>(subpath + num2Str(i) + "/auto_select_optimum_flight_level/enabled").read(mission_xml).value())) { // Mode: change flight level
-            data.mode = (data.CI_via_speed_switch) ? flight_conditions::CLIMBVARCAS : flight_conditions::CLIMBCONSTCAS;
+            data.mode = (data.CI_via_speed_switch) ? Flight_conditions::CLIMBVARCAS : Flight_conditions::CLIMBCONSTCAS;
             data.mach_switch = true;
         } else if (data.mode_name == "change_flight_level_constant_ROC" && // Mode: change flight level while maintaining a constant rate of climb
                   !(EndnodeReadOnly<bool>(subpath + num2Str(i) + "/auto_select_optimum_flight_level/enabled").read(mission_xml).value())) {
-            data.mode = flight_conditions::FLCHANGE;
+            data.mode = Flight_conditions::FLCHANGE;
         } else if (data.mode_name == "cruise") {
-            data.mode = (data.CI_via_speed_switch) ? flight_conditions::CRUISECI : flight_conditions::CRUISE;
+            data.mode = (data.CI_via_speed_switch) ? Flight_conditions::CRUISECI : Flight_conditions::CRUISE;
             if (data.auto_FL_optimum)
                 *auto_climb_switch = data.auto_FL_optimum;
             if (accuracyCheck(data.auto_altitude_steps, 0., ACCURACY_HIGH)) {
@@ -267,18 +267,18 @@ void mission_file_data_handler::read_flight_steps(double* average_shaft_bleed, d
             }
             *step_height_cruise = convertUnit(METER, FOOT, data.auto_altitude_steps);
         } else if (data.mode_name == "change_speed_to_Mach") { // Mode: change speed to Mach number
-            data.mode = flight_conditions::ACCELERATE;
+            data.mode = Flight_conditions::ACCELERATE;
             data.mach_switch = true;
         } else if (data.mode_name == "descend_to_approach") { // Mode: descend to approach
-            data.mode = (data.CI_via_speed_switch) ? flight_conditions::DESCENTCI : flight_conditions::DESCENT;
+            data.mode = (data.CI_via_speed_switch) ? Flight_conditions::DESCENTCI : Flight_conditions::DESCENT;
         } else if (data.mode_name == "air_to_air_fuelling") { // Mode: air to air fueling (UNUSED BY NOW)
-            data.mode = flight_conditions::AIRTOAIRFUELLING;
+            data.mode = Flight_conditions::AIRTOAIRFUELLING;
             data.transfer_time = mission_xml.at(subpath + num2Str(i) + "/transfer_time");
             data.transfer_rate = mission_xml.at(subpath + num2Str(i) + "/transfer_rate");
             data.rel_delta_fuel_mass = mission_xml.at(subpath + num2Str(i) + "/rel_delta_fuel_mass");
             data.delta_payload_mass = mission_xml.at(subpath + num2Str(i) + "/delta_payload_mass");
         } else if (data.mode_name == "free_flight_minimum_fuel") { // Mode: free flight with minimum fuel
-            data.mode = flight_conditions::FREEFLIGHT;
+            data.mode = Flight_conditions::FREEFLIGHT;
             data.rel_segment_length = checkBoundaries(mission_xml.at(subpath + num2Str(i) + "/relSegmentLength"), 0., true, 1., true);
         } else {
             data.mode = 0;
@@ -357,12 +357,12 @@ void mission_file_data_handler::read_approach_steps(const double& max_operating_
         data.derate = EndnodeReadOnly<double>(subpath + num2Str(i) + "/derate").read(mission_xml).value();
         data.config = EndnodeReadOnly<std::string>(subpath + num2Str(i) + "/configuration").read(mission_xml).value();
         if (data.mode_name == "descend") { // Mode: descend
-            data.mode = flight_conditions::APPROACH;
+            data.mode = Flight_conditions::APPROACH;
             data.altitude = EndnodeReadOnly<double>(subpath + num2Str(i) + "/altitude").read(mission_xml).value();
             data.glidepath = EndnodeReadOnly<double>(subpath + num2Str(i) + "/glide_path").read(mission_xml).value();
             data.energy_carrier_id = descent_id;
         } else if (data.mode_name == "change_speed") { // Mode: change speed
-            data.mode = flight_conditions::DECELERATE;
+            data.mode = Flight_conditions::DECELERATE;
             data.ground_distance = EndnodeReadOnly<double>(subpath + num2Str(i) + "/ground_distance").read(mission_xml).value();
             data.glidepath = EndnodeReadOnly<double>(subpath + num2Str(i) + "/glide_path").read(mission_xml).value();
             data.CAS = EndnodeReadOnly<double>(subpath + num2Str(i) + "/calibrated_airspeed").read(mission_xml).value();
@@ -373,12 +373,12 @@ void mission_file_data_handler::read_approach_steps(const double& max_operating_
             }
             data.energy_carrier_id = descent_id;
         } else if (data.mode_name == "landing") { // Mode: landing
-            data.mode = flight_conditions::LANDING;
+            data.mode = Flight_conditions::LANDING;
             data.altitude = EndnodeReadOnly<double>(subpath + num2Str(i) + "/altitude").read(mission_xml).value();
             data.glidepath = EndnodeReadOnly<double>(subpath + num2Str(i) + "/glide_path").read(mission_xml).value();
             data.energy_carrier_id = landing_id;
         } else if (data.mode_name == "level_glide_slope_interception") { // Mode: level glide slope interception
-            data.mode = flight_conditions::GSINTERCEPTION;
+            data.mode = Flight_conditions::GSINTERCEPTION;
             data.energy_carrier_id = descent_id;
         } else {
             continue; //no data available
diff --git a/mission_analysis/src/libs/mission_file_data_handler/mission_file_data_handler.h b/mission_analysis/src/libs/mission_file_data_handler/mission_file_data_handler.h
index 3100a9d481417f9333f9b8069272fe85d03db7b4..3cb0cc570bba9de3629086a26b682c4e2bf62f45 100644
--- a/mission_analysis/src/libs/mission_file_data_handler/mission_file_data_handler.h
+++ b/mission_analysis/src/libs/mission_file_data_handler/mission_file_data_handler.h
@@ -89,11 +89,11 @@ class mission_file_data_handler {
     double cargo_mass;               /**< Air cargo on board [kg] */
 
     /* Constructor and destructor */
-    /** \brief Constructor for class flight_conditions
+    /** \brief Constructor for class Flight_conditions
      * \param path_to_mission_xml: reference to the mission XML
      */
     explicit mission_file_data_handler(const std::string& path_to_mission_xml);
-    /** \brief Destructor for class flight_conditions
+    /** \brief Destructor for class Flight_conditions
      */
     virtual ~mission_file_data_handler();
 
diff --git a/mission_analysis/src/standard_mission/flight_segments/flight_segments.cpp b/mission_analysis/src/standard_mission/flight_segments/flight_segments.cpp
index 91edb3f3ac197a160d8c5f7fad32fc9d67c4c0e4..f4626aa8f5acc79cc4d9a9b28019c6e413bfb514 100644
--- a/mission_analysis/src/standard_mission/flight_segments/flight_segments.cpp
+++ b/mission_analysis/src/standard_mission/flight_segments/flight_segments.cpp
@@ -85,7 +85,7 @@ standard_mission::mission_segment::mission_segment(const std::map<int, double>&
 standard_mission::mission_segment::~mission_segment() {
 }
 
-void standard_mission::calculate_ground_run(operating_conditions* oc, flight_conditions* fc, const uint16_t& a_mission_step) {
+void standard_mission::calculate_ground_run(Operating_conditions* oc, Flight_conditions* fc, const uint16_t& a_mission_step) {
     /* Calculate the number of steps */
     uint16_t steps = static_cast<uint16_t>(ceil(fabs((fc->end_TAS - fc->TAS) /
         EndnodeReadOnly<double>("program_settings/precision/acceleration_increment").read(this->rtIO->moduleConfig).value())));
@@ -94,7 +94,7 @@ void standard_mission::calculate_ground_run(operating_conditions* oc, flight_con
     for (uint16_t step_number(0); step_number < steps; ++step_number) {
         this->set_segment_initial_conditions(fc, true, this->aero.CLgroundRoll);
         fc->end_TAS = fc->TAS + delta_TAS;
-        if (this->mission_file->mission_data.at(a_mission_step).mode == flight_conditions::LANDING) { //Activation of thrust reverser right after touchdown if desired
+        if (this->mission_file->mission_data.at(a_mission_step).mode == Flight_conditions::LANDING) { //Activation of thrust reverser right after touchdown if desired
             if (EndnodeReadOnly<bool>("program_settings/general/landing/thrust_reverser/enable").read(this->rtIO->moduleConfig).value() &&
                 fc->end_TAS > convertUnit(CALIBRATEDAIRSPEED, TRUEAIRSPEED, fc->altitude, this->atm,
                 EndnodeReadOnly<double>("program_settings/general/landing/thrust_reverser/deactivation_speed").read(this->rtIO->moduleConfig).value())) {
@@ -122,9 +122,9 @@ void standard_mission::calculate_ground_run(operating_conditions* oc, flight_con
     }
 }
 
-void standard_mission::takeoff_calculation(operating_conditions* oc, flight_conditions* fc, const uint16_t& a_mission_step) {
+void standard_mission::takeoff_calculation(Operating_conditions* oc, Flight_conditions* fc, const uint16_t& a_mission_step) {
     myRuntimeInfo->out << "Take-off calculation ..." << std::endl;
-    oc->set_segment_operating_conditions(a_mission_step);
+    oc->set_segment_Operating_conditions(a_mission_step);
     /* Set the initial conditions of the segment */
     this->set_segment_initial_conditions(fc);
     /* Takeoff distance is composed of ground run (break release until lift off) and 1st climb segment to screen height (35ft) */
@@ -150,7 +150,7 @@ void standard_mission::takeoff_calculation(operating_conditions* oc, flight_cond
     myRuntimeInfo->out << "Takeoff distance total: " << this->takeoff_distance.value() << " m." << std::endl;
 }
 
-void standard_mission::climb_to_cruise_altitude(operating_conditions* oc, flight_conditions* fc, const uint16_t& a_mission_step) {
+void standard_mission::climb_to_cruise_altitude(Operating_conditions* oc, Flight_conditions* fc, const uint16_t& a_mission_step) {
     myRuntimeInfo->out << "Climb to cruise altitude ... " << std::endl;
     this->change_altitude_at_constant_speed(oc, fc, a_mission_step);
     if (this->cruise_profile_start == 0 && this->mission_profile.size()) {
@@ -173,8 +173,8 @@ void standard_mission::climb_to_cruise_altitude(operating_conditions* oc, flight
     }
 }
 
-void standard_mission::climb_to_service_ceiling(operating_conditions* oc, flight_conditions* fc, const uint16_t& a_mission_step) {
-    flight_conditions start_of_climb_fc = *fc;
+void standard_mission::climb_to_service_ceiling(Operating_conditions* oc, Flight_conditions* fc, const uint16_t& a_mission_step) {
+    Flight_conditions start_of_climb_fc = *fc;
     mission_segment start_of_climb_segment = this->mission_profile.back();
     double CAS = convertUnit(TRUEAIRSPEED, CALIBRATEDAIRSPEED, fc->altitude, this->atm, fc->TAS); // Stays constant below transition altitude!
     double transition_mach = this->mission_file->mission_data.at(a_mission_step).mach; // Constant climb speed (Mach number) above transition altitude
@@ -302,7 +302,7 @@ void standard_mission::climb_to_service_ceiling(operating_conditions* oc, flight
     }
 }
 
-void standard_mission::climb_iteration(operating_conditions* oc, flight_conditions* fc, const uint16_t &mission_step, const double& minimum_ROC,
+void standard_mission::climb_iteration(Operating_conditions* oc, Flight_conditions* fc, const uint16_t &mission_step, const double& minimum_ROC,
                             const bool& save_data) {
     /* Climb Iteration until convergence of average climb angle mean_glidepath_angle */
     double residuum(0.);
@@ -339,7 +339,7 @@ double standard_mission::calculate_top_of_descent_aircraft_mass(const double& cu
     return top_of_descent_aircraft_mass;
 }
 
-double standard_mission::calculate_climb_or_descent(operating_conditions* oc, flight_conditions* fc, const uint16_t& a_mission_step,
+double standard_mission::calculate_climb_or_descent(Operating_conditions* oc, Flight_conditions* fc, const uint16_t& a_mission_step,
                                         const bool& simulation_mode) {
     double range_for_descent(0.);
     /* Set delta_h for climb/descent */
@@ -357,17 +357,17 @@ double standard_mission::calculate_climb_or_descent(operating_conditions* oc, fl
      * default: for CLIMBCONSTCAS, APPROACH, FLCHANGE, FLCHANGESIMULATION, and LANDING, the CAS and Mach equals in every altitude
      */
     switch (this->mission_file->mission_data.at(a_mission_step).mode) {
-        case flight_conditions::CLIMBTOCRUISE:
-        case flight_conditions::CLIMBTOCRUISECI:
-        case flight_conditions::CLIMBTOSERVICECEILING: {
+        case Flight_conditions::CLIMBTOCRUISE:
+        case Flight_conditions::CLIMBTOCRUISECI:
+        case Flight_conditions::CLIMBTOSERVICECEILING: {
             CAS = convertUnit(TRUEAIRSPEED, CALIBRATEDAIRSPEED, fc->altitude, this->atm, fc->TAS);
             mach = this->mission_file->mission_data.at(a_mission_step).mach;
             transition_mach = this->mission_file->desired_cruise_speed +
                 this->delta_mach_above_crossover; //Normally, transition Mach Number is equal to initial cruise Mach number + delta
             break;
         }
-        case flight_conditions::DESCENT:
-        case flight_conditions::DESCENTCI: {
+        case Flight_conditions::DESCENT:
+        case Flight_conditions::DESCENTCI: {
             mach = convertUnit(TRUEAIRSPEED, MACH, fc->altitude, this->atm, fc->TAS);
             CAS = this->mission_file->mission_data.at(a_mission_step).CAS;
             transition_mach = //Normally, transition_mach is equal to initial cruise Mach number + delta, but descent is defined different
@@ -394,8 +394,8 @@ double standard_mission::calculate_climb_or_descent(operating_conditions* oc, fl
          * (this is not needed for climb since after climb to cruise segment there is a dedicated acceleration segment)
          */
         if (fc->delta_h < 0. && fc->altitude < transitionAltitude &&
-            (this->mission_file->mission_data.at(a_mission_step).mode == flight_conditions::DESCENT ||
-                this->mission_file->mission_data.at(a_mission_step).mode == flight_conditions::DESCENTCI)) {
+            (this->mission_file->mission_data.at(a_mission_step).mode == Flight_conditions::DESCENT ||
+                this->mission_file->mission_data.at(a_mission_step).mode == Flight_conditions::DESCENTCI)) {
              //Descent and current speed above upper boundary for descent speed endCAS
             myRuntimeInfo->out << "Current speed ("
                         << convertUnit(METERPERSECOND, KNOTS, convertUnit(TRUEAIRSPEED, CALIBRATEDAIRSPEED, fc->altitude, this->atm, fc->TAS))
@@ -405,7 +405,7 @@ double standard_mission::calculate_climb_or_descent(operating_conditions* oc, fl
              * because it is set to 0 for speed change at constant altitude
              */
             uint16_t mode_backup(this->mission_file->mission_data.at(a_mission_step).mode);
-            this->mission_file->mission_data.at(a_mission_step).mode = flight_conditions::DECELERATE;
+            this->mission_file->mission_data.at(a_mission_step).mode = Flight_conditions::DECELERATE;
             double delta_h_backup = fc->delta_h;
             /* To decelerate to a constant CAS (first CAS in Descent-Speed-Schedule), the true airspeed has to be used as reference, not the Mach number */
             this->mission_file->mission_data.at(a_mission_step).mach_switch = false;
@@ -419,15 +419,15 @@ double standard_mission::calculate_climb_or_descent(operating_conditions* oc, fl
     uint16_t steps(0);
     double altitude_increment(EndnodeReadOnly<double>("program_settings/precision/altitude_increment").read(this->rtIO->moduleConfig).value());
     if (simulation_mode) {
-        if (this->mission_file->mission_data.at(a_mission_step).mode == flight_conditions::DESCENT ||
-            this->mission_file->mission_data.at(a_mission_step).mode == flight_conditions::DESCENTCI) {
+        if (this->mission_file->mission_data.at(a_mission_step).mode == Flight_conditions::DESCENT ||
+            this->mission_file->mission_data.at(a_mission_step).mode == Flight_conditions::DESCENTCI) {
             altitude_increment = 500.;
         } else {
             altitude_increment = 20.;
         }
     }
     steps = static_cast<uint16_t>(ceil(fabs(fc->delta_h / altitude_increment)));
-    flight_conditions fc_tmp(*fc);
+    Flight_conditions fc_tmp(*fc);
     fc_tmp.delta_h /= steps;
     if (!simulation_mode) {
         myRuntimeInfo->out << ((fc_tmp.delta_h > 0.) ? "Climb step: " : "Descent step: ")
@@ -439,7 +439,7 @@ double standard_mission::calculate_climb_or_descent(operating_conditions* oc, fl
     }
     for (uint16_t step_number(0); step_number < steps; ++step_number) {
         this->set_segment_initial_conditions(&fc_tmp, !simulation_mode);
-        if (optimum_ROC && this->mission_file->mission_data.at(a_mission_step).mode == flight_conditions::CLIMBTOSERVICECEILING) {
+        if (optimum_ROC && this->mission_file->mission_data.at(a_mission_step).mode == Flight_conditions::CLIMBTOSERVICECEILING) {
             this->calculate_max_ROC_speed(&mach, fc_tmp, 1.);
             fc_tmp.TAS = fc_tmp.end_TAS;
             /* Convert Mach number into true airspeed */
@@ -451,17 +451,17 @@ double standard_mission::calculate_climb_or_descent(operating_conditions* oc, fl
             /* Convert calibrated airspeed into true airspeed */
             fc_tmp.end_TAS = convertUnit(CALIBRATEDAIRSPEED, TRUEAIRSPEED, fc_tmp.altitude + fc_tmp.delta_h, this->atm, CAS);
         }
-        if (this->mission_file->mission_data.at(a_mission_step).mode == flight_conditions::FLCHANGE) {
+        if (this->mission_file->mission_data.at(a_mission_step).mode == Flight_conditions::FLCHANGE) {
             this->climb_iteration(oc, &fc_tmp, a_mission_step, this->mission_file->mission_data.at(a_mission_step).ROC);
-        } else if (this->mission_file->mission_data.at(a_mission_step).mode == flight_conditions::FLCHANGESIMULATION) {
+        } else if (this->mission_file->mission_data.at(a_mission_step).mode == Flight_conditions::FLCHANGESIMULATION) {
             this->climb_iteration(oc, &fc_tmp, a_mission_step, this->mission_file->mission_data.at(a_mission_step).ROC, !simulation_mode);
-        } else if (this->mission_file->mission_data.at(a_mission_step).mode == flight_conditions::DESCENT ||
-                    this->mission_file->mission_data.at(a_mission_step).mode == flight_conditions::DESCENTCI ||
-                    this->mission_file->mission_data.at(a_mission_step).mode == flight_conditions::APPROACH ||
-                    this->mission_file->mission_data.at(a_mission_step).mode == flight_conditions::LANDING) {
+        } else if (this->mission_file->mission_data.at(a_mission_step).mode == Flight_conditions::DESCENT ||
+                    this->mission_file->mission_data.at(a_mission_step).mode == Flight_conditions::DESCENTCI ||
+                    this->mission_file->mission_data.at(a_mission_step).mode == Flight_conditions::APPROACH ||
+                    this->mission_file->mission_data.at(a_mission_step).mode == Flight_conditions::LANDING) {
             this->climb_iteration(oc, &fc_tmp, a_mission_step, 0., !simulation_mode);
         } else {
-            flight_conditions backup_fc(fc_tmp);
+            Flight_conditions backup_fc(fc_tmp);
             try {
                 this->climb_iteration(oc, &fc_tmp, a_mission_step);
             } catch (const std::string& error_message) {
@@ -476,7 +476,7 @@ double standard_mission::calculate_climb_or_descent(operating_conditions* oc, fl
                 }
             }
             /* Iterate optimum ICA-FlightLevel */
-            if (this->mission_file->mission_data.at(a_mission_step).mode == flight_conditions::CLIMBTOCRUISE &&
+            if (this->mission_file->mission_data.at(a_mission_step).mode == Flight_conditions::CLIMBTOCRUISE &&
                                                                     this->mission_file->mission_data.at(a_mission_step).auto_FL_optimum &&
                                                                     step_number == (steps - 2)) {
                 myRuntimeInfo->out << "Check optimum ICA ..." << std::endl;
@@ -527,13 +527,13 @@ double standard_mission::calculate_climb_or_descent(operating_conditions* oc, fl
 void standard_mission::estimate_descent(const bool& last_segment_free_flight_switch) {
     /* Estimate distance for the descend */
     /* Initialize operating conditions object */
-    operating_conditions descent_oc(&(this->mission_file->mission_data));
+    Operating_conditions descent_oc(&(this->mission_file->mission_data));
     /* Set the operating conditions of the segment */
-    descent_oc.set_segment_operating_conditions(this->top_of_descent_index);
+    descent_oc.set_segment_Operating_conditions(this->top_of_descent_index);
     /* Initialize flight conditions object */
-    flight_conditions descent_fc(&(this->mission_file->mission_data), &descent_oc,
+    Flight_conditions descent_fc(&(this->mission_file->mission_data), &descent_oc,
                                                 &this->aero, &this->atm, &this->engine, this->variable_camber_segment_quantity);
-    flight_conditions descent_fc_next_FL(descent_fc);
+    Flight_conditions descent_fc_next_FL(descent_fc);
     /* Get height at top of descent (TOD) and bottom of descent (BOD) */
     if (last_segment_free_flight_switch) { // Determine FF height and speed
         this->mission_file->mission_data.at(this->top_of_descent_index).mach = this->mission_file->desired_cruise_speed;
@@ -572,13 +572,13 @@ void standard_mission::estimate_descent(const bool& last_segment_free_flight_swi
     myRuntimeInfo->info << "Top of descent mass: " << this->top_of_descent_mass.value() << std::endl;
 }
 
-std::pair<double, double> standard_mission::calculate_descent(const operating_conditions& oc,
-                                                            const flight_conditions& fc, double top_of_descent_mass_tmp) {
+std::pair<double, double> standard_mission::calculate_descent(const Operating_conditions& oc,
+                                                            const Flight_conditions& fc, double top_of_descent_mass_tmp) {
     //Save engine operating conditions for normal cruise before changes from flight level change simulation occur
     int energy_carrier_id(fc.mission_data->at(fc.operating_condition->mission_step).energy_carrier_id);
     std::vector<OperatingPoint> backup_operating_points = this->engine.get_operating_points(energy_carrier_id);
-    operating_conditions descent_oc = oc;
-    flight_conditions descent_fc(&this->mission_file->mission_data, &descent_oc, &this->aero, &this->atm, &this->engine, this->variable_camber_segment_quantity);
+    Operating_conditions descent_oc = oc;
+    Flight_conditions descent_fc(&this->mission_file->mission_data, &descent_oc, &this->aero, &this->atm, &this->engine, this->variable_camber_segment_quantity);
     double descent_range_tmp(0.);
     double aircraft_mass_before_descent(top_of_descent_mass_tmp);
     /* Set initial flight condition */
@@ -587,15 +587,15 @@ std::pair<double, double> standard_mission::calculate_descent(const operating_co
     descent_fc.TAS = convertUnit(MACH, TRUEAIRSPEED, descent_fc.altitude, this->atm, this->mission_file->mission_data.at(this->top_of_descent_index).mach);
     /* Calculate descend range */
     for (size_t i(this->end_of_descent_index); i < this->mission_file->mission_data.size(); ++i) {
-        if (this->mission_file->mission_data.at(i).mode == flight_conditions::DESCENT) { // Descend_to_Approach
+        if (this->mission_file->mission_data.at(i).mode == Flight_conditions::DESCENT) { // Descend_to_Approach
             descent_range_tmp += this->change_altitude_at_constant_speed(&descent_oc, &descent_fc, i, true);
-        } else if (this->mission_file->mission_data.at(i).mode == flight_conditions::APPROACH) { // Descend
+        } else if (this->mission_file->mission_data.at(i).mode == Flight_conditions::APPROACH) { // Descend
             descent_range_tmp += this->change_altitude_at_constant_speed(&descent_oc, &descent_fc, i, true);
-        } else if (this->mission_file->mission_data.at(i).mode == flight_conditions::DECELERATE) { // Change speed
+        } else if (this->mission_file->mission_data.at(i).mode == Flight_conditions::DECELERATE) { // Change speed
             descent_range_tmp += this->change_speed_at_constant_ROC(&descent_oc, &descent_fc, i, true);
-        }  else if (this->mission_file->mission_data.at(i).mode == flight_conditions::GSINTERCEPTION) { // GlideslopeInterception
+        }  else if (this->mission_file->mission_data.at(i).mode == Flight_conditions::GSINTERCEPTION) { // GlideslopeInterception
             descent_range_tmp += this->glideslope_interception(&descent_oc, &descent_fc, i, true);
-        }  else if (this->mission_file->mission_data.at(i).mode == flight_conditions::LANDING) { // Flare to touch down
+        }  else if (this->mission_file->mission_data.at(i).mode == Flight_conditions::LANDING) { // Flare to touch down
             descent_range_tmp += this->landing(&descent_oc, &descent_fc, i, true);
         }
     }
@@ -604,8 +604,8 @@ std::pair<double, double> standard_mission::calculate_descent(const operating_co
 }
 
 std::pair<double, double> standard_mission::iterate_descent(double* segmend_end_range, double* top_of_descent_aircraft_mass,
-                                                            const double& current_descent_distance, const operating_conditions& oc,
-                                                            const flight_conditions& fc, const uint16_t& a_mission_step) {
+                                                            const double& current_descent_distance, const Operating_conditions& oc,
+                                                            const Flight_conditions& fc, const uint16_t& a_mission_step) {
     std::pair<double, double> the_descend;
     double descend_distance(current_descent_distance);
     double iteration_accuracy(1.); //Iteration accuracy is 1NM
@@ -625,12 +625,12 @@ std::pair<double, double> standard_mission::iterate_descent(double* segmend_end_
     return std::make_pair(the_descend.first, the_descend.second);
 }
 
-double standard_mission::glideslope_interception(operating_conditions* oc, flight_conditions* fc, const uint16_t& a_mission_step,
+double standard_mission::glideslope_interception(Operating_conditions* oc, Flight_conditions* fc, const uint16_t& a_mission_step,
                                        const bool& simulation_mode) {
     double range_for_descent(0.);
     if (!simulation_mode) myRuntimeInfo->out << "Glideslope Interception ... " << std::endl;
     /* Set the operating conditions of the segment */
-    oc->set_segment_operating_conditions(a_mission_step);
+    oc->set_segment_Operating_conditions(a_mission_step);
     /* Set the initial conditions of the segment */
     this->set_segment_initial_conditions(fc, !simulation_mode);
     fc->end_TAS = fc->TAS;
@@ -667,12 +667,12 @@ double standard_mission::glideslope_interception(operating_conditions* oc, fligh
     return range_for_descent;
 }
 
-double standard_mission::landing(operating_conditions* oc, flight_conditions* fc, const uint16_t& a_mission_step, const bool& simulation_mode) {
+double standard_mission::landing(Operating_conditions* oc, Flight_conditions* fc, const uint16_t& a_mission_step, const bool& simulation_mode) {
     /**< \todo [T148] (https://unicado.ilr.rwth-aachen.de/T148): Consider using this method - http://walter.bislins.ch/aviatik/index.asp?page=Bremsweg+eines+Verkehrsflugzeugs
      */
     if (!simulation_mode) myRuntimeInfo->out << "Landing ... " << std::endl;
     double descent_to_touchdown_range(0.);
-    oc->set_segment_operating_conditions(a_mission_step);
+    oc->set_segment_Operating_conditions(a_mission_step);
     /* Set the initial conditions for the segment */
     this->set_segment_initial_conditions(fc, !simulation_mode);
     if (!simulation_mode) this->landing_distance = this->mission_profile.back().end_range; //get current range when landing is started
@@ -685,7 +685,7 @@ double standard_mission::landing(operating_conditions* oc, flight_conditions* fc
         //Ground run
         myRuntimeInfo->out << "Rolling on the runway during the reaction time ..." << std::endl;
         this->mission_file->mission_data.at(a_mission_step).glidepath = 0.; // set track angle of last segment to zero for ground run
-        this->mission_file->mission_data.at(a_mission_step).mode = flight_conditions::TAKEOFF;
+        this->mission_file->mission_data.at(a_mission_step).mode = Flight_conditions::TAKEOFF;
         this->set_segment_initial_conditions(fc, true, this->aero.CLgroundRoll);
         fc->end_altitude = 0.;
         fc->end_glidepath_angle = 0.;
@@ -708,7 +708,7 @@ double standard_mission::landing(operating_conditions* oc, flight_conditions* fc
         fc->end_CL = this->aero.CLgroundRoll;
         fc->end_angle_of_attack = 0.;
         fc->end_specific_air_range = 0.;
-        this->mission_file->mission_data.at(a_mission_step).mode = flight_conditions::LANDING;
+        this->mission_file->mission_data.at(a_mission_step).mode = Flight_conditions::LANDING;
         this->save_segment_data(fc, *oc, a_mission_step);
         /* Clear origin vector */
         fc->origin_polar.clear();
@@ -728,7 +728,7 @@ double standard_mission::landing(operating_conditions* oc, flight_conditions* fc
     return descent_to_touchdown_range;
 }
 
-double standard_mission::change_speed_at_constant_ROC(operating_conditions* oc, flight_conditions* fc, const uint16_t& a_mission_step,
+double standard_mission::change_speed_at_constant_ROC(Operating_conditions* oc, Flight_conditions* fc, const uint16_t& a_mission_step,
                                          const bool& simulation_mode) {
     if (!simulation_mode) myRuntimeInfo->out << "Change speed with constant ROC ... " << std::endl;
     double speed_change_range(0.);
@@ -737,7 +737,7 @@ double standard_mission::change_speed_at_constant_ROC(operating_conditions* oc,
     double acceleration_increment(0.);
     double minimum_acceleration(0.);
     /* Set the operating conditions of the segment */
-    oc->set_segment_operating_conditions(a_mission_step);
+    oc->set_segment_Operating_conditions(a_mission_step);
     /* Set the initial conditions of the segment */
     this->set_segment_initial_conditions(fc, !simulation_mode);
     if (this->mission_file->mission_data.at(a_mission_step).mach_switch) {
@@ -792,7 +792,7 @@ double standard_mission::change_speed_at_constant_ROC(operating_conditions* oc,
             /* Convert calibrated airspeed into true airspeed */
             fc->end_TAS = convertUnit(CALIBRATEDAIRSPEED, TRUEAIRSPEED, fc->altitude, this->atm, speed);
         }
-        flight_conditions backup_fc(*fc);
+        Flight_conditions backup_fc(*fc);
         try {
             this->fixed_ROC_acceleration_iteration(oc, fc, minimum_acceleration, a_mission_step, !simulation_mode);
         } catch (const std::string& error_message) {
@@ -818,18 +818,18 @@ double standard_mission::change_speed_at_constant_ROC(operating_conditions* oc,
     return speed_change_range;
 }
 
-double standard_mission::change_altitude_at_constant_speed(operating_conditions* oc, flight_conditions* fc, const uint16_t& a_mission_step,
+double standard_mission::change_altitude_at_constant_speed(Operating_conditions* oc, Flight_conditions* fc, const uint16_t& a_mission_step,
                                               const bool& simulation_mode) {
     if (!simulation_mode) {
         myRuntimeInfo->out << "Climb or descent with constant CAS or Mach number "
-                           << ((this->mission_file->mission_data.at(a_mission_step).mode == flight_conditions::FLCHANGE) ? "(with constant ROC) ..." : "...")
+                           << ((this->mission_file->mission_data.at(a_mission_step).mode == Flight_conditions::FLCHANGE) ? "(with constant ROC) ..." : "...")
                            << std::endl;
     }
     /* Set the operating conditions of the segment */
-    oc->set_segment_operating_conditions(a_mission_step);
+    oc->set_segment_Operating_conditions(a_mission_step);
     if (this->mission_file->mission_data.at(a_mission_step).mode ==
-            flight_conditions::FLCHANGESIMULATION ||
-            this->mission_file->mission_data.at(a_mission_step).mode == flight_conditions::FLCHANGE) {
+            Flight_conditions::FLCHANGESIMULATION ||
+            this->mission_file->mission_data.at(a_mission_step).mode == Flight_conditions::FLCHANGE) {
         /* Set engine rating for flight level change to that preset in the mission.xml; if no flight level change segment is available, the rating Climb is used */
         std::vector<mission_file_data_handler::mission_data_set>::iterator theFLchangeMode(find_if(this->mission_file->mission_data.begin(),
                                                     this->mission_file->mission_data.end(),
@@ -844,14 +844,14 @@ double standard_mission::change_altitude_at_constant_speed(operating_conditions*
     /* Set the initial conditions of the segment */
     this->set_segment_initial_conditions(fc, !simulation_mode);
     uint16_t mode_backup(this->mission_file->mission_data.at(a_mission_step).mode);
-    if (this->mission_file->mission_data.at(a_mission_step).mode == flight_conditions::TAKEOFF) {
+    if (this->mission_file->mission_data.at(a_mission_step).mode == Flight_conditions::TAKEOFF) {
         /* Climb from LOF to Screen Height (35 ft) with constant CAS */
         fc->end_altitude = convertUnit(FOOT, METER, 35.); // Conversion of end_altitude from [ft] to [m]
-        this->mission_file->mission_data.at(a_mission_step).mode = flight_conditions::CLIMBCONSTCAS;
-    } else if (this->mission_file->mission_data.at(a_mission_step).mode == flight_conditions::LANDING) {
+        this->mission_file->mission_data.at(a_mission_step).mode = Flight_conditions::CLIMBCONSTCAS;
+    } else if (this->mission_file->mission_data.at(a_mission_step).mode == Flight_conditions::LANDING) {
         fc->end_altitude = convertUnit(FOOT, METER, 0.); // Conversion of end_altitude from [ft] to [m] (kept in with conversion to mark the Unit)
     } else if (this->mission_file->mission_data.at(a_mission_step).mode ==
-                        flight_conditions::CLIMBTOCRUISE && this->mission_file->mission_data.at(a_mission_step).auto_FL_optimum) {
+                        Flight_conditions::CLIMBTOCRUISE && this->mission_file->mission_data.at(a_mission_step).auto_FL_optimum) {
         this->calculate_optimum_FL(&fc->end_altitude, this->mission_file->desired_cruise_speed, 0., fc->aircraft_mass, oc->config,
                             1., oc->rating, this->mission_file->mission_data.at(a_mission_step).round_to_regular_FL);
     } else {
@@ -860,7 +860,7 @@ double standard_mission::change_altitude_at_constant_speed(operating_conditions*
     double delta_range(this->calculate_climb_or_descent(oc, fc, a_mission_step, simulation_mode));
     /* Reset mode */
     this->mission_file->mission_data.at(a_mission_step).mode = mode_backup;
-    if (this->requirement_switch && this->mission_file->mission_data.at(a_mission_step).mode == flight_conditions::CLIMBCONSTCAS) { // save TTC
+    if (this->requirement_switch && this->mission_file->mission_data.at(a_mission_step).mode == Flight_conditions::CLIMBCONSTCAS) { // save TTC
         // Save time up to 1500 ft
         if (fabs(this->mission_profile.back().end_altitude - convertUnit(FOOT, METER, 1500.)) < ACCURACY_LOW &&
             accuracyCheck(this->atm.getTemperature(0.), ISA_TEMPERATURE + this->delta_ISA, ACCURACY_HIGH) &&
@@ -871,13 +871,13 @@ double standard_mission::change_altitude_at_constant_speed(operating_conditions*
     return delta_range;
 }
 
-void standard_mission::cruise_at_constant_mach(operating_conditions* oc, flight_conditions* fc, const uint16_t& a_mission_step) {
+void standard_mission::cruise_at_constant_mach(Operating_conditions* oc, Flight_conditions* fc, const uint16_t& a_mission_step) {
     myRuntimeInfo->out << "Cruise at constant Mach number ... " << std::endl;
     bool iterate_top_of_descent_mass(EndnodeReadOnly<bool>("program_settings/general/iterate_top_of_descent_mass").read(this->rtIO->moduleConfig).value());
     int energy_carrier_id(fc->mission_data->at(fc->operating_condition->mission_step).energy_carrier_id);
 
     /* Set the operating conditions of the segment */
-    oc->set_segment_operating_conditions(a_mission_step);
+    oc->set_segment_Operating_conditions(a_mission_step);
     /* Set the initial conditions of the segment */
     this->set_segment_initial_conditions(fc);
     double x_end = this->mission_file->mission_data.at(a_mission_step).rel_segment_length *
@@ -916,9 +916,9 @@ void standard_mission::cruise_at_constant_mach(operating_conditions* oc, flight_
                     ((step_number % static_cast<uint16_t>(rangeSteps / rangeStepsFLchange)) == 0 || step_number == 0)) {
                     /*******FLIGHT LEVEL CHANGE SIMULATION ***************/
                     /* Calculate conditions with flight level change */
-                    operating_conditions backup_oc(*oc);
-                    flight_conditions backup_fc(*fc);
-                    flight_conditions FL_change_fc(*fc);
+                    Operating_conditions backup_oc(*oc);
+                    Flight_conditions backup_fc(*fc);
+                    Flight_conditions FL_change_fc(*fc);
                     //Save engine operating conditions for normal cruise before changes from flight level change simulation occur
                     std::vector<OperatingPoint> backup_operating_points = this->engine.get_operating_points(energy_carrier_id);
                     try {
@@ -928,7 +928,7 @@ void standard_mission::cruise_at_constant_mach(operating_conditions* oc, flight_
                         this->engine.set_operating_points(energy_carrier_id, backup_operating_points); //Reset engine operating conditions to normal cruise conditions
                         *oc = backup_oc;
                         *fc = backup_fc;
-                        this->mission_file->mission_data.at(a_mission_step).mode = flight_conditions::CRUISE;
+                        this->mission_file->mission_data.at(a_mission_step).mode = Flight_conditions::CRUISE;
                         /* Perform cruise iteration */
                         this->cruise_iteration(oc, fc, a_mission_step, true);
                         continue;
@@ -974,16 +974,16 @@ void standard_mission::cruise_at_constant_mach(operating_conditions* oc, flight_
                             *oc = backup_oc;
                             *fc = backup_fc;
                             /* Set new mission data */
-                            this->mission_file->mission_data.at(a_mission_step).mode = flight_conditions::FLCHANGE;
+                            this->mission_file->mission_data.at(a_mission_step).mode = Flight_conditions::FLCHANGE;
                             this->mission_file->mission_data.at(a_mission_step).altitude =
                                 fc->altitude + this->mission_file->mission_data.at(a_mission_step).auto_altitude_steps;
                             /* Change FL */
                             this->set_segment_initial_conditions(fc);
                             this->change_altitude_at_constant_speed(oc, fc, a_mission_step);
-                            flight_conditions finalSegmentFLchangeReal(*fc);
+                            Flight_conditions finalSegmentFLchangeReal(*fc);
                             /* Reset values */
                             myRuntimeInfo->out << "<--- continue cruising..." << std::endl;
-                            this->mission_file->mission_data.at(a_mission_step).mode = flight_conditions::CRUISE;
+                            this->mission_file->mission_data.at(a_mission_step).mode = Flight_conditions::CRUISE;
                             oc->rating = "cruise";
                             fc->update_operating_condition(*oc);
                             this->set_segment_initial_conditions(fc);
@@ -1014,9 +1014,9 @@ void standard_mission::cruise_at_constant_mach(operating_conditions* oc, flight_
     }
 }
 
-void standard_mission::air_to_air_fuelling(operating_conditions* oc, flight_conditions* fc, const uint16_t& a_mission_step) {
+void standard_mission::air_to_air_fuelling(Operating_conditions* oc, Flight_conditions* fc, const uint16_t& a_mission_step) {
     myRuntimeInfo->out << "Air-to-air Fueling ... " << std::endl;
-    oc->set_segment_operating_conditions(a_mission_step);
+    oc->set_segment_Operating_conditions(a_mission_step);
     /* Set the initial conditions of the segment */
     this->set_segment_initial_conditions(fc);
     /* Set the true airspeed at the end of the segment */
@@ -1052,10 +1052,10 @@ void standard_mission::air_to_air_fuelling(operating_conditions* oc, flight_cond
     }
 }
 
-void standard_mission::free_flight(operating_conditions* oc, flight_conditions* fc, const uint16_t& a_mission_step) {
+void standard_mission::free_flight(Operating_conditions* oc, Flight_conditions* fc, const uint16_t& a_mission_step) {
     myRuntimeInfo->out << "Climbing to Free-Flight-Optimum ... " << std::endl;
     /* Set the operating conditions of the segment */
-    oc->set_segment_operating_conditions(a_mission_step);
+    oc->set_segment_Operating_conditions(a_mission_step);
     /* Set the initial conditions of the segment */
     this->set_segment_initial_conditions(fc);
     /* Convert true airspeed into Mach number */
@@ -1087,7 +1087,7 @@ void standard_mission::free_flight(operating_conditions* oc, flight_conditions*
             /* Convert Mach number into true airspeed */
             fc->end_TAS = convertUnit(MACH, TRUEAIRSPEED, fc->altitude + fc->delta_h, this->atm, transition_mach);
         }
-        flight_conditions backup_fc(*fc);
+        Flight_conditions backup_fc(*fc);
         try {
             this->climb_iteration(oc, fc, a_mission_step);
         } catch (const std::string& error_message) {
@@ -1109,7 +1109,7 @@ void standard_mission::free_flight(operating_conditions* oc, flight_conditions*
     /* Free-Flight-Cruise */
     myRuntimeInfo->out << "Free-Flight-Cruise ... " << std::endl;
     /* Set the operating conditions of the segment */
-    oc->set_segment_operating_conditions(a_mission_step);
+    oc->set_segment_Operating_conditions(a_mission_step);
     /* Set the initial conditions of the segment */
     this->set_segment_initial_conditions(fc);
 
@@ -1183,14 +1183,14 @@ void standard_mission::calculate_econ_cruise_speed(double* econ_mach_number, con
     return;
 }
 
-void standard_mission::simulate_FL_change(flight_conditions* fc, const operating_conditions& oc, const double& altitude_change_step,
+void standard_mission::simulate_FL_change(Flight_conditions* fc, const Operating_conditions& oc, const double& altitude_change_step,
                                         const uint16_t& a_mission_step) {
     /* Backup */
     double aircraft_massBeforeClimb(fc->end_aircraft_mass);
     double delta_xClimb(0.);
-    operating_conditions theFLchangeOC(oc); //OperatingCondition
+    Operating_conditions theFLchangeOC(oc); //OperatingCondition
     /* Simulate flight level change */
-    this->mission_file->mission_data.at(a_mission_step).mode = flight_conditions::FLCHANGESIMULATION;
+    this->mission_file->mission_data.at(a_mission_step).mode = Flight_conditions::FLCHANGESIMULATION;
     this->mission_file->mission_data.at(a_mission_step).altitude = fc->altitude + altitude_change_step;
     this->set_segment_initial_conditions(fc, false);
     delta_xClimb = (this->change_altitude_at_constant_speed(&theFLchangeOC, fc, a_mission_step, true));
@@ -1199,7 +1199,7 @@ void standard_mission::simulate_FL_change(flight_conditions* fc, const operating
     fc->aircraft_mass = fc->end_aircraft_mass;
     fc->TAS = fc->end_TAS;
     fc->altitude = fc->end_altitude;
-    this->mission_file->mission_data.at(a_mission_step).mode = flight_conditions::CRUISE;
+    this->mission_file->mission_data.at(a_mission_step).mode = Flight_conditions::CRUISE;
     theFLchangeOC.rating = "cruise";
     fc->update_operating_condition(theFLchangeOC);
     this->set_segment_initial_conditions(fc, false);
@@ -1211,7 +1211,7 @@ void standard_mission::simulate_FL_change(flight_conditions* fc, const operating
     this->mission_file->mission_data.at(a_mission_step).altitude = fc->altitude - altitude_change_step;
 }
 
-void standard_mission::fixed_ROC_acceleration_iteration(operating_conditions* oc, flight_conditions* fc, const double& min_acceleration,
+void standard_mission::fixed_ROC_acceleration_iteration(Operating_conditions* oc, Flight_conditions* fc, const double& min_acceleration,
                                             const uint16_t &mission_step, const bool& save_data) {
     /* Fixed ROC Iteration until convergence of delta_h */
     double residuum(0.);
@@ -1243,7 +1243,7 @@ void standard_mission::fixed_ROC_acceleration_iteration(operating_conditions* oc
     oc->delete_used_bleed_and_shaft_power_offtakes(fc->delta_t);
 }
 
-void standard_mission::check_iteration_conditions(operating_conditions* oc, flight_conditions* fc,
+void standard_mission::check_iteration_conditions(Operating_conditions* oc, Flight_conditions* fc,
                                                     const uint16_t &mission_step, const double& minimum_ROC) {
     /* Check if flight direction is forward */
     if (fc->delta_x < 0.) {
@@ -1281,7 +1281,7 @@ void standard_mission::check_iteration_conditions(operating_conditions* oc, flig
     }
 }
 
-void standard_mission::cruise_iteration(operating_conditions* oc, flight_conditions* fc, const uint16_t &mission_step, bool save_data) {
+void standard_mission::cruise_iteration(Operating_conditions* oc, Flight_conditions* fc, const uint16_t &mission_step, bool save_data) {
     /* Cruise Iteration until convergence of average fuel flow mean_fuel_mass_flow */
     double residuum(0.);
     uint16_t counter(0);
@@ -1310,7 +1310,7 @@ void standard_mission::cruise_iteration(operating_conditions* oc, flight_conditi
     oc->delete_used_bleed_and_shaft_power_offtakes(fc->delta_t);
 }
 
-void standard_mission::free_flight_iteration(operating_conditions* oc, flight_conditions* fc, const uint16_t &mission_step, bool save_data) {
+void standard_mission::free_flight_iteration(Operating_conditions* oc, Flight_conditions* fc, const uint16_t &mission_step, bool save_data) {
     int energy_carrier_id(fc->mission_data->at(fc->operating_condition->mission_step).energy_carrier_id);
     /* Add bleed and ShaftPower-Offtakes */
     fc->bleed = oc->background_bleed;
@@ -1450,7 +1450,7 @@ void standard_mission::free_flight_iteration(operating_conditions* oc, flight_co
     oc->delete_used_bleed_and_shaft_power_offtakes(fc->delta_t);
 }
 
-void standard_mission::set_segment_initial_conditions(flight_conditions* fc, const bool& use_mission_condition, const double& an_end_CL) {
+void standard_mission::set_segment_initial_conditions(Flight_conditions* fc, const bool& use_mission_condition, const double& an_end_CL) {
     /* Segment initial conditions have to be iterated until convergence due to internal dependencies
      * iteration values are: CL, Drag, and thrust
      * note: the weight (mass) as fourth force has not to be integrated here because it is fixed as segment start value as well as the true airspeed (TAS) and flight altitude (h)
@@ -1511,7 +1511,7 @@ void standard_mission::set_segment_initial_conditions(flight_conditions* fc, con
     fc->energyflow = {energy_carrier_id, this->engine.get_aircraft_energyflow(energy_carrier_id, fc->fuel_mass_flow)};
 }
 
-void standard_mission::set_initial_iteration_start_values(flight_conditions* fc, const double& an_end_CL) {
+void standard_mission::set_initial_iteration_start_values(Flight_conditions* fc, const double& an_end_CL) {
     /* Flight track values */
     fc->glidepath_angle = fc->end_glidepath_angle;
     /* Acceleration */
@@ -1526,7 +1526,7 @@ void standard_mission::set_initial_iteration_start_values(flight_conditions* fc,
     fc->set_initial_thrust();
 }
 
-void standard_mission::set_initial_aerodynamic_values(flight_conditions* fc, const double& an_end_CL) {
+void standard_mission::set_initial_aerodynamic_values(Flight_conditions* fc, const double& an_end_CL) {
     if (std::isnan(an_end_CL)) {
         fc->CL = this->aero.getCL(fc->altitude,
                                                                 convertUnit(TRUEAIRSPEED, MACH, fc->altitude, this->atm, fc->TAS),
@@ -1551,12 +1551,12 @@ void standard_mission::set_initial_aerodynamic_values(flight_conditions* fc, con
                                                         fc->altitude, fc->CL,
                                                         fc->operating_condition->config, atm));
     }
-    if (this->mission_file->mission_data.at(fc->operating_condition->mission_step).mode == flight_conditions::LANDING) {
+    if (this->mission_file->mission_data.at(fc->operating_condition->mission_step).mode == Flight_conditions::LANDING) {
         fc->drag *= this->aero.maxSpoilerFactor; //activate ground spoilers
     }
 }
 
-void standard_mission::set_iteration_start_values(flight_conditions* fc, const double& end_track_angle, const double& end_acceleration, const double& an_end_CL) {
+void standard_mission::set_iteration_start_values(Flight_conditions* fc, const double& end_track_angle, const double& end_acceleration, const double& an_end_CL) {
     /* Flight track values */
     fc->end_glidepath_angle = end_track_angle;
     fc->mean_glidepath_angle = (fc->glidepath_angle + fc->end_glidepath_angle) / 2.;
@@ -1595,7 +1595,7 @@ void standard_mission::set_iteration_start_values(flight_conditions* fc, const d
     fc->set_thrust();
 }
 
-void standard_mission::set_aerodynamic_values(flight_conditions* fc, const double& an_end_CL) {
+void standard_mission::set_aerodynamic_values(Flight_conditions* fc, const double& an_end_CL) {
     double mach(convertUnit(TRUEAIRSPEED, MACH, fc->end_altitude, this->atm, fc->end_TAS));
     fc->end_reynolds = atm.getDensity(fc->end_altitude) *
                                         this->MAC * fc->end_TAS / atm.getViscosity(fc->end_altitude);
@@ -1634,7 +1634,7 @@ void standard_mission::set_aerodynamic_values(flight_conditions* fc, const doubl
         throwError(__FILE__, __func__, __LINE__, "Drag NaN.");
     }
     /* Activate spoilers during Landing or if thrust is larger than required thrust for stationary flight */
-    if (this->mission_file->mission_data.at(fc->operating_condition->mission_step).mode == flight_conditions::LANDING ||
+    if (this->mission_file->mission_data.at(fc->operating_condition->mission_step).mode == Flight_conditions::LANDING ||
         (fc->engine_limit_reached &&
             (fc->end_thrust - (sin(fc->mean_glidepath_angle) * fc->end_aircraft_mass * G_FORCE +
                 fc->end_drag + fc->end_aircraft_mass * fc->mean_acceleration)) / fc->end_thrust > ACCURACY_HIGH)) {
@@ -1643,7 +1643,7 @@ void standard_mission::set_aerodynamic_values(flight_conditions* fc, const doubl
     }
 }
 
-void standard_mission::set_specific_air_range(flight_conditions* fc) {
+void standard_mission::set_specific_air_range(Flight_conditions* fc) {
     double mach(convertUnit(TRUEAIRSPEED, MACH, fc->end_altitude, this->atm, fc->end_TAS));
     double LoD(this->aero.getCLLoverD(mach, fc->end_CL, fc->operating_condition->config));
     if (sophistication_level != UNSOPHISTICATED) {
@@ -1656,7 +1656,7 @@ void standard_mission::set_specific_air_range(flight_conditions* fc) {
     fc->end_specific_air_range = LoD * fc->end_TAS / (TSFC * fc->end_aircraft_mass * G_FORCE);
 }
 
-void standard_mission::set_segment_end_conditions(flight_conditions* fc, const double& end_TAS, const double& end_altitude,
+void standard_mission::set_segment_end_conditions(Flight_conditions* fc, const double& end_TAS, const double& end_altitude,
                                                     const double& end_track_angle, const double& end_acceleration,
                                                     const double& an_end_CL, const bool& use_breguet) {
     /* Segment end conditions have to be iterated until convergence due to internal dependencies
@@ -1718,7 +1718,7 @@ void standard_mission::set_segment_end_conditions(flight_conditions* fc, const d
     fc->stabilizer_incidence = aero.getIStabPolar(mach, fc->end_CL, fc->operating_condition->config);
 }
 
-void standard_mission::set_segment_end_cg(flight_conditions *fc) {
+void standard_mission::set_segment_end_cg(Flight_conditions *fc) {
     if (sophistication_level != UNSOPHISTICATED) { // TODO(Gerrit): end_total_fuel_mass und previous_loaded_fuel_mass anpassen!
         double new_fuel_mass = this->previous_loaded_fuel_mass[0] + (this->mission_profile.back().end_total_fuel_mass[0] - fc->step_fuel_mass);
         if (fc->first_run_switch) {
@@ -1743,7 +1743,7 @@ void standard_mission::set_segment_end_cg(flight_conditions *fc) {
     }
 }
 
-void standard_mission::save_segment_data(flight_conditions* fc, const operating_conditions &oc, unsigned int mission_step) {
+void standard_mission::save_segment_data(Flight_conditions* fc, const Operating_conditions &oc, unsigned int mission_step) {
     double aircraft_mass_tmp = this->mission_profile.back().end_total_mass - fc->step_fuel_mass;
     int energy_carrier_id(fc->mission_data->at(fc->operating_condition->mission_step).energy_carrier_id);
     if (aircraft_mass_tmp <= 0. || std::isnan(aircraft_mass_tmp) || std::isinf(aircraft_mass_tmp)) {
@@ -1775,7 +1775,7 @@ void standard_mission::save_segment_data(flight_conditions* fc, const operating_
                     error_message << "Reduce drag.";
                     throwError(__FILE__, __func__, __LINE__, error_message.str());
                 } else {}
-                operating_conditions oc_tmp(oc);
+                Operating_conditions oc_tmp(oc);
                 oc_tmp.rating = newRating;
                 myRuntimeInfo->info << error_message.str() << "Automatically increasing thrust rating tmporarily from '" << oc.rating << "' to '"
                                     << oc_tmp.rating << "'" << std::endl;
@@ -1805,11 +1805,12 @@ void standard_mission::save_segment_data(flight_conditions* fc, const operating_
     }
 
     /* Add landing or takeoff fuel if the step is within one of these segments */
-    if (fc->operating_condition->config == "approach" || fc->operating_condition->config == "approach_landing_gear_out"
-        || fc->operating_condition->config == "landing") {
-        this->landing_fuel_mass[energy_carrier_id_tmp] += fc->step_fuel_mass;
-    } else if (fc->operating_condition->config == "takeoff" || fc->operating_condition->config == "takeoff_landing_gear_retracted") {
-        this->takeoff_fuel_mass[energy_carrier_id_tmp] += fc->step_fuel_mass;
+    if (fc->altitude <= (convertUnit(FOOT, METER, 3000.))) { // If altitude is below FL30, LTO reached
+        if (this->cruise_profile_start == 0) { // If no cruise profile was reached yet, assume takeoff is in progress
+            this->takeoff_fuel_mass[energy_carrier_id_tmp] += fc->step_fuel_mass;
+        } else { // if cruise was flown, assume landing is in progress
+            this->landing_fuel_mass[energy_carrier_id_tmp] += fc->step_fuel_mass;
+        }
     }
 
     // Push the result
@@ -1901,7 +1902,7 @@ void standard_mission::save_segment_data(flight_conditions* fc, const operating_
     }
 }
 
-void standard_mission::interpolate_stabilizer_incidence(flight_conditions *fc) {
+void standard_mission::interpolate_stabilizer_incidence(Flight_conditions *fc) {
     double current_cg;
     double design_value = fc->stabilizer_incidence;
     if (fc->new_aircraft_cg != 0) {
@@ -1920,7 +1921,7 @@ void standard_mission::interpolate_stabilizer_incidence(flight_conditions *fc) {
     fc->stabilizer_incidence = this->interpolateViaCoG(current_cg, design_value, partner_value);
 }
 
-bool standard_mission::decide_FL_change(const flight_conditions& cruise_fc, const flight_conditions& next_FL_fc,
+bool standard_mission::decide_FL_change(const Flight_conditions& cruise_fc, const Flight_conditions& next_FL_fc,
                                         const double& cost_index, const double& cruise_range, const double& cruise_fuel) {
     /* Calculate ranges until descent for constant flight level (rest_range_cruise) and for flight level change (rest_range_climb) using the same starting point x */
     double rest_range(this->mission_file->Range - this->mission_profile.back().end_range);
@@ -2010,7 +2011,7 @@ void standard_mission::calculate_optimum_FL(double* optimum_altitude, const doub
     return;
 }
 
-void standard_mission::calculate_max_ROC_speed(double* mach, const flight_conditions& fc, const double& derate) {
+void standard_mission::calculate_max_ROC_speed(double* mach, const Flight_conditions& fc, const double& derate) {
     double rel_step_size(1.e-2); // Relative step size
     double mach_1(0.);
     double mach_2(0.);
diff --git a/mission_analysis/src/standard_mission/standard_mission/standard_mission.cpp b/mission_analysis/src/standard_mission/standard_mission/standard_mission.cpp
index 7799ac7d63184a4101ae7fd27d5028889c689a15..6edda0d785e594c5f8de59209734b2726296feef 100644
--- a/mission_analysis/src/standard_mission/standard_mission/standard_mission.cpp
+++ b/mission_analysis/src/standard_mission/standard_mission/standard_mission.cpp
@@ -322,10 +322,10 @@ void standard_mission::initialize() {
 }
 
 void standard_mission::run() {
-    operating_conditions oc(&this->mission_file->mission_data); // Initialization of operating conditions object
+    Operating_conditions oc(&this->mission_file->mission_data); // Initialization of operating conditions object
     oc.config = this->mission_file->mission_data.at(0).config;
     oc.rating = this->mission_file->mission_data.at(0).rating;
-    flight_conditions fc(&this->mission_file->mission_data, &oc,
+    Flight_conditions fc(&this->mission_file->mission_data, &oc,
                                         &this->aero, &this->atm, &this->engine, this->variable_camber_segment_quantity); // Initialization of flight conditions object
     // fill an empty map with needed energy carrier IDs and initialize them with 0 J consumed energy
     std::map<int, double> initial_energy;
@@ -383,63 +383,63 @@ void standard_mission::run() {
         myRuntimeInfo->out << "Current CL:       " << this->mission_profile.back().end_CL << std::endl;
         switch (this->mission_file->mission_data.at(i).mode) {
             /* Mode: take off */
-            case flight_conditions::TAKEOFF:
+            case Flight_conditions::TAKEOFF:
                 this->takeoff_calculation(&oc, &fc, i);
                 break;
             /* Mode: accelerate while maintaining a constant rate of climb */
-            case flight_conditions::ACCELERATE:
+            case Flight_conditions::ACCELERATE:
                 this->change_speed_at_constant_ROC(&oc, &fc, i);
                 break;
             /* Mode: climb while maintaining a constant calibrated airspeed */
-            case flight_conditions::CLIMBCONSTCAS:
+            case Flight_conditions::CLIMBCONSTCAS:
                 this->change_altitude_at_constant_speed(&oc, &fc, i);
                 break;
             /* Mode: climb to cruise altitude */
-            case flight_conditions::CLIMBTOCRUISE:
+            case Flight_conditions::CLIMBTOCRUISE:
                 this->climb_to_cruise_altitude(&oc, &fc, i);
                 break;
             /* Mode: cruise with a constant Mach number */
-            case flight_conditions::CRUISE:
+            case Flight_conditions::CRUISE:
                 this->cruise_at_constant_mach(&oc, &fc, i);
                 break;
             /* Mode: descend to approach */
-            case flight_conditions::DESCENT:
+            case Flight_conditions::DESCENT:
                 myRuntimeInfo->out << "Descent to 10.000 ft ... " << std::endl;
                 this->cruise_profile_end = this->mission_profile.size() - 1; // Set index
                 this->change_altitude_at_constant_speed(&oc, &fc, i);
                 break;
             /* Mode: approach to landing */
-            case flight_conditions::APPROACH:
+            case Flight_conditions::APPROACH:
                 myRuntimeInfo->out << "Approach to landing ... " << std::endl;
                 this->change_altitude_at_constant_speed(&oc, &fc, i);
                 break;
             /* Mode: decelerate during approach */
-            case flight_conditions::DECELERATE:
+            case Flight_conditions::DECELERATE:
                 this->change_speed_at_constant_ROC(&oc, &fc, i);
                 break;
             /* Mode: landing */
-            case flight_conditions::LANDING:
+            case Flight_conditions::LANDING:
                 this->landing(&oc, &fc, i);
                 break;
             /* Mode: glide slope interception */
-            case flight_conditions::GSINTERCEPTION:
+            case Flight_conditions::GSINTERCEPTION:
                 this->glideslope_interception(&oc, &fc, i);
                 break;
             /* Mode: climb (change flight level) with a constant calibrated airspeed or Mach number at a fixed rate of climb */
-            case flight_conditions::FLCHANGE:
+            case Flight_conditions::FLCHANGE:
                 this->change_altitude_at_constant_speed(&oc, &fc, i);
                 break;
             /* Mode: climb to service ceiling */
-            case flight_conditions::CLIMBTOSERVICECEILING:
+            case Flight_conditions::CLIMBTOSERVICECEILING:
                 this->climb_to_service_ceiling(&oc, &fc, i);
                 i = INT_MAX; // Break for loop after service ceiling (requirement check). Other steps are not needed anymore
                 break;
             /* Mode: air to air fueling */
-            case flight_conditions::AIRTOAIRFUELLING:
+            case Flight_conditions::AIRTOAIRFUELLING:
                 this->air_to_air_fuelling(&oc, &fc, i);
                 break;
             /* Mode: free flight */
-            case flight_conditions::FREEFLIGHT:
+            case Flight_conditions::FREEFLIGHT:
                 this->free_flight(&oc, &fc, i);
                 break;
             /* No valid mission mode, error message */
@@ -501,9 +501,9 @@ void standard_mission::update() {
     this->check_and_add_nodes(subpath + "/in_flight_energy", description);
     description = "Amount of energy needed for trip segments (all segments from takeoff to landing) for specified energy carrier";
     this->update_energy_nodes(this->trip_fuel_mass, subpath + "/in_flight_energy/trip_energy", description, &(energy_carrier_id), &(consumed_energy));
-    description = "Amount of energy needed for landing segment for specified energy carrier";
-    this->update_energy_nodes(this->takeoff_fuel_mass, subpath + "/in_flight_energy/takeoff_energy", description, &(energy_carrier_id), &(consumed_energy));
     description = "Amount of energy needed for takeoff segment for specified energy carrier";
+    this->update_energy_nodes(this->takeoff_fuel_mass, subpath + "/in_flight_energy/takeoff_energy", description, &(energy_carrier_id), &(consumed_energy));
+    description = "Amount of energy needed for landing segment for specified energy carrier";
     this->update_energy_nodes(this->landing_fuel_mass, subpath + "/in_flight_energy/landing_energy", description, &(energy_carrier_id), &(consumed_energy));
 
     /* Taxiing */
@@ -651,12 +651,12 @@ void standard_mission::analyze_mission_profile(bool* last_segment_free_flight_sw
         modes.push_back(mission_file->mission_data.at(i).mode);
     }
     /* Iterators to find the configuration entries */
-    std::vector<int>::iterator entryCruise = find(modes.begin(), modes.end(), flight_conditions::CRUISE); // Iterator to find the configuration entry
-    std::vector<int>::iterator entryFF = find(modes.begin(), modes.end(), flight_conditions::FREEFLIGHT); // Iterator to find the configuration entry
-    std::vector<int>::iterator descent_entry = find(modes.begin(), modes.end(), flight_conditions::DESCENT); // Iterator to find the configuration entry
+    std::vector<int>::iterator entryCruise = find(modes.begin(), modes.end(), Flight_conditions::CRUISE); // Iterator to find the configuration entry
+    std::vector<int>::iterator entryFF = find(modes.begin(), modes.end(), Flight_conditions::FREEFLIGHT); // Iterator to find the configuration entry
+    std::vector<int>::iterator descent_entry = find(modes.begin(), modes.end(), Flight_conditions::DESCENT); // Iterator to find the configuration entry
 
     if (entryCruise == modes.end() && this->requirement_switch) { // No cruise phase given? Check whether the requirements missions works (if turned on)
-        entryCruise = find(modes.begin(), modes.end(), flight_conditions::CLIMBTOSERVICECEILING); // CLIMTOSERVICECEILING is only used in requirement mission
+        entryCruise = find(modes.begin(), modes.end(), Flight_conditions::CLIMBTOSERVICECEILING); // CLIMTOSERVICECEILING is only used in requirement mission
         if (entryCruise == modes.end()) { // Undefined mission type
             /* Error message */
             throwError(__FILE__, __func__, __LINE__, "Undefined mission type. No Cruise phase for normal mission or climb_to_service_ceiling phase for requirement mission given.");
@@ -668,12 +668,12 @@ void standard_mission::analyze_mission_profile(bool* last_segment_free_flight_sw
         if (entryCruise != modes.end()) { // Already at the end?
             position = static_cast<uint16_t>(entryCruise - modes.begin());
             positions.push_back(position); // Save positions with cruise entries
-            entryCruise = find(entryCruise + 1, modes.end(), flight_conditions::CRUISE); // Let the iterator search further
+            entryCruise = find(entryCruise + 1, modes.end(), Flight_conditions::CRUISE); // Let the iterator search further
         }
         if (entryFF != modes.end()) { // Already at the end?
             position = static_cast<uint16_t>(entryFF - modes.begin());
             positions.push_back(position); // Save positions with cruise entries
-            entryFF = find(entryFF + 1, modes.end(), flight_conditions::FREEFLIGHT); // Let the iterator search further
+            entryFF = find(entryFF + 1, modes.end(), Flight_conditions::FREEFLIGHT); // Let the iterator search further
             *last_segment_free_flight_switch = true;
         }
     }
@@ -681,7 +681,7 @@ void standard_mission::analyze_mission_profile(bool* last_segment_free_flight_sw
     this->top_of_descent_index = position; // Top of descent
     while (descent_entry != modes.end()) { // Until the search iterator reaches its end
         this->end_of_descent_index = static_cast<uint16_t>(descent_entry - modes.begin());
-        descent_entry = find(descent_entry + 1, modes.end(), flight_conditions::DESCENT); // Let the iterator search further
+        descent_entry = find(descent_entry + 1, modes.end(), Flight_conditions::DESCENT); // Let the iterator search further
     }
     /* Output of segment distances */
     for (size_t i(0); i < positions.size(); i++) {
diff --git a/mission_analysis/src/standard_mission/standard_mission/standard_mission.h b/mission_analysis/src/standard_mission/standard_mission/standard_mission.h
index decc880c806a112105155b7385e638b91b3adcb8..41eaad27584601a94ebba7e6ed550baf6ad26699 100644
--- a/mission_analysis/src/standard_mission/standard_mission/standard_mission.h
+++ b/mission_analysis/src/standard_mission/standard_mission/standard_mission.h
@@ -414,33 +414,33 @@ class standard_mission : public Strategy {
      * \param fc: pointer to a flight condition object
      * \param a_mission_step: reference to a mission step [-]
      */
-    void calculate_ground_run(operating_conditions* oc, flight_conditions* fc, const uint16_t& a_mission_step);
+    void calculate_ground_run(Operating_conditions* oc, Flight_conditions* fc, const uint16_t& a_mission_step);
     /** \brief Function calculates take off
      * \param oc: pointer to an operating condition object
      * \param fc: pointer to a flight condition object
      * \param a_mission_step: reference to a mission step [-]
      */
-    void takeoff_calculation(operating_conditions* oc, flight_conditions* fc, const uint16_t& a_mission_step);
+    void takeoff_calculation(Operating_conditions* oc, Flight_conditions* fc, const uint16_t& a_mission_step);
     /** \brief Function climbs to cruise altitude
      * \param oc: pointer to an operating condition object
      * \param fc: pointer to a flight condition object
      * \param a_mission_step: reference to a mission step [-]
      */
-    void climb_to_cruise_altitude(operating_conditions* oc, flight_conditions* fc, const uint16_t& a_mission_step);
+    void climb_to_cruise_altitude(Operating_conditions* oc, Flight_conditions* fc, const uint16_t& a_mission_step);
     /** \brief Function to climb to service ceiling
      * \param oc: pointer to an operating condition object
      * \param fc: pointer to a flight condition object
      * \param a_mission_step: reference to a mission step [-]
      */
-    void climb_to_service_ceiling(operating_conditions* oc, flight_conditions* fc, const uint16_t& a_mission_step);
+    void climb_to_service_ceiling(Operating_conditions* oc, Flight_conditions* fc, const uint16_t& a_mission_step);
     /** \brief Function for climb iteration
-     * \param oc operating_conditions*: pointer to an operating condition object
-     * \param fc flight_conditions*: pointer to a flight condition object
+     * \param oc Operating_conditions*: pointer to an operating condition object
+     * \param fc Flight_conditions*: pointer to a flight condition object
      * \param mission_step uint16_t: constant reference to a mission step [-]
      * \param minimum_ROC constant reference to a minimum rate of climb value that should be maintained during climb iteration [m/s]
      * \param save_data constant reference for a switch if the calculated flight condition data should be saved to the mission_profile vector [-]
      */
-    void climb_iteration(operating_conditions* oc, flight_conditions* fc, const uint16_t &mission_step,
+    void climb_iteration(Operating_conditions* oc, Flight_conditions* fc, const uint16_t &mission_step,
                         const double& minimum_ROC = convertUnit(FOOTPERMINUTE, METERPERSECOND, 100.), const bool& save_data = true);
     /** \brief Function estimates the aircraft mass at top of descent using Breguet Range equation with current aircraft mass and current SAR
      * \param current_aircraft_mass const double&: Mass of aircraft at begin of cruise range until start of descent [kg]
@@ -458,7 +458,7 @@ class standard_mission : public Strategy {
      * \param simulation_mode Constant reference to a switch if the function should run the estimation mode or the real mode; default is the real mode
      * \return range_for_descent if simulation_mode is active, the needed range to descent to approach is returned [m]
      */
-    double calculate_climb_or_descent(operating_conditions* oc, flight_conditions* fc,
+    double calculate_climb_or_descent(Operating_conditions* oc, Flight_conditions* fc,
                                     const uint16_t& a_mission_step, const bool& simulation_mode = false);
     /** \brief Function estimates the values for top of descent, bottom of descent and with this the range for descent
      *  \param last_segment_free_flight_switch Constant reference to a switch if the last mission segment is a free_flight segment
@@ -470,18 +470,18 @@ class standard_mission : public Strategy {
      * \param top_of_descent_mass: mass at top of descent [kg]
      * \return (Range, Fuel) pair<double, double>: Returns the descent distance of the approach route [m] and the consumed fuel [kg]
      */
-    std::pair<double, double> calculate_descent(const operating_conditions& oc, const flight_conditions& fc, double top_of_descent_mass);
+    std::pair<double, double> calculate_descent(const Operating_conditions& oc, const Flight_conditions& fc, double top_of_descent_mass);
     /** \brief Function updates the descent range current_descent_distance and with this also the end of current cruise segment as well as the aircraft mass at top of descent
      * \param segmend_end_range double*: pointer to the cruise end of current segment
      * \param top_of_descent_aircraft_mass double*: pointer to the current aircraft mass at top of descent
      * \param current_descent_distance const double&: constant reference to the current descent distance
      * \param oc const operatingCondition&: constant reference to an operating condition object
-     * \param fc const flight_conditions&: constant reference to a flight condition object
+     * \param fc const Flight_conditions&: constant reference to a flight condition object
      * \param a_mission_step: reference to a mission step [-]
      * \return (Range, Fuel) pair<double, double>: Returns the descent distance of the approach route [m] and the consumed fuel [kg]
      */
     std::pair<double, double> iterate_descent(double* segmend_end_range, double* top_of_descent_aircraft_mass, const double& current_descent_distance,
-                                const operating_conditions& oc, const flight_conditions& fc, const uint16_t& a_mission_step);
+                                const Operating_conditions& oc, const Flight_conditions& fc, const uint16_t& a_mission_step);
     /** \brief Function to calculate glideslope interception
      * \param oc: pointer to an operating condition object
      * \param fc: pointer to a flight condition object
@@ -489,7 +489,7 @@ class standard_mission : public Strategy {
      * \param simulation_mode Constant reference to a switch if the function should run the estimation mode or the real mode; default is the real mode
      * \return range_for_descent Needed range to descent to perform a glide slope landing [m]
      */
-    double glideslope_interception(operating_conditions* oc, flight_conditions* fc, const uint16_t& a_mission_step,
+    double glideslope_interception(Operating_conditions* oc, Flight_conditions* fc, const uint16_t& a_mission_step,
                                     const bool& simulation_mode = false);
     /** \brief Function for landing
      * \param oc: pointer to an operating condition object
@@ -498,7 +498,7 @@ class standard_mission : public Strategy {
      * \param simulation_mode Constant reference to a switch if the function should run the estimation mode or the real mode; default is the real mode
      * \return range_for_descentToTouchdown the needed range to descent from screen height (50ft) to touchdown is returned [m]
      */
-    double landing(operating_conditions* oc, flight_conditions* fc, const uint16_t& a_mission_step, const bool& simulation_mode = false);
+    double landing(Operating_conditions* oc, Flight_conditions* fc, const uint16_t& a_mission_step, const bool& simulation_mode = false);
     /** \brief Function changes speed at constant rate of climb
      * \param oc: pointer to an operating condition object
      * \param fc: pointer to a flight condition object
@@ -506,7 +506,7 @@ class standard_mission : public Strategy {
      * \param simulation_mode Constant reference to a switch if the function should run the estimation mode or the real mode; default is the real mode
      * \return range_for_descent if simulation_mode is active, the needed range to descent to approach is returned [m]
      */
-    double change_speed_at_constant_ROC(operating_conditions* oc, flight_conditions* fc,
+    double change_speed_at_constant_ROC(Operating_conditions* oc, Flight_conditions* fc,
                                         const uint16_t& a_mission_step, const bool& simulation_mode = false);
     /** \brief Function changes altitude with constant speed
      * \details if missionData.mach_switch is active, the Mach number is set constant during climb, else the CAS is taken (e.g. for CLIMBWITHCONSTCAS)
@@ -516,26 +516,26 @@ class standard_mission : public Strategy {
      * \param simulation_mode Constant reference to a switch if the function should run the estimation mode or the real mode; default is the real mode
      * \return descentRange if simulation_mode is active, the needed range to descent to approach is returned [m]
      */
-    double change_altitude_at_constant_speed(operating_conditions* oc, flight_conditions* fc,
+    double change_altitude_at_constant_speed(Operating_conditions* oc, Flight_conditions* fc,
                                                 const uint16_t& a_mission_step, const bool& simulation_mode = false);
     /** \brief Function calculates cruise with constant Mach number
      * \param oc: pointer to an operating condition object
      * \param fc: pointer to a flight condition object
      * \param a_mission_step: reference to a mission step [-]
      */
-    void cruise_at_constant_mach(operating_conditions* oc, flight_conditions* fc, const uint16_t& a_mission_step);
+    void cruise_at_constant_mach(Operating_conditions* oc, Flight_conditions* fc, const uint16_t& a_mission_step);
     /** \brief Function for air to air fuelling
      * \param oc: pointer to an operating condition object
      * \param fc: pointer to a flight condition object
      * \param a_mission_step: reference to a mission step [-]
      */
-    void air_to_air_fuelling(operating_conditions* oc, flight_conditions* fc, const uint16_t& a_mission_step);
+    void air_to_air_fuelling(Operating_conditions* oc, Flight_conditions* fc, const uint16_t& a_mission_step);
     /** \brief Function for free flight
      * \param oc: pointer to an operating condition object
      * \param fc: pointer to a flight condition object
      * \param a_mission_step: reference to a mission step [-]
      */
-    void free_flight(operating_conditions* oc, flight_conditions* fc, const uint16_t& a_mission_step);
+    void free_flight(Operating_conditions* oc, Flight_conditions* fc, const uint16_t& a_mission_step);
     /** \brief Function calculates ECON cruise speed. The Mach number and the flight altitude h are changed to the maximum range values.
      * \param econ_mach_number: pointer to ECON Mach number [-]
      * \param altitude: reference to altitude [m]
@@ -552,7 +552,7 @@ class standard_mission : public Strategy {
      * \param altitude_change_step: altitude change within the step [m]
      * \param a_mission_step: reference to mission_step
      */
-    void simulate_FL_change(flight_conditions* fc, const operating_conditions& oc,
+    void simulate_FL_change(Flight_conditions* fc, const Operating_conditions& oc,
                                 const double& altitude_change_step, const uint16_t& a_mission_step);
     /** \brief Function iterates fixed rate of climb acceleration
      * \param oc: pointer to an operating condition object
@@ -561,48 +561,48 @@ class standard_mission : public Strategy {
      * \param mission_step: reference to a mission step [-]
      * \param save_data constant reference for a switch if the calculated flight condition data should be saved to the mission_profile vector [-]
      */
-    void fixed_ROC_acceleration_iteration(operating_conditions* oc,  flight_conditions* fc, const double& min_acceleration,
+    void fixed_ROC_acceleration_iteration(Operating_conditions* oc,  Flight_conditions* fc, const double& min_acceleration,
                                         const uint16_t &mission_step, const bool& save_data);
     /** \brief Function checks the conditions after iteration
      * \details flight time, flight direction, minimum ROC, and flight track angle are checked for valid values; program is aborted if values are not valid
-     * \param oc operating_conditions*: pointer to an operating condition object
-     * \param fc flight_conditions*: pointer to a flight condition object
+     * \param oc Operating_conditions*: pointer to an operating condition object
+     * \param fc Flight_conditions*: pointer to a flight condition object
      * \param mission_step uint16_t: constant reference to a mission step [-]
      * \param minimum_ROC constant reference to a minimum rate of climb value that should be maintained during climb iteration [ft/min]
      */
-    void check_iteration_conditions(operating_conditions* oc, flight_conditions* fc, const uint16_t &mission_step, const double& minimum_ROC);
+    void check_iteration_conditions(Operating_conditions* oc, Flight_conditions* fc, const uint16_t &mission_step, const double& minimum_ROC);
     /** \brief Function for cruise iteration
      * \param oc: pointer to an operating condition object
      * \param fc: pointer to a flight condition object
      * \param mission_step: reference to a mission step [-]
      * \param save_data constant reference for a switch if the calculated flight condition data should be saved to the mission_profile vector [-]
      */
-    void cruise_iteration(operating_conditions* oc, flight_conditions* fc, const uint16_t &mission_step, bool save_data);
+    void cruise_iteration(Operating_conditions* oc, Flight_conditions* fc, const uint16_t &mission_step, bool save_data);
     /** \brief Function for free flight iteration
      * \param oc: pointer to an operating condition object
      * \param fc: pointer to a flight condition object
      * \param mission_step: reference to a mission step [-]
      * \param save_data constant reference for a switch if the calculated flight condition data should be saved to the mission_profile vector [-]
      */
-    void free_flight_iteration(operating_conditions* oc, flight_conditions* fc, const uint16_t &mission_step, bool save_data);
+    void free_flight_iteration(Operating_conditions* oc, Flight_conditions* fc, const uint16_t &mission_step, bool save_data);
     /** \brief Function sets segment initial conditions
      *  \param fc: pointer to a flight condition object
      *  \param use_mission_condition constant reference to decide whether the last mission step results should be used for m, altitude, and TAS or not; default: true [-]
      *  \param an_end_CL constant reference to an end lift coefficient of the segment; if not preset, it is calculated from constant level flight [-]
      */
-    void set_segment_initial_conditions(flight_conditions* fc, const bool& use_mission_condition = true, const double& an_end_CL = NAN);
+    void set_segment_initial_conditions(Flight_conditions* fc, const bool& use_mission_condition = true, const double& an_end_CL = NAN);
     /** \brief Function sets initial segment iteration start values
      *  \details values for glidepath_angle, a, liftcoefficient, drag and thrust are set
      *  \param fc: pointer to a flight condition object
      *  \param an_end_CL constant reference to an end lift coefficient of the segment; if not preset, it is calculated from constant level flight [-]
      */
-    void set_initial_iteration_start_values(flight_conditions* fc, const double& an_end_CL);
+    void set_initial_iteration_start_values(Flight_conditions* fc, const double& an_end_CL);
     /** \brief Functions sets initial segment value for CL and Drag
      *  \details if needed, drag is updated by using spoilers
      *  \param fc: pointer to a flight condition object
      *  \param an_end_CL constant reference to an end lift coefficient of the segment; if not preset, it is calculated from constant level flight [-]
      */
-    void set_initial_aerodynamic_values(flight_conditions* fc, const double& an_end_CL);
+    void set_initial_aerodynamic_values(Flight_conditions* fc, const double& an_end_CL);
     /** \brief Function sets iteration start values
      *  \details values for are set
      *  \param fc: pointer to a flight condition object
@@ -610,18 +610,18 @@ class standard_mission : public Strategy {
      *  \param end_acceleration constant reference to an end acceleration of the segment [m/s^2]
      *  \param an_end_CL constant reference to an end lift coefficient of the segment; if not preset, it is calculated from constant level flight [-]
      */
-    void set_iteration_start_values(flight_conditions* fc, const double& end_track_angle, const double& end_acceleration, const double& an_end_CL);
+    void set_iteration_start_values(Flight_conditions* fc, const double& end_track_angle, const double& end_acceleration, const double& an_end_CL);
     /** \brief Functions sets values for CLend and DragEnd
      *  \details if needed, DragEnd is updated by using spoilers
      *  \param fc: pointer to a flight condition object
      *  \param an_end_CL constant reference to an end lift coefficient of the segment; if not preset, it is calculated from constant level flight [-]
      */
-    void set_aerodynamic_values(flight_conditions* fc, const double& an_end_CL);
+    void set_aerodynamic_values(Flight_conditions* fc, const double& an_end_CL);
     /** \brief Function sets a value for set_specific_air [m/kg]
      *  \details the current end conditions for Lift over Drag, true airspeed, TSFC, and aircraft mass are used to calculate specific air range as L/D * end_TAS / (TSFC * aircraft mass)
      *  \param fc constant reference to an end lift coefficient of the segment; if not preset, it is calculated from constant level flight [-]
      */
-    void set_specific_air_range(flight_conditions* fc);
+    void set_specific_air_range(Flight_conditions* fc);
     /** \brief Function sets segment end conditions
      *  \param fc: pointer to a flight condition object
      *  \param end_TAS constant reference to an end velocity of the segment given as true airspeed [m/s]
@@ -631,22 +631,22 @@ class standard_mission : public Strategy {
      *  \param an_end_CL constant reference to an end lift coefficient of the segment; if not preset, it is calculated from constant level flight [-]
      *  \param use_breguet switch if Breguet equation is used for fuel mass calculation (true) or current engine fuel flow (false - default) [-]
      */
-    void set_segment_end_conditions(flight_conditions* fc, const double& end_TAS, const double& end_altitude, const double& end_track_angle,
+    void set_segment_end_conditions(Flight_conditions* fc, const double& end_TAS, const double& end_altitude, const double& end_track_angle,
                                     const double& end_acceleration, const double& an_end_CL = NAN, const bool& use_breguet = false);
     /** \brief Function calculates the CoG at the end of each segment
      *  \param fc: pointer to a flight condition object
      */
-    void set_segment_end_cg(flight_conditions *fc);
+    void set_segment_end_cg(Flight_conditions *fc);
     /** \brief Function saves segment data
      * \param fc: reference to a flight condition
      * \param oc: reference to an operating condition
      * \param mission_step: mission step [-]
      */
-    void save_segment_data(flight_conditions* fc, const operating_conditions &oc, unsigned int mission_step);
+    void save_segment_data(Flight_conditions* fc, const Operating_conditions &oc, unsigned int mission_step);
     /** \brief Function interpolates the stabilizer angle i_stab between CoGs
-     *  \param fc pointer to flight_conditions object
+     *  \param fc pointer to Flight_conditions object
      */
-    void interpolate_stabilizer_incidence(flight_conditions *fc);
+    void interpolate_stabilizer_incidence(Flight_conditions *fc);
     /** \brief Function decides whether the flight level is changed.
      * \param cruise_flight_condition: constant reference to object of cruise flight conditions
      * \param next_FL_flight_condition: constant reference to object of flight level change flight conditions
@@ -655,7 +655,7 @@ class standard_mission : public Strategy {
      * \param cruise_fuel: reference to the cruise fuel used from reference mission point (end_range) to end of constant level cruise segment [kg]
      * \return true or false [-]
      */
-    bool decide_FL_change(const flight_conditions& cruise_flight_condition, const flight_conditions& next_FL_flight_condition,
+    bool decide_FL_change(const Flight_conditions& cruise_flight_condition, const Flight_conditions& next_FL_flight_condition,
                             const double& cost_index, const double& cruise_range, const double& cruise_fuel);
     /** \brief Function calculates the optimum flight level
      * \param optimum_altitude: pointer to altitude [m]
@@ -677,7 +677,7 @@ class standard_mission : public Strategy {
      * \param derate: reference to relative derate to the selected rating [-]
      * \param rating: reference to rating
      */
-    void calculate_max_ROC_speed(double* mach, const flight_conditions& fc, const double& derate);
+    void calculate_max_ROC_speed(double* mach, const Flight_conditions& fc, const double& derate);
     /** \brief Function calculates optimum speed and flight level.
      * \param econ_mach_number: pointer to ECON Mach number [-]
      * \param altitude: pointer to altitude [m]