/*******************************************************************************
*
* McStas, neutron ray-tracing package
*         Copyright 1997-2002, All rights reserved
*         Risoe National Laboratory, Roskilde, Denmark
*         Institut Laue Langevin, Grenoble, France
*
* Component: Guide_gravity
*
* %I
* Written by: <a href="mailto:farhi@ill.fr">Emmanuel Farhi</a>
* Date: Aug 03 2001
* Version: $Revision: 1.15 $
* Origin: <a href="http://www.ill.fr">ILL (France)</a>.
* Release: McStas 1.6
* Modified by: E. Farhi, from Gravity_guide by K. Lefmann (buggy).
* Modified by: E. Farhi, focusing channels are now ok (Sept 4th, 2001).
* Modified by: E. Farhi, 2D channel array. Correct focus bug (Dec 14th 2002)
* Modified by: E. Farhi, Waviness+chamfers+nelements (Aug 19th 2003)
*
* Neutron guide with gravity. Can be channeled and focusing.
* Waviness may be specified, as well as side chamfers (on substrate).
*
* %D
* Models a rectangular guide tube centered on the Z axis. The entrance lies
* in the X-Y plane. Gravitation applies also when reaching the guide input
* window. The guide can be channeled (k,d parameters). The guide coating
* specifications may be entered via different ways (global, or for
* each wall m-value).
* Waviness (random) may be specified either globally or for each mirror type.
* Side chamfers (due to substrate processing) may be specified the same way.
* The guide section may be splitted into nelements equivalent parts of length
* l/nelements. Chamfers do apply in between these parts.
* For details on the geometry calculation see the description in the McStas
* reference manual.
*
* Example: Guide_gravity(w1=0.1, h1=0.1, w2=0.1, h2=0.1, l=12, 
*           R0=0.99, Qc=0.0219, alpha=6.07, m=1.0, W=0.003, k=1, d=0.0005)
*
* %P
* INPUT PARAMETERS:
*
* w1:      (m)    Width at the guide entry
* h1:      (m)    Height at the guide entry
* w2:      (m)    Width at the guide exit
* h2:      (m)    Height at the guide exit
* l:       (m)    length of guide
* R0:      (1)    Low-angle reflectivity
* Qc:      (AA-1) Critical scattering vector
* alpha:   (AA)   Slope of reflectivity
* m:       (1)    m-value of material. Zero means completely absorbing.
* W:       (AA-1) Width of supermirror cut-off
* d:       (m)    Thicxkness of subdividing walls [0]
* k:       (1)    Number of vertical channels in the guide (>= 1) [1]
*                 (k-1 vertical dividing walls)
*
* Optional input parameters: (different ways for m-specifications)
*
* mleft:   (1)    m-value of material for left.   vert. mirror
* mright:  (1)    m-value of material for right.  vert. mirror
* mtop:    (1)    m-value of material for top.    horz. mirror
* mbottom: (1)    m-value of material for bottom. horz. mirror
* kh       (1)    Number of horizontal channels in the guide (>= 1)
*                 (kh-1 horizontal dividing walls)
*                 this enables to have k*kh rectangular channels
* G        (m/s2) Gravitation norm. 0 value disables G effects.
* wavy     (deg)  Global guide waviness
* wavy_z   (deg)  Partial waviness along propagation axis
* wavy_tb  (deg)  Partial waviness in transverse direction for top/bottom mirrors
* wavy_lr  (deg)  Partial waviness in transverse direction for left/right mirrors
* chamfers (m)    Global chamfers specifications (in/out/mirror sides)
* chamfers_z  (m) Input and output chamfers
* chamfers_lr (m) Chamfers on left/right mirror sides
* chamfers_tb (m) Chamfers on top/bottom mirror sides
* nelements   (1) Number of sections in the guide element (length l/nelements)
* 
* OUTPUT PARAMETERS
*
* GVars:              (1) internal variables
* GVars.N_reflection: (1) Array of the cumulated Number of reflections 
*                   N_reflection[0] total nb of reflections
*                   N_reflection[1,2,3,4] l/r/t/b reflections
*                   N_reflection[5] total nb neutrons exiting guide
*                   N_reflection[6] total nb neutrons entering guide
*
* %D
* Example values: m=4 Qc=0.02 W=1/300 alpha=6.49 R0=1
*
* %E
*******************************************************************************/

DEFINE COMPONENT Guide_gravity
DEFINITION PARAMETERS ()
SETTING PARAMETERS (w1, h1, w2, h2, l, 
  R0=0.99, Qc=0.0219, alpha=6.07, m=1.0, W=0.003, k=1, d=0.0005,
  mleft=-1, mright=-1, mtop=-1, mbottom=-1, kh=1, G=-9.81, 
  wavy=0, wavy_z=0, wavy_tb=0, wavy_lr=0,
  chamfers=0, chamfers_z=0, chamfers_lr=0, chamfers_tb=0, nelements=1)
OUTPUT PARAMETERS (GVars)
STATE PARAMETERS (x,y,z,vx,vy,vz,t,s1,s2,p)

SHARE
%{
#ifndef Gravity_guide_Version
#define Gravity_guide_Version "1.6"

#ifndef PROP_GRAV_DT
#error McStas : You need PROP_GRAV_DT (McStas >= 1.4.3) to run this component
#endif

/* 
* G:       (m/s^2) Gravitation acceleration along y axis [-9.81]
* Gx:      (m/s^2) Gravitation acceleration along x axis [0]
* Gy:      (m/s^2) Gravitation acceleration along y axis [-9.81]
* Gz:      (m/s^2) Gravitation acceleration along z axis [0]
* mh:      (1)    m-value of material for left/right vert. mirrors
* mv:      (1)    m-value of material for top/bottom horz. mirrors
* mx:      (1)    m-value of material for left/right vert. mirrors
* my:      (1)    m-value of material for top/bottom horz. mirrors
*/

  typedef struct Gravity_guide_Vars
  {
    double gx;
    double gy;
    double gz;
    double nx[6], ny[6], nz[6];
    double wx[6], wy[6], wz[6];
    double A[6], norm_n2[6], norm_n[6];
    long   N_reflection[7];
    double w1c, h1c;
    double w2c, h2c;
    double M[5];
    double nzC[5], norm_n2c[5], Ac[5];
    double n_dot_v[6];
    double wav_lr, wav_tb, wav_z;
    double chamfer_z, chamfer_lr, chamfer_tb;
    char   compcurname[256];
  } Gravity_guide_Vars_type;

  void Gravity_guide_Init(Gravity_guide_Vars_type *aVars, 
    MCNUM a_w1, MCNUM a_h1, MCNUM a_w2, MCNUM a_h2, MCNUM a_l, MCNUM a_R0,
    MCNUM a_Qc, MCNUM a_alpha, MCNUM a_m, MCNUM a_W, MCNUM a_k, MCNUM a_d,
    MCNUM a_Gx, MCNUM a_Gy, MCNUM a_Gz, 
    MCNUM a_mleft, MCNUM a_mright, MCNUM a_mtop, MCNUM a_mbottom, MCNUM a_kh, 
    MCNUM a_wavy_lr, MCNUM a_wavy_tb, MCNUM a_wavy_z, MCNUM a_wavy,
    MCNUM a_chamfers_z, MCNUM a_chamfers_lr, MCNUM a_chamfers_tb, MCNUM a_chamfers)
  {
    int i;

    for (i=0; i<7; aVars->N_reflection[i++] = 0);
    for (i=0; i<5; aVars->M[i++] = 0);

    aVars->gx = a_Gx; /* The gravitation vector in the current component axis system */
    aVars->gy = a_Gy;
    aVars->gz = a_Gz;

    if (a_k <= 0 || a_kh <= 0) { fprintf(stderr,"%s: Fatal: no channel in this guide (kh or k=0).\n", aVars->compcurname); exit(-1); }
    if (a_d < 0) { fprintf(stderr,"%s: Fatal: subdividing walls have negative thickness in this guide (d<0).\n", aVars->compcurname); exit(-1); }
    aVars->w1c = (a_w1 - (a_k-1) *a_d)/(double)a_k;
    aVars->w2c = (a_w2 - (a_k-1) *a_d)/(double)a_k;
    aVars->h1c = (a_h1 - (a_kh-1)*a_d)/(double)a_kh;
    aVars->h2c = (a_h2 - (a_kh-1)*a_d)/(double)a_kh;

    for (i=0; i <= 4;   aVars->M[i++]=a_m);
    if (a_mleft   >= 0) aVars->M[1] =a_mleft  ;
    if (a_mright  >= 0) aVars->M[2] =a_mright ;
    if (a_mtop    >= 0) aVars->M[3] =a_mtop   ;
    if (a_mbottom >= 0) aVars->M[4] =a_mbottom;

    aVars->nx[1] =  a_l; aVars->ny[1] =  0;   aVars->nz[1] =  0.5*(aVars->w2c-aVars->w1c); /* 1:+X left       */
    aVars->nx[2] = -a_l; aVars->ny[2] =  0;   aVars->nz[2] =  -aVars->nz[1];  /* 2:-X right      */
    aVars->nx[3] =  0;   aVars->ny[3] =  a_l; aVars->nz[3] =  0.5*(aVars->h2c-aVars->h1c);  /* 3:+Y top        */
    aVars->nx[4] =  0;   aVars->ny[4] = -a_l; aVars->nz[4] =  -aVars->nz[3];  /* 4:-Y bottom     */
    aVars->nx[5] =  0;   aVars->ny[5] =  0;   aVars->nz[5] =  a_l;             /* 5:+Z exit       */
    aVars->nx[0] =  0;   aVars->ny[0] =  0;   aVars->nz[0] = -a_l;             /* 0:Z0 input      */

    aVars->wx[1] = +(aVars->w1c)/2; aVars->wy[1] =  0;      aVars->wz[1] = 0;   /* 1:+X left       */
    aVars->wx[2] = -(aVars->w1c)/2; aVars->wy[2] =  0;      aVars->wz[2] = 0;   /* 2:-X right      */
    aVars->wx[3] =  0;                  aVars->wy[3] = +(aVars->h1c)/2; aVars->wz[3] = 0;   /* 3:+Y top        */
    aVars->wx[4] =  0;                  aVars->wy[4] = -(aVars->h1c)/2; aVars->wz[4] = 0;   /* 4:-Y bottom     */
    aVars->wx[5] =  0;                  aVars->wy[5] =  0;      aVars->wz[5] = a_l;   /* 5:+Z exit       */
    aVars->wx[0] =  0;                  aVars->wy[0] =  0;      aVars->wz[0] = 0;   /* 0:Z0 input      */

    for (i=0; i <= 5; i++)
    {
      aVars->A[i] = scalar_prod(aVars->nx[i], aVars->ny[i], aVars->nz[i], aVars->gx, aVars->gy, aVars->gz)/2;
      aVars->norm_n2[i] = aVars->nx[i]*aVars->nx[i] + aVars->ny[i]*aVars->ny[i] + aVars->nz[i]*aVars->nz[i];
      if (aVars->norm_n2[i] <= 0)
        { fprintf(stderr,"%s: Fatal: normal vector norm %i is null/negative ! check guide dimensions.\n", aVars->compcurname, i); exit(-1); } /* should never occur */
      else
        aVars->norm_n[i] = sqrt(aVars->norm_n2[i]);
    }
    /* partial computations for l/r sides, to save computing time */  
    for (i=1; i <= 4; i++)
    {
      aVars->nzC[i]      = aVars->nz[i];
      aVars->norm_n2c[i] = aVars->nx[i]*aVars->nx[i] + aVars->ny[i]*aVars->ny[i];
      aVars->Ac[i]       = aVars->nx[i]*aVars->gx    + aVars->ny[i]*aVars->gy;
    }
    /* handle waviness init */
    if (a_wavy && (!a_wavy_tb && !a_wavy_lr && !a_wavy_z))
    { aVars->wav_tb=aVars->wav_lr=aVars->wav_z=a_wavy; } 
    else
    { aVars->wav_tb=a_wavy_tb; aVars->wav_lr=a_wavy_lr; aVars->wav_z=a_wavy_z; }
    aVars->wav_tb *= DEG2RAD/(sqrt(8*log(2)));   /* Convert from deg FWHM to rad Gaussian sigma */
    aVars->wav_lr *= DEG2RAD/(sqrt(8*log(2)));
    aVars->wav_z  *= DEG2RAD/(sqrt(8*log(2)));
    /* handle chamfers init */
    if (a_chamfers && (!a_chamfers_z && !a_chamfers_lr && !a_chamfers_tb))
    { aVars->chamfer_z=aVars->chamfer_lr=aVars->chamfer_tb=a_chamfers; }
    else
    { 
      aVars->chamfer_z=a_chamfers_z;
      aVars->chamfer_lr=a_chamfers_lr;
      aVars->chamfer_tb=a_chamfers_tb;
    }
  }

  int Gravity_guide_Trace(double *dt,
        Gravity_guide_Vars_type *aVars, 
        double cx, double cy, double cz,
	      double cvx, double cvy, double cvz,
        double cxnum, double cxk, double cynum, double cyk,
        double *cnx, double *cny,double *cnz)
  {
    double B, C;
    int    ret=0;
    int    side=0;
    double n1;
    double dt0, dt_min=0;
    int i;
    double loc_num, loc_k;
    int    i_slope=3;
      
    /* look if there is a previous intersection with guide sides */
    /* A = 0.5 n.g; B = n.v; C = n.(r-W); */
    /* 5=+Z side: n=(0, 0, -l) ; W = (0, 0, l) (at z=l, guide exit)*/
    B = aVars->nz[5]*cvz; C = aVars->nz[5]*(cz - aVars->wz[5]);
    ret = plane_intersect_Gfast(&dt0, aVars->A[5], B, C);
    if (ret && dt0>10e-10)
    { dt_min = dt0; side=5; aVars->n_dot_v[5] = B; }
    
    loc_num = cynum; loc_k = cyk;
    for (i=4; i>0; i--)
    { 
      if (i == 2) { i_slope=1; loc_num = cxnum; loc_k = cxk; }
      
      if (aVars->nzC[i_slope] != 0) {
      n1 = loc_k - 2*(loc_num);  /* slope of l/r/u/d sides depends on the channel ! */    
      loc_num++;
      aVars->nz[i] = aVars->nzC[i]*n1; 
      aVars->A[i] = aVars->Ac[i] + aVars->nz[i]*aVars->gz; }
      if (i < 3)
      {      B = aVars->nx[i]*cvx + aVars->nz[i]*cvz; C = aVars->nx[i]*(cx-aVars->wx[i]) + aVars->nz[i]*cz; }
      else { B = aVars->ny[i]*cvy + aVars->nz[i]*cvz; C = aVars->ny[i]*(cy-aVars->wy[i]) + aVars->nz[i]*cz; }
      ret = plane_intersect_Gfast(&dt0, aVars->A[i], B, C);
      if (ret && dt0>10e-10 && (dt0<dt_min || !dt_min))
      { dt_min = dt0; side=i; aVars->n_dot_v[i] = B; 
        if (aVars->nzC[i] != 0) 
        { aVars->norm_n2[i] = aVars->norm_n2c[i] + aVars->nz[i]*aVars->nz[i]; aVars->norm_n[i] = sqrt(aVars->norm_n2[i]); }
      }
     }
    
    *dt = dt_min;
    /* handles waviness: rotate n vector and adapt n_dot_v */
    if (side > 0 && side < 5 && (aVars->wav_z || aVars->wav_lr || aVars->wav_tb))
    {
      double nt_x, nt_y, nt_z;  /* transverse vector */
      double nn_x, nn_y, nn_z;  /* normal vector (tmp) */
      double phi;
      /* normal vector n_z = [ 0,0,1], n_t = n x n_z; */
      vec_prod(nt_x,nt_y,nt_z, aVars->nx[side],aVars->ny[side],aVars->nz[side], 0,0,1);
      /* rotate n with angle wavy_z around n_t -> nn */
      if (aVars->wav_z) {
        phi = aVars->wav_z;
        rotate(nn_x,nn_y,nn_z, aVars->nx[side],aVars->ny[side],aVars->nz[side], aVars->wav_z*randnorm(), nt_x,nt_y,nt_z);
      } else { nn_x=aVars->nx[side]; nn_y=aVars->ny[side]; nn_z=aVars->nz[side]; }
      /* rotate n with angle wavy_{x|y} around n_z -> nt */
      phi = (side <=2) ? aVars->wav_lr : aVars->wav_tb;
      if (phi) {
        rotate(nt_x,nt_y,nt_z, nn_x,nn_y,nn_z, phi*randnorm(), 0,0,1);
      } else { nt_x=nn_x; nt_y=nn_y; nt_z=nn_z; }
      *cnx=nt_x; *cny=nt_y; *cnz=nt_z; 
      /* re-compute n_dot_v */
      aVars->n_dot_v[side] = nt_x*cvx + nt_y*cvy + nt_z*cvz;
    } else
    { *cnx=aVars->nx[side]; *cny=aVars->ny[side]; *cnz=aVars->nz[side]; }
    return (side);
  }
#endif
%}

DECLARE 
%{
  Gravity_guide_Vars_type GVars;
%}

INITIALIZE
%{
  double Gx=0, Gy=9.81, Gz=0;
  Coords mcLocG; 
  int i;
  
  if (W < 0 || k <= 0 || kh <= 0 || R0 < 0 || Qc < 0)
  { fprintf(stderr,"Guide_gravity: %s: W k R0 Qc must be >0.\n", NAME_CURRENT_COMP);
    exit(-1); }
  
  mcLocG = rot_apply(ROT_A_CURRENT_COMP, coords_set(Gx,G,Gz));
  coords_get(mcLocG, &Gx, &Gy, &Gz);
    
  strcpy(GVars.compcurname, NAME_CURRENT_COMP);
  
  if (l > 0 && nelements > 0) {
    Gravity_guide_Init(&GVars, 
      w1, h1, w2, h2, l, R0,
      Qc, alpha, m, W, k, d,
      Gx, Gy, Gz, mleft, mright, mtop, 
      mbottom, kh, wavy_lr, wavy_tb, wavy_z, wavy,
      chamfers_z, chamfers_lr, chamfers_tb, chamfers);
    if (!G) for (i=0; i<5; GVars.A[i++] = 0);
  }

%}

TRACE
%{
  if (l > 0 && nelements > 0) {
    double B, C, dt;
    int    ret, bounces = 0;
    double this_width, this_height;

    /* propagate to box input (with gravitation) in comp local coords */
    /* 0=Z0 side: n=(0, 0, l) ; W = (0, 0, 0) (at z=0, guide input)*/
    B = -l*vz; C = -l*z;

    ret = plane_intersect_Gfast(&dt, GVars.A[0], B, C);
    if (ret && dt>0)
    { 
      PROP_GRAV_DT(dt, GVars.gx, GVars.gy, GVars.gz);
      GVars.N_reflection[6]++;
      this_width = w1; this_height=h1;
    } else
    {
      this_width = w1+(w2-w1)*z/l;  /* already inside !! */
      this_height= h1+(h2-h1)*z/l;
    }
    /* check if we are in the box input, else absorb */
    if (z>= 0 && z<=l && (fabs(x) > this_width/2 || fabs(y) > this_height/2)) ABSORB;
    else if(dt > 0)
    {   
      double w_edge, w_adj; /* Channel displacement on X */
      double h_edge, h_adj; /* Channel displacement on Y */
      double w_chnum,h_chnum; /* channel indexes */
      /* X: Shift origin to center of channel hit (absorb if hit dividing walls) */
      x += w1/2.0;
      w_chnum = floor(x/(GVars.w1c+d));  /* 0= right side, k+1=left side  */
      w_edge  = w_chnum*(GVars.w1c+d); 
      if(x - w_edge > GVars.w1c)
      {
        x -= w1/2.0; /* Re-adjust origin */
        ABSORB;
      }
      w_adj = w_edge + (GVars.w1c)/2.0;
      x -= w_adj; w_adj -=  w1/2.0;

      /* Y: Shift origin to center of channel hit (absorb if hit dividing walls) */
      y += h1/2.0;
      h_chnum = floor(y/(GVars.h1c+d));  /* 0= lower side, k+1=upper side  */
      h_edge  = h_chnum*(GVars.h1c+d); 
      if(y - h_edge > GVars.h1c)
      {
        y -= h1/2.0; /* Re-adjust origin */
        ABSORB;
      }
      h_adj = h_edge + (GVars.h1c)/2.0;
      y -= h_adj; h_adj -=  h1/2.0;

      /* neutron is now in the input window of the guide */
      /* do loops on reflections in the box */
      for(;;)
      {
        /* get intersections for all box sides */
        double q, nx,ny,nz;
        double this_length;
        int side=0;

        bounces++;
        /* now look for intersection with guide sides and exit */
        side = Gravity_guide_Trace(&dt, &GVars, x, y, z,
	          vx, vy, vz, w_chnum, k, h_chnum, kh,
            &nx, &ny, &nz);

        /* only positive dt are valid */
        /* exit reflection loops if no intersection (neutron is after box) */
        if (side == 0 || dt <= 0)
          { fprintf(stderr,"%s: warning: neutron has entered guide, but can not exit !\n", GVars.compcurname); 
            x += w_adj; y += h_adj; ABSORB; } /* should never occur */   

        /* propagate to dt */
        PROP_GRAV_DT(dt, GVars.gx, GVars.gy, GVars.gz);

        /* do reflection on speed for l/r/u/d sides */
        if (side == 5) /* neutron reaches end of guide: end loop and exit comp */
          { GVars.N_reflection[side]++; x += w_adj; y += h_adj; SCATTER; x -= w_adj; y -= h_adj; break; }
        /* else reflection on a guide wall */
        if(GVars.M[side] == 0 || Qc == 0)  /* walls are absorbing */
          { x += w_adj; y += h_adj; ABSORB; }
        /* handle chamfers */
        this_width = w1+(w2-w1)*z/l;
        this_height= h1+(h2-h1)*z/l;
        this_length= fmod(z, l/nelements);
        /* absorb on input/output of element parts */
        if (GVars.chamfer_z && (this_length<GVars.chamfer_z || this_length>l/nelements-GVars.chamfer_z)) 
        { x += w_adj; y += h_adj; ABSORB; }
        /* absorb on l/r/t/b sides */
        if (GVars.chamfer_lr && (side==1 || side==2) && (fabs(y+h_adj)>this_height/2-GVars.chamfer_lr))
        { x += w_adj; y += h_adj; ABSORB; }
        if (GVars.chamfer_tb && (side==3 || side==4) && (fabs(x+w_adj)>this_width/2- GVars.chamfer_tb))
        { x += w_adj; y += h_adj; ABSORB; }
        /* change/mirror velocity: h_f = v - n.2*n.v/|n|^2 */  
        GVars.N_reflection[side]++; /* GVars.norm_n2 > 0 was checked at INIT */
        dt = 2*GVars.n_dot_v[side]/GVars.norm_n2[side]; /* 2*n.v/|n|^2 */
        vx -= nx*dt;
        vy -= ny*dt;
        vz -= nz*dt;

        /* compute q and modify neutron weight */
        /* scattering q=|k_i-k_f| = V2Q*|vf - v| = V2Q*2*n.v/|n| */
        q = 2*V2Q*fabs(GVars.n_dot_v[side])/GVars.norm_n[side];
        B = R0;
        if(q > Qc)
        {
          double arg;
          if (W>0) arg = (q-GVars.M[side]*Qc)/W;
          else arg = (q-GVars.M[side]*Qc)*10000; /* W = 0.00001 */

          if(arg < 10) B *= .5*(1-tanh(arg))*(1-alpha*(q-Qc));
          else { x += w_adj; y += h_adj; ABSORB; }; /* Cutoff ~ 1E-10 */
         }
         if (B < 0) B=0;
         else if (B > 1) B=1;
         p *= B;
         x += w_adj; y += h_adj; SCATTER; x -= w_adj; y -= h_adj; 
         GVars.N_reflection[0]++;
         /* go to the next reflection */
         if (bounces > 1000) ABSORB;
       } /* end for */
       x += w_adj; y += h_adj; /* Re-adjust origin after SCATTER */
    }
  } /* if l */
%}


MCDISPLAY
%{

  if (l > 0 && nelements > 0) {
    int i,j,n;
    double x1,x2,x3,x4;
    double y1,y2,y3,y4;
    
    magnify("xy");
    for (n=0; n<nelements; n++)
    {
      double z0, z1;
      z0 = n*(l/nelements);
      z1 = (n+1)*(l/nelements);
      
      for(j = 0; j < kh; j++)
      {
        y1 = j*(GVars.h1c+d)         - h1/2.0;
        y2 = j*(GVars.h2c+d)         - h2/2.0;
        y3 = (j+1)*(GVars.h1c+d) - d - h1/2.0;
        y4 = (j+1)*(GVars.h2c+d) - d - h2/2.0;
        for(i = 0; i < k; i++)
        {
          x1 = i*(GVars.w1c+d)         - w1/2.0;
          x2 = i*(GVars.w2c+d)         - w2/2.0;
          x3 = (i+1)*(GVars.w1c+d) - d - w1/2.0;
          x4 = (i+1)*(GVars.w2c+d) - d - w2/2.0;
          multiline(5,
                    x1, y1, z0,
                    x2, y2, z1,
                    x2, y4, z1,
                    x1, y3, z0,
                    x1, y1, z0);
          multiline(5,
                    x3, y1, z0,
                    x4, y2, z1,
                    x4, y4, z1,
                    x3, y3, z0,
                    x3, y1, z0);
        }
        line(-w1/2.0, y1, z0, w1/2.0, y1, z0);
        line(-w2/2.0, y2, z1, w2/2.0, y2, z1);
      }
    }
  }
  else {
    /* A bit ugly; hard-coded dimensions. */
    magnify("");
    line(0,0,0,0.2,0,0);
    line(0,0,0,0,0.2,0);
    line(0,0,0,0,0,0.2);
  }
  
%}

END
