gistfile1.txt

Laying out the Solar Array
==========================

1) Component Awareness
----------------------
    Components need to know about each other so that rules can be kept,
    an calculations can be made based on the inter-connectedness of the
    array as a whole of pieces.
    
    To accomplish this I am going to make components a lot smarter then
    they are now. Currently they understand their x,y layout and their
    width/height and not much else.
    
    PANELS
    -------
    
    +---------+ +---------+ +---------+ +---------+ +---------+
    | 11      | | 12      | | 13      | | 14      | | 15      |
    |         | |         | |         | |         | |         |
    +---------+ +---------+ +---------+ +---------+ +---------+
    +---------+ +---------+ +---------+ +---------+ +---------+
    | 6       | | 7       | | 8       | | 9       | | 10      |
    |         | |         | |         | |         | |         |
    +---------+ +---------+ +---------+ +---------+ +---------+
    +---------+ +---------+ +---------+ +---------+ +---------+
    | 1       | | 2       | | 3       | | 4       | | 5       |
    |         | |         | |         | |         | |         |
    +---------+ +---------+ +---------+ +---------+ +---------+
    
    Panel #1 knows this:
      Top     => #6
      Right   => #2
      Bottom  => 
      Left    => 
      
    And because it knows the location of it's linking panels, it also
    knows things like this:
      Edges   => [Left, Bottom]
      Corner  => Left Bottom
      
    Now that Panel #1 knows that stuff it makes it very easy to walk
    from panel to panel in any direction. And we can simply rotate the
    panels and interlocks and skirt 90deg to accommodate E-W/N-S. More
    on that later, but there will be a Transposer, it's job is just to
    swap array values to make x=y, and y=x.
    
    
    INTERLOCKS
    ----------
    
    +---------+ +---------+ +---------+ +---------+ +---------+
    | 11      | | 12      | | 13      | | 14      | | 15      |
    |         | |         | |         | |         | |         |
    +---------+ +---------+ +---------+ +---------+ +---------+
           e -----     f -----     g -----     h -----
    +---------+ +---------+ +---------+ +---------+ +---------+
    | 6       | | 7       | | 8       | | 9       | | 10      |
    |         | |         | |         | |         | |         |
    +---------+ +---------+ +---------+ +---------+ +---------+
           a -----     b -----     c -----     d -----
    +---------+ +---------+ +---------+ +---------+ +---------+
    | 1       | | 2       | | 3       | | 4       | | 5       |
    |         | |         | |         | |         | |         |
    +---------+ +---------+ +---------+ +---------+ +---------+
      
    Interlock (a) knows this:
      TopLeft     => #6
      TopRight    => #7
      BottomLeft  => #1
      BottomRight => #2
      
    This means many things, but a key point to take away here is this;
    the interlocks used to be laid as a sheet based on x,z and some
    fuzzy math. 
    
    They will now get their x,y directly from the panels
    connected to them and will not be laid separately, but as part of
    panels. This also means we can just rotate and get our interlocks
    in the right place.
    
    This also allows our rules (like grounding) to be based not on math
    but instead by running a "circuit checker" starting at #1 and make 
    sure we can reach every panel in the array. This is important when
    the user starts mucking around with the positioning like an installer
    might.