Doc-hu: Updated macros for web

[lilypond.git] / lily / beam-quanting.cc

diff --git a/lily/beam-quanting.cc b/lily/beam-quanting.cc
index c982c6d812f65dd9a881caa67dd0218172c893d6..2ecf070d4009e5009213f4714307d0ab4b19f3a7 100644 (file)
--- a/lily/beam-quanting.cc
+++ b/lily/beam-quanting.cc
@@ -1,10 +1,21 @@
 /*
 /*

-  beam-quanting.cc -- implement Beam quanting functions
+  This file is part of LilyPond, the GNU music typesetter.

 
 

-  source file of the GNU LilyPond music typesetter
-
-  (c) 1997--2006 Han-Wen Nienhuys <hanwen@xs4all.nl>
+  Copyright (C) 1997--2011 Han-Wen Nienhuys <hanwen@xs4all.nl>

   Jan Nieuwenhuizen <janneke@gnu.org>
   Jan Nieuwenhuizen <janneke@gnu.org>

+
+  LilyPond is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  LilyPond is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.

 */
 
 #include "beam.hh"
 */
 
 #include "beam.hh"


@@ -12,6 +23,7 @@
 #include <algorithm>
 using namespace std;
 
 #include <algorithm>
 using namespace std;
 

+#include "grob.hh"

 #include "align-interface.hh"
 #include "international.hh"
 #include "output-def.hh"
 #include "align-interface.hh"
 #include "international.hh"
 #include "output-def.hh"


@@ -19,6 +31,7 @@ using namespace std;
 #include "staff-symbol-referencer.hh"
 #include "stem.hh"
 #include "warn.hh"
 #include "staff-symbol-referencer.hh"
 #include "stem.hh"
 #include "warn.hh"

+#include "main.hh"

 
 Real
 get_detail (SCM alist, SCM sym, Real def)
 
 Real
 get_detail (SCM alist, SCM sym, Real def)


@@ -35,15 +48,13 @@ Beam_quant_parameters::fill (Grob *him)
 {
   SCM details = him->get_property ("details");
 
 {
   SCM details = him->get_property ("details");
 

-  INTER_QUANT_PENALTY = get_detail (details, ly_symbol2scm ("inter-quant-penalty"), 1000.0);

   SECONDARY_BEAM_DEMERIT = get_detail (details, ly_symbol2scm ("secondary-beam-demerit"), 10.0);
   STEM_LENGTH_DEMERIT_FACTOR = get_detail (details, ly_symbol2scm ("stem-length-demerit-factor"), 5);
   REGION_SIZE = get_detail (details, ly_symbol2scm ("region-size"), 2);
   BEAM_EPS = get_detail (details, ly_symbol2scm ("beam-eps"), 1e-3);
   SECONDARY_BEAM_DEMERIT = get_detail (details, ly_symbol2scm ("secondary-beam-demerit"), 10.0);
   STEM_LENGTH_DEMERIT_FACTOR = get_detail (details, ly_symbol2scm ("stem-length-demerit-factor"), 5);
   REGION_SIZE = get_detail (details, ly_symbol2scm ("region-size"), 2);
   BEAM_EPS = get_detail (details, ly_symbol2scm ("beam-eps"), 1e-3);

-
-  // possibly ridiculous, but too short stems just won't do

   STEM_LENGTH_LIMIT_PENALTY = get_detail (details, ly_symbol2scm ("stem-length-limit-penalty"), 5000);
   DAMPING_DIRECTION_PENALTY = get_detail (details, ly_symbol2scm ("damping-direction-penalty"), 800);
   STEM_LENGTH_LIMIT_PENALTY = get_detail (details, ly_symbol2scm ("stem-length-limit-penalty"), 5000);
   DAMPING_DIRECTION_PENALTY = get_detail (details, ly_symbol2scm ("damping-direction-penalty"), 800);

+  HINT_DIRECTION_PENALTY = get_detail (details, ly_symbol2scm ("hint-direction-penalty"), 20);

   MUSICAL_DIRECTION_FACTOR = get_detail (details, ly_symbol2scm ("musical-direction-factor"), 400);
   IDEAL_SLOPE_FACTOR = get_detail (details, ly_symbol2scm ("ideal-slope-factor"), 10);
   ROUND_TO_ZERO_SLOPE = get_detail (details, ly_symbol2scm ("round-to-zero-slope"), 0.02);
   MUSICAL_DIRECTION_FACTOR = get_detail (details, ly_symbol2scm ("musical-direction-factor"), 400);
   IDEAL_SLOPE_FACTOR = get_detail (details, ly_symbol2scm ("ideal-slope-factor"), 10);
   ROUND_TO_ZERO_SLOPE = get_detail (details, ly_symbol2scm ("round-to-zero-slope"), 0.02);


@@ -61,8 +72,8 @@ struct Quant_score
   Real yr;
   Real demerits;
 
   Real yr;
   Real demerits;
 

-#if DEBUG_QUANTING
-  std::string score_card_;
+#if DEBUG_BEAM_SCORING
+  string score_card_;

 #endif
 };
 
 #endif
 };
 


@@ -78,11 +89,11 @@ struct Quant_score
 */
 
 int
 */
 
 int

-best_quant_score_idx (Array<Quant_score> const &qscores)
+best_quant_score_idx (vector<Quant_score> const &qscores)

 {
   Real best = 1e6;
   int best_idx = -1;
 {
   Real best = 1e6;
   int best_idx = -1;

-  for (int i = qscores.size (); i--;)
+  for (vsize i = qscores.size (); i--;)

     {
       if (qscores[i].demerits < best)
        {
     {
       if (qscores[i].demerits < best)
        {


@@ -109,28 +120,26 @@ Beam::quanting (SCM smob, SCM posns)
   /*
     Calculations are relative to a unit-scaled staff, i.e. the quants are
     divided by the current staff_space.
   /*
     Calculations are relative to a unit-scaled staff, i.e. the quants are
     divided by the current staff_space.

-

   */
   Real ss = Staff_symbol_referencer::staff_space (me);
   */
   Real ss = Staff_symbol_referencer::staff_space (me);

-  Real thickness = Beam::get_thickness (me) / ss;
+  Real beam_thickness = Beam::get_beam_thickness (me) / ss;

   Real slt = Staff_symbol_referencer::line_thickness (me) / ss;
 
   Real dy_mus = robust_scm2double (me->get_property ("least-squares-dy"), 0);
   Real straddle = 0.0;
   Real slt = Staff_symbol_referencer::line_thickness (me) / ss;
 
   Real dy_mus = robust_scm2double (me->get_property ("least-squares-dy"), 0);
   Real straddle = 0.0;

-  Real sit = (thickness - slt) / 2;
+  Real sit = (beam_thickness - slt) / 2;

   Real inter = 0.5;
   Real inter = 0.5;

-  Real hang = 1.0 - (thickness - slt) / 2;
+  Real hang = 1.0 - (beam_thickness - slt) / 2;

   Real quants [] = {straddle, sit, inter, hang };
 
   int num_quants = int (sizeof (quants) / sizeof (Real));
   Real quants [] = {straddle, sit, inter, hang };
 
   int num_quants = int (sizeof (quants) / sizeof (Real));

-  Array<Real> quantsl;
-  Array<Real> quantsr;
+  vector<Real> quantsl;
+  vector<Real> quantsr;

 
   /*
     going to REGION_SIZE == 2, yields another 0.6 second with
     wtk1-fugue2.
 
 
   /*
     going to REGION_SIZE == 2, yields another 0.6 second with
     wtk1-fugue2.
 

-

     (result indexes between 70 and 575)  ? --hwn.
 
   */
     (result indexes between 70 and 575)  ? --hwn.
 
   */


@@ -139,56 +148,56 @@ Beam::quanting (SCM smob, SCM posns)
     Do stem computations.  These depend on YL and YR linearly, so we can
     precompute for every stem 2 factors.
   */
     Do stem computations.  These depend on YL and YR linearly, so we can
     precompute for every stem 2 factors.
   */

-  Link_array<Grob> stems
+  vector<Grob*> stems

     = extract_grob_array (me, "stems");
     = extract_grob_array (me, "stems");

-  Array<Stem_info> stem_infos;
-  Array<Real> base_lengths;
-  Array<Real> stem_xposns;
+  vector<Stem_info> stem_infos;
+  vector<Real> base_lengths;
+  vector<Real> stem_xposns;

 
   Drul_array<bool> dirs_found (0, 0);
   Grob *common[2];
   for (int a = 2; a--;)
     common[a] = common_refpoint_of_array (stems, me, Axis (a));
 
 
   Drul_array<bool> dirs_found (0, 0);
   Grob *common[2];
   for (int a = 2; a--;)
     common[a] = common_refpoint_of_array (stems, me, Axis (a));
 

-  Grob *fvs = first_visible_stem (me);
-  Grob *lvs = last_visible_stem (me);
+  Grob *fvs = first_normal_stem (me);
+  Grob *lvs = last_normal_stem (me);

   Real xl = fvs ? fvs->relative_coordinate (common[X_AXIS], X_AXIS) : 0.0;
   Real xr = fvs ? lvs->relative_coordinate (common[X_AXIS], X_AXIS) : 0.0;
 
   /*
   Real xl = fvs ? fvs->relative_coordinate (common[X_AXIS], X_AXIS) : 0.0;
   Real xr = fvs ? lvs->relative_coordinate (common[X_AXIS], X_AXIS) : 0.0;
 
   /*

-    We store some info to quickly interpolate.
-
-    Sometimes my head is screwed on backwards.  The stemlength are
-    AFFINE linear in YL and YR. If YL == YR == 0, then we might have
+    We store some info to quickly interpolate.  The stemlength are
+    affine linear in YL and YR. If YL == YR == 0, then we might have

     stem_y != 0.0, when we're cross staff.
 
   */
     stem_y != 0.0, when we're cross staff.
 
   */

-  for (int i = 0; i < stems.size (); i++)
+  for (vsize i = 0; i < stems.size (); i++)

     {
       Grob *s = stems[i];
 
       Stem_info si (Stem::get_stem_info (s));
       si.scale (1 / ss);
     {
       Grob *s = stems[i];
 
       Stem_info si (Stem::get_stem_info (s));
       si.scale (1 / ss);

-      stem_infos.push (si);
-      dirs_found[stem_infos.top ().dir_] = true;
+      stem_infos.push_back (si);
+      dirs_found[stem_infos.back ().dir_] = true;

 
       bool f = to_boolean (s->get_property ("french-beaming"))
        && s != lvs && s != fvs;
 
 
       bool f = to_boolean (s->get_property ("french-beaming"))
        && s != lvs && s != fvs;
 

-      base_lengths.push (calc_stem_y (me, s, common, xl, xr,
-                                     Interval (0, 0), f) / ss);
-      stem_xposns.push (s->relative_coordinate (common[X_AXIS], X_AXIS));
-    }
+      if (Stem::is_normal_stem (s))
+       {
+         base_lengths.push_back (calc_stem_y (me, s, common, xl, xr, CENTER, 
+                                              Interval (0, 0), f) / ss);
+       }
+      else
+       {
+         base_lengths.push_back (0);
+       }

 
 

-  bool xstaff = false;
-  if (lvs && fvs)
-    {
-      Grob *commony = fvs->common_refpoint (lvs, Y_AXIS);
-      xstaff = Align_interface::has_interface (commony);
+      stem_xposns.push_back (s->relative_coordinate (common[X_AXIS], X_AXIS));

     }
     }

+  bool xstaff = Align_interface::has_interface (common[Y_AXIS]);

 
   Direction ldir = Direction (stem_infos[0].dir_);
 
   Direction ldir = Direction (stem_infos[0].dir_);

-  Direction rdir = Direction (stem_infos.top ().dir_);
+  Direction rdir = Direction (stem_infos.back ().dir_);

   bool is_knee = dirs_found[LEFT] && dirs_found[RIGHT];
 
   int region_size = (int) parameters.REGION_SIZE;
   bool is_knee = dirs_found[LEFT] && dirs_found[RIGHT];
 
   int region_size = (int) parameters.REGION_SIZE;


@@ -205,28 +214,28 @@ Beam::quanting (SCM smob, SCM posns)
   for (int i = -region_size; i < region_size; i++)
     for (int j = 0; j < num_quants; j++)
       {
   for (int i = -region_size; i < region_size; i++)
     for (int j = 0; j < num_quants; j++)
       {

-       quantsl.push (i + quants[j] + int (yl));
-       quantsr.push (i + quants[j] + int (yr));
+       quantsl.push_back (i + quants[j] + int (yl));
+       quantsr.push_back (i + quants[j] + int (yr));

       }
 
       }
 

-  Array<Quant_score> qscores;
+  vector<Quant_score> qscores;

 
 

-  for (int l = 0; l < quantsl.size (); l++)
-    for (int r = 0; r < quantsr.size (); r++)
+  for (vsize l = 0; l < quantsl.size (); l++)
+    for (vsize r = 0; r < quantsr.size (); r++)

       {
        Quant_score qs;
        qs.yl = quantsl[l];
        qs.yr = quantsr[r];
        qs.demerits = 0.0;
 
       {
        Quant_score qs;
        qs.yl = quantsl[l];
        qs.yr = quantsr[r];
        qs.demerits = 0.0;
 

-       qscores.push (qs);
+       qscores.push_back (qs);

       }
 
   /* This is a longish function, but we don't separate this out into
      neat modular separate subfunctions, as the subfunctions would be
      called for many values of YL, YR. By precomputing various
      parameters outside of the loop, we can save a lot of time. */
       }
 
   /* This is a longish function, but we don't separate this out into
      neat modular separate subfunctions, as the subfunctions would be
      called for many values of YL, YR. By precomputing various
      parameters outside of the loop, we can save a lot of time. */

-  for (int i = qscores.size (); i--;)
+  for (vsize i = qscores.size (); i--;)

     {
       Real d = score_slopes_dy (qscores[i].yl, qscores[i].yr,
                                dy_mus, yr- yl,
     {
       Real d = score_slopes_dy (qscores[i].yl, qscores[i].yr,
                                dy_mus, yr- yl,


@@ -234,7 +243,7 @@ Beam::quanting (SCM smob, SCM posns)
                                xstaff, &parameters);
       qscores[i].demerits += d;
 
                                xstaff, &parameters);
       qscores[i].demerits += d;
 

-#if DEBUG_QUANTING
+#if DEBUG_BEAM_SCORING

       qscores[i].score_card_ += to_string ("S%.2f", d);
 #endif
     }
       qscores[i].score_card_ += to_string ("S%.2f", d);
 #endif
     }


@@ -242,25 +251,25 @@ Beam::quanting (SCM smob, SCM posns)
   Real rad = Staff_symbol_referencer::staff_radius (me);
   Drul_array<int> edge_beam_counts
     (Stem::beam_multiplicity (stems[0]).length () + 1,
   Real rad = Staff_symbol_referencer::staff_radius (me);
   Drul_array<int> edge_beam_counts
     (Stem::beam_multiplicity (stems[0]).length () + 1,

-     Stem::beam_multiplicity (stems.top ()).length () + 1);
+     Stem::beam_multiplicity (stems.back ()).length () + 1);

 
   Real beam_translation = get_beam_translation (me) / ss;
 
   Real reasonable_score = (is_knee) ? 200000 : 100;
 
   Real beam_translation = get_beam_translation (me) / ss;
 
   Real reasonable_score = (is_knee) ? 200000 : 100;

-  for (int i = qscores.size (); i--;)
+  for (vsize i = qscores.size (); i--;)

     if (qscores[i].demerits < reasonable_score)
       {
        Real d = score_forbidden_quants (qscores[i].yl, qscores[i].yr,
     if (qscores[i].demerits < reasonable_score)
       {
        Real d = score_forbidden_quants (qscores[i].yl, qscores[i].yr,

-                                        rad, slt, thickness, beam_translation,
+                                        rad, slt, beam_thickness, beam_translation,

                                         edge_beam_counts, ldir, rdir, &parameters);
        qscores[i].demerits += d;
 
                                         edge_beam_counts, ldir, rdir, &parameters);
        qscores[i].demerits += d;
 

-#if DEBUG_QUANTING
+#if DEBUG_BEAM_SCORING

        qscores[i].score_card_ += to_string (" F %.2f", d);
 #endif
       }
 
        qscores[i].score_card_ += to_string (" F %.2f", d);
 #endif
       }
 

-  for (int i = qscores.size (); i--;)
+  for (vsize i = qscores.size (); i--;)

     if (qscores[i].demerits < reasonable_score)
       {
        Real d = score_stem_lengths (stems, stem_infos,
     if (qscores[i].demerits < reasonable_score)
       {
        Real d = score_stem_lengths (stems, stem_infos,


@@ -270,24 +279,22 @@ Beam::quanting (SCM smob, SCM posns)
                                     qscores[i].yl, qscores[i].yr, &parameters);
        qscores[i].demerits += d;
 
                                     qscores[i].yl, qscores[i].yr, &parameters);
        qscores[i].demerits += d;
 

-#if DEBUG_QUANTING
+#if DEBUG_BEAM_SCORING

        qscores[i].score_card_ += to_string (" L %.2f", d);
 #endif
       }
 
   int best_idx = best_quant_score_idx (qscores);
 
        qscores[i].score_card_ += to_string (" L %.2f", d);
 #endif
       }
 
   int best_idx = best_quant_score_idx (qscores);
 

-#if DEBUG_QUANTING
+#if DEBUG_BEAM_SCORING

   SCM inspect_quants = me->get_property ("inspect-quants");
   SCM inspect_quants = me->get_property ("inspect-quants");

-  if (to_boolean (me->layout ()->lookup_variable (ly_symbol2scm ("debug-beam-quanting")))
+  if (to_boolean (me->layout ()->lookup_variable (ly_symbol2scm ("debug-beam-scoring")))

       && scm_is_pair (inspect_quants))
     {
       Drul_array<Real> ins = ly_scm2interval (inspect_quants);
 
       && scm_is_pair (inspect_quants))
     {
       Drul_array<Real> ins = ly_scm2interval (inspect_quants);
 

-      int i = 0;
-

       Real mindist = 1e6;
       Real mindist = 1e6;

-      for (; i < qscores.size (); i++)
+      for (vsize i = 0; i < qscores.size (); i++)

        {
          Real d = fabs (qscores[i].yl- ins[LEFT]) + fabs (qscores[i].yr - ins[RIGHT]);
          if (d < mindist)
        {
          Real d = fabs (qscores[i].yl- ins[LEFT]) + fabs (qscores[i].yr - ins[RIGHT]);
          if (d < mindist)


@@ -297,7 +304,7 @@ Beam::quanting (SCM smob, SCM posns)
            }
        }
       if (mindist > 1e5)
            }
        }
       if (mindist > 1e5)

-       programming_error ("can't find quant");
+       programming_error ("cannot find quant");

     }
 #endif
 
     }
 #endif
 


@@ -313,15 +320,15 @@ Beam::quanting (SCM smob, SCM posns)
                                          qscores[best_idx].yr);
     }
   
                                          qscores[best_idx].yr);
     }
   

-#if DEBUG_QUANTING
+#if DEBUG_BEAM_SCORING

   if (best_idx >= 0
   if (best_idx >= 0

-      && to_boolean (me->layout ()->lookup_variable (ly_symbol2scm ("debug-beam-quanting"))))
+      && to_boolean (me->layout ()->lookup_variable (ly_symbol2scm ("debug-beam-scoring"))))

     {
       qscores[best_idx].score_card_ += to_string ("i%d", best_idx);
 
       // debug quanting
       me->set_property ("quant-score",
     {
       qscores[best_idx].score_card_ += to_string ("i%d", best_idx);
 
       // debug quanting
       me->set_property ("quant-score",

-                       scm_makfrom0str (qscores[best_idx].score_card_.c_str ()));
+                       ly_string2scm (qscores[best_idx].score_card_));

     }
 #endif
 
     }
 #endif
 


@@ -329,10 +336,10 @@ Beam::quanting (SCM smob, SCM posns)
 }
 
 Real
 }
 
 Real

-Beam::score_stem_lengths (Link_array<Grob> const &stems,
-                         Array<Stem_info> const &stem_infos,
-                         Array<Real> const &base_stem_ys,
-                         Array<Real> const &stem_xs,
+Beam::score_stem_lengths (vector<Grob*> const &stems,
+                         vector<Stem_info> const &stem_infos,
+                         vector<Real> const &base_stem_ys,
+                         vector<Real> const &stem_xs,

                          Real xl, Real xr,
                          bool knee,
                          Real yl, Real yr,
                          Real xl, Real xr,
                          bool knee,
                          Real yl, Real yr,


@@ -343,10 +350,10 @@ Beam::score_stem_lengths (Link_array<Grob> const &stems,
   Drul_array<Real> score (0, 0);
   Drul_array<int> count (0, 0);
 
   Drul_array<Real> score (0, 0);
   Drul_array<int> count (0, 0);
 

-  for (int i = 0; i < stems.size (); i++)
+  for (vsize i = 0; i < stems.size (); i++)

     {
       Grob *s = stems[i];
     {
       Grob *s = stems[i];

-      if (Stem::is_invisible (s))
+      if (!Stem::is_normal_stem (s))

        continue;
 
       Real x = stem_xs[i];
        continue;
 
       Real x = stem_xs[i];


@@ -377,8 +384,7 @@ Beam::score_stem_lengths (Link_array<Grob> const &stems,
   Direction d = DOWN;
   do
     score[d] /= max (count[d], 1);
   Direction d = DOWN;
   do
     score[d] /= max (count[d], 1);

-  while (flip (&d) != DOWN)
-    ;
+  while (flip (&d) != DOWN);

 
   return score[LEFT] + score[RIGHT];
 }
 
   return score[LEFT] + score[RIGHT];
 }


@@ -401,10 +407,19 @@ Beam::score_slopes_dy (Real yl, Real yr,
     TODO: find a way to incorporate the complexity of the beam in this
     penalty.
   */
     TODO: find a way to incorporate the complexity of the beam in this
     penalty.
   */

-  if (fabs (dy / dx) > parameters->ROUND_TO_ZERO_SLOPE
-      && sign (dy_damp) != sign (dy))
-    dem += parameters->DAMPING_DIRECTION_PENALTY;
-
+  if (sign (dy_damp) != sign (dy))
+    {
+      if (!dy)
+       {
+         if (fabs (dy_damp / dx) > parameters->ROUND_TO_ZERO_SLOPE)
+           dem += parameters->DAMPING_DIRECTION_PENALTY;
+         else
+           dem += parameters->HINT_DIRECTION_PENALTY;
+       }
+      else
+       dem += parameters->DAMPING_DIRECTION_PENALTY;
+    }
+  

   dem += parameters->MUSICAL_DIRECTION_FACTOR
     * max (0.0, (fabs (dy) - fabs (dy_mus)));
 
   dem += parameters->MUSICAL_DIRECTION_FACTOR
     * max (0.0, (fabs (dy) - fabs (dy_mus)));
 


@@ -437,7 +452,7 @@ Real
 Beam::score_forbidden_quants (Real yl, Real yr,
                              Real radius,
                              Real slt,
 Beam::score_forbidden_quants (Real yl, Real yr,
                              Real radius,
                              Real slt,

-                             Real thickness, Real beam_translation,
+                             Real beam_thickness, Real beam_translation,

                              Drul_array<int> beam_counts,
                              Direction ldir, Direction rdir,
 
                              Drul_array<int> beam_counts,
                              Direction ldir, Direction rdir,
 


@@ -465,8 +480,8 @@ Beam::score_forbidden_quants (Real yl, Real yr,
            will be in the gap of the (2, sit) quant, leading to a
            false demerit.
          */
            will be in the gap of the (2, sit) quant, leading to a
            false demerit.
          */

-         Real gap1 = y[d] - stem_dir * ((j - 1) * beam_translation + thickness / 2 - slt / 2.2);
-         Real gap2 = y[d] - stem_dir * (j * beam_translation - thickness / 2 + slt / 2.2);
+         Real gap1 = y[d] - stem_dir * ((j - 1) * beam_translation + beam_thickness / 2 - slt / 2.2);
+         Real gap2 = y[d] - stem_dir * (j * beam_translation - beam_thickness / 2 + slt / 2.2);

 
          Interval gap;
          gap.add_point (gap1);
 
          Interval gap;
          gap.add_point (gap1);


@@ -494,9 +509,9 @@ Beam::score_forbidden_quants (Real yl, Real yr,
   if (max (beam_counts[LEFT], beam_counts[RIGHT]) >= 2)
     {
       Real straddle = 0.0;
   if (max (beam_counts[LEFT], beam_counts[RIGHT]) >= 2)
     {
       Real straddle = 0.0;

-      Real sit = (thickness - slt) / 2;
+      Real sit = (beam_thickness - slt) / 2;

       Real inter = 0.5;
       Real inter = 0.5;

-      Real hang = 1.0 - (thickness - slt) / 2;
+      Real hang = 1.0 - (beam_thickness - slt) / 2;

 
       Direction d = LEFT;
       do
 
       Direction d = LEFT;
       do