Connected Chemistry 7 Ideal Gas Law

globals
[
  tick-delta                  ;; how much we advance the tick counter this time through
  max-tick-delta              ;; the largest tick-delta is allowed to be
  box-edge-y                  ;; distance of box edge from axes
  box-edge
  instant-pressure           ;; the pressure at this tick or instant in time
  pressure-history           ;; a history of the four instant-pressure values
  pressure                   ;; the pressure average of the pressure-history (for curve smoothing in the pressure plots)
  particles-to-add
  zero-pressure-count        ;; how many zero entries are in pressure-history
  wall-hits-per-particle     ;; average number of wall hits per particle
  delta-horizontal-surface   ;; the size of the wall surfaces that run horizontally - the top and bottom of the box
  delta-vertical-surface     ;; the size of the wall surfaces that run vertically - the left and right of the box
  walls                      ;; agentset containing patches that are the walls of the box
  heated-walls
  piston-wall
  init-avg-speed init-avg-energy  ;; initial averages
  avg-speed avg-energy
  outside-energy
  min-outside-energy
  max-outside-energy
  temp-increment
  piston-position            ;; xcor of piston wall
  piston-color               ;; color of piston
  wall-color                 ;; color of wall
  run-go?                    ;; flag of whether or not its safe for go to run
  volume
  total-particle-number
  temperature
  temp-volume
  temp-target-wall
  maxparticles
  gravity-acceleration       ;; placeholder needed for logging in Modeling Across the Curriculum Activities

  show-dark?                 ;; hides or shows the dark particles in the simulation.
                             ;; see NetLogo features Info tab for full explanation of
                             ;; what dark particles are and why they are used.
]

breed [ particles particle ]
breed [ flashes flash ]
breed [ volume-target a-target ]
breed [ dark-particles dark-particle ]


flashes-own [birthday]

particles-own
[
  speed mass energy          ;; particle info
  wall-hits                  ;; # of wall hits during this ticks cycle ("big tick")
  momentum-difference        ;; used to calculate pressure from wall hits
  last-collision
  dark-particle?
   momentum-instant
]


dark-particles-own
[
  speed mass energy          ;; particle info
  wall-hits                  ;; # of wall hits during this ticks cycle ("big tick")
  momentum-difference        ;; used to calculate pressure from wall hits
  last-collision
  momentum-instant
]

to setup
  ca reset-ticks
  set maxparticles 400
  set run-go? true
  set show-dark? false
  set temp-increment 7.5
  set min-outside-energy 0
  set max-outside-energy 300
  set-default-shape particles "circle"
  set-default-shape flashes "square"
  set-default-shape dark-particles "nothing"
  set box-edge (max-pycor - 1)
  set particles-to-add 0
  set max-tick-delta 0.1073
  ;; box has constant size...
  set box-edge-y (max-pycor - 1)
  set box-edge (max-pxcor - 1)
  ;;; the delta of the horizontal or vertical surface of
  ;;; the inside of the box must exclude the two patches
  ;; that are the where the perpendicular walls join it,
  ;;; but must also add in the axes as an additional patch
  ;;; example:  a box with an box-edge of 10, is drawn with
  ;;; 19 patches of wall space on the inside of the box
  set piston-position init-wall-position - box-edge

  set delta-horizontal-surface  ( 2 * (box-edge - 1) + 1) - (abs (piston-position - box-edge))
  set delta-vertical-surface  ( 2 * (box-edge-y - 1) + 1)
  set volume (delta-horizontal-surface * delta-vertical-surface * 1)  ;;depth of 1
  set outside-energy 100
  set piston-color orange

  set wall-color (scale-color red outside-energy -60 340)
  draw-box-piston
  make-particles maxparticles
  set pressure-history [0 0 0]  ;; plotted pressure will be averaged over the past 3 entries
  set zero-pressure-count 0
  update-variables
  set init-avg-speed avg-speed
  set init-avg-energy avg-energy
  set temperature avg-energy * 6
  create-volume-target 1 [set color white ht]
  set total-particle-number initial-number
  reset-ticks
  recolor
end 

to go
   if not run-go? [stop]

  set temperature avg-energy * 6
  ask particles [ bounce ]
  ask particles [ move ]
   ask particles [showlabel]
  if collide? [
    ask particles with [dark-particle? = false]
    [ check-for-collision]
    ask particles with [dark-particle? = true]
    [ check-for-collision-dark ]
  ]
  tick-advance tick-delta
  if floor ticks > floor (ticks - tick-delta)
  [
    ifelse any? particles
          [ set wall-hits-per-particle mean [wall-hits] of particles with [dark-particle? = false] ]
          [ set wall-hits-per-particle 0 ]
    ask particles
      [ set wall-hits 0 ]
    calculate-pressure
    update-variables
    update-plots
  ]
  calculate-tick-delta
  calculate-wall-color

    ask flashes with [ticks - birthday > 0.4]

      [ if ( shade-of? pcolor piston-color)
          [set pcolor piston-color]
        if ( shade-of? pcolor wall-color)
          [set pcolor wall-color]
         die
         ]
  ask patches with [pycor = 0 and pxcor < (1 - box-edge)]
  [
    set pcolor 10 ;; trick the bounce code so particles don't go into the inlet
  ]

    recolor
    display
end 

to update-variables
  set avg-speed  mean [speed] of particles
  set avg-energy mean [energy] of particles
end 

to cool
  ifelse ( outside-energy > 20 ) [ set outside-energy outside-energy - temp-increment ] [ set outside-energy 0 ]
  if (outside-energy = 0)
   [ user-message "You are currently trying to cool the walls of the container below absolute zero (OK or -273C).  Absolute zero is the lowest theoretical temperature for all matter in the universe and has never been achieved in a real-world laboratory"]
  calculate-wall-color
  ask heated-walls
      [set pcolor wall-color]
end 

to heat
  set outside-energy outside-energy + temp-increment
    if (outside-energy > 300)
    [set outside-energy 300
    user-message "You have reached the maximum allowable temperature for the walls of the container in this model."]
    calculate-wall-color
    ask heated-walls
      [set pcolor wall-color]
end 

to calculate-tick-delta
  ifelse any? particles with [speed > 0]
    [ set tick-delta min list (1 / (ceiling max [speed] of particles )) max-tick-delta ]
    [ set tick-delta max-tick-delta ]
end 


;;; Pressure is defined as the force per unit area.  In this context,
;;; that means the total momentum per unit time transferred to the walls
;;; by particle hits, divided by the surface area of the walls.  (Here
;;; we're in a two dimensional world, so the "surface area" of the walls
;;; is just their delta.)  Each wall contributes a different amount
;;; to the total pressure in the box, based on the number of collisions, the
;;; direction of each collision, and the delta of the wall.  Conservation of momentum
;;; in hits ensures that the difference in momentum for the particles is equal to and
;;; opposite to that for the wall.  The force on each wall is the rate of change in
;;; momentum imparted to the wall, or the sum of change in momentum for each particle:
;;; F = SUM  [d(mv)/dt] = SUM [m(dv/dt)] = SUM [ ma ], in a direction perpendicular to
;;; the wall surface.  The pressure (P) on a given wall is the force (F) applied to that
;;; wall over its surface area.  The total pressure in the box is sum of each wall's
;;; pressure contribution.

to calculate-pressure
  ;; by summing the momentum change for each particle,
  ;; the wall's total momentum change is calculated

  set pressure 15 * sum [momentum-difference] of particles with [dark-particle? = false]
  set pressure-history lput pressure but-first pressure-history

  ask particles
    [ set momentum-difference 0 ]  ;; once the contribution to momentum has been calculated
                                   ;; this value is reset to zero till the next wall hit
end 

to bounce  ;; particle procedure
  let new-patch 0
  let new-px 0
  let new-py 0

  ;; get the coordinates of the patch we'll be on if we go forward 1
  if (shade-of? black pcolor and shade-of? black [pcolor] of patch-at dx dy)
    [stop]
  ;; get the coordinates of the patch we'll be on if we go forward 1
  set new-px round (xcor + dx)
  set new-py round (ycor + dy)
  ;; if hitting left wall or piston (on right), reflect heading around x axis
  if ((abs new-px = box-edge or new-px = piston-position))
    [
      set heading (- heading)
      set wall-hits wall-hits + 1
  ;;  if the particle is hitting a vertical wall, only the horizontal component of the speed
  ;;  vector can change.  The change in velocity for this component is 2 * the speed of the particle,
  ;; due to the reversing of direction of travel from the collision with the wall
      set momentum-difference momentum-difference + (abs (dx * 2 * mass * speed) / delta-vertical-surface) ]
  ;; if hitting top or bottom wall, reflect heading around y axis
  if (abs new-py = box-edge-y)
    [ set heading (180 - heading)
      set wall-hits wall-hits + 1
  ;;  if the particle is hitting a horizontal wall, only the vertical component of the speed
  ;;  vector can change.  The change in velocity for this component is 2 * the speed of the particle,
  ;; due to the reversing of direction of travel from the collision with the wall
      set momentum-difference momentum-difference + (abs (dy * 2 * mass * speed) / delta-horizontal-surface)  ]

  if [heated-wall?] of patch new-px new-py  ;; check if the patch ahead of us is heated
  [
    set energy ((energy +  outside-energy ) / 2)
    set speed sqrt (2 * energy / mass )
    recolor
  ]
   if (dark-particle? = false) [
  ask patch new-px new-py
  [ sprout 1 [
                ht
                 set breed flashes
                 set birthday ticks
                 ifelse shade-of? ([pcolor] of patch-here) piston-color

                   [set pcolor piston-color - 3]
                   [set pcolor 11]
    ]   ]
  ]
end 

to move  ;; particle procedure
  if patch-ahead (speed * tick-delta) != patch-here
    [ set last-collision nobody ]
  jump (speed * tick-delta)
end 

to check-for-collision  ;; particle procedure
  let candidate 0

  ;; Here we impose a rule that collisions only take place when there
  ;; are exactly two particles per patch.  We do this because when the
  ;; student introduces new particles from the side, we want them to
  ;; form a uniform wavefront.
  ;;
  ;; Why do we want a uniform wavefront?  Because it is actually more
  ;; realistic.  (And also because the curriculum uses the uniform
  ;; wavefront to help teach the relationship between particle collisions,
  ;; wall hits, and pressure.)
  ;;
  ;; Why is it realistic to assume a uniform wavefront?  Because in reality,
  ;; whether a collision takes place would depend on the actual headings
  ;; of the particles, not merely on their proximity.  Since the particles
  ;; in the wavefront have identical speeds and near-identical headings,
  ;; in reality they would not collide.  So even though the two-particles
  ;; rule is not itself realistic, it produces a realistic result.  Also,
  ;; unless the number of particles is extremely large, it is very rare
  ;; for three or more particles to land on the same patch (for example,
  ;; with 400 particles it happens less than 1% of the time).  So imposing
  ;; this additional rule should have only a negligible effect on the
  ;; aggregate behavior of the system.
  ;;
  ;; Why does this rule produce a uniform wavefront?  The particles all
  ;; start out on the same patch, which means that without the only-two
  ;; rule, they would all start colliding with each other immediately,
  ;; resulting in much random variation of speeds and headings.  With
  ;; the only-two rule, they are prevented from colliding with each other
  ;; until they have spread out a lot.  (And in fact, if you observe
  ;; the wavefront closely, you will see that it is not completely smooth,
  ;; because some collisions eventually do start occurring when it thins out while fanning.)

  if count other particles-here with [dark-particle? = false] = 1
  [
    ;; the following conditions are imposed on collision candidates:
    ;;   1. they must have a lower who number than my own, because collision
    ;;      code is asymmetrical: it must always happen from the point of view
    ;;      of just one particle.
    ;;   2. they must not be the same particle that we last collided with on
    ;;      this patch, so that we have a chance to leave the patch after we've
    ;;      collided with someone.
    set candidate one-of other particles-here with
      [who < [who] of myself and myself != last-collision]
    ;; we also only collide if one of us has non-zero speed. It's useless
    ;; (and incorrect, actually) for two particles with zero speed to collide.
    if (candidate != nobody) and (speed > 0 or [speed] of candidate > 0)
    [
      collide-with candidate
      set last-collision candidate
      ask candidate [ set last-collision myself ]
    ]
  ]
end 

to check-for-collision-dark  ;; particle procedure
  let candidate 0


  ;; Here we impose a rule that collisions only take place when there
  ;; are exactly two particles per patch.  We do this because when the
  ;; student introduces new particles from the side, we want them to
  ;; form a uniform wavefront.
  ;;
  ;; Why do we want a uniform wavefront?  Because it is actually more
  ;; realistic.  (And also because the curriculum uses the uniform
  ;; wavefront to help teach the relationship between particle collisions,
  ;; wall hits, and pressure.)
  ;;
  ;; Why is it realistic to assume a uniform wavefront?  Because in reality,
  ;; whether a collision takes place would depend on the actual headings
  ;; of the particles, not merely on their proximity.  Since the particles
  ;; in the wavefront have identical speeds and near-identical headings,
  ;; in reality they would not collide.  So even though the two-particles
  ;; rule is not itself realistic, it produces a realistic result.  Also,
  ;; unless the number of particles is extremely large, it is very rare
  ;; for three or more particles to land on the same patch (for example,
  ;; with 400 particles it happens less than 1% of the time).  So imposing
  ;; this additional rule should have only a negligible effect on the
  ;; aggregate behavior of the system.
  ;;
  ;; Why does this rule produce a uniform wavefront?  The particles all
  ;; start out on the same patch, which means that without the only-two
  ;; rule, they would all start colliding with each other immediately,
  ;; resulting in much random variation of speeds and headings.  With
  ;; the only-two rule, they are prevented from colliding with each other
  ;; until they have spread out a lot.  (And in fact, if you observe
  ;; the wavefront closely, you will see that it is not completely smooth,
  ;; because some collisions eventually do start occurring when it thins out while fanning.)

  if count other particles-here with [dark-particle? = true] = 1
  [
    ;; the following conditions are imposed on collision candidates:
    ;;   1. they must have a lower who number than my own, because collision
    ;;      code is asymmetrical: it must always happen from the point of view
    ;;      of just one particle.
    ;;   2. they must not be the same particle that we last collided with on
    ;;      this patch, so that we have a chance to leave the patch after we've
    ;;      collided with someone.
    set candidate one-of other particles-here with
      [who < [who] of myself and myself != last-collision and dark-particle? = true]
    ;; we also only collide if one of us has non-zero speed. It's useless
    ;; (and incorrect, actually) for two particles with zero speed to collide.
    if (candidate != nobody) and (speed > 0 or [speed] of candidate > 0)
    [
      collide-with candidate
      set last-collision candidate
      ask candidate [ set last-collision myself ]
    ]
  ]
end 

;; implements a collision with another particle.
;;
;; THIS IS THE HEART OF THE PARTICLE SIMULATION, AND YOU ARE STRONGLY ADVISED
;; NOT TO CHANGE IT UNLESS YOU REALLY UNDERSTAND WHAT YOU'RE DOING!
;;
;; The two particles colliding are self and other-particle, and while the
;; collision is performed from the point of view of self, both particles are
;; modified to reflect its effects. This is somewhat complicated, so I'll
;; give a general outline here:
;;   1. Do initial setup, and determine the heading between particle centers
;;      (call it theta).
;;   2. Convert the representation of the velocity of each particle from
;;      speed/heading to a theta-based vector whose first component is the
;;      particle's speed along theta, and whose second component is the speed
;;      perpendicular to theta.
;;   3. Modify the velocity vectors to reflect the effects of the collision.
;;      This involves:
;;        a. computing the velocity of the center of mass of the whole system
;;           along direction theta
;;        b. updating the along-theta components of the two velocity vectors.
;;   4. Convert from the theta-based vector representation of velocity back to
;;      the usual speed/heading representation for each particle.
;;   5. Perform final cleanup and update derived quantities.

to collide-with [ other-particle ] ;; particle procedure
  let mass2 0
  let speed2 0
  let heading2 0
  let theta 0
  let v1t 0
  let v1l 0
  let v2t 0
  let v2l 0
  let vcm 0


  ;;; PHASE 1: initial setup

  ;; for convenience, grab some quantities from other-particle
  set mass2 [mass] of other-particle
  set speed2 [speed] of other-particle
  set heading2 [heading] of other-particle

  ;; since particles are modeled as zero-size points, theta isn't meaningfully
  ;; defined. we can assign it randomly without affecting the model's outcome.
  set theta (random-float 360)



  ;;; PHASE 2: convert velocities to theta-based vector representation

  ;; now convert my velocity from speed/heading representation to components
  ;; along theta and perpendicular to theta
  set v1t (speed * cos (theta - heading))
  set v1l (speed * sin (theta - heading))

  ;; do the same for other-particle
  set v2t (speed2 * cos (theta - heading2))
  set v2l (speed2 * sin (theta - heading2))



  ;;; PHASE 3: manipulate vectors to implement collision

  ;; compute the velocity of the system's center of mass along theta
  set vcm (((mass * v1t) + (mass2 * v2t)) / (mass + mass2) )

  ;; now compute the new velocity for each particle along direction theta.
  ;; velocity perpendicular to theta is unaffected by a collision along theta,
  ;; so the next two lines actually implement the collision itself, in the
  ;; sense that the effects of the collision are exactly the following changes
  ;; in particle velocity.
  set v1t (2 * vcm - v1t)
  set v2t (2 * vcm - v2t)



  ;;; PHASE 4: convert back to normal speed/heading

  ;; now convert my velocity vector into my new speed and heading
  set speed sqrt ((v1t ^ 2) + (v1l ^ 2))
  set energy (0.5 * mass * (speed ^ 2))
  ;; if the magnitude of the velocity vector is 0, atan is undefined. but
  ;; speed will be 0, so heading is irrelevant anyway. therefore, in that
  ;; case we'll just leave it unmodified.
  if v1l != 0 or v1t != 0
    [ set heading (theta - (atan v1l v1t)) ]

  ;; and do the same for other-particle
  ;; and do the same for other-particle
  ask other-particle [
    set speed sqrt ((v2t ^ 2) + (v2l ^ 2))
    set energy (0.5 * mass * (speed ^ 2))
    if v2l != 0 or v2t != 0
      [ set heading (theta - (atan v2l v2t)) ]
  ]



  ;; PHASE 5: final updates

  ;; now recolor, since color is based on quantities that may have changed
  ;;recolor
  ;;ask other-particle
  ;;  [ recolor ]
end 


;;
;;; visualization procedures
;;;

to showlabel
 ifelse labels?
    [
      set label who
      set label-color white
      if (who = 0) [set label-color (orange + 1)]
    ]
    [set label ""]
end 

to calculate-wall-color
  set wall-color (scale-color red outside-energy -60 340)
end 

to recolor
   if speed-as-color? = "red-green-blue" [ ask particles [recolor-banded ] ]
    if speed-as-color? = "purple shades" [ ask particles [recolor-shaded ]]
    if speed-as-color? = "one color" [ ask particles [recolor-none ]]
end 

to recolor-banded  ;; particle procedure
  ifelse speed < (0.5 * 10)
  [
    set color blue
  ]
  [
    ifelse speed > (1.5 * 10)
      [ set color red ]
      [ set color green ]
  ]
end 

to recolor-shaded
  ifelse speed < 27
  [ set color 111 + speed / 3 ]
  [ set color 119.999 ]
end 

to recolor-none
  set color green - 1
end 




;;;
;;; drawing procedures
;;;

;; draws the box

to make-box
  set heated-walls patches with [ ((pxcor = -1 * box-edge) and (abs pycor <= box-edge-y)) or
                     ((abs pycor = box-edge-y) and (pxcor <= piston-position) and (abs pxcor <= box-edge)) ]


  ask heated-walls  [ set pcolor white ]
  ;;color the left side of the wall grey:
  ask patches with [ ((pxcor = ( box-edge)) and (abs pycor <= box-edge-y))]
    [set pcolor grey]
end 

;; creates initial particles

to make-particles [number]
  create-particles number
  [
    setup-particle
    set speed random-float 20
    set energy (0.5 * mass * speed * speed)
    random-position
     set dark-particle? true
  ]

  set total-particle-number initial-number

  ask particles with [who <= initial-number]
    [
      set dark-particle? false
      set shape "circle"
      recolor
  ]
  calculate-tick-delta
end 

to setup-particle  ;; particle procedure

  set speed 10
  set mass 1.0
  set energy (0.5 * mass * speed * speed)
  set last-collision nobody
  set wall-hits 0
  set momentum-difference 0
  set dark-particle? true
  ifelse show-dark? [set shape "default"][set shape "nothing" set color green]
end 

;; place particle at random location inside the box.

to random-position ;; particle procedure
  setxy ((1 - box-edge)  + random-float (box-edge + piston-position - 3))
        ((1 - box-edge-y) + random-float (2 * box-edge-y - 2))
end 

to add-particles
    set particles-to-add number-to-add

 ;;   show particles-to-add
 ;;   show total-particle-number
    ifelse ((particles-to-add + total-particle-number ) > maxparticles)
    [user-message (word "The maximum number of particles allowed in this model is " maxparticles ".  You can not add "  number-to-add
     " more particles to the " (count particles with [dark-particle? = false]) " you already have in the model")]
    [
    if number-to-add > 0 [
       ask particles with [who <= (total-particle-number + particles-to-add) and who >= total-particle-number and who <= maxparticles]
        [ set dark-particle? false
          set shape "circle"
          setxy (- box-edge + 1) 0
          set heading 90 ;; east
          rt 45 - random-float 90
          set speed 10
          recolor
        ]
      set total-particle-number (count particles with [dark-particle? = false])
      set particles-to-add 0

      calculate-tick-delta
      ]
    ]
end 


;;
;; ------ Moveable wall procedures----------
;;

to move-piston

 set run-go? false
  if ((mouse-down?) and (mouse-ycor < (max-pycor - 1)))
   ;;note: if user clicks too far to the right, nothing will happen
   [ if (mouse-xcor >= piston-position and mouse-xcor < box-edge - 2)
      [ piston-out ceiling (mouse-xcor - piston-position) ]
     set run-go? true
     ask volume-target [ht]
     stop
   ]

   set temp-target-wall 0
   set temp-volume 0

  ifelse (mouse-xcor >= piston-position and mouse-xcor < box-edge - 2)
      [set temp-target-wall (( ( 2 * (box-edge - 1) + 1) - (abs (mouse-xcor - box-edge) - 1) )) ]  ;;depth of 1
      [ set temp-target-wall (2 * box-edge - 1) ]

    ifelse (mouse-xcor <= piston-position)
      [ set temp-volume volume ]
      [ set temp-volume (temp-target-wall * delta-vertical-surface * 1)]

   ask volume-target [st setxy mouse-xcor mouse-ycor set label (word "volume: "  floor temp-volume)]

   if (abs mouse-ycor > box-edge-y) [ask volume-target [ht set label ""]]
end 

to piston-out [dist]
  if (dist > 0)
  [ ifelse ((piston-position + dist) < box-edge - 1)
    [ undraw-piston
      set piston-position (piston-position + dist)
      draw-box-piston ]
    [ undraw-piston
      set piston-position (box-edge - 1)
      draw-box-piston ]
   set delta-horizontal-surface  ( 2 * (box-edge - 1) + 1) - (abs (piston-position - box-edge) - 1)
   set volume (delta-horizontal-surface * delta-vertical-surface * 1)  ;;depth of 1
  ]
end 

to draw-box-piston

  set heated-walls patches with [ ((pxcor = -1 * box-edge) and (abs pycor <= box-edge-y)) or
                     ((abs pycor = box-edge-y) and (pxcor <= piston-position) and (abs pxcor <= box-edge)) ]
  ask heated-walls  [ set pcolor wall-color ]

  set piston-wall patches with [ ((pxcor = (round piston-position)) and ((abs pycor) < box-edge-y)) ]
  ask piston-wall  [ set pcolor piston-color ]
  ;; make sides of box that are to right right of the piston grey

  ask patches with [pycor = 0 and pxcor < (1 - box-edge)]
  [
    set pcolor 10 ;; trick the bounce code so particles don't go into the inlet
    ask patch-at 0  1 [ set pcolor wall-color ]
    ask patch-at 0 -1 [ set pcolor wall-color ]
  ]

  ask patches with [(pxcor > (round piston-position)) and (abs (pxcor) < box-edge)
                    and ((abs pycor) = box-edge-y)]
    [set pcolor grey]
  ask patches with [ ((pxcor = ( box-edge)) and (abs pycor <= box-edge-y))]
    [set pcolor grey]
end 

to undraw-piston
  ask patches with [ (pxcor = round piston-position) and ((abs pycor) < box-edge-y) ]
    [ set pcolor black ]

 ;; ask flashes with [ (xcor = round piston-position) and ((abs ycor) < box-edge) ]
 ;;   [ set color white ]
end 



;; reports true if there is a heated wall at the given location

to-report heated-wall?

      if (( abs pxcor = -1 * box-edge) and (abs pycor <= box-edge-y)) or
                     ((abs pycor = box-edge-y) and (abs pxcor <= box-edge))
        [report true]
     ;]
     report false
end 


; Copyright 2005 Uri Wilensky.
; See Info tab for full copyright and license.