Berechnung

src/ch/spherIC/recurvebowsight/RBSMainActivity.java

@@ -29,6 +29,7 @@ import android.widget.Toast;
 import android.widget.ViewFlipper;
 
 import ch.spherIC.recurvebowsight.components.FontArrayAdapter;
+import ch.spherIC.recurvebowsight.components.FontTextView;
 import ch.spherIC.recurvebowsight.components.RiserSpinner;
 import ch.spherIC.recurvebowsight.components.SightSpinner;
 import ch.spherIC.recurvebowsight.components.XSpinner;
@@ -51,15 +52,17 @@ import java.util.List;
 import java.util.StringTokenizer;
 
 
-public class RBSMainActivity extends Activity implements ChooseArcherySetupDlgDismissListener {
+public class RBSMainActivity extends Activity implements ChooseArcherySetupDlgDismissListener, TrajectoryCalculation {
 
-    public static final DecimalFormat DF = new DecimalFormat("0.###");
+    public static final DecimalFormat DF = new DecimalFormat("0.##");
+    public static final DecimalFormat DF_EVS = new DecimalFormat("0.#");
 
     public static final int DLG_CHOOSE_ARCHERYSETUP = 0;
     public static final int DLG_USERGUIDE_PARAMS = 1;
     public static final int DLG_USERGUIDE_SIGHT = 2;
     public static final int DLG_ABOUT = 3;
 
+    private static final Double ANGLE_90 = 90d;
     private static final int MIN_DISTANCE = 50;
 
     private ViewFlipper viewFlipper;
@@ -94,14 +97,14 @@ public class RBSMainActivity extends Activity implements ChooseArcherySetupDlgDi
     private TextView scaHTxtFld;
     private TextView scVertScaleRngTxtFld;
     private TextView scVertScaleMiddleTxtFld;
-    private TextView scEvSValue;
+    private FontTextView scEvSValue;
 
+    private boolean showInfoMenu;
     private IArcherySetup selectedArcherySetup;
+    private Double startAngle;
 
     private Activity riserSightConfigActivity;
 
-    private boolean showInfoMenu;
-//    private Menu optionsMenu;
 
     @Override
     public void onCreate(final Bundle savedInstanceState) {
@@ -126,14 +129,11 @@ public class RBSMainActivity extends Activity implements ChooseArcherySetupDlgDi
 
         List<IRiser> risers = RiserDao.getInstance().loadAll();
         risers.add(0, new Riser(-999, getResources().getString(R.string.caption_NoSelection), "", null, null, null));
-        this.scRiserSpinner.setAdapter(new FontArrayAdapter<IRiser>(this, R.layout.rbs_spinner, risers,
-                                                                    this.scRiserSpinner));
+        this.scRiserSpinner.setAdapter(new FontArrayAdapter<IRiser>(this, R.layout.rbs_spinner, risers, this.scRiserSpinner));
 
         List<ISight> sights = SightDao.getInstance().loadAll();
-        sights.add(0,
-                   new Sight(-999, getResources().getString(R.string.caption_NoSelection), "", null, null, "", null, null));
-        this.scSightSpinner.setAdapter(new FontArrayAdapter<ISight>(this, R.layout.rbs_spinner, sights,
-                                                                    this.scSightSpinner));
+        sights.add(0, new Sight(-999, getResources().getString(R.string.caption_NoSelection), "", null, null, "", null, null));
+        this.scSightSpinner.setAdapter(new FontArrayAdapter<ISight>(this, R.layout.rbs_spinner, sights, this.scSightSpinner));
 
         addRiserAndSightSpinnerListeners();
 
@@ -195,7 +195,7 @@ public class RBSMainActivity extends Activity implements ChooseArcherySetupDlgDi
         this.scaHTxtFld = (TextView) findViewById(R.id.scaHTxtFld);
         this.scVertScaleRngTxtFld = (TextView) findViewById(R.id.scVertScaleRngTxtFld);
         this.scVertScaleMiddleTxtFld = (TextView) findViewById(R.id.scVertSkalaMiddleTxtFld);
-        this.scEvSValue = (TextView) findViewById(R.id.scEvSValue);
+        this.scEvSValue = (FontTextView) findViewById(R.id.scEvSValue);
     }
 
 
@@ -237,9 +237,10 @@ public class RBSMainActivity extends Activity implements ChooseArcherySetupDlgDi
                         }
 
                         RBSMainActivity.this.scHeVSTxtFld.setVisibility(View.INVISIBLE);
-                        RBSMainActivity.this.scHeVSTxtFld.setLayoutParams(new LinearLayout.LayoutParams(RBSMainActivity.this.scHeVSTxtFld.getLayoutParams().width,
-                                                                                                        RBSMainActivity.this.scHeVSTxtFld.getLayoutParams().height,
-                                                                                                        0f));
+                        RBSMainActivity.this.scHeVSTxtFld.setLayoutParams(new LinearLayout.LayoutParams(RBSMainActivity.this.scHeVSTxtFld
+                                                                                                        .getLayoutParams().width,
+                                                                                                        RBSMainActivity.this.scHeVSTxtFld
+                                                                                                        .getLayoutParams().height, 0f));
                         RBSMainActivity.this.scHeVSSpinner.setVisibility(View.VISIBLE);
 
                         LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(RBSMainActivity.this.scHeVSSpinner.getLayoutParams().width,
@@ -247,14 +248,13 @@ public class RBSMainActivity extends Activity implements ChooseArcherySetupDlgDi
                                                                                          1f);
                         params.gravity = Gravity.FILL_VERTICAL;
                         RBSMainActivity.this.scHeVSSpinner.setLayoutParams(params);
-                        RBSMainActivity.this.scHeVSSpinner.setAdapter(new FontArrayAdapter<String>(RBSMainActivity.this,
-                                                                                                   R.layout.rbs_spinner,
-                                                                                                   listHeVis,
-                                                                                                   RBSMainActivity.this.scHeVSSpinner));
+                        RBSMainActivity.this.scHeVSSpinner.setAdapter(new FontArrayAdapter<String>(RBSMainActivity.this, R.layout.rbs_spinner,
+                                                                                                   listHeVis, RBSMainActivity.this.scHeVSSpinner));
                         RBSMainActivity.this.scHeVSSpinner.setSelection(0);
                         if (RBSMainActivity.this.selectedArcherySetup != null
                             && RBSMainActivity.this.selectedArcherySetup.getSight().getId() == sight.getId()) {
-                            RBSMainActivity.this.scHeVSSpinner.setSelectionByVal(DF.format(RBSMainActivity.this.selectedArcherySetup.getSightHorSetting()));
+                            RBSMainActivity.this.scHeVSSpinner.setSelectionByVal(DF.format(RBSMainActivity.this.selectedArcherySetup
+                                                                                           .getSightHorSetting()));
                         }
                         RBSMainActivity.this.scaVTxtFld.setText(DF.format(sight.getAV()));
                         RBSMainActivity.this.scaHTxtFld.setText(DF.format(sight.getAH()));
@@ -262,15 +262,16 @@ public class RBSMainActivity extends Activity implements ChooseArcherySetupDlgDi
                                                                           + DF.format(sight.getVertSkalaRangeMax()));
                     } else {
                         RBSMainActivity.this.scHeVSSpinner.setVisibility(View.INVISIBLE);
-                        RBSMainActivity.this.scHeVSSpinner.setLayoutParams(new LinearLayout.LayoutParams(RBSMainActivity.this.scHeVSSpinner.getLayoutParams().width,
-                                                                                                         RBSMainActivity.this.scHeVSSpinner.getLayoutParams().height,
-                                                                                                         0f));
+                        RBSMainActivity.this.scHeVSSpinner.setLayoutParams(new LinearLayout.LayoutParams(RBSMainActivity.this.scHeVSSpinner
+                                                                                                         .getLayoutParams().width,
+                                                                                                         RBSMainActivity.this.scHeVSSpinner
+                                                                                                         .getLayoutParams().height, 0f));
                         RBSMainActivity.this.scHeVSTxtFld.setVisibility(View.VISIBLE);
-                        RBSMainActivity.this.scHeVSTxtFld.setLayoutParams(new LinearLayout.LayoutParams(RBSMainActivity.this.scHeVSTxtFld.getLayoutParams().width,
-                                                                                                        RBSMainActivity.this.scHeVSTxtFld.getLayoutParams().height,
-                                                                                                        1f));
-                        RBSMainActivity.this.scHeVSSpinner.setAdapter(new FontArrayAdapter<String>(RBSMainActivity.this,
-                                                                                                   R.layout.rbs_spinner,
+                        RBSMainActivity.this.scHeVSTxtFld.setLayoutParams(new LinearLayout.LayoutParams(RBSMainActivity.this.scHeVSTxtFld
+                                                                                                        .getLayoutParams().width,
+                                                                                                        RBSMainActivity.this.scHeVSTxtFld
+                                                                                                        .getLayoutParams().height, 1f));
+                        RBSMainActivity.this.scHeVSSpinner.setAdapter(new FontArrayAdapter<String>(RBSMainActivity.this, R.layout.rbs_spinner,
                                                                                                    new ArrayList<String>(),
                                                                                                    RBSMainActivity.this.scHeVSSpinner));
                         RBSMainActivity.this.scaVTxtFld.setText("");
@@ -625,12 +626,15 @@ public class RBSMainActivity extends Activity implements ChooseArcherySetupDlgDi
                && !this.targetCenterHeightTxtFld.getText().toString().isEmpty()
                && this.calcTimeIntervalCboBox.getSelectedItem() != null
                && this.calcAccuracyCboBox.getSelectedItem() != null
-               && !this.scVvisHTxtFld.getText().toString().isEmpty()
+               && allSightParamFieldsValid();
+    }
+
+    private boolean allSightParamFieldsValid() {
+        return !this.scVvisHTxtFld.getText().toString().isEmpty()
                && !this.scVvisVTxtFld.getText().toString().isEmpty()
                && !this.scaHTxtFld.getText().toString().isEmpty()
                && !this.scaVTxtFld.getText().toString().isEmpty()
                && !this.scVertScaleRngTxtFld.getText().toString().isEmpty()
-               && !this.scVertScaleMiddleTxtFld.getText().toString().isEmpty()
                && ((this.scHeVSSpinner.getVisibility() == View.VISIBLE && this.scHeVSSpinner.getSelectedItem() != null)
                    || (this.scHeVSTxtFld.getVisibility() == View.VISIBLE && !this.scHeVSTxtFld.getText().toString().isEmpty()))
                && !this.scVertScaleMiddleTxtFld.getText().toString().isEmpty();
@@ -642,7 +646,9 @@ public class RBSMainActivity extends Activity implements ChooseArcherySetupDlgDi
     private void calculate() {
 
         if (allParamFieldsValid()) {
-            // CALCULATION!!
+
+            /** TODO: TrajectoryCalculator-Objekt instanzieren mit Eigabewerten, CalculationTask instanzieren und executen mit TrajectoryCalculator-Objekt*/
+
         } else {
             Toast toast = Toast.makeText(this, getResources().getString(R.string.caption_FillAllMandatoryFields), Toast.LENGTH_LONG);
             toast.setGravity(Gravity.CENTER, 0, 0);
@@ -651,4 +657,89 @@ public class RBSMainActivity extends Activity implements ChooseArcherySetupDlgDi
     }
 
 
+    @Override
+    public void onCalculationDone(final Double[][] flightCurve, final Double startAngle, final Double[] maxHCurve) {
+        this.startAngle = startAngle;
+        calculateSettings();
+    }
+
+    private void calculateSettings() {
+
+        if (allSightParamFieldsValid()) {
+            Double x0;
+            Double y0;
+            Double x1;
+            Double y1;
+            Double x2;
+            Double y2;
+            Double x3;
+            Double y3;
+            Double r;
+            Double s;
+            Double vVh = Double.valueOf(this.scVvisHTxtFld.getText().toString()) + Double.valueOf(this.scaHTxtFld.getText().toString());
+            Double vVv = Double.valueOf(this.scVvisVTxtFld.getText().toString()) + Double.valueOf(this.scaVTxtFld.getText().toString());
+            Double a = Double.valueOf(this.bowPulloutTxtFld.getText().toString()) * 10;
+            Double heVs = this.scHeVSSpinner.getVisibility() == View.VISIBLE ? Double.valueOf(this.scHeVSSpinner.getSelectedItem().toString())
+                                                                             : Double.valueOf(this.scHeVSTxtFld.getText().toString());
+            Double lhNA = this.selectedArcherySetup.getHNA() * 10;
+            Double dltH = (Double.valueOf(this.arrowNockHeightTxtFld.getText().toString())
+                           - Double.valueOf(this.targetCenterHeightTxtFld.getText().toString())) * Math.pow(10, 3);
+            Double ldistH = Double.valueOf(this.shootingDistanzTxtFld.getText().toString()) * Math.pow(10, 3);
+            Double minSkala = this.scVertScaleRngTxtFld.getText().toString().contains("-")
+                              ? Double.valueOf(this.scVertScaleRngTxtFld.getText().toString().substring(0,
+                                                                                                        this.scVertScaleRngTxtFld.getText().toString()
+                                                                                                                                 .indexOf('-'))) : 0d;
+            Double maxSkala = this.scVertScaleRngTxtFld.getText().toString().contains("-")
+                              ? Double.valueOf(this.scVertScaleRngTxtFld.getText().toString().substring(this.scVertScaleRngTxtFld.getText().toString()
+                                                                                                                                 .indexOf('-') + 1,
+                                                                                                        this.scVertScaleRngTxtFld.getText().toString()
+                                                                                                                                 .length())) : 0d;
+
+            // PIN auf Höhe Pfeil
+            x0 = (a + vVh + heVs) * Math.cos(Math.toRadians(this.startAngle));
+            y0 = (a + vVh + heVs) * Math.sin(Math.toRadians(this.startAngle));
+
+            // PIN auf Höhe Horizontalschlitten Visier
+            x2 = x0 + vVv * Math.cos(Math.toRadians(ANGLE_90 + this.startAngle));
+            y2 = y0 + vVv * Math.sin(Math.toRadians(ANGLE_90 + this.startAngle));
+
+            // Schnittpunkt der Achse Horizontalschlitten Visier mit Achse Befestigungslöcher Visier
+            x3 = (a + vVh) * Math.cos(Math.toRadians(this.startAngle)) + vVv * Math.cos(Math.toRadians(ANGLE_90 + this.startAngle));
+            y3 = (a + vVh) * Math.sin(Math.toRadians(this.startAngle)) + vVv * Math.sin(Math.toRadians(ANGLE_90 + this.startAngle));
+
+            // Unbekannte der Vektorgeradengleichung
+            r = (lhNA * (x0 - x2) - x0 * y2 + x2 * y0) / (ldistH * (y0 - y2) + (dltH - lhNA) * (x2 - x0));
+            s = -((ldistH * (lhNA - y0) + (dltH - lhNA) * x0) / (ldistH * (y0 - y2) + (dltH - lhNA) * (x2 - x0)));
+
+            // Pin auf Visierlinie
+            x1 = r * ldistH;
+            y1 = lhNA + r * (dltH - lhNA);
+
+            // Unten (+) oder oben (-) von (x2/y2) ?
+            Double n = ((y2 - y3) * (x1 - x3) - (x2 - x3) * (y1 - y3)) < 0 ? -1.0 : 1.0;
+
+            // Abstand P1 - P2
+            Double d = Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2)) * n;
+
+            // Einstellung auf vert. Skala
+            Double sV = Double.valueOf(this.scVertScaleMiddleTxtFld.getText().toString()) + d;
+
+            this.scEvSValue.setText(DF_EVS.format(sV));
+
+            if (minSkala <= sV && sV <= maxSkala) {
+                this.scEvSValue.setBackgroundDrawable(getResources().getDrawable(R.drawable.evs_ok_background));
+            } else {
+                this.scEvSValue.setBackgroundDrawable(getResources().getDrawable(R.drawable.evs_nok_background));
+            }
+
+        } else {
+            this.scEvSValue.setText("");
+
+            Toast toast = Toast.makeText(this, getResources().getString(R.string.caption_FillAllMandatoryFields), Toast.LENGTH_LONG);
+            toast.setGravity(Gravity.CENTER, 0, 0);
+            toast.show();
+        }
+    }
+
+
 }

src/ch/spherIC/recurvebowsight/TrajectoryCalculation.java

@@ -0,0 +1,12 @@
+/**
+ * Copyright (C) 2012-2022 spherIC.net
+ *
+ * @author Florindo Smilari
+ */
+package ch.spherIC.recurvebowsight;
+
+public interface TrajectoryCalculation {
+
+    void onCalculationDone(Double[][] flightCurve, Double startAngle, Double[] maxHCurve);
+
+}

src/ch/spherIC/recurvebowsight/logic/CalculationTask.java

@@ -0,0 +1,29 @@
+/**
+ * Copyright (C) 2005-2012 XELOG AG
+ */
+package ch.spherIC.recurvebowsight.logic;
+
+import android.os.AsyncTask;
+
+
+/**
+ * @author  FC Smilari
+ */
+public class CalculationTask extends AsyncTask<TrajectoryCalculator, Void, TrajectoryCalculator> {
+
+    @Override
+    protected TrajectoryCalculator doInBackground(final TrajectoryCalculator... params) {
+        TrajectoryCalculator trjCalc = params[0];
+
+        /** TODO: Berechnung anlog ArrowFlight-TrajectoryCalculatorThread.run(), Resultate in trjCalc abspeichern */
+
+
+        return trjCalc;
+    }
+
+    @Override
+    protected void onPostExecute(final TrajectoryCalculator trjCalc) {
+        super.onPostExecute(trjCalc);
+        trjCalc.getListener().onCalculationDone(trjCalc.getFlightCurve(), trjCalc.getStartAngle(), trjCalc.getMaxHCurve());
+    }
+}

src/ch/spherIC/recurvebowsight/logic/TrajectoryCalculator.java

@@ -0,0 +1,250 @@
+/**
+ * Copyright (C) 2012-2022 spherIC.net
+ *
+ * @author Florindo Smilari
+ */
+package ch.spherIC.recurvebowsight.logic;
+
+import ch.spherIC.recurvebowsight.TrajectoryCalculation;
+
+import java.util.ArrayList;
+import java.util.List;
+
+
+public class TrajectoryCalculator {
+
+    public static final int IDX_T = 0;
+    public static final int IDX_VX = 1;
+    public static final int IDX_VY = 2;
+    public static final int IDX_X = 3;
+    public static final int IDX_Y = 4;
+
+    public static final Double GRAVITY = Double.valueOf(9.81);
+
+    private static final Double CELSIUS_TO_KELVIN = 273.15;
+    private static final Double R_L = 287.058;
+    private static final Double R_D = 461.0;
+    private static final Double PRESS_AIR = 101325.0;
+    private static final Double E_T0 = 611.2;
+    private static final Double T0 = 17.62;
+    private static final Double T1 = 243.12;
+
+    private Double arrowDiameter;
+    private Double arrowCw;
+    private Double arrowWeight;
+    private Double v0;
+    private Double distance;
+    private Double deltaHeight;
+    private Double airTemperature;
+    private Double relativeHumidity;
+    private Double deltaTime;
+    private Double calculationPrecision;
+    private TrajectoryCalculation listener;
+
+    private Double[][] flightCurve;
+    private Double startAngle;
+    private Double[] maxHCurve;
+
+
+    /**
+     * Konstruktor.
+     *
+     * @param  arrowDiameter
+     * @param  arrowCw
+     * @param  arrowWeight
+     * @param  v0
+     * @param  distance
+     * @param  deltaHeight
+     * @param  airTemperature
+     * @param  relativeHumidity
+     * @param  startAngle
+     * @param  deltaTime
+     * @param  calculationPrecision
+     * @param  listener
+     */
+    public TrajectoryCalculator(final Double arrowDiameter,
+                                final Double arrowCw,
+                                final Double arrowWeight,
+                                final Double v0,
+                                final Double distance,
+                                final Double deltaHeight,
+                                final Double airTemperature,
+                                final Double relativeHumidity,
+                                final Double deltaTime,
+                                final Double calculationPrecision,
+                                final TrajectoryCalculation listener) {
+        super();
+        this.arrowDiameter = arrowDiameter;
+        this.arrowCw = arrowCw;
+        this.arrowWeight = arrowWeight;
+        this.v0 = v0;
+        this.distance = distance;
+        this.deltaHeight = deltaHeight;
+        this.airTemperature = airTemperature;
+        this.relativeHumidity = relativeHumidity;
+        this.deltaTime = deltaTime;
+        this.calculationPrecision = calculationPrecision;
+        this.listener = listener;
+    }
+
+
+    public Double[][] calculateTrajectory() {
+
+        List<Double[]> results = new ArrayList<Double[]>();
+        Double angle = Math.toRadians(this.startAngle);
+        Double vxOld = Math.cos(angle) * this.v0;
+        Double vyOld = Math.sin(angle) * this.v0;
+        Double vxNew = 0d;
+        Double vyNew = 0d;
+        Double xNew = 0d;
+        Double yNew = 0d;
+        Double xOld = 0d;
+        Double yOld = 0d;
+        Double totTime = 0d;
+        Double k = calculateFrictionCoeficient(this.arrowCw, this.arrowDiameter, this.airTemperature, this.relativeHumidity);
+        Double m = this.arrowWeight;
+        Double[] r1 = new Double[5];
+
+        r1[TrajectoryCalculator.IDX_T] = totTime;
+        r1[TrajectoryCalculator.IDX_VX] = vxOld;
+        r1[TrajectoryCalculator.IDX_VY] = vyOld;
+        r1[TrajectoryCalculator.IDX_X] = xOld;
+        r1[TrajectoryCalculator.IDX_Y] = yOld;
+        results.add(r1);
+
+        while (xNew <= this.distance) {
+
+            vxNew = vxOld + this.deltaTime * -(k / m) * Math.sqrt(vxOld * vxOld + vyOld * vyOld) * vxOld;
+            vyNew = vyOld + this.deltaTime * (-(k / m) * Math.sqrt(vxOld * vxOld + vyOld * vyOld) * vyOld - TrajectoryCalculator.GRAVITY);
+
+            xNew = xOld + this.deltaTime * ((vxOld + vxNew) / 2);
+            yNew = yOld + this.deltaTime * ((vyOld + vyNew) / 2);
+
+            vxOld = vxNew;
+            vyOld = vyNew;
+
+            xOld = xNew;
+            yOld = yNew;
+
+            totTime += this.deltaTime;
+
+            r1 = new Double[5];
+            r1[TrajectoryCalculator.IDX_T] = totTime;
+            r1[TrajectoryCalculator.IDX_VX] = vxOld;
+            r1[TrajectoryCalculator.IDX_VY] = vyOld;
+            r1[TrajectoryCalculator.IDX_X] = xOld;
+            r1[TrajectoryCalculator.IDX_Y] = yOld;
+            results.add(r1);
+        }
+
+        Double[] rLow = results.get(results.size() - 2);
+        Double[] rHigh = results.get(results.size() - 1);
+        if (rLow[IDX_X] < this.distance && rHigh[IDX_X] > this.distance) {
+            Double deltaT1 = rHigh[IDX_T] - rLow[IDX_T];
+            Double deltaVx1 = rHigh[IDX_VX] - rLow[IDX_VX];
+            Double deltaVy1 = rHigh[IDX_VY] - rLow[IDX_VY];
+            Double deltaX1 = rHigh[IDX_X] - rLow[IDX_X];
+            Double deltaY1 = rHigh[IDX_Y] - rLow[IDX_Y];
+
+            Double deltaX2 = this.distance - rLow[IDX_X];
+            Double deltaY2 = deltaY1 * deltaX2 / deltaX1;
+            Double deltaVx2 = deltaVx1 / deltaX1 * deltaX2;
+            Double deltaVy2 = deltaVy1 / deltaY1 * deltaY2;
+            Double deltaT2 = deltaT1 / deltaX1 * deltaX2;
+
+            results.get(results.size() - 1)[IDX_T] = results.get(results.size() - 2)[IDX_T] + deltaT2;
+            results.get(results.size() - 1)[IDX_VX] = results.get(results.size() - 2)[IDX_VX] + deltaVx2;
+            results.get(results.size() - 1)[IDX_VY] = results.get(results.size() - 2)[IDX_VY] + deltaVy2;
+            results.get(results.size() - 1)[IDX_X] = results.get(results.size() - 2)[IDX_X] + deltaX2;
+            results.get(results.size() - 1)[IDX_Y] = results.get(results.size() - 2)[IDX_Y] + deltaY2;
+        }
+
+
+        return results.toArray(new Double[][] {});
+    }
+
+
+    public Double calculateFrictionCoeficient(final Double arrowCw, final Double arrowDiameter,
+                                              final Double airTemperature, final Double relativeHumidity) {
+
+        Double eW = TrajectoryCalculator.E_T0
+                    * Math.pow(Math.E, TrajectoryCalculator.T0 * airTemperature / (TrajectoryCalculator.T1 + airTemperature));
+
+        Double rF = TrajectoryCalculator.R_L
+                    / (1 - relativeHumidity * eW / TrajectoryCalculator.PRESS_AIR * (1 - TrajectoryCalculator.R_L / TrajectoryCalculator.R_D));
+        Double airDensity = TrajectoryCalculator.PRESS_AIR / (rF * (airTemperature + TrajectoryCalculator.CELSIUS_TO_KELVIN));
+
+        Double friction = airDensity * arrowCw * (Math.pow(arrowDiameter, 2) / 4 * Math.PI) / 2;
+        return friction;
+    }
+
+
+    public Double getArrowDiameter() {
+        return this.arrowDiameter;
+    }
+
+    public Double getArrowCw() {
+        return this.arrowCw;
+    }
+
+    public Double getArrowWeight() {
+        return this.arrowWeight;
+    }
+
+    public Double getV0() {
+        return this.v0;
+    }
+
+    public Double getDistance() {
+        return this.distance;
+    }
+
+    public Double getDeltaHeight() {
+        return this.deltaHeight;
+    }
+
+    public Double getAirTemperature() {
+        return this.airTemperature;
+    }
+
+    public Double getRelativeHumidity() {
+        return this.relativeHumidity;
+    }
+
+    public Double getDeltaTime() {
+        return this.deltaTime;
+    }
+
+    public Double getCalculationPrecision() {
+        return this.calculationPrecision;
+    }
+
+    public TrajectoryCalculation getListener() {
+        return this.listener;
+    }
+
+    public Double[][] getFlightCurve() {
+        return this.flightCurve;
+    }
+
+    public void setFlightCurve(final Double[][] flightCurve) {
+        this.flightCurve = flightCurve;
+    }
+
+    public Double[] getMaxHCurve() {
+        return this.maxHCurve;
+    }
+
+    public void setMaxHCurve(final Double[] maxHCurve) {
+        this.maxHCurve = maxHCurve;
+    }
+
+    public Double getStartAngle() {
+        return this.startAngle;
+    }
+
+    public void setStartAngle(final Double startAngle) {
+        this.startAngle = startAngle;
+    }
+
+}

src/ch/spherIC/recurvebowsight/model/ArcherySetup.java

@@ -325,21 +325,4 @@ public class ArcherySetup implements IArcherySetup {
     public void setSightHorSetting(final Double sightHorSetting) {
         this.sightHorSetting = sightHorSetting;
     }
-
-    /**
-     * @return  the hNA
-     */
-    @Override
-    public Double gethNA() {
-        return this.hNA;
-    }
-
-    /**
-     * @param  hNA  the hNA to set
-     */
-    @Override
-    public void sethNA(final Double hNA) {
-        this.hNA = hNA;
-    }
-
 }

src/ch/spherIC/recurvebowsight/model/IArcherySetup.java

@@ -68,8 +68,4 @@ public interface IArcherySetup extends IEntity {
     String getName();
 
     void setName(String name);
-
-    Double gethNA();
-
-    void sethNA(Double hNA);
 }