X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=src%2FFDM%2FJSBSim.cxx;h=406ce3a42bd6f9e85704d2ab475c03980029b1cf;hb=bb785797b9dd171f21c2577e0ba1a9c84e107583;hp=dc40c5a325103e99fcfb19c7351971fb0747dd93;hpb=1868e44ee44977069bd296afa30674318c7af161;p=flightgear.git

diff --git a/src/FDM/JSBSim.cxx b/src/FDM/JSBSim.cxx
index dc40c5a32..406ce3a42 100644
--- a/src/FDM/JSBSim.cxx
+++ b/src/FDM/JSBSim.cxx
@@ -23,7 +23,7 @@
 
 #include <simgear/compiler.h>
 
-#ifdef FG_MATH_EXCEPTION_CLASH
+#ifdef SG_MATH_EXCEPTION_CLASH
 #  include <math.h>
 #endif
 
@@ -31,276 +31,596 @@
 
 #include <simgear/constants.h>
 #include <simgear/debug/logstream.hxx>
-#include <simgear/math/fg_geodesy.hxx>
-#include <simgear/misc/fgpath.hxx>
+#include <simgear/math/sg_geodesy.hxx>
+#include <simgear/misc/sg_path.hxx>
+
+#include <Scenery/scenery.hxx>
 
 #include <Aircraft/aircraft.hxx>
 #include <Controls/controls.hxx>
-#include <Main/options.hxx>
+#include <Main/globals.hxx>
+#include <Main/fg_props.hxx>
+
+#include <FDM/JSBSim/FGFDMExec.h>
+#include <FDM/JSBSim/FGAircraft.h>
+#include <FDM/JSBSim/FGFCS.h>
+#include <FDM/JSBSim/FGPosition.h>
+#include <FDM/JSBSim/FGRotation.h>
+#include <FDM/JSBSim/FGState.h>
+#include <FDM/JSBSim/FGTranslation.h>
+#include <FDM/JSBSim/FGAuxiliary.h>
+#include <FDM/JSBSim/FGDefs.h>
+#include <FDM/JSBSim/FGInitialCondition.h>
+#include <FDM/JSBSim/FGTrim.h>
+#include <FDM/JSBSim/FGAtmosphere.h>
+#include <FDM/JSBSim/FGMassBalance.h>
+#include <FDM/JSBSim/FGAerodynamics.h>
+#include "JSBSim.hxx"
+
+/******************************************************************************/
+
+FGJSBsim::FGJSBsim( double dt ) 
+  : FGInterface(dt)
+{
+    bool result;
+   
+    fdmex=new FGFDMExec;
+    
+    State        = fdmex->GetState();
+    Atmosphere   = fdmex->GetAtmosphere();
+    FCS          = fdmex->GetFCS();
+    MassBalance  = fdmex->GetMassBalance();
+    Propulsion   = fdmex->GetPropulsion();
+    Aircraft     = fdmex->GetAircraft();
+    Translation  = fdmex->GetTranslation();
+    Rotation     = fdmex->GetRotation();
+    Position     = fdmex->GetPosition();
+    Auxiliary    = fdmex->GetAuxiliary();
+    Aerodynamics = fdmex->GetAerodynamics();
+    
+    Atmosphere->UseInternal();
+    
+    fgic=new FGInitialCondition(fdmex);
+    needTrim=true;
+  
+    SGPath aircraft_path( globals->get_fg_root() );
+    aircraft_path.append( "Aircraft" );
+
+    SGPath engine_path( globals->get_fg_root() );
+    engine_path.append( "Engine" );
+    set_delta_t( dt );
+    State->Setdt( dt );
+
+    result = fdmex->LoadModel( aircraft_path.str(),
+                               engine_path.str(),
+                               fgGetString("/sim/aircraft") );
+    
+
+    if (result) {
+      SG_LOG( SG_FLIGHT, SG_INFO, "  loaded aircraft.");
+    } else {
+      SG_LOG( SG_FLIGHT, SG_INFO,
+              "  aircraft does not exist (you may have mis-typed the name).");
+      throw(-1);
+    }
+
+    int Neng = Propulsion->GetNumEngines();
+    SG_LOG(SG_FLIGHT,SG_INFO, "Neng: " << Neng );
+    
+    for(int i=0;i<Neng;i++) {
+        add_engine( FGEngInterface() );
+    }  
+    
+    fgSetDouble("/fdm/trim/pitch-trim", FCS->GetPitchTrimCmd());
+    fgSetDouble("/fdm/trim/throttle",   FCS->GetThrottleCmd(0));
+    fgSetDouble("/fdm/trim/aileron",    FCS->GetDaCmd());
+    fgSetDouble("/fdm/trim/rudder",     FCS->GetDrCmd());
+
+    startup_trim = fgGetNode("/sim/startup/trim", true);
 
-#include <FDM/JSBsim/FGFDMExec.h>
-#include <FDM/JSBsim/FGAircraft.h>
-#include <FDM/JSBsim/FGFCS.h>
-#include <FDM/JSBsim/FGPosition.h>
-#include <FDM/JSBsim/FGRotation.h>
-#include <FDM/JSBsim/FGState.h>
-#include <FDM/JSBsim/FGTranslation.h>
-#include <FDM/JSBsim/FGAuxiliary.h>
-#include <FDM/JSBsim/FGDefs.h>
+    trimmed = fgGetNode("/fdm/trim/trimmed", true);
+    trimmed->setBoolValue(false);
 
-#include "JSBsim.hxx"
+    pitch_trim = fgGetNode("/fdm/trim/pitch-trim", true );
+    throttle_trim = fgGetNode("/fdm/trim/throttle", true );
+    aileron_trim = fgGetNode("/fdm/trim/aileron", true );
+    rudder_trim = fgGetNode("/fdm/trim/rudder", true );
+}
+
+/******************************************************************************/
+FGJSBsim::~FGJSBsim(void) {
+    if (fdmex != NULL) {
+        delete fdmex; fdmex=NULL;
+        delete fgic; fgic=NULL;
+    }  
+}
 
+/******************************************************************************/
 
 // Initialize the JSBsim flight model, dt is the time increment for
 // each subsequent iteration through the EOM
-int FGJSBsim::init( double dt ) {
-    FG_LOG( FG_FLIGHT, FG_INFO, "Starting and initializing JSBsim" );
 
-    FG_LOG( FG_FLIGHT, FG_INFO, "  created FDMExec" );
+void FGJSBsim::init() {
+    
+    SG_LOG( SG_FLIGHT, SG_INFO, "Starting and initializing JSBsim" );
+   
+    // Explicitly call the superclass's
+    // init method first.
+    FGInterface::init();
+
+    SG_LOG( SG_FLIGHT, SG_INFO, "  Initializing JSBSim with:" );
+
+    switch(fgic->GetSpeedSet()) {
+    case setned:
+        SG_LOG(SG_FLIGHT,SG_INFO, "  Vn,Ve,Vd= "
+               << Position->GetVn() << ", "
+               << Position->GetVe() << ", "
+               << Position->GetVd() << " ft/s");
+    break;
+    case setuvw:
+        SG_LOG(SG_FLIGHT,SG_INFO, "  U,V,W= "
+               << Translation->GetUVW(1) << ", "
+               << Translation->GetUVW(2) << ", "
+               << Translation->GetUVW(3) << " ft/s");
+    break;
+    case setmach:
+        SG_LOG(SG_FLIGHT,SG_INFO, "  Mach: "
+               << Translation->GetMach() );
+    break;
+    case setvc:
+    default:
+        SG_LOG(SG_FLIGHT,SG_INFO, "  Indicated Airspeed: "
+               << Auxiliary->GetVcalibratedKTS() << " knots" );
+    break;
+    }
 
-    FGPath aircraft_path( current_options.get_fg_root() );
-    aircraft_path.append( "Aircraft" );
+    SG_LOG( SG_FLIGHT, SG_INFO, "  Bank Angle: "
+            <<  Rotation->Getphi()*RADTODEG << " deg");
+    SG_LOG( SG_FLIGHT, SG_INFO, "  Pitch Angle: "
+            << Rotation->Gettht()*RADTODEG << " deg"  );
+    SG_LOG( SG_FLIGHT, SG_INFO, "  True Heading: "
+            << Rotation->Getpsi()*RADTODEG << " deg"  );
+    SG_LOG( SG_FLIGHT, SG_INFO, "  Latitude: "
+            <<  Position->GetLatitude() << " deg" );
+    SG_LOG( SG_FLIGHT, SG_INFO, "  Longitude: "
+            <<  Position->GetLongitude() << " deg"  );
 
-    FGPath engine_path( current_options.get_fg_root() );
-    engine_path.append( "Engine" );
+    SG_LOG( SG_FLIGHT, SG_INFO, "  loaded initial conditions" );
 
-    FDMExec.GetAircraft()->LoadAircraft( aircraft_path.str(), 
-					 engine_path.str(), 
-					 current_options.get_aircraft() );
-    FG_LOG( FG_FLIGHT, FG_INFO, "  loaded aircraft" << 
-	    current_options.get_aircraft() );
-
-    FG_LOG( FG_FLIGHT, FG_INFO, "Initializing JSBsim with:" );
-    FG_LOG( FG_FLIGHT, FG_INFO, "    U: " << current_options.get_uBody() );
-    FG_LOG( FG_FLIGHT, FG_INFO, "    V: " <<current_options.get_vBody() );
-    FG_LOG( FG_FLIGHT, FG_INFO, "    W: " <<current_options.get_wBody() );
-    FG_LOG( FG_FLIGHT, FG_INFO, "  phi: " <<get_Phi() );
-    FG_LOG( FG_FLIGHT, FG_INFO, "theta: " <<  get_Theta() );
-    FG_LOG( FG_FLIGHT, FG_INFO, "  psi: " <<  get_Psi() );
-    FG_LOG( FG_FLIGHT, FG_INFO, "  lat: " <<  get_Latitude() );
-    FG_LOG( FG_FLIGHT, FG_INFO, "  lon: " <<  get_Longitude() );
-    FG_LOG( FG_FLIGHT, FG_INFO, "  alt: " <<  get_Altitude() );
-
-    FDMExec.GetState()->Initialize(
-      current_options.get_uBody(),
-      current_options.get_vBody(),
-      current_options.get_wBody(),
-      get_Phi() * DEGTORAD,
-      get_Theta() * DEGTORAD,
-      get_Psi() * DEGTORAD,
-      get_Latitude(),
-      get_Longitude(),
-      get_Altitude()
-    );
-
-    FG_LOG( FG_FLIGHT, FG_INFO, "  loaded initial conditions" );
-
-    FDMExec.GetState()->Setdt( dt );
-    FG_LOG( FG_FLIGHT, FG_INFO, "  set dt" );
-
-    FG_LOG( FG_FLIGHT, FG_INFO, "Finished initializing JSBsim" );
+    SG_LOG( SG_FLIGHT, SG_INFO, "  set dt" );
 
-    copy_from_JSBsim();
-
-    return 1;
+    SG_LOG( SG_FLIGHT, SG_INFO, "Finished initializing JSBSim" );
 }
 
+/******************************************************************************/
 
 // Run an iteration of the EOM (equations of motion)
-int FGJSBsim::update( int multiloop ) {
+
+bool FGJSBsim::update( int multiloop ) {
+
+    int i;
+
     double save_alt = 0.0;
-    double time_step = (1.0 / current_options.get_model_hz()) * multiloop;
-    double start_elev = get_Altitude();
 
-    // lets try to avoid really screwing up the JSBsim model
-    if ( get_Altitude() < -9000 ) {
-      save_alt = get_Altitude();
-      set_Altitude( 0.0 );
+    copy_to_JSBsim();
+
+    trimmed->setBoolValue(false);
+
+    if ( needTrim && startup_trim->getBoolValue() ) {
+
+        //fgic->SetSeaLevelRadiusFtIC( get_Sea_level_radius() );
+        //fgic->SetTerrainAltitudeFtIC( scenery.cur_elev * SG_METER_TO_FEET );
+
+        FGTrim *fgtrim;
+        if(fgic->GetVcalibratedKtsIC() < 10 ) {
+            fgic->SetVcalibratedKtsIC(0.0);
+            fgtrim=new FGTrim(fdmex,fgic,tGround);
+        } else {
+            fgtrim=new FGTrim(fdmex,fgic,tLongitudinal);
+        }
+        if(!fgtrim->DoTrim()) {
+            fgtrim->Report();
+            fgtrim->TrimStats();
+        } else {
+            trimmed->setBoolValue(true);
+        }
+        fgtrim->ReportState();
+        delete fgtrim;
+
+        needTrim=false;
+
+        pitch_trim->setDoubleValue( FCS->GetPitchTrimCmd() );
+        throttle_trim->setDoubleValue( FCS->GetThrottleCmd(0) );
+        aileron_trim->setDoubleValue( FCS->GetDaCmd() );
+        rudder_trim->setDoubleValue( FCS->GetDrCmd() );
+
+        globals->get_controls()->set_elevator_trim(FCS->GetPitchTrimCmd());
+        globals->get_controls()->set_elevator(FCS->GetDeCmd());
+        globals->get_controls()->set_throttle(FGControls::ALL_ENGINES,
+                                              FCS->GetThrottleCmd(0));
+
+        globals->get_controls()->set_aileron(FCS->GetDaCmd());
+        globals->get_controls()->set_rudder( FCS->GetDrCmd());
+    
+        SG_LOG( SG_FLIGHT, SG_INFO, "  Trim complete" );
+    }
+  
+    for( i=0; i<get_num_engines(); i++ ) {
+      get_engine(i)->set_RPM( Propulsion->GetThruster(i)->GetRPM() );
+      get_engine(i)->set_Throttle( globals->get_controls()->get_throttle(i) );
     }
 
-    // copy control positions into the JSBsim structure
-
-    FDMExec.GetFCS()->SetDaCmd( controls.get_aileron());
-    FDMExec.GetFCS()->SetDeCmd( controls.get_elevator()
-                                               + controls.get_elevator_trim() );
-    FDMExec.GetFCS()->SetDrCmd( controls.get_rudder());
-    FDMExec.GetFCS()->SetDfCmd( 0.0 );
-    FDMExec.GetFCS()->SetDsbCmd( 0.0 );
-    FDMExec.GetFCS()->SetDspCmd( 0.0 );
-    FDMExec.GetFCS()->SetThrottleCmd( FGControls::ALL_ENGINES,
-                                           controls.get_throttle( 0 ) * 100.0 );
-    // FCS->SetBrake( controls.get_brake( 0 ) );
-
-    // Inform JSBsim of the local terrain altitude
-    // Runway_altitude =   get_Runway_altitude();
-
-    // old -- FGInterface_2_JSBsim() not needed except for Init()
-    // translate FG to JSBsim structure
-    // FGInterface_2_JSBsim(f);
-    // printf("FG_Altitude = %.2f\n", FG_Altitude * 0.3048);
-    // printf("Altitude = %.2f\n", Altitude * 0.3048);
-    // printf("Radius to Vehicle = %.2f\n", Radius_to_vehicle * 0.3048);
-
-    /* FDMExec.GetState()->Setsim_time(State->Getsim_time()
-				    + State->Getdt() * multiloop); */
-
-    for ( int i = 0; i < multiloop; i++ ) {
-      FDMExec.Run();
+    for ( i=0; i < multiloop; i++ ) {
+        fdmex->Run();
     }
 
     // printf("%d FG_Altitude = %.2f\n", i, FG_Altitude * 0.3048);
     // printf("%d Altitude = %.2f\n", i, Altitude * 0.3048);
-    
+
     // translate JSBsim back to FG structure so that the
-    // autopilot (and the rest of the sim can use the updated
-    // values
+    // autopilot (and the rest of the sim can use the updated values
 
     copy_from_JSBsim();
+    return true;
+}
 
-    // but lets restore our original bogus altitude when we are done
-    if ( save_alt < -9000.0 ) {
-      set_Altitude( save_alt );
-    }
+/******************************************************************************/
 
-    double end_elev = get_Altitude();
-    if ( time_step > 0.0 ) {
-      // feet per second
-      set_Climb_Rate( (end_elev - start_elev) / time_step );
-    }
+// Convert from the FGInterface struct to the JSBsim generic_ struct
 
-    return 1;
-}
+bool FGJSBsim::copy_to_JSBsim() {
+    // copy control positions into the JSBsim structure
 
+    FCS->SetDaCmd( globals->get_controls()->get_aileron());
+    FCS->SetDeCmd( globals->get_controls()->get_elevator());
+    FCS->SetPitchTrimCmd(globals->get_controls()->get_elevator_trim());
+    FCS->SetDrCmd( -globals->get_controls()->get_rudder());
+    FCS->SetDfCmd(  globals->get_controls()->get_flaps() );
+    FCS->SetDsbCmd( 0.0 ); //speedbrakes
+    FCS->SetDspCmd( 0.0 ); //spoilers
+    FCS->SetLBrake( globals->get_controls()->get_brake( 0 ) );
+    FCS->SetRBrake( globals->get_controls()->get_brake( 1 ) );
+    FCS->SetCBrake( globals->get_controls()->get_brake( 2 ) );
+    for (int i = 0; i < get_num_engines(); i++) {
+      FCS->SetThrottleCmd(i, globals->get_controls()->get_throttle(i));
+    }
 
-// Convert from the FGInterface struct to the JSBsim generic_ struct
-int FGJSBsim::copy_to_JSBsim() {
-    return 1;
+    Position->SetSeaLevelRadius( get_Sea_level_radius() );
+    Position->SetRunwayRadius( scenery.cur_elev*SG_METER_TO_FEET
+                               + get_Sea_level_radius() );
+
+    Atmosphere->SetExTemperature(get_Static_temperature());
+    Atmosphere->SetExPressure(get_Static_pressure());
+    Atmosphere->SetExDensity(get_Density());
+    Atmosphere->SetWindNED(get_V_north_airmass(),
+                           get_V_east_airmass(),
+                           get_V_down_airmass());
+//    SG_LOG(SG_FLIGHT,SG_INFO, "Wind NED: "
+//                  << get_V_north_airmass() << ", "
+//                  << get_V_east_airmass()  << ", "
+//                  << get_V_down_airmass() );
+
+    return true;
 }
 
+/******************************************************************************/
 
 // Convert from the JSBsim generic_ struct to the FGInterface struct
-int FGJSBsim::copy_from_JSBsim() {
+
+bool FGJSBsim::copy_from_JSBsim() {
+    unsigned int i, j;
+
+    _set_Inertias( MassBalance->GetMass(),
+                   MassBalance->GetIxx(),
+                   MassBalance->GetIyy(),
+                   MassBalance->GetIzz(),
+                   MassBalance->GetIxz() );
+
+    _set_CG_Position( MassBalance->GetXYZcg(1),
+                      MassBalance->GetXYZcg(2),
+                      MassBalance->GetXYZcg(3) );
+
+    _set_Accels_Body( Translation->GetUVWdot(1),
+                      Translation->GetUVWdot(2),
+                      Translation->GetUVWdot(3) );
+
+    _set_Accels_CG_Body( Translation->GetUVWdot(1),
+                         Translation->GetUVWdot(2),
+                         Translation->GetUVWdot(3) );
+
+    //_set_Accels_CG_Body_N ( Translation->GetNcg(1),
+    //                       Translation->GetNcg(2),
+    //                       Translation->GetNcg(3) );
+    //
+    _set_Accels_Pilot_Body( Auxiliary->GetPilotAccel(1),
+                            Auxiliary->GetPilotAccel(2),
+                            Auxiliary->GetPilotAccel(3) );
+
+    //_set_Accels_Pilot_Body_N( Auxiliary->GetNpilot(1),
+    //                         Auxiliary->GetNpilot(2),
+    //                         Auxiliary->GetNpilot(3) );
+
+    _set_Nlf( Aerodynamics->GetNlf() );
 
     // Velocities
-    set_Velocities_Local( FDMExec.GetPosition()->GetVn(),
-			  FDMExec.GetPosition()->GetVe(),
-			  FDMExec.GetPosition()->GetVd() );
-    // set_Velocities_Ground( V_north_rel_ground, V_east_rel_ground,
-    // 		     V_down_rel_ground );
-    // set_Velocities_Local_Airmass( V_north_airmass, V_east_airmass,
-    // 			    V_down_airmass );
-    // set_Velocities_Local_Rel_Airmass( V_north_rel_airmass,
-    //                          V_east_rel_airmass, V_down_rel_airmass );
-    // set_Velocities_Gust( U_gust, V_gust, W_gust );
-    // set_Velocities_Wind_Body( U_body, V_body, W_body );
-
-    // set_V_rel_wind( V_rel_wind );
-    // set_V_true_kts( V_true_kts );
-    // set_V_rel_ground( V_rel_ground );
-    // set_V_inertial( V_inertial );
-    // set_V_ground_speed( V_ground_speed );
-    // set_V_equiv( V_equiv );
-
-    set_V_equiv_kts( FDMExec.GetAuxiliary()->GetVequivalentKTS() );
-    //set_V_calibrated( FDMExec.GetAuxiliary()->GetVcalibratedFPS() );
-    set_V_calibrated_kts( FDMExec.GetAuxiliary()->GetVcalibratedKTS() );
-
-    set_Omega_Body( FDMExec.GetState()->GetParameter(FG_ROLLRATE),
-		    FDMExec.GetState()->GetParameter(FG_PITCHRATE),
-		    FDMExec.GetState()->GetParameter(FG_YAWRATE) );
-    // set_Omega_Local( P_local, Q_local, R_local );
-    // set_Omega_Total( P_total, Q_total, R_total );
-
-    set_Euler_Rates( FDMExec.GetRotation()->Getphi(),
-		     FDMExec.GetRotation()->Gettht(),
-		     FDMExec.GetRotation()->Getpsi() );
-
-    // ***FIXME*** set_Geocentric_Rates( Latitude_dot, Longitude_dot, Radius_dot );
-	
-    set_Mach_number( FDMExec.GetTranslation()->GetMach());
+
+    _set_Velocities_Local( Position->GetVn(),
+                           Position->GetVe(),
+                           Position->GetVd() );
+
+    _set_Velocities_Wind_Body( Translation->GetUVW(1),
+                               Translation->GetUVW(2),
+                               Translation->GetUVW(3) );
+
+    _set_V_rel_wind( Translation->GetVt() );
+
+    _set_V_equiv_kts( Auxiliary->GetVequivalentKTS() );
+
+    // _set_V_calibrated( Auxiliary->GetVcalibratedFPS() );
+
+    _set_V_calibrated_kts( Auxiliary->GetVcalibratedKTS() );
+
+    _set_V_ground_speed( Position->GetVground() );
+
+    _set_Omega_Body( Rotation->GetPQR(1),
+                     Rotation->GetPQR(2),
+                     Rotation->GetPQR(3) );
+
+    _set_Euler_Rates( Rotation->GetEulerRates(1),
+                      Rotation->GetEulerRates(2),
+                      Rotation->GetEulerRates(3) );
+
+    _set_Geocentric_Rates(Position->GetLatitudeDot(),
+                          Position->GetLongitudeDot(),
+                          Position->Gethdot() );
+
+    _set_Mach_number( Translation->GetMach() );
 
     // Positions
-    double lat_geoc = FDMExec.GetPosition()->GetLatitude();
-    double lon = FDMExec.GetPosition()->GetLongitude();
-    double alt = FDMExec.GetPosition()->Geth();
-    double lat_geod, tmp_alt, sl_radius1, sl_radius2, tmp_lat_geoc;
-    fgGeocToGeod( lat_geoc, EQUATORIAL_RADIUS_M + alt * FEET_TO_METER,
-		  &lat_geod, &tmp_alt, &sl_radius1 );
-    fgGeodToGeoc( lat_geod, alt * FEET_TO_METER, &sl_radius2, &tmp_lat_geoc );
-
-    FG_LOG( FG_FLIGHT, FG_DEBUG, "lon = " << lon << " lat_geod = " << lat_geod
-	    << " lat_geoc = " << lat_geoc
-	    << " alt = " << alt << " tmp_alt = " << tmp_alt * METER_TO_FEET
-	    << " sl_radius1 = " << sl_radius1 * METER_TO_FEET
-	    << " sl_radius2 = " << sl_radius2 * METER_TO_FEET
-	    << " Equator = " << EQUATORIAL_RADIUS_FT );
-	    
-    set_Geocentric_Position( lat_geoc, lon, 
-			       sl_radius2 * METER_TO_FEET + alt );
-    set_Geodetic_Position( lat_geod, lon, alt );
-    set_Euler_Angles( FDMExec.GetRotation()->Getphi(),
-		      FDMExec.GetRotation()->Gettht(),
-		      FDMExec.GetRotation()->Getpsi() );
-
-    // Miscellaneous quantities
-    // set_T_Local_to_Body(T_local_to_body_m);
-    // set_Gravity( Gravity );
-    // set_Centrifugal_relief( Centrifugal_relief );
-
-    set_Alpha( FDMExec.GetTranslation()->Getalpha() );
-    set_Beta( FDMExec.GetTranslation()->Getbeta() );
-    // set_Alpha_dot( Alpha_dot );
-    // set_Beta_dot( Beta_dot );
-
-    // set_Cos_alpha( Cos_alpha );
-    // set_Sin_alpha( Sin_alpha );
-    // set_Cos_beta( Cos_beta );
-    // set_Sin_beta( Sin_beta );
-
-    // set_Cos_phi( Cos_phi );
-    // set_Sin_phi( Sin_phi );
-    // set_Cos_theta( Cos_theta );
-    // set_Sin_theta( Sin_theta );
-    // set_Cos_psi( Cos_psi );
-    // set_Sin_psi( Sin_psi );
-
-    // ***ATTENDTOME*** set_Gamma_vert_rad( Gamma_vert_rad );
+    _updatePosition( Position->GetLatitude(),
+                     Position->GetLongitude(),
+                     Position->Geth() );
+
+    _set_Altitude_AGL( Position->GetDistanceAGL() );
+
+    _set_Euler_Angles( Rotation->Getphi(),
+                       Rotation->Gettht(),
+                       Rotation->Getpsi() );
+
+    _set_Alpha( Translation->Getalpha() );
+    _set_Beta( Translation->Getbeta() );
+
+
+    _set_Gamma_vert_rad( Position->GetGamma() );
     // set_Gamma_horiz_rad( Gamma_horiz_rad );
 
-    // set_Sigma( Sigma );
-    // set_Density( Density );
-    // set_V_sound( V_sound );
-    // set_Mach_number( Mach_number );
+    _set_Earth_position_angle( Auxiliary->GetEarthPositionAngle() );
+
+    _set_Climb_Rate( Position->Gethdot() );
+
+
+    for ( i = 1; i <= 3; i++ ) {
+        for ( j = 1; j <= 3; j++ ) {
+            _set_T_Local_to_Body( i, j, State->GetTl2b(i,j) );
+        }
+    }
+    return true;
+}
+
+void FGJSBsim::snap_shot(void) {
+    fgic->SetLatitudeRadIC(get_Lat_geocentric() );
+    fgic->SetLongitudeRadIC( get_Longitude() );
+    fgic->SetAltitudeFtIC( get_Altitude() );
+    fgic->SetTerrainAltitudeFtIC( get_Runway_altitude() );
+    fgic->SetVtrueFpsIC( get_V_rel_wind() );
+    fgic->SetPitchAngleRadIC( get_Theta() );
+    fgic->SetRollAngleRadIC( get_Phi() );
+    fgic->SetTrueHeadingRadIC( get_Psi() );
+    fgic->SetClimbRateFpsIC( get_Climb_Rate() );
+}
+
+
+bool FGJSBsim::ToggleDataLogging(void) {
+    return fdmex->GetOutput()->Toggle();
+}
+
+
+bool FGJSBsim::ToggleDataLogging(bool state) {
+    if (state) {
+      fdmex->GetOutput()->Enable();
+      return true;
+    } else {
+      fdmex->GetOutput()->Disable();
+      return false;
+    }
+}
 
-    // set_Static_pressure( Static_pressure );
-    // set_Total_pressure( Total_pressure );
-    // set_Impact_pressure( Impact_pressure );
-    // set_Dynamic_pressure( Dynamic_pressure );
 
-    // set_Static_temperature( Static_temperature );
-    // set_Total_temperature( Total_temperature );
+//Positions
+void FGJSBsim::set_Latitude(double lat) {
+    double sea_level_radius_meters,lat_geoc;
 
-    /* **FIXME*** */ set_Sea_level_radius( sl_radius2 * METER_TO_FEET );
-    /* **FIXME*** */ set_Earth_position_angle( 0.0 );
+    SG_LOG(SG_FLIGHT,SG_INFO,"FGJSBsim::set_Latitude: " << lat );
 
-    /* ***FIXME*** */ set_Runway_altitude( 0.0 );
-    // set_Runway_latitude( Runway_latitude );
-    // set_Runway_longitude( Runway_longitude );
-    // set_Runway_heading( Runway_heading );
-    // set_Radius_to_rwy( Radius_to_rwy );
+    snap_shot();
+    sgGeodToGeoc( lat, get_Altitude() , &sea_level_radius_meters, &lat_geoc);
+    _set_Sea_level_radius( sea_level_radius_meters * SG_METER_TO_FEET  );
+    fgic->SetSeaLevelRadiusFtIC( sea_level_radius_meters * SG_METER_TO_FEET  );
+    fgic->SetLatitudeRadIC( lat_geoc );
+    fdmex->RunIC(fgic); //loop JSBSim once
+    copy_from_JSBsim(); //update the bus
+    needTrim=true;
+}
 
-    // set_CG_Rwy_Local( D_cg_north_of_rwy, D_cg_east_of_rwy, D_cg_above_rwy);
-    // set_CG_Rwy_Rwy( X_cg_rwy, Y_cg_rwy, H_cg_rwy );
-    // set_Pilot_Rwy_Local( D_pilot_north_of_rwy, D_pilot_east_of_rwy, 
-    //                        D_pilot_above_rwy );
-    // set_Pilot_Rwy_Rwy( X_pilot_rwy, Y_pilot_rwy, H_pilot_rwy );
+void FGJSBsim::set_Longitude(double lon) {
 
-    set_sin_lat_geocentric( lat_geoc );
-    set_cos_lat_geocentric( lat_geoc );
-    set_sin_cos_longitude( lon );
-    set_sin_cos_latitude( lat_geod );
+    SG_LOG(SG_FLIGHT,SG_INFO,"FGJSBsim::set_Longitude: " << lon );
 
-    return 1;
+    snap_shot();
+    fgic->SetLongitudeRadIC(lon);
+    fdmex->RunIC(fgic); //loop JSBSim once
+    copy_from_JSBsim(); //update the bus
+    needTrim=true;
 }
 
+void FGJSBsim::set_Altitude(double alt) {
+    double sea_level_radius_meters,lat_geoc;
+
+    SG_LOG(SG_FLIGHT,SG_INFO, "FGJSBsim::set_Altitude: " << alt );
+
+    snap_shot();
+    sgGeodToGeoc( get_Latitude(), alt , &sea_level_radius_meters, &lat_geoc);
+    _set_Sea_level_radius( sea_level_radius_meters * SG_METER_TO_FEET  );
+    fgic->SetSeaLevelRadiusFtIC( sea_level_radius_meters * SG_METER_TO_FEET );
+    fgic->SetLatitudeRadIC( lat_geoc );
+    fgic->SetAltitudeFtIC(alt);
+    fdmex->RunIC(fgic); //loop JSBSim once
+    copy_from_JSBsim(); //update the bus
+    needTrim=true;
+}
+
+void FGJSBsim::set_V_calibrated_kts(double vc) {
+    SG_LOG(SG_FLIGHT,SG_INFO, "FGJSBsim::set_V_calibrated_kts: " <<  vc );
+
+    snap_shot();
+    fgic->SetVcalibratedKtsIC(vc);
+    fdmex->RunIC(fgic); //loop JSBSim once
+    copy_from_JSBsim(); //update the bus
+    needTrim=true;
+}
+
+void FGJSBsim::set_Mach_number(double mach) {
+    SG_LOG(SG_FLIGHT,SG_INFO, "FGJSBsim::set_Mach_number: " <<  mach );
+
+    snap_shot();
+    fgic->SetMachIC(mach);
+    fdmex->RunIC(fgic); //loop JSBSim once
+    copy_from_JSBsim(); //update the bus
+    needTrim=true;
+}
+
+void FGJSBsim::set_Velocities_Local( double north, double east, double down ){
+    SG_LOG(SG_FLIGHT,SG_INFO, "FGJSBsim::set_Velocities_Local: "
+       << north << ", " <<  east << ", " << down );
+
+    snap_shot();
+    fgic->SetVnorthFpsIC(north);
+    fgic->SetVeastFpsIC(east);
+    fgic->SetVdownFpsIC(down);
+    fdmex->RunIC(fgic); //loop JSBSim once
+    copy_from_JSBsim(); //update the bus
+    needTrim=true;
+}
+
+void FGJSBsim::set_Velocities_Wind_Body( double u, double v, double w){
+    SG_LOG(SG_FLIGHT,SG_INFO, "FGJSBsim::set_Velocities_Wind_Body: "
+       << u << ", " <<  v << ", " <<  w );
+
+    snap_shot();
+    fgic->SetUBodyFpsIC(u);
+    fgic->SetVBodyFpsIC(v);
+    fgic->SetWBodyFpsIC(w);
+    fdmex->RunIC(fgic); //loop JSBSim once
+    copy_from_JSBsim(); //update the bus
+    needTrim=true;
+}
+
+//Euler angles
+void FGJSBsim::set_Euler_Angles( double phi, double theta, double psi ) {
+    SG_LOG(SG_FLIGHT,SG_INFO, "FGJSBsim::set_Euler_Angles: "
+       << phi << ", " << theta << ", " << psi );
+
+    snap_shot();
+    fgic->SetPitchAngleRadIC(theta);
+    fgic->SetRollAngleRadIC(phi);
+    fgic->SetTrueHeadingRadIC(psi);
+    fdmex->RunIC(fgic); //loop JSBSim once
+    copy_from_JSBsim(); //update the bus
+    needTrim=true;
+}
+
+//Flight Path
+void FGJSBsim::set_Climb_Rate( double roc) {
+    SG_LOG(SG_FLIGHT,SG_INFO, "FGJSBsim::set_Climb_Rate: " << roc );
+
+    snap_shot();
+    fgic->SetClimbRateFpsIC(roc);
+    fdmex->RunIC(fgic); //loop JSBSim once
+    copy_from_JSBsim(); //update the bus
+    needTrim=true;
+}
+
+void FGJSBsim::set_Gamma_vert_rad( double gamma) {
+    SG_LOG(SG_FLIGHT,SG_INFO, "FGJSBsim::set_Gamma_vert_rad: " << gamma );
+
+    snap_shot();
+    fgic->SetFlightPathAngleRadIC(gamma);
+    fdmex->RunIC(fgic); //loop JSBSim once
+    copy_from_JSBsim(); //update the bus
+    needTrim=true;
+}
+
+//Earth
+void FGJSBsim::set_Sea_level_radius(double slr) {
+    SG_LOG(SG_FLIGHT,SG_INFO, "FGJSBsim::set_Sea_level_radius: " << slr );
+
+    snap_shot();
+    fgic->SetSeaLevelRadiusFtIC(slr);
+    fdmex->RunIC(fgic); //loop JSBSim once
+    copy_from_JSBsim(); //update the bus
+    needTrim=true;
+}
+
+void FGJSBsim::set_Runway_altitude(double ralt) {
+    SG_LOG(SG_FLIGHT,SG_INFO, "FGJSBsim::set_Runway_altitude: " << ralt );
+
+    snap_shot();
+    _set_Runway_altitude( ralt );
+    fgic->SetTerrainAltitudeFtIC( ralt );
+    fdmex->RunIC(fgic); //loop JSBSim once
+    copy_from_JSBsim(); //update the bus
+    needTrim=true;
+}
+
+void FGJSBsim::set_Static_pressure(double p) {
+    SG_LOG(SG_FLIGHT,SG_INFO, "FGJSBsim::set_Static_pressure: " << p );
+
+    snap_shot();
+    Atmosphere->SetExPressure(p);
+    if(Atmosphere->External() == true)
+    needTrim=true;
+}
+
+void FGJSBsim::set_Static_temperature(double T) {
+    SG_LOG(SG_FLIGHT,SG_INFO, "FGJSBsim::set_Static_temperature: " << T );
+    
+    snap_shot();
+    Atmosphere->SetExTemperature(T);
+    if(Atmosphere->External() == true)
+    needTrim=true;
+}
+ 
+
+void FGJSBsim::set_Density(double rho) {
+    SG_LOG(SG_FLIGHT,SG_INFO, "FGJSBsim::set_Density: " << rho );
+    
+    snap_shot();
+    Atmosphere->SetExDensity(rho);
+    if(Atmosphere->External() == true)
+    needTrim=true;
+}
+  
+
+void FGJSBsim::set_Velocities_Local_Airmass (double wnorth, 
+                         double weast, 
+                         double wdown ) {
+    SG_LOG(SG_FLIGHT,SG_INFO, "FGJSBsim::set_Velocities_Local_Airmass: " 
+       << wnorth << ", " << weast << ", " << wdown );
+    
+    _set_Velocities_Local_Airmass( wnorth, weast, wdown );
+    snap_shot();
+    Atmosphere->SetWindNED(wnorth, weast, wdown );
+    if(Atmosphere->External() == true)
+        needTrim=true;
+}