Changeset 155

Timestamp:

Sep 24, 2010 4:07:24 PM (13 years ago)

Author:

vondreele

Message:

changes for structure drawing

Location:

trunk

Files:

• ElementTable.py (modified) (2 diffs)
• GSASII.py (modified) (10 diffs)
• GSASIIElem.py (modified) (1 diff)
• GSASIIIO.py (modified) (4 diffs)
• GSASIIgrid.py (modified) (6 diffs)
• GSASIIlattice.py (modified) (3 diffs)
• GSASIIphsGUI.py (modified) (34 diffs)
• GSASIIplot.py (modified) (16 diffs)
• GSASIIspc.py (modified) (5 diffs)

trunk/ElementTable.py

@@ -1 +1 @@
 #Element table for building periodic table with valences & JMOL colors
+import wx        
 #Need these in case go back to this periodic table coloring scheme
-import wx        
 REcolor = wx.Colour(128, 128, 255)
 Metcolor = wx.Colour(192, 192, 192)
@@ -11 +11 @@
 White = wx.Colour(255, 255, 255)            
 ElTable = [
-    (["H","H-1"],                  0,0, "Hydrogen",    White,           0.0000,wx.Colour(0xff,0xff,0xff)),
-    (["He",],                     17,0, "Helium",      Noblecolor,      0.0000,wx.Colour(0xd9,0xff,0xff)),
-    (["Li","Li+1"],                0,1, "Lithium",     Alkcolor,        0.0004,wx.Colour(0xcc,0x80,0xff)),
-    (["Be","Be+2"],                1,1, "Beryllium",   AlkEcolor,       0.0006,wx.Colour(0xc2,0xff,0x00)),
-    (["B",],                       2,1, "Boron",       NonMetcolor,     0.0012,wx.Colour(0xff,0xb5,0xb5)),
-    (["C",],                      13,1, "Carbon",      NonMetcolor,     0.0018,wx.Colour(0x90,0x90,0x90)),
-    (["N",],                      14,1, "Nitrogen",    NonMetcolor,     0.0030,wx.Colour(0x30,0x50,0xf8)),
-    (["O","O-1","O-2"],            15,1, "Oxygen",      NonMetcolor,     0.0042,wx.Colour(0xff,0x0d,0x0d)),
-    (["F","F-1"],                  16,1, "Fluorine",    NonMetcolor,     0.0054,wx.Colour(0x90,0xe0,0x50)),
-    (["Ne",],                     17,1, "Neon",        Noblecolor,      0.0066,wx.Colour(0xb3,0xe3,0xf5)),
-    (["Na","Na+1"],                 0,2, "Sodium",      Alkcolor,        0.0084,wx.Colour(0xab,0x5c,0xf2)),
-    (["Mg","Mg+2"],                1,2, "Magnesium",   AlkEcolor,       0.0110,wx.Colour(0x8a,0xff,0x00)),
-    (["Al","Al+3"],                2,2, "Aluminum",    SemMetcolor,     0.0125,wx.Colour(0xbf,0xa6,0xa6)),
-    (["Si","Si+4"],               13,2, "Silicon",     NonMetcolor,     0.0158,wx.Colour(0xf0,0xc8,0xa0)),
-    (["P",],                      14,2, "Phosphorus",  NonMetcolor,     0.0180,wx.Colour(0xff,0x80,0x00)),
-    (["S",],                      15,2, "Sulphur",     NonMetcolor,     0.0210,wx.Colour(0xff,0xff,0x30)),
-    (["Cl","Cl-1"],               16,2, "Chlorine",    NonMetcolor,     0.0250,wx.Colour(0x1f,0xf0,0x1f)),
-    (["Ar",],                     17,2, "Argon",       Noblecolor,      0.0285,wx.Colour(0x80,0xd1,0xe3)),
-    (["K","K+1"],                  0,3, "Potassium",   Alkcolor,        0.0320,wx.Colour(0x3d,0xff,0x00)),
-    (["Ca","Ca+2"],                1,3, "Calcium",     AlkEcolor,       0.0362,wx.Colour(0x3d,0xff,0x00)),
-    (["Sc","Sc+3"],                2,3, "Scandium",    Metcolor,        0.0410,wx.Colour(0xe6,0xe6,0xe6)),
-    (["Ti","Ti+2","Ti+3","Ti+4"],  3,3, "Titanium",    Metcolor,        0.0460,wx.Colour(0xbf,0xc2,0xc7)),
-    (["V","V+2","V+3","V+5"],      4,3, "Vanadium",    Metcolor,        0.0510,wx.Colour(0xa6,0xa6,0xab)),
-    (["Cr","Cr+2","Cr+3"],         5,3, "Chromium",    Metcolor,        0.0560,wx.Colour(0x8a,0x99,0xc7)),
-    (["Mn","Mn+2","Mn+3","Mn+4"],  6,3, "Manganese",   Metcolor,        0.0616,wx.Colour(0x9c,0x7a,0xc7)),
-    (["Fe","Fe+2","Fe3"],          7,3, "Iron",        Metcolor,        0.0680,wx.Colour(0xe0,0x66,0x33)),
-    (["Co","Co+2","Co+3"],         8,3, "Cobalt",      Metcolor,        0.0740,wx.Colour(0xf0,0x90,0xa0)),
-    (["Ni","Ni+2","Ni+3"],         9,3, "Nickel",      Metcolor,        0.0815,wx.Colour(0x50,0xd0,0x50)),
-    (["Cu","Cu+1","Cu+2"],        10,3, "Copper",      Metcolor,        0.0878,wx.Colour(0xc8,0x80,0x33)),
-    (["Zn","Zn+2"],               11,3, "Zinc",        Metcolor,        0.0960,wx.Colour(0x7d,0x80,0xb0)),
-    (["Ga","Ga+3"],               12,3, "Gallium",     SemMetcolor,      0.104,wx.Colour(0xc2,0x8f,0x8f)),
-    (["Ge","Ge+4"],               13,3, "Germanium",   SemMetcolor,      0.114,wx.Colour(0x66,0x8f,0x8f)),
-    (["As",],                     14,3, "Arsenic",     NonMetcolor,      0.120,wx.Colour(0xbd,0x80,0xe3)),
-    (["Se",],                     15,3, "Selenium",    NonMetcolor,      0.132,wx.Colour(0xff,0xa1,0x00)),
-    (["Br","Br-1"],               16,3, "Bromine",     NonMetcolor,      0.141,wx.Colour(0xa6,0x29,0x29)),
-    (["Kr",],                     17,3, "Krypton",     Noblecolor,       0.150,wx.Colour(0x5c,0xb8,0xd1)),
-    (["Rb","Rb+1"],                0,4, "Rubidium",    Alkcolor,         0.159,wx.Colour(0x70,0x2e,0xb0)),
-    (["Sr","Sr+2"],                1,4, "Strontium",   AlkEcolor,        0.171,wx.Colour(0x00,0xff,0x00)),
-    (["Y","Y+3"],                  2,4, "Yittrium",    Metcolor,         0.180,wx.Colour(0x94,0xff,0xff)),
-    (["Zr","Zr+4"],                3,4, "Zirconium",   Metcolor,         0.192,wx.Colour(0x94,0xe0,0xe0)),
-    (["Nb","Nb+3","Nb+5"],         4,4, "Niobium",     Metcolor,         0.204,wx.Colour(0x73,0xc2,0xc9)),
-    (["Mo","Mo+3","Mo+5","Mo+6"],  5,4, "Molybdenium", Metcolor,         0.216,wx.Colour(0x54,0xb5,0xb5)),
-    (["Tc",],                      6,4, "Technetium",  Metcolor,         0.228,wx.Colour(0x3b,0x9e,0x9e)),
-    (["Ru","Ru+3","Ru+4"],         7,4, "Ruthenium",   Metcolor,         0.246,wx.Colour(0x24,0x8f,0x8f)),
-    (["Rh","Rh+3","Rh+4"],         8,4, "Rhodium",     Metcolor,         0.258,wx.Colour(0x0a,0x7d,0x8c)),
-    (["Pd","Pd+2","Pd+4"],         9,4, "Palladium",   Metcolor,         0.270,wx.Colour(0x00,0x69,0x85)),
-    (["Ag","Ag+1","Ag+2"],        10,4, "Silver",      Metcolor,         0.285,wx.Colour(0xc0,0xc0,0xc0)),
-    (["Cd","Cd+2"],               11,4, "Cadmium",     Metcolor,         0.300,wx.Colour(0xff,0xd9,0x8f)),
-    (["In","In+3"],               12,4, "Indium",      SemMetcolor,      0.318,wx.Colour(0xa6,0x75,0x73)),
-    (["Sn","Sn+2","Sn+4"],        13,4, "Tin",         SemMetcolor,      0.330,wx.Colour(0x66,0x80,0x80)),
-    (["Sb","Sb+3","Sb+5"],        14,4, "Antimony",    SemMetcolor,      0.348,wx.Colour(0x9e,0x63,0xb5)),
-    (["Te",],                     15,4, "Tellurium",   NonMetcolor,      0.363,wx.Colour(0xd4,0x7a,0x00)),
-    (["I","I-1"],                 16,4, "Iodine",      NonMetcolor,      0.384,wx.Colour(0x94,0x00,0x94)),
-    (["Xe",],                     17,4, "Xenon",       Noblecolor,       0.396,wx.Colour(0x42,0x9e,0xb0)),
-    (["Cs","Cs+1"],                0,5, "Caesium",     Alkcolor,         0.414,wx.Colour(0x57,0x17,0x8f)),
-    (["Ba","Ba+2"],                1,5, "Barium",      AlkEcolor,        0.438,wx.Colour(0x00,0xc9,0x00)),
-    (["La","La+3"],                2,5, "Lanthanium",  Metcolor,         0.456,wx.Colour(0x70,0xd4,0xff)),
-    (["Ce","Ce+3","Ce+4"],     3.5,6.5, "Cerium",      REcolor,          0.474,wx.Colour(0xff,0xff,0xc7)),
-    (["Pr","Pr+3","Pr+4"],     4.5,6.5, "Praseodymium",REcolor,          0.492,wx.Colour(0xd9,0xff,0xc7)),
-    (["Nd","Nd+3"],            5.5,6.5, "Neodymium",   REcolor,          0.516,wx.Colour(0xc7,0xff,0xc7)),
-    (["Pm","Pm+3"],            6.5,6.5, "Promethium",  REcolor,          0.534,wx.Colour(0xa3,0xff,0xc7)),
-    (["Sm","Sm+3"],            7.5,6.5, "Samarium",    REcolor,          0.558,wx.Colour(0x8f,0xff,0xc7)),
-    (["Eu","Eu+2","Eu+3"],     8.5,6.5, "Europium",    REcolor,          0.582,wx.Colour(0x61,0xff,0xc7)),
-    (["Gd","Gd+3"],            9.5,6.5, "Gadolinium",  REcolor,          0.610,wx.Colour(0x45,0xff,0xc7)),
-    (["Tb","Tb+3"],           10.5,6.5, "Terbium",     REcolor,          0.624,wx.Colour(0x30,0xff,0xc7)),
-    (["Dy","Dy+3"],           11.5,6.5, "Dysprosium",  REcolor,          0.648,wx.Colour(0x1f,0xff,0xc7)),
-    (["Ho","Ho+3"],           12.5,6.5, "Holmium",     REcolor,          0.672,wx.Colour(0x00,0xff,0x9c)),
-    (["Er","Er+3"],           13.5,6.5, "Erbium",      REcolor,          0.696,wx.Colour(0x00,0xe6,0x75)),
-    (["Tm","Tm+3"],           14.5,6.5, "Thulium",     REcolor,          0.723,wx.Colour(0x00,0xd4,0x52)),
-    (["Yb","Yb+2","Yb+3"],    15.5,6.5, "Ytterbium",   REcolor,          0.750,wx.Colour(0x00,0xbf,0x38)),
-    (["Lu","Lu+3"],           16.5,6.5, "Lutetium",    REcolor,          0.780,wx.Colour(0x00,0xab,0x24)),
-    (["Hf","Hf+4"],                3,5, "Hafnium",     Metcolor,         0.804,wx.Colour(0x4d,0xc2,0xff)),
-    (["Ta","Ta+5"],                4,5, "Tantalum",    Metcolor,         0.834,wx.Colour(0x4d,0xa6,0xff)),
-    (["W","W+6"],                  5,5, "Tungsten",    Metcolor,         0.864,wx.Colour(0x21,0x94,0xd6)),
-    (["Re",],                      6,5, "Rhenium",     Metcolor,         0.900,wx.Colour(0x26,0x7d,0xab)),
-    (["Os","Os+4"],                7,5, "Osmium",      Metcolor,         0.919,wx.Colour(0x26,0x66,0x96)),
-    (["Ir","Ir+3","Ir+4"],         8,5, "Iridium",     Metcolor,         0.948,wx.Colour(0x17,0x54,0x87)),
-    (["Pt","Pt+2","Pt+4"],         9,5, "Platinium",   Metcolor,         0.984,wx.Colour(0xd0,0xd0,0xe0)),
-    (["Au","Au+1","Au+3"],        10,5, "Gold",        Metcolor,         1.014,wx.Colour(0xff,0xd1,0x23)),
-    (["Hg","Hg+1","Hg+2"],        11,5, "Mercury",     Metcolor,         1.046,wx.Colour(0xb8,0xb8,0xd0)),
-    (["Tl","Tl+1","Tl+3"],        12,5, "Thallium",    SemMetcolor,      1.080,wx.Colour(0xa6,0x54,0x4d)),
-    (["Pb","Pb+2","Pb+4"],        13,5, "Lead",        SemMetcolor,      1.116,wx.Colour(0x57,0x59,0x61)),
-    (["Bi","Bi+3","Bi+5"],        14,5, "Bismuth",     SemMetcolor,      1.149,wx.Colour(0x9e,0x4f,0xb5)),
-    (["Po",],                     15,5, "Polonium",    SemMetcolor,      1.189,wx.Colour(0xab,0x5c,0x00)),
-    (["At",],                     16,5, "Astatine",    NonMetcolor,      1.224,wx.Colour(0x75,0x4f,0x45)),
-    (["Rn",],                     17,5, "Radon",       Noblecolor,       1.260,wx.Colour(0x42,0x82,0x96)),
-    (["Fr",],                      0,6, "Francium",    Alkcolor,         1.296,wx.Colour(0x42,0x00,0x66)),
-    (["Ra","Ra+2"],                1,6, "Radium",      AlkEcolor,        1.332,wx.Colour(0x00,0x7d,0x00)),
-    (["Ac","Ac+3"],                2,6, "Actinium",    Metcolor,         1.374,wx.Colour(0x70,0xab,0xfa)),
-    (["Th","Th+4"],            3.5,7.5, "Thorium",     REcolor,          1.416,wx.Colour(0x00,0xba,0xff)),
-    (["Pa",],                  4.5,7.5, "Protactinium",REcolor,          1.458,wx.Colour(0x00,0xa1,0xff)),
-    (["U","U+3","U+4","U+6"],  5.5,7.5, "Uranium",     REcolor,          1.470,wx.Colour(0x00,0x8f,0xff)),
-    (["Np","Np+3","Np+4","Np+6"], 6.5,7.5, "Neptunium",   REcolor,       1.536,wx.Colour(0x00,0x80,0xff)),
-    (["Pu","Pu+3","Pu+4","Pu+6"], 7.5,7.5, "Plutonium",   REcolor,       1.584,wx.Colour(0x00,0x6b,0xff)),
-    (["Am",],                  8.5,7.5, "Americium",   REcolor,          1.626,wx.Colour(0x54,0x5c,0xf2)),
-    (["Cm",],                  9.5,7.5, "Curium",      REcolor,          1.669,wx.Colour(0x78,0x5c,0xe3)),
-    (["Bk",],                 10.5,7.5, "Berkelium",   REcolor,          1.716,wx.Colour(0x8a,0x4f,0xe3)),
-    (["Cf",],                 11.5,7.5, "Californium", REcolor,          1.764,wx.Colour(0xa1,0x36,0xd4)),
-    (["Q","QA","QB","QC","QD"],  14.5,7.5, "Special form factor", REcolor,  0.000,wx.Colour(0xa1,0x36,0xd4)),
+    (["H","H-1"],                  0,0, "Hydrogen",    White,           0.0000,wx.Colour(255,255,255)),
+    (["He",],                     17,0, "Helium",      Noblecolor,      0.0000,wx.Colour(217,255,255)),
+    (["Li","Li+1"],                0,1, "Lithium",     Alkcolor,        0.0004,wx.Colour(204,128,255)),
+    (["Be","Be+2"],                1,1, "Beryllium",   AlkEcolor,       0.0006,wx.Colour(194,255,0)),
+    (["B",],                       2,1, "Boron",       NonMetcolor,     0.0012,wx.Colour(255,181,181)),
+    (["C",],                      13,1, "Carbon",      NonMetcolor,     0.0018,wx.Colour(144,144,144)),
+    (["N",],                      14,1, "Nitrogen",    NonMetcolor,     0.0030,wx.Colour(48,80,248)),
+    (["O","O-1","O-2"],            15,1, "Oxygen",      NonMetcolor,     0.0042,wx.Colour(255,13,13)),
+    (["F","F-1"],                  16,1, "Fluorine",    NonMetcolor,     0.0054,wx.Colour(144,224,80)),
+    (["Ne",],                     17,1, "Neon",        Noblecolor,      0.0066,wx.Colour(179,227,245)),
+    (["Na","Na+1"],                 0,2, "Sodium",      Alkcolor,        0.0084,wx.Colour(171,92,242)),
+    (["Mg","Mg+2"],                1,2, "Magnesium",   AlkEcolor,       0.0110,wx.Colour(138,255,0)),
+    (["Al","Al+3"],                2,2, "Aluminum",    SemMetcolor,     0.0125,wx.Colour(191,166,166)),
+    (["Si","Si+4"],               13,2, "Silicon",     NonMetcolor,     0.0158,wx.Colour(240,200,160)),
+    (["P",],                      14,2, "Phosphorus",  NonMetcolor,     0.0180,wx.Colour(255,128,0)),
+    (["S",],                      15,2, "Sulphur",     NonMetcolor,     0.0210,wx.Colour(255,255,48)),
+    (["Cl","Cl-1"],               16,2, "Chlorine",    NonMetcolor,     0.0250,wx.Colour(31,240,31)),
+    (["Ar",],                     17,2, "Argon",       Noblecolor,      0.0285,wx.Colour(128,209,227)),
+    (["K","K+1"],                  0,3, "Potassium",   Alkcolor,        0.0320,wx.Colour(61,255,0)),
+    (["Ca","Ca+2"],                1,3, "Calcium",     AlkEcolor,       0.0362,wx.Colour(61,255,0)),
+    (["Sc","Sc+3"],                2,3, "Scandium",    Metcolor,        0.0410,wx.Colour(230,230,230)),
+    (["Ti","Ti+2","Ti+3","Ti+4"],  3,3, "Titanium",    Metcolor,        0.0460,wx.Colour(191,194,199)),
+    (["V","V+2","V+3","V+5"],      4,3, "Vanadium",    Metcolor,        0.0510,wx.Colour(166,166,171)),
+    (["Cr","Cr+2","Cr+3"],         5,3, "Chromium",    Metcolor,        0.0560,wx.Colour(138,153,199)),
+    (["Mn","Mn+2","Mn+3","Mn+4"],  6,3, "Manganese",   Metcolor,        0.0616,wx.Colour(156,122,199)),
+    (["Fe","Fe+2","Fe3"],          7,3, "Iron",        Metcolor,        0.0680,wx.Colour(224,102,51)),
+    (["Co","Co+2","Co+3"],         8,3, "Cobalt",      Metcolor,        0.0740,wx.Colour(240,144,160)),
+    (["Ni","Ni+2","Ni+3"],         9,3, "Nickel",      Metcolor,        0.0815,wx.Colour(80,208,80)),
+    (["Cu","Cu+1","Cu+2"],        10,3, "Copper",      Metcolor,        0.0878,wx.Colour(200,128,51)),
+    (["Zn","Zn+2"],               11,3, "Zinc",        Metcolor,        0.0960,wx.Colour(125,128,176)),
+    (["Ga","Ga+3"],               12,3, "Gallium",     SemMetcolor,      0.104,wx.Colour(194,143,143)),
+    (["Ge","Ge+4"],               13,3, "Germanium",   SemMetcolor,      0.114,wx.Colour(102,143,143)),
+    (["As",],                     14,3, "Arsenic",     NonMetcolor,      0.120,wx.Colour(189,128,227)),
+    (["Se",],                     15,3, "Selenium",    NonMetcolor,      0.132,wx.Colour(255,161,0)),
+    (["Br","Br-1"],               16,3, "Bromine",     NonMetcolor,      0.141,wx.Colour(166,41,41)),
+    (["Kr",],                     17,3, "Krypton",     Noblecolor,       0.150,wx.Colour(92,184,209)),
+    (["Rb","Rb+1"],                0,4, "Rubidium",    Alkcolor,         0.159,wx.Colour(112,46,176)),
+    (["Sr","Sr+2"],                1,4, "Strontium",   AlkEcolor,        0.171,wx.Colour(0,255,0)),
+    (["Y","Y+3"],                  2,4, "Yittrium",    Metcolor,         0.180,wx.Colour(148,255,255)),
+    (["Zr","Zr+4"],                3,4, "Zirconium",   Metcolor,         0.192,wx.Colour(148,224,224)),
+    (["Nb","Nb+3","Nb+5"],         4,4, "Niobium",     Metcolor,         0.204,wx.Colour(115,194,201)),
+    (["Mo","Mo+3","Mo+5","Mo+6"],  5,4, "Molybdenium", Metcolor,         0.216,wx.Colour(84,181,181)),
+    (["Tc",],                      6,4, "Technetium",  Metcolor,         0.228,wx.Colour(59,158,158)),
+    (["Ru","Ru+3","Ru+4"],         7,4, "Ruthenium",   Metcolor,         0.246,wx.Colour(36,143,143)),
+    (["Rh","Rh+3","Rh+4"],         8,4, "Rhodium",     Metcolor,         0.258,wx.Colour(10,125,140)),
+    (["Pd","Pd+2","Pd+4"],         9,4, "Palladium",   Metcolor,         0.270,wx.Colour(0,105,133)),
+    (["Ag","Ag+1","Ag+2"],        10,4, "Silver",      Metcolor,         0.285,wx.Colour(192,192,192)),
+    (["Cd","Cd+2"],               11,4, "Cadmium",     Metcolor,         0.300,wx.Colour(255,217,143)),
+    (["In","In+3"],               12,4, "Indium",      SemMetcolor,      0.318,wx.Colour(166,117,115)),
+    (["Sn","Sn+2","Sn+4"],        13,4, "Tin",         SemMetcolor,      0.330,wx.Colour(102,128,128)),
+    (["Sb","Sb+3","Sb+5"],        14,4, "Antimony",    SemMetcolor,      0.348,wx.Colour(158,99,181)),
+    (["Te",],                     15,4, "Tellurium",   NonMetcolor,      0.363,wx.Colour(212,122,0)),
+    (["I","I-1"],                 16,4, "Iodine",      NonMetcolor,      0.384,wx.Colour(148,0,148)),
+    (["Xe",],                     17,4, "Xenon",       Noblecolor,       0.396,wx.Colour(66,158,176)),
+    (["Cs","Cs+1"],                0,5, "Caesium",     Alkcolor,         0.414,wx.Colour(87,23,143)),
+    (["Ba","Ba+2"],                1,5, "Barium",      AlkEcolor,        0.438,wx.Colour(0,201,0)),
+    (["La","La+3"],                2,5, "Lanthanium",  Metcolor,         0.456,wx.Colour(112,212,255)),
+    (["Ce","Ce+3","Ce+4"],     3.5,6.5, "Cerium",      REcolor,          0.474,wx.Colour(255,255,199)),
+    (["Pr","Pr+3","Pr+4"],     4.5,6.5, "Praseodymium",REcolor,          0.492,wx.Colour(217,255,199)),
+    (["Nd","Nd+3"],            5.5,6.5, "Neodymium",   REcolor,          0.516,wx.Colour(199,255,199)),
+    (["Pm","Pm+3"],            6.5,6.5, "Promethium",  REcolor,          0.534,wx.Colour(163,255,199)),
+    (["Sm","Sm+3"],            7.5,6.5, "Samarium",    REcolor,          0.558,wx.Colour(143,255,199)),
+    (["Eu","Eu+2","Eu+3"],     8.5,6.5, "Europium",    REcolor,          0.582,wx.Colour(97,255,199)),
+    (["Gd","Gd+3"],            9.5,6.5, "Gadolinium",  REcolor,          0.610,wx.Colour(69,255,199)),
+    (["Tb","Tb+3"],           10.5,6.5, "Terbium",     REcolor,          0.624,wx.Colour(48,255,199)),
+    (["Dy","Dy+3"],           11.5,6.5, "Dysprosium",  REcolor,          0.648,wx.Colour(31,255,199)),
+    (["Ho","Ho+3"],           12.5,6.5, "Holmium",     REcolor,          0.672,wx.Colour(0,255,156)),
+    (["Er","Er+3"],           13.5,6.5, "Erbium",      REcolor,          0.696,wx.Colour(0,230,117)),
+    (["Tm","Tm+3"],           14.5,6.5, "Thulium",     REcolor,          0.723,wx.Colour(0,212,82)),
+    (["Yb","Yb+2","Yb+3"],    15.5,6.5, "Ytterbium",   REcolor,          0.750,wx.Colour(0,191,56)),
+    (["Lu","Lu+3"],           16.5,6.5, "Lutetium",    REcolor,          0.780,wx.Colour(0,171,36)),
+    (["Hf","Hf+4"],                3,5, "Hafnium",     Metcolor,         0.804,wx.Colour(77,194,255)),
+    (["Ta","Ta+5"],                4,5, "Tantalum",    Metcolor,         0.834,wx.Colour(77,166,255)),
+    (["W","W+6"],                  5,5, "Tungsten",    Metcolor,         0.864,wx.Colour(33,148,214)),
+    (["Re",],                      6,5, "Rhenium",     Metcolor,         0.900,wx.Colour(38,125,171)),
+    (["Os","Os+4"],                7,5, "Osmium",      Metcolor,         0.919,wx.Colour(38,102,150)),
+    (["Ir","Ir+3","Ir+4"],         8,5, "Iridium",     Metcolor,         0.948,wx.Colour(23,84,135)),
+    (["Pt","Pt+2","Pt+4"],         9,5, "Platinium",   Metcolor,         0.984,wx.Colour(208,208,224)),
+    (["Au","Au+1","Au+3"],        10,5, "Gold",        Metcolor,         1.014,wx.Colour(255,209,35)),
+    (["Hg","Hg+1","Hg+2"],        11,5, "Mercury",     Metcolor,         1.046,wx.Colour(184,184,208)),
+    (["Tl","Tl+1","Tl+3"],        12,5, "Thallium",    SemMetcolor,      1.080,wx.Colour(166,84,77)),
+    (["Pb","Pb+2","Pb+4"],        13,5, "Lead",        SemMetcolor,      1.116,wx.Colour(87,89,97)),
+    (["Bi","Bi+3","Bi+5"],        14,5, "Bismuth",     SemMetcolor,      1.149,wx.Colour(158,79,181)),
+    (["Po",],                     15,5, "Polonium",    SemMetcolor,      1.189,wx.Colour(171,92,0)),
+    (["At",],                     16,5, "Astatine",    NonMetcolor,      1.224,wx.Colour(117,79,69)),
+    (["Rn",],                     17,5, "Radon",       Noblecolor,       1.260,wx.Colour(66,130,150)),
+    (["Fr",],                      0,6, "Francium",    Alkcolor,         1.296,wx.Colour(66,0,102)),
+    (["Ra","Ra+2"],                1,6, "Radium",      AlkEcolor,        1.332,wx.Colour(0,125,0)),
+    (["Ac","Ac+3"],                2,6, "Actinium",    Metcolor,         1.374,wx.Colour(112,171,250)),
+    (["Th","Th+4"],            3.5,7.5, "Thorium",     REcolor,          1.416,wx.Colour(0,186,255)),
+    (["Pa",],                  4.5,7.5, "Protactinium",REcolor,          1.458,wx.Colour(0,161,255)),
+    (["U","U+3","U+4","U+6"],  5.5,7.5, "Uranium",     REcolor,          1.470,wx.Colour(0,143,255)),
+    (["Np","Np+3","Np+4","Np+6"], 6.5,7.5, "Neptunium",   REcolor,       1.536,wx.Colour(0,128,255)),
+    (["Pu","Pu+3","Pu+4","Pu+6"], 7.5,7.5, "Plutonium",   REcolor,       1.584,wx.Colour(0,107,255)),
+    (["Am",],                  8.5,7.5, "Americium",   REcolor,          1.626,wx.Colour(84,92,242)),
+    (["Cm",],                  9.5,7.5, "Curium",      REcolor,          1.669,wx.Colour(120,92,227)),
+    (["Bk",],                 10.5,7.5, "Berkelium",   REcolor,          1.716,wx.Colour(138,79,227)),
+    (["Cf",],                 11.5,7.5, "Californium", REcolor,          1.764,wx.Colour(161,54,212)),
+    (["Q","QA","QB","QC","QD"],  14.5,7.5, "Special form factor", REcolor,  0.000,wx.Colour(161,54,212)),
     ]

trunk/GSASII.py

@@ -17 +17 @@
 import GSASIIplot as G2plt
 import GSASIIpwdGUI as G2pdG
+import OpenGL as ogl
 
 # print versions
@@ -24 +25 @@
 print "matplotlib: ",mpl.__version__
 print "numpy:      ",np.__version__
-
-__version__ = '0.1.3'
+print "OpenGL:     ",ogl.__version__
+
+__version__ = '0.1.4'
 
 # useful degree trig functions
@@ -264 +266 @@
         if pltNum >= 0:                         #to avoid the startup with no plot!
             pltPage = self.G2plotNB.nb.GetPage(pltNum)
-            pltPlot = pltPage.figure.gca()
+#            pltPlot = pltPage.figure.gca()
+            pltPlot = pltPage.figure
         item = event.GetItem()
         G2gd.MovePatternTreeToGrid(self,item)
@@ -520 +523 @@
             parent = self.GetParent()
             parent.Raise()
-            self.SetReturnCode(wx.ID_OK)
-            self.MakeModal(False)              
+            self.EndModal(wx.ID_OK)              
             self.Destroy()
             
@@ -527 +529 @@
             parent = self.GetParent()
             parent.Raise()
-            self.SetReturnCode(wx.ID_CANCEL)
-            self.MakeModal(False)              
+            self.EndModal(wx.ID_CANCEL)              
             self.Destroy()
             
@@ -592 +593 @@
             parent = self.GetParent()
             parent.Raise()
-            self.SetReturnCode(wx.ID_OK)
-            self.MakeModal(False)              
+            self.EndModal(wx.ID_OK)              
             self.Destroy()
             
@@ -599 +599 @@
             parent = self.GetParent()
             parent.Raise()
-            self.SetReturnCode(wx.ID_CANCEL)
-            self.MakeModal(False)              
+            self.EndModal(wx.ID_CANCEL)              
             self.Destroy()
             
@@ -810 +809 @@
         SGData = {'SpGrp':'P 1'}
         self.PatternTree.SetItemPyData(sub, \
-            {'General':{'Name':'phase name','Type':'nuclear','SGData':SGData,'Cell':[False,10.,10.,10.,90.,90.,90,1000.],
-            'Scale':[False,1.0],'Pawley dmin':0.25},'Atoms':[]})
+            {'General':{'Name':PhaseName,'Type':'nuclear','SGData':SGData,'Cell':[False,10.,10.,10.,90.,90.,90,1000.],
+            'Scale':[False,1.0],'Pawley dmin':0.25},'Atoms':[],'Drawing':{}})
 
         
@@ -841 +840 @@
                         i += 1
                     for item in DelItemList:
+                        name = self.PatternTree.GetItemText(item)
                         self.PatternTree.Delete(item)
+                        self.G2plotNB.Delete(name)
             finally:
                 dlg.Destroy()
@@ -1004 +1005 @@
                     EXPfile = dlg.GetPath()
                     self.dirname = dlg.GetDirectory()
-                    Phase = G2IO.ReadEXPPhase(EXPfile)
+                    Phase = G2IO.ReadEXPPhase(self,EXPfile)
             finally:
                 dlg.Destroy()

trunk/GSASIIElem.py

@@ -78 +78 @@
                     Drad = float(S[12:22])
                     Arad = float(S[22:32])
+                    Vdrad = float(S[32:38])
                     Color = ET.ElTable[Elements.index(Symbol)][6]
     FFdata.close()
-    AtomInfo={'Symbol':Symbol,'Mass':Mass,'Z':Z,'Drad':Drad,'Arad':Arad,'Color':Color}    
+    AtomInfo={'Symbol':Symbol,'Mass':Mass,'Z':Z,'Drad':Drad,'Arad':Arad,'Vdrad':Vdrad,'Color':Color}    
     return AtomInfo
       

trunk/GSASIIIO.py

@@ -844 +844 @@
     print 'index peak list saved'
     
-def ReadEXPPhase(filename):
+def ReadEXPPhase(self,filename):
     import GSASIIspc as G2spc
     import GSASIIlattice as G2lat
@@ -930 +930 @@
     Phase['General'] = {'Name':PhaseName,'Type':Ptype,'SGData':SGData,'Cell':[False,]+abc+angles+[Volume,],'Scale':[False,1.0]}
     Phase['Atoms'] = Atoms
+    Phase['Drawing'] = {}
     return Phase
        
@@ -974 +975 @@
             if Type[0] in '123456789':
                 Type = Type[1:]
-            Atom = [int(S[22:27]),S[17:20].upper(),S[20:22],
+            Atom = [S[22:27].strip(),S[17:20].upper(),S[20:22],
                 S[12:17].strip(),Type.strip(),'',XYZ[0],XYZ[1],XYZ[2],
                 float(S[55:61]),SytSym,Mult,'I',Uiso,0,0,0,0,0,0]
@@ -997 +998 @@
     Phase['General'] = {'Name':PhaseName,'Type':'macromolecular','SGData':SGData,'Cell':[False,]+cell+[Volume,],'Scale':[False,1.0]}
     Phase['Atoms'] = Atoms
+    Phase['Drawing'] = {}
     
     return Phase

trunk/GSASIIgrid.py

@@ -14 +14 @@
 ] = [wx.NewId() for _init_coll_Atom_Items in range(6)]
 
+[ wxID_DRAWATOMSTYLE, wxID_DRAWATOMLABEL, wxID_DRAWVIEWPOINT, wxID_DRAWTRANSFORM,
+    wxID_DRAWDELETE, wxID_DRAWFILLCELL, wxID_DRAWADDEQUIV, wxID_DRAWFILLCOORD,
+] = [wx.NewId() for _init_coll_DrawAtom_Items in range(8)]
+
 [ wxID_IMCALIBRATE, wxID_IMINTEGRATE, wxID_IMCLEARCALIB, wxID_SAVEINTG, 
     wxID_IMCOPYCONTROLS, wxID_INTEGRATEALL,
@@ -40 +44 @@
         
     def _init_coll_AtomsMenu(self,parent):
-        parent.Append(menu=self.AtomEdit, title='Edit atom list')
+        parent.Append(menu=self.AtomEdit, title='Edit')
+        
+    def _init_coll_DrawAtomsMenu(self,parent):
+        parent.Append(menu=self.DrawAtomEdit, title='Edit')        
 
     def _init_coll_IndPeaksMenu(self,parent):
@@ -73 +80 @@
             help='Select atoms to transform first')
             
+    def _init_coll_DrawAtom_Items(self,parent):
+        parent.Append(id=wxID_DRAWATOMSTYLE, kind=wx.ITEM_NORMAL,text='Atom style',
+            help='Select atoms first')
+        parent.Append(id=wxID_DRAWATOMLABEL, kind=wx.ITEM_NORMAL,text='Atom label',
+            help='Select atoms first')
+        parent.Append(id=wxID_DRAWVIEWPOINT, kind=wx.ITEM_NORMAL,text='View point',
+            help='View point is 1st atom selected')
+        parent.Append(id=wxID_DRAWADDEQUIV, kind=wx.ITEM_NORMAL,text='Add atoms',
+            help='Add symmetry & cell equivalents to drawing set from selected atoms')
+        parent.Append(id=wxID_DRAWTRANSFORM, kind=wx.ITEM_NORMAL,text='Transform atoms',
+            help='Transform selected atoms by symmetry & cell translations')
+        parent.Append(id=wxID_DRAWFILLCOORD, kind=wx.ITEM_NORMAL,text='Fill CN-sphere',
+            help='Fill coordination sphere for selected atoms')            
+        parent.Append(id=wxID_DRAWFILLCELL, kind=wx.ITEM_NORMAL,text='Fill unit cell',
+            help='Fill unit cell with selected atoms')
+        parent.Append(id=wxID_DRAWDELETE, kind=wx.ITEM_NORMAL,text='Delete atoms',
+            help='Delete atoms from drawing set')
+
     def _init_coll_IndPeaks_Items(self,parent):
         parent.Append(help='Load/Reload index peaks from peak list',id=wxID_INDXRELOAD, 
@@ -121 +146 @@
         
         self.AtomsMenu = wx.MenuBar()
+        self.DrawAtomsMenu = wx.MenuBar()
         self.ImageMenu = wx.MenuBar()
         self.MaskMenu = wx.MenuBar()
@@ -128 +154 @@
         self.IndexMenu = wx.MenuBar()
         self.AtomEdit = wx.Menu(title='')
+        self.DrawAtomEdit = wx.Menu(title='')
         self.ImageEdit = wx.Menu(title='')
         self.MaskEdit = wx.Menu(title='')
@@ -136 +163 @@
         self._init_coll_AtomsMenu(self.AtomsMenu)
         self._init_coll_Atom_Items(self.AtomEdit)
+        self._init_coll_DrawAtomsMenu(self.DrawAtomsMenu)
+        self._init_coll_DrawAtom_Items(self.DrawAtomEdit)
         self._init_coll_ImageMenu(self.ImageMenu)
         self._init_coll_Image_Items(self.ImageEdit)

trunk/GSASIIlattice.py

@@ -1 +1 @@
 '''Perform lattice-related computations'''
 
+import math
 import numpy as np
 import numpy.linalg as nl
@@ -118 +119 @@
     '''Computes orthogonalization matrix from unit cell constants
     cell is tuple with a,b,c,alpha, beta, gamma (degrees)
-    returns list of two 3x3 numpy arrays
-       A for crystal to Cartesian transformations A*x = X 
-       B (inverse) for Cartesian to crystal transformation B*X = x
+    returns tuple of two 3x3 numpy arrays (A,B)
+       A for crystal to Cartesian transformations A*x = np.inner(A,x) = X 
+       B (= inverse of A) for Cartesian to crystal transformation B*X = np.inner(B*x) = x
     '''
     G,g = cell2Gmat(cell) 
@@ -134 +135 @@
     B = nl.inv(A)
     return A,B
+    
+#def U2Uij(U):
+#    #returns the UIJ vector U11,U22,U33,U12,U13,U23 from tensor U
+#    return [U[0][0],U[1][1],U[2][2],U[0][1],U[0][2],U[1][2]]
+#    
+#def Uij2U(Uij):
+#    #returns the thermal motion tensor U from Uij as numpy array
+#    return np.array([[Uij[0],Uij[3],Uij[4]],[Uij[3],Uij[1],Uij[5]],[Uij[4],Uij[5],Uij[2]]])
+#    
+def Uij2betaij(Uij,G):
+    '''
+    Convert Uij to beta-ij tensors
+    input:
+    Uij - numpy array [Uij]
+    G - reciprocal metric tensor
+    returns:
+    beta-ij - numpy array [beta-ij]
+    '''
+    pass
+    
+def criticalEllipse(prob):
+    '''
+    Calculate critical values for probability ellipsoids from probability
+    '''
+    if not ( 0.01 <= prob < 1.0):
+        return 1.54 
+    coeff = np.array([6.44988E-09,4.16479E-07,1.11172E-05,1.58767E-04,0.00130554,
+        0.00604091,0.0114921,-0.040301,-0.6337203,1.311582])
+    llpr = math.log(-math.log(prob))
+    return np.polyval(coeff,llpr)
+    
+def CellBlock(nCells):
+    '''
+    Generate block of unit cells n*n*n on a side; [0,0,0] centered, n = 2*nCells+1
+    currently only works for nCells = 0 or 1 (not >1)
+    '''
+    if nCells:
+        N = 2*nCells+1
+        N2 = N*N
+        N3 = N*N*N
+        cellArray = []
+        A = np.array(range(N3))
+        cellGen = np.array([A/N2-1,A/N%N-1,A%N-1]).T
+        for cell in cellGen:
+            cellArray.append(cell)
+        return cellArray
+    else:
+        return [0,0,0]
+                        
+    
+
+#Permutations and Combinations
+# Four routines: combinations,uniqueCombinations, selections & permutations
+#These taken from Python Cookbook, 2nd Edition. 19.15 p724-726
+#    
+def _combinators(_handle, items, n):
+    ''' factored-out common structure of all following combinators '''
+    if n==0:
+        yield [ ]
+        return
+    for i, item in enumerate(items):
+        this_one = [ item ]
+        for cc in _combinators(_handle, _handle(items, i), n-1):
+            yield this_one + cc
+def combinations(items, n):
+    ''' take n distinct items, order matters '''
+    def skipIthItem(items, i):
+        return items[:i] + items[i+1:]
+    return _combinators(skipIthItem, items, n)
+def uniqueCombinations(items, n):
+    ''' take n distinct items, order is irrelevant '''
+    def afterIthItem(items, i):
+        return items[i+1:]
+    return _combinators(afterIthItem, items, n)
+def selections(items, n):
+    ''' take n (not necessarily distinct) items, order matters '''
+    def keepAllItems(items, i):
+        return items
+    return _combinators(keepAllItems, items, n)
+def permutations(items):
+    ''' take all items, order matters '''
+    return combinations(items, len(items))
 
 #reflection generation routines

trunk/GSASIIphsGUI.py

@@ -24 +24 @@
 cosd = lambda x: math.cos(x*math.pi/180.)
 asind = lambda x: 180.*math.asin(x)/math.pi
-            
-def UpdatePhaseData(self,item,data,oldPage):
-    
-    class SymOpDialog(wx.Dialog):
-        def __init__(self,parent,SGData):
-            wx.Dialog.__init__(self,parent,-1,'Select symmetry operator', 
-                pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
-            panel = wx.Panel(self)
-            self.SGData = SGData
-            self.OpSelected = [0,0,0,0,0,0]
-            mainSizer = wx.BoxSizer(wx.VERTICAL)            
-            mainSizer.Add((5,5),0)
-            if SGData['SGInv']:
-                choice = ['No','Yes']
-                self.inv = wx.RadioBox(panel,-1,'Choose inversion?',choices=choice)
-                self.inv.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
-                mainSizer.Add(self.inv,0,wx.ALIGN_CENTER_VERTICAL)
-            mainSizer.Add((5,5),0)
-            if SGData['SGLatt'] != 'P':
-                LattOp = G2spc.Latt2text(SGData['SGLatt']).split(';')
-                self.latt = wx.RadioBox(panel,-1,'Choose cell centering?',choices=LattOp)
-                self.latt.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
-                mainSizer.Add(self.latt,0,wx.ALIGN_CENTER_VERTICAL)
-            mainSizer.Add((5,5),0)
-            if SGData['SGLaue'] in ['-1','2/m','mmm','4/m','4/mmm']:
-                Ncol = 2
-            else:
-                Ncol = 3
-            OpList = []
-            for M,T in SGData['SGOps']:
-                OpList.append(G2spc.MT2text(M,T))
-            self.oprs = wx.RadioBox(panel,-1,'Choose space group operator?',choices=OpList,
-                majorDimension=Ncol)
-            self.oprs.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
-            mainSizer.Add(self.oprs,0,wx.ALIGN_CENTER_VERTICAL)
-            mainSizer.Add((5,5),0)
-            mainSizer.Add(wx.StaticText(panel,-1,"   Choose unit cell?"),0,wx.ALIGN_CENTER_VERTICAL)
-            mainSizer.Add((5,5),0)
-            cellSizer = wx.BoxSizer(wx.HORIZONTAL)
-            cellSizer.Add((5,0),0)
-            cellName = ['X','Y','Z']
-            self.cell = []
-            for i in range(3):
-                self.cell.append(wx.SpinCtrl(panel,-1,cellName[i],size=wx.Size(50,20)))
-                self.cell[-1].SetRange(-3,3)
-                self.cell[-1].SetValue(0)
-                self.cell[-1].Bind(wx.EVT_SPINCTRL, self.OnOpSelect)
-                cellSizer.Add(self.cell[-1],0,wx.ALIGN_CENTER_VERTICAL)
-            mainSizer.Add(cellSizer,0,)
+
+class SymOpDialog(wx.Dialog):
+    def __init__(self,parent,SGData,New=True):
+        wx.Dialog.__init__(self,parent,-1,'Select symmetry operator',
+            pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
+        panel = wx.Panel(self)
+        self.SGData = SGData
+        self.New = New
+        self.OpSelected = [0,0,0,0,0,0]
+        mainSizer = wx.BoxSizer(wx.VERTICAL)
+        mainSizer.Add((5,5),0)
+        if SGData['SGInv']:
+            choice = ['No','Yes']
+            self.inv = wx.RadioBox(panel,-1,'Choose inversion?',choices=choice)
+            self.inv.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
+            mainSizer.Add(self.inv,0,wx.ALIGN_CENTER_VERTICAL)
+        mainSizer.Add((5,5),0)
+        if SGData['SGLatt'] != 'P':
+            LattOp = G2spc.Latt2text(SGData['SGLatt']).split(';')
+            self.latt = wx.RadioBox(panel,-1,'Choose cell centering?',choices=LattOp)
+            self.latt.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
+            mainSizer.Add(self.latt,0,wx.ALIGN_CENTER_VERTICAL)
+        mainSizer.Add((5,5),0)
+        if SGData['SGLaue'] in ['-1','2/m','mmm','4/m','4/mmm']:
+            Ncol = 2
+        else:
+            Ncol = 3
+        OpList = []
+        for M,T in SGData['SGOps']:
+            OpList.append(G2spc.MT2text(M,T))
+        self.oprs = wx.RadioBox(panel,-1,'Choose space group operator?',choices=OpList,
+            majorDimension=Ncol)
+        self.oprs.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
+        mainSizer.Add(self.oprs,0,wx.ALIGN_CENTER_VERTICAL)
+        mainSizer.Add((5,5),0)
+        mainSizer.Add(wx.StaticText(panel,-1,"   Choose unit cell?"),0,wx.ALIGN_CENTER_VERTICAL)
+        mainSizer.Add((5,5),0)
+        cellSizer = wx.BoxSizer(wx.HORIZONTAL)
+        cellSizer.Add((5,0),0)
+        cellName = ['X','Y','Z']
+        self.cell = []
+        for i in range(3):
+            self.cell.append(wx.SpinCtrl(panel,-1,cellName[i],size=wx.Size(50,20)))
+            self.cell[-1].SetRange(-3,3)
+            self.cell[-1].SetValue(0)
+            self.cell[-1].Bind(wx.EVT_SPINCTRL, self.OnOpSelect)
+            cellSizer.Add(self.cell[-1],0,wx.ALIGN_CENTER_VERTICAL)
+        mainSizer.Add(cellSizer,0,)
+        if self.New:
             choice = ['No','Yes']
             self.new = wx.RadioBox(panel,-1,'Generate new positions?',choices=choice)
             self.new.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
             mainSizer.Add(self.new,0,wx.ALIGN_CENTER_VERTICAL)
-            mainSizer.Add((5,5),0)
-                            
-            OkBtn = wx.Button(panel,-1,"Ok")
-            OkBtn.Bind(wx.EVT_BUTTON, self.OnOk)
-            cancelBtn = wx.Button(panel,-1,"Cancel")
-            cancelBtn.Bind(wx.EVT_BUTTON, self.OnCancel)
-            btnSizer = wx.BoxSizer(wx.HORIZONTAL)
-            btnSizer.Add((20,20),1)
-            btnSizer.Add(OkBtn)
-            btnSizer.Add((20,20),1)
-            btnSizer.Add(cancelBtn)
-            btnSizer.Add((20,20),1)
-            
-            mainSizer.Add(btnSizer,0,wx.EXPAND|wx.BOTTOM|wx.TOP, 10)
-            panel.SetSizer(mainSizer)
-            panel.Fit()
-            self.Fit()
-            
-        def OnOpSelect(self,event):
-            self.OpSelected = [0,0,0,[],0]
-            if self.SGData['SGInv']:
-                self.OpSelected[0] = self.inv.GetSelection()
-            if self.SGData['SGLatt'] != 'P':            
-                self.OpSelected[1] = self.latt.GetSelection()
-            self.OpSelected[2] = self.oprs.GetSelection()
-            for i in range(3):
-                self.OpSelected[3].append(float(self.cell[i].GetValue()))
-            self.OpSelected[4] = self.new.GetSelection()
-                
-        def GetSelection(self):
-            return self.OpSelected
-                            
-        def OnOk(self,event):
-            parent = self.GetParent()
-            parent.Raise()
-            self.SetReturnCode(wx.ID_OK)
-            self.MakeModal(False)              
-            self.Destroy()
-            
-        def OnCancel(self,event):
-            parent = self.GetParent()
-            parent.Raise()
-            self.SetReturnCode(wx.ID_CANCEL)
-            self.MakeModal(False)              
-            self.Destroy()            
-        
+        mainSizer.Add((5,5),0)
+
+        OkBtn = wx.Button(panel,-1,"Ok")
+        OkBtn.Bind(wx.EVT_BUTTON, self.OnOk)
+        cancelBtn = wx.Button(panel,-1,"Cancel")
+        cancelBtn.Bind(wx.EVT_BUTTON, self.OnCancel)
+        btnSizer = wx.BoxSizer(wx.HORIZONTAL)
+        btnSizer.Add((20,20),1)
+        btnSizer.Add(OkBtn)
+        btnSizer.Add((20,20),1)
+        btnSizer.Add(cancelBtn)
+        btnSizer.Add((20,20),1)
+
+        mainSizer.Add(btnSizer,0,wx.EXPAND|wx.BOTTOM|wx.TOP, 10)
+        panel.SetSizer(mainSizer)
+        panel.Fit()
+        self.Fit()
+
+    def OnOpSelect(self,event):
+        self.OpSelected = [0,0,0,[]]
+        if self.SGData['SGInv']:
+            self.OpSelected[0] = self.inv.GetSelection()
+        if self.SGData['SGLatt'] != 'P':
+            self.OpSelected[1] = self.latt.GetSelection()
+        self.OpSelected[2] = self.oprs.GetSelection()
+        for i in range(3):
+            self.OpSelected[3].append(float(self.cell[i].GetValue()))
+        if self.New:
+            self.OpSelected.append(self.new.GetSelection())
+
+    def GetSelection(self):
+        return self.OpSelected
+
+    def OnOk(self,event):
+        parent = self.GetParent()
+        parent.Raise()
+        self.EndModal(wx.ID_OK)
+        self.Destroy()
+
+    def OnCancel(self,event):
+        parent = self.GetParent()
+        parent.Raise()
+        self.EndModal(wx.ID_CANCEL)
+        self.Destroy()
+
+def UpdatePhaseData(self,item,data,oldPage):
+
     Atoms = []
     self.SelectedRow = 0
-    
+
     def BookResize(event):
         w,h = self.GetSize()
         self.dataDisplay.SetSize(wx.Size(w,h))
         
+    def UpdateGeneral():
+        generalData = data['General']
+        atomData = data['Atoms']
+        generalData['AtomTypes'] = []
+        generalData['NoAtoms'] = {}
+        generalData['BondRadii'] = []
+        generalData['AngleRadii'] = []
+        generalData['vdWRadii'] = []
+        generalData['AtomMass'] = []
+        generalData['Color'] = []
+        colType = 1
+        colSS = 7
+        if generalData['Type'] =='macromolecular':
+            colType = 4
+            colSS = 10
+        for atom in atomData:
+            atom[colType] = atom[colType].lower().capitalize()              #force to standard form
+            if generalData['AtomTypes'].count(atom[colType]):
+                generalData['NoAtoms'][atom[colType]] += atom[colSS-1]*float(atom[colSS+1])
+            elif atom[colType] != 'UNK':
+                Info = G2elem.GetAtomInfo(atom[colType])
+                generalData['AtomTypes'].append(atom[colType])
+                generalData['BondRadii'].append(Info['Drad'])
+                generalData['AngleRadii'].append(Info['Arad'])
+                generalData['vdWRadii'].append(Info['Vdrad'])
+                generalData['AtomMass'].append(Info['Mass'])
+                generalData['NoAtoms'][atom[colType]] = atom[colSS-1]*float(atom[colSS+1])
+                generalData['Color'].append(Info['Color'])
+
     def FillGeneralGrid():
         rowLabels = ['Phase name','Phase type','Space group',
-            'Lattice ',' parameters','Scale factor','Elements','No. per cell',
-            'Atom weight','','Bond radii','Angle radii','Color']
+            'Lattice ',' parameters','Scale factor','Density','Elements','No. per cell',
+            'Atom weight','Bond radii','Angle radii','vdw radii','Color']
         def SetLatticeParametersStyle(SGData,table):
             clist = [1,2,3,4,5,6]
@@ -167 +197 @@
                     clist = [4,5]
             for c in clist:
-                General.SetCellStyle(4,c,VERY_LIGHT_GREY,True)                
-            
+                General.SetCellStyle(4,c,VERY_LIGHT_GREY,True)
+
         def RefreshGeneralGrid(event):
-                
+
             r,c =  event.GetRow(),event.GetCol()
             generalData['Name'] = table[0][0]
@@ -177 +207 @@
             SpcGp = table[2][0]
             SGErr,SGData = G2spc.SpcGroup(SpcGp)
-            if r == 2 and c == 0:
+            if r == 0:
+                self.G2plotNB.Rename(oldName,generalData['Name'])
+            elif r == 2 and c == 0:
                 if SGErr:
                     text = [G2spc.SGErrors(SGErr)+'\nSpace Group set to previous']
@@ -200 +232 @@
             generalData['Scale'][1] = float(General.GetCellValue(5,1))
             General.ForceRefresh()
-            
+
+        UpdateGeneral()
         generalData = data['General']
-        atomData = data['Atoms']
-        generalData['AtomTypes'] = []
-        generalData['NoAtoms'] = {}
-        generalData['BondRadii'] = []
-        generalData['AngleRadii'] = []
-        generalData['AtomMass'] = []
-        generalData['Color'] = []
-        colType = 1
-        colSS = 7
-        self.dataFrame.setSizePosLeft([600,350])
-        if generalData['Type'] =='macromolecular':
-            colType = 4
-            colSS = 10
-        for atom in atomData:
-            atom[colType] = atom[colType].lower().capitalize()              #force to standard form
-            if generalData['AtomTypes'].count(atom[colType]):
-                generalData['NoAtoms'][atom[colType]] += atom[colSS-1]*atom[colSS+1]
-            elif atom[colType] != 'UNK':
-                Info = G2elem.GetAtomInfo(atom[colType])
-                generalData['AtomTypes'].append(atom[colType])
-                generalData['BondRadii'].append(Info['Drad'])
-                generalData['AngleRadii'].append(Info['Arad'])
-                generalData['AtomMass'].append(Info['Mass'])
-                generalData['NoAtoms'][atom[colType]] = atom[colSS-1]*atom[colSS+1]
-                generalData['Color'].append(Info['Color'])
+        self.dataFrame.setSizePosLeft([750,340])
         colLabels = []
         colLabels += ['' for i in range(max(8,len(generalData['AtomTypes'])))]
@@ -242 +251 @@
             rowLabels[6] = 'd min'
         else:
-            table.append(generalData['AtomTypes']+['' for i in range(max(8,len(generalData['AtomTypes'])))]) #element list
             mass = 0.
             for i,elem in enumerate(generalData['AtomTypes']):
                 mass += generalData['NoAtoms'][elem]*generalData['AtomMass'][i]
+            Volume = generalData['Cell'][7]
+            if generalData['Type'] == 'macromolecular' and mass > 0.0:
+                table.append([mass/(0.6022137*Volume),'Matthews coeff.',Volume/mass,'','','','','',''])
+            else:
+                table.append([mass/(0.6022137*Volume),'','','','','','','',''])
+            for i,elem in enumerate(generalData['AtomTypes']):
                 line.append(generalData['NoAtoms'][elem])
-            Volume = generalData['Cell'][7]
+            table.append(generalData['AtomTypes']+['' for i in range(max(8,len(generalData['AtomTypes'])))]) #element list
             table.append(line+['' for i in range(max(8,len(generalData['AtomTypes'])))]) #No. per cell
             table.append(generalData['AtomMass']+['' for i in range(max(8,len(generalData['AtomTypes'])))])  #At. wt.
-            if generalData['Type'] == 'macromolecular' and mass > 0.0:
-                table.append(['density',mass/(0.6022137*Volume),'Matthews coeff.',Volume/mass,'','','','',''])            
-            else:
-                table.append(['density',mass/(0.6022137*Volume),'','','','','','',''])
             table.append(generalData['BondRadii']+['' for i in range(max(8,len(generalData['AtomTypes'])))])
             table.append(generalData['AngleRadii']+['' for i in range(max(8,len(generalData['AtomTypes'])))])
+            table.append(generalData['vdWRadii']+['' for i in range(max(8,len(generalData['AtomTypes'])))])
             table.append(['','','','','','','',''])                        #contains colors
         Types = [wg.GRID_VALUE_STRING for i in range(max(8,len(generalData['AtomTypes'])))]
@@ -275 +286 @@
                 General.SetCellRenderer(4,c,wg.GridCellFloatRenderer(10,5))
                 General.SetCellEditor(4,c,wg.GridCellFloatEditor(10,5))
-                General.SetReadOnly(9,c,isReadOnly=True)
             else:
                 General.SetCellRenderer(4,c,wg.GridCellFloatRenderer(10,3))
                 General.SetCellEditor(4,c,wg.GridCellFloatEditor(10,3))
-            for r in range(6,12):
+            for r in range(6,13):
                 General.SetReadOnly(r,c,isReadOnly=True)
         r = rowLabels.index('Color')
@@ -286 +296 @@
 
         General.SetReadOnly(4,7,isReadOnly=True)                            #cell volume - no edit
-        General.SetCellEditor(1,0,wg.GridCellChoiceEditor(['nuclear','modulated',   #phase type 
+        General.SetCellEditor(1,0,wg.GridCellChoiceEditor(['nuclear','modulated',   #phase type
             'magnetic','macromolecular','Pawley'],False))                           #- change only if no atoms
         if line:                                                    #no.of atoms not zero!
             General.SetReadOnly(1,0,isReadOnly=True)                #can't change phase type
-        General.SetCellRenderer(4,0,wg.GridCellBoolRenderer())              #lattice parameters            
+        General.SetCellRenderer(4,0,wg.GridCellBoolRenderer())              #lattice parameters
         General.SetCellEditor(4,0,wg.GridCellBoolEditor())
         SetLatticeParametersStyle(SGData,table)
         General.SetCellRenderer(5,1,wg.GridCellFloatRenderer(10,4))         #scale factor
         General.SetCellEditor(5,1,wg.GridCellFloatEditor(10,4))
-        General.SetCellRenderer(5,0,wg.GridCellBoolRenderer())            
+        General.SetCellRenderer(5,0,wg.GridCellBoolRenderer())
         General.SetCellEditor(5,0,wg.GridCellBoolEditor())
-        General.SetCellRenderer(9,1,wg.GridCellFloatRenderer(8,3))
-        General.SetCellRenderer(9,3,wg.GridCellFloatRenderer(8,3))
-    
+        General.SetCellRenderer(6,0,wg.GridCellFloatRenderer(8,3))
+        General.SetCellRenderer(6,2,wg.GridCellFloatRenderer(8,3))
+
     def FillAtomsGrid():
-        
+
+        self.dataFrame.setSizePosLeft([700,300])
         generalData = data['General']
         atomData = data['Atoms']
+        AAchoice = ": ,ALA,ARG,ASN,ASP,CYS,GLN,GLU,GLY,HIS,ILE,LEU,LYS,MET,PHE,PRO,SER,THR,TRP,TYR,VAL,MSE,HOH,UNK"
         Types = [wg.GRID_VALUE_STRING,wg.GRID_VALUE_STRING,wg.GRID_VALUE_CHOICE+": ,X,XU,U,F,FX,FXU,FU",
             wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_FLOAT+':10,4', #x,y,z,frac
-            wg.GRID_VALUE_STRING,wg.GRID_VALUE_NUMBER,wg.GRID_VALUE_CHOICE+":I,A",
+            wg.GRID_VALUE_STRING,wg.GRID_VALUE_STRING,wg.GRID_VALUE_CHOICE+":I,A",
             wg.GRID_VALUE_FLOAT+':10,4',                                                            #Uiso
             wg.GRID_VALUE_STRING,wg.GRID_VALUE_STRING,wg.GRID_VALUE_STRING,                         #Uij - placeholders
@@ -318 +330 @@
         elif generalData['Type'] == 'macromolecular':
             colLabels = ['res no','residue','chain'] + colLabels
-            Types = [wg.GRID_VALUE_NUMBER,
-                wg.GRID_VALUE_CHOICE+": ,ALA,ARG,ASN,ASP,CYS,GLN,GLU,GLY,HIS,ILE,LEU,LYS,MET,PHE,PRO,SER,THR,TRP,TYR,VAL,MSE,HOH,UNK",
+            Types = [wg.GRID_VALUE_STRING,
+                wg.GRID_VALUE_CHOICE+AAchoice,
                 wg.GRID_VALUE_STRING] + Types
         elif generalData['Type'] == 'modulated':
             Types += []
             colLabels += []
-                    
+
         def RefreshAtomGrid(event):
-            
+
             def chkUij(Uij,CSI):
                 return Uij
-                
+
             r,c =  event.GetRow(),event.GetCol()
             if r < 0 and c < 0:
-                Atoms.ClearSelection()
+                for row in range(Atoms.GetNumberRows()):
+                    Atoms.SelectRow(row,True)                    
             if r < 0:                          #double click on col label! Change all atoms!
                 sel = -1
@@ -341 +354 @@
                         choice = ['F - site fraction','X - coordinates','U - thermal parameters']
                     elif Type in ['magnetic',]:
-                        choice = ['F - site fraction','X - coordinates','U - thermal parameters','M - magnetic moment']                        
+                        choice = ['F - site fraction','X - coordinates','U - thermal parameters','M - magnetic moment']
                     dlg = wx.MultiChoiceDialog(self,'Select','Refinement controls',choice)
                     if dlg.ShowModal() == wx.ID_OK:
@@ -348 +361 @@
                         for x in sel:
                             parms += choice[x][0]
-                    dlg.Destroy()                            
+                    dlg.Destroy()
                 elif Atoms.GetColLabelValue(c) == 'I/A':
                     choice = ['Isotropic','Anisotropic']
@@ -357 +370 @@
                     dlg.Destroy()
                 elif Atoms.GetColLabelValue(c) == 'Type':
-                    choice = generalData['AtomTypes']                           
+                    choice = generalData['AtomTypes']
                     dlg = wx.SingleChoiceDialog(self,'Select','Atom types',choice)
                     if dlg.ShowModal() == wx.ID_OK:
@@ -411 +424 @@
                                 Atoms.SelectRow(row,True)
                     dlg.Destroy()
+                elif Atoms.GetColLabelValue(c) == 'Uiso':       #this needs to ask for value
+                    pass                                        #& then change all 'I' atoms
                 if sel >= 0 and noSkip:
                     ui = colLabels.index('U11')
@@ -434 +449 @@
                                 Uij = atomData[r][ui:ui+6]
                                 atomData[r][us] = (Uij[0]+Uij[1]+Uij[2])/3.0
-                                atomData[r][ui:ui+6] = [0,0,0,0,0,0] 
+                                atomData[r][ui:ui+6] = [0,0,0,0,0,0]
                                 Atoms.SetCellRenderer(r,us,wg.GridCellFloatRenderer(10,4))
                                 Atoms.SetCellStyle(r,us,WHITE,False)
@@ -441 +456 @@
                                     Atoms.SetCellRenderer(r,ci,wg.GridCellStringRenderer())
                                     Atoms.SetCellValue(r,ci,'')
-                                    Atoms.SetCellStyle(r,ci,VERY_LIGHT_GREY,True)                        
+                                    Atoms.SetCellStyle(r,ci,VERY_LIGHT_GREY,True)
                         Atoms.SetCellValue(r,c,parms)
-            elif c < 0:                    #picked atom row
-                self.SelectedRow = r
             elif Atoms.GetColLabelValue(c) in ['Name']:
                 atomData[r][c] = Atoms.GetCellValue(r,c)
             elif Atoms.GetColLabelValue(c) in ['x','y','z']:
+                atomData[r][c] = float(Atoms.GetCellValue(r,c))
                 ci = colLabels.index('x')
                 XYZ = atomData[r][ci:ci+3]
@@ -458 +472 @@
                 atomData[r][SScol] = Sytsym
                 atomData[r][Mulcol] = Mult
+                Atoms.SetCellValue(r,SScol,Sytsym)
+                Atoms.SetCellValue(r,Mulcol,str(Mult))
                 if atomData[r][colLabels.index('I/A')] == 'A':
                     ui = colLabels.index('U11')
@@ -466 +482 @@
                         Atoms.SetCellStyle(r,ci,VERY_LIGHT_GREY,True)
                         if CSI[2][i]:
-                            Atoms.SetCellStyle(r,ci,WHITE,False)                    
+                            Atoms.SetCellStyle(r,ci,WHITE,False)
+                UpdateGeneral()
             elif Atoms.GetColLabelValue(c) == 'I/A':
+                atomData[r][c] = Atoms.GetCellValue(r,c)
                 if atomData[r][c] == 'I':
                     Uij = atomData[r][c+2:c+8]
@@ -478 +496 @@
                         Atoms.SetCellRenderer(r,ci,wg.GridCellStringRenderer())
                         Atoms.SetCellValue(r,ci,'')
-                        Atoms.SetCellStyle(r,ci,VERY_LIGHT_GREY,True)                        
+                        Atoms.SetCellStyle(r,ci,VERY_LIGHT_GREY,True)
                 else:
                     Uiso = atomData[r][c+1]
@@ -493 +511 @@
                             Atoms.SetCellStyle(r,ci,WHITE,False)
             elif Atoms.GetColLabelValue(c) in ['U11','U22','U33','U12','U13','U23']:
+                atomData[r][c] = float(Atoms.GetCellValue(r,c))
                 CSI = G2spc.GetCSuinel(atomData[r][colLabels.index('site sym')])
-                value = atomData[r][c]
                 iUij = CSI[0][c-colLabels.index('U11')]
                 for i in range(6):
                     if iUij == CSI[0][i]:
                         atomData[r][i+colLabels.index('U11')] = value*CSI[1][i]
-            Atoms.ForceRefresh()
-            
+            elif Atoms.GetColLabelValue(c) == 'Uiso':
+                atomData[r][c] = float(Atoms.GetCellValue(r,c))                
+            data['Atoms'] = atomData
+
+        def RowSelect(event):
+            r,c =  event.GetRow(),event.GetCol()
+            if r < 0 and c < 0:
+                if Atoms.IsSelection():
+                    Atoms.ClearSelection()
+            elif c < 0:                   #only row clicks
+                if event.ControlDown():                    
+                    if r in Atoms.GetSelectedRows():
+                        Atoms.DeselectRow(r)
+                    else:
+                        Atoms.SelectRow(r,True)
+                elif event.ShiftDown():
+                    for row in range(r+1):
+                        Atoms.SelectRow(row,True)
+                else:
+                    Atoms.ClearSelection()
+                    Atoms.SelectRow(r,True)                
+                
         def ChangeSelection(event):
             r,c =  event.GetRow(),event.GetCol()
@@ -514 +552 @@
                     Atoms.DeselectCol(c)
                 else:
-                    Atoms.SelectCol(c,True)            
-                    
+                    Atoms.SelectCol(c,True)
+
         def AtomTypeSelect(event):
             r,c =  event.GetRow(),event.GetCol()
@@ -528 +566 @@
                         atomData[r][c-1] = name[:1]+'(%d)'%(r+1)
                 PE.Destroy()
-                Atoms.ForceRefresh()
+                UpdateGeneral()
+                FillAtomsGrid()
             else:
                 event.Skip()
-        
+
         table = []
         rowLabels = []
@@ -544 +583 @@
         Atoms.Bind(wg.EVT_GRID_CELL_CHANGE, RefreshAtomGrid)
         Atoms.Bind(wg.EVT_GRID_LABEL_LEFT_DCLICK, RefreshAtomGrid)
+        Atoms.Bind(wg.EVT_GRID_LABEL_LEFT_CLICK, RowSelect)
         Atoms.Bind(wg.EVT_GRID_LABEL_RIGHT_CLICK, ChangeSelection)
         Atoms.Bind(wg.EVT_GRID_SELECT_CELL, AtomTypeSelect)
@@ -571 +611 @@
                     if CSI[2][i]:
                         Atoms.SetCellStyle(row,ci,WHITE,False)
-                            
+
     def AtomAdd(event):
         atomData = data['Atoms']
@@ -584 +624 @@
         elif generalData['Type'] == 'magnetic':
             atomData.append(['UNK','UNK','',0,0,0,1,Sytsym,Mult,0,'I',0.01,0,0,0,0,0,0,0,0,0])
-        FillAtomsGrid()            
+        FillAtomsGrid()
         event.StopPropagation()
-                
+
     def AtomInsert(event):
         indx = Atoms.GetSelectedRows()
@@ -602 +642 @@
             elif generalData['Type'] == 'magnetic':
                 atomData.insert(indx,['UNK','UNK','',0,0,0,1,Sytsym,Mult,'I',0.01,0,0,0,0,0,0,0,0,0])
-            FillAtomsGrid()            
+            FillAtomsGrid()
         event.StopPropagation()
-        
+
     def AtomDelete(event):
         indx = Atoms.GetSelectedRows()
@@ -612 +652 @@
             for ind in indx:
                 atom = atomData[ind]
-                del atomData[ind]                
-            FillAtomsGrid()            
+                del atomData[ind]
+            FillAtomsGrid()
         event.StopPropagation()
-        
+
     def AtomRefine(event):
+        colLabels = [Atoms.GetColLabelValue(c) for c in range(Atoms.GetNumberCols())]
+        c = colLabels.index('refine')
         indx = Atoms.GetSelectedRows()
         if indx:
@@ -624 +666 @@
             if Type in ['nuclear','macromolecular']:
                 choice = ['F - site fraction','X - coordinates','U - thermal parameters']
-            elif Type in ['magnetic',]:
-                choice = ['F - site fraction','X - coordinates','U - thermal parameters','M - magnetic moment']                        
+            elif Type == 'magnetic':
+                choice = ['F - site fraction','X - coordinates','U - thermal parameters','M - magnetic moment']
             dlg = wx.MultiChoiceDialog(self,'Select','Refinement controls',choice)
             if dlg.ShowModal() == wx.ID_OK:
@@ -631 +673 @@
                 parms = ''
                 for x in sel:
-                    parms += choice[x][0]                            
-            dlg.Destroy()            
-            colLabels = [Atoms.GetColLabelValue(c) for c in range(Atoms.GetNumberCols())]
-            c = colLabels.index('refine')
-            for r in indx:
-                atomData[r][c] = parms
-            Atoms.ForceRefresh()                           
-        
-    def AtomModify(event):
+                    parms += choice[x][0]
+                for r in indx:
+                    atomData[r][c] = parms
+                Atoms.ForceRefresh()
+            dlg.Destroy()
+
+    def AtomModify(event):                  #intent to implement global modifications (+,-,*,/, etc.)?
         indx = Atoms.GetSelectedRows()
         if indx:
             atomData = data['Atoms']
             generalData = data['General']
-        
-    def AtomTransform(event):        
+
+    def AtomTransform(event):
         indx = Atoms.GetSelectedRows()
         if indx:
@@ -656 +696 @@
             generalData = data['General']
             SGData = generalData['SGData']
-            dlg = SymOpDialog(self,SGData)
+            dlg = SymOpDialog(self,SGData,True)
             try:
                 if dlg.ShowModal() == wx.ID_OK:
@@ -663 +703 @@
                     cent = SGData['SGCen'][Cent]
                     M,T = SGData['SGOps'][Opr]
+                    print M,T
                     for ind in indx:
                         XYZ = np.array(atomData[ind][cx:cx+3])
@@ -678 +719 @@
                             Uij = atom[cuij:cuij+6]
                             U = G2spc.Uij2U(Uij)
-                            U = np.inner(np.inner(M.T,U),M)
+                            U = np.inner(np.inner(M,U),M)
                             Uij = G2spc.U2Uij(U)
                             atom[cuij:cuij+6] = Uij
@@ -687 +728 @@
             Atoms.ClearSelection()
             if New:
-                FillAtomsGrid()            
-            else:                        
+                FillAtomsGrid()
+            else:
                 Atoms.ForceRefresh()
+
+    def SetupDrawingData():
+        generalData = data['General']
+        atomData = data['Atoms']
+        AA3letter = ['ALA','ARG','ASN','ASP','CYS','GLN','GLU','GLY','HIS','ILE',
+            'LEU','LYS','MET','PHE','PRO','SER','THR','TRP','TYR','VAL','MSE','HOH','WAT','UNK']
+        AA1letter = ['A','R','N','D','C','Q','E','G','H','I',
+            'L','K','M','F','P','S','T','W','Y','V','M',' ',' ',' ']
+        defaultDrawing = {'viewPoint':[[0.5,0.5,0.5],[0,0]],'showHydrogen':True,'backColor':[0,0,0],'depthFog':False,
+            'Zclip':50.0,'cameraPos':50.,'pickItem':'Atoms','showBadContacts':False,
+            'bondRadius':0.1,'ballScale':0.33,'vdwScale':0.67,'ellipseProb':50,'sizeH':0.50,'packing':False,
+            'unitCellBox':False,'showABC':True,'fogFactor':1.0,'showSymElem':False,'selectedAtoms':[],
+            'Rotation':[0.0,0.0,0.0,np.array([0,0])],'bondList':{}}
+        try:
+            drawingData = data['Drawing']
+        except KeyError:
+            data['Drawing'] = {}
+            drawingData = data['Drawing']
+        if not drawingData:                 #fill with defaults if empty
+            drawingData = copy.copy(defaultDrawing)
+            drawingData['Atoms'] = []
+        if not drawingData['Atoms']:
+            for atom in atomData:
+                if generalData['Type'] == 'nuclear':
+                    drawingData['Atoms'].append(atom[:2]+atom[3:6]+['1',]+['lines',]+
+                        ['',]+atom[9:17]+[[]])
+                    drawingData['atomPtrs'] = [2,1,6]         #x, type & style
+                elif generalData['Type'] == 'macromolecular':
+                    try:
+                        oneLetter = AA3letter.index(atom[1])
+                    except ValueError:
+                        oneLetter = -1
+                    drawingData['Atoms'].append([atom[1].strip()+atom[0],]+
+                        [AA1letter[oneLetter]+atom[0],]+atom[2:5]+
+                        atom[6:9]+['1',]+['lines',]+['',]+atom[12:20]+[[]])
+                    drawingData['atomPtrs'] = [5,4,9]         #x, type & style
+                elif generalData['Type'] == 'magnetic':
+                    drawingData['Atoms'].append(atom[:2]+atom[3:6]+['lines',]+['',]+atom[9:20]+[[]])
+#            elif generalData['Type'] == 'modulated':
+#                ?????   for future
+            data['Drawing'] = drawingData
+
+    def UpdateDrawAtoms():
+        self.dataFrame.setSizePosLeft([600,300])
+        generalData = data['General']
+        SetupDrawingData()
+        drawingData = data['Drawing']
+        atomData = drawingData['Atoms']
+        Types = [wg.GRID_VALUE_STRING,wg.GRID_VALUE_STRING,
+            wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_FLOAT+':10,5',    #x,y,z
+            wg.GRID_VALUE_STRING,wg.GRID_VALUE_CHOICE+": ,lines,vdW balls,sticks,balls & sticks,ellipsoids,polyhedra",
+            wg.GRID_VALUE_CHOICE+": ,type,name,number",wg.GRID_VALUE_STRING,]
+        styleChoice = [' ','lines','vdW balls','sticks','balls & sticks','ellipsoids','polyhedra']
+        labelChoice = [' ','type','name','number']
+        colLabels = ['Name','Type','x','y','z','Sym Op','Style','Label','I/A']
+        if generalData['Type'] == 'macromolecular':
+            colLabels = ['Residue','1-letter','Chain'] + colLabels
+            Types = [wg.GRID_VALUE_STRING,wg.GRID_VALUE_STRING,wg.GRID_VALUE_STRING]+Types
+            Types[8] = wg.GRID_VALUE_CHOICE+": ,lines,vdW balls,sticks,balls & sticks,ellipsoids,ribbons,schematic"
+            styleChoice = [' ','lines','vdW balls','sticks','balls & sticks','ellipsoids','ribbons','schematic']
+            labelChoice = [' ','type','name','number','residue','1-letter','chain']
+            Types[9] = wg.GRID_VALUE_CHOICE+": ,type,name,number,residue,1-letter,chain"
+#        elif generalData['Type'] == 'modulated':
+#            Types += []
+#            colLabels += []
+
+        def RefreshAtomGrid(event):
+
+            def SetChoice(name,c,n=0):
+                choice = []
+                for r in range(len(atomData)):
+                    if n:
+                        srchStr = str(atomData[r][c][:n])
+                    else:
+                        srchStr = str(atomData[r][c])
+                    if srchStr not in choice:
+                        if n:
+                            choice.append(str(atomData[r][c][:n]))
+                        else:
+                            choice.append(str(atomData[r][c]))
+                choice.sort()
+
+                dlg = wx.MultiChoiceDialog(self,'Select',name,choice)
+                if dlg.ShowModal() == wx.ID_OK:
+                    sel = dlg.GetSelections()
+                    parms = []
+                    for x in sel:
+                        parms.append(choice[x])
+                    noSkip = False
+                    drawAtoms.ClearSelection()
+                    drawingData['selectedAtoms'] = []
+                    for row in range(len(atomData)):
+                        test = atomData[row][c]
+                        if n:
+                            test = test[:n]
+                        if  test in parms:
+                            drawAtoms.SelectRow(row,True)
+                            drawingData['selectedAtoms'].append(row)
+                dlg.Destroy()
+                
+            r,c =  event.GetRow(),event.GetCol()
+            if r < 0 and c < 0:
+                for row in range(drawAtoms.GetNumberRows()):
+                    drawingData['selectedAtoms'].append(row)
+                    drawAtoms.SelectRow(row,True)                    
+            elif r < 0:                          #dclick on col label
+                sel = -1
+                Parms = False
+                noSkip = True
+                if drawAtoms.GetColLabelValue(c) == 'Style':
+                    dlg = wx.SingleChoiceDialog(self,'Select','Atom drawing style',styleChoice)
+                    if dlg.ShowModal() == wx.ID_OK:
+                        sel = dlg.GetSelection()
+                        parms = styleChoice[sel]
+                        for r in range(len(atomData)):
+                            atomData[r][c] = parms
+                            drawAtoms.SetCellValue(r,c,parms)
+                        FindBonds()
+                        G2plt.PlotStructure(self,data)
+                    dlg.Destroy()
+                elif drawAtoms.GetColLabelValue(c) == 'Label':
+                    dlg = wx.SingleChoiceDialog(self,'Select','Atom labelling style',labelChoice)
+                    if dlg.ShowModal() == wx.ID_OK:
+                        sel = dlg.GetSelection()
+                        parms = labelChoice[sel]
+                        for r in range(len(atomData)):
+                            atomData[r][c] = parms
+                            drawAtoms.SetCellValue(r,c,parms)
+                        G2plt.PlotStructure(self,data)
+                    dlg.Destroy()                    
+                elif drawAtoms.GetColLabelValue(c) == 'Residue':
+                    SetChoice('Residue',c,3)
+                elif drawAtoms.GetColLabelValue(c) == '1-letter':
+                    SetChoice('1-letter',c,1)
+                elif drawAtoms.GetColLabelValue(c) == 'Chain':
+                    SetChoice('Chain',c)
+                elif drawAtoms.GetColLabelValue(c) == 'Name':
+                    SetChoice('Name',c)
+                elif drawAtoms.GetColLabelValue(c) == 'Sym Op':
+                    SetChoice('Name',c)
+                elif drawAtoms.GetColLabelValue(c) == 'Type':
+                    SetChoice('Type',c)
+                elif drawAtoms.GetColLabelValue(c) in ['x','y','z','I/A']:
+                    drawAtoms.ClearSelection()
+            else:
+                if drawAtoms.GetColLabelValue(c) in ['Style','Label']:
+                    atomData[r][c] = drawAtoms.GetCellValue(r,c)
+                    FindBonds()
+                    G2plt.PlotStructure(self,data)                    
+                    
+        def RowSelect(event):
+            r,c =  event.GetRow(),event.GetCol()
+            if r < 0 and c < 0:
+                if drawAtoms.IsSelection():
+                    drawAtoms.ClearSelection()
+            elif c < 0:                   #only row clicks
+                if event.ControlDown():                    
+                    if r in drawAtoms.GetSelectedRows():
+                        drawAtoms.DeselectRow(r)
+                    else:
+                        drawAtoms.SelectRow(r,True)
+                elif event.ShiftDown():
+                    for row in range(r+1):
+                        drawAtoms.SelectRow(row,True)
+                else:
+                    drawAtoms.ClearSelection()
+                    drawAtoms.SelectRow(r,True)                
+            drawingData['selectedAtoms'] = []
+            drawingData['selectedAtoms'] = drawAtoms.GetSelectedRows()
+                
+        table = []
+        rowLabels = []
+        for i,atom in enumerate(drawingData['Atoms']):
+            table.append(atom[:colLabels.index('I/A')+1])
+            rowLabels.append(str(i+1))
+
+        atomTable = G2gd.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
+        drawAtoms.SetTable(atomTable, True)
+        drawAtoms.SetMargins(0,0)
+        drawAtoms.AutoSizeColumns(True)
+        drawAtoms.SetColSize(colLabels.index('Style'),80)
+        drawAtoms.Bind(wg.EVT_GRID_CELL_CHANGE, RefreshAtomGrid)
+        drawAtoms.Bind(wg.EVT_GRID_LABEL_LEFT_DCLICK, RefreshAtomGrid)
+        drawAtoms.Bind(wg.EVT_GRID_LABEL_LEFT_CLICK, RowSelect)
+        indx = drawingData['selectedAtoms']
+        if indx:
+            for r in range(len(atomData)):
+                if r in indx:
+                    drawAtoms.SelectRow(r)
+        for c in range(len(colLabels)):
+            if colLabels[c] not in ['Style','Label']:
+                attr = wg.GridCellAttr()                #needs to be here - gets lost if outside loop!
+                attr.SetReadOnly(True)
+                attr.SetBackgroundColour(VERY_LIGHT_GREY)
+                drawAtoms.SetColAttr(c,attr)
+        FindBonds()
+        G2plt.PlotStructure(self,data)
+
+    def DrawAtomStyle(event):
+        indx = drawAtoms.GetSelectedRows()
+        if indx:
+            generalData = data['General']
+            atomData = data['Drawing']['Atoms']
+            cx,ct,cs = data['Drawing']['atomPtrs']
+            styleChoice = [' ','lines','vdW balls','sticks','balls & sticks','ellipsoids','polyhedra']
+            if generalData['Type'] == 'macromolecular':
+                styleChoice = [' ','lines','vdW balls','sticks','balls & sticks','ellipsoids','ribbons','schematic']
+            dlg = wx.SingleChoiceDialog(self,'Select','Atom drawing style',styleChoice)
+            if dlg.ShowModal() == wx.ID_OK:
+                sel = dlg.GetSelection()
+                parms = styleChoice[sel]
+                for r in indx:
+                    atomData[r][cs] = parms
+                    drawAtoms.SetCellValue(r,cs,parms)
+            dlg.Destroy()
+            FindBonds()
+            G2plt.PlotStructure(self,data)
+
+    def DrawAtomLabel(event):
+        indx = drawAtoms.GetSelectedRows()
+        if indx:
+            generalData = data['General']
+            atomData = data['Drawing']['Atoms']
+            cx,ct,cs = data['Drawing']['atomPtrs']
+            styleChoice = [' ','type','name','number']
+            if generalData['Type'] == 'macromolecular':
+                styleChoice = [' ','type','name','number','residue','1-letter','chain']
+            dlg = wx.SingleChoiceDialog(self,'Select','Atom label style',styleChoice)
+            if dlg.ShowModal() == wx.ID_OK:
+                sel = dlg.GetSelection()
+                parms = styleChoice[sel]
+                for r in indx:
+                    atomData[r][cs+1] = parms
+                    drawAtoms.SetCellValue(r,cs+1,parms)
+            dlg.Destroy()
+            G2plt.PlotStructure(self,data)
+
+    def SetViewPoint(event):
+        indx = drawAtoms.GetSelectedRows()
+        if indx:
+            atomData = data['Drawing']['Atoms']
+            cx = data['Drawing']['atomPtrs'][0]
+            data['Drawing']['viewPoint'] = [atomData[indx[0]][cx:cx+3],[indx[0],0]]
+            drawAtoms.ClearSelection()                                  #do I really want to do this?
+            G2plt.PlotStructure(self,data)
+            
+    def noDuplicate(xyz,atomData):                  #be careful where this is used - it's slow
+        cx = data['Drawing']['atomPtrs'][0]
+        if True in [np.allclose(np.array(xyz),np.array(atom[cx:cx+3]),atol=0.0002) for atom in atomData]:
+            return False
+        else:
+            return True
+                
+    def AddSymEquiv(event):
+        indx = drawAtoms.GetSelectedRows()
+        indx.sort()
+        if indx:
+            colLabels = [drawAtoms.GetColLabelValue(c) for c in range(drawAtoms.GetNumberCols())]
+            cx = colLabels.index('x')
+            cuia = colLabels.index('I/A')
+            cuij = cuia+2
+            atomData = data['Drawing']['Atoms']
+            generalData = data['General']
+            SGData = generalData['SGData']
+            dlg = SymOpDialog(self,SGData,False)
+            try:
+                if dlg.ShowModal() == wx.ID_OK:
+                    Inv,Cent,Opr,Cell = dlg.GetSelection()
+                    Cell = np.array(Cell)
+                    cent = SGData['SGCen'][Cent]
+                    M,T = SGData['SGOps'][Opr]
+                    for ind in indx:
+                        XYZ = np.array(atomData[ind][cx:cx+3])
+                        XYZ = np.inner(M,XYZ)+T
+                        if Inv:
+                            XYZ = -XYZ
+                        XYZ = XYZ+cent+Cell
+                        if noDuplicate(XYZ,atomData):
+                            atom = copy.copy(atomData[ind])
+                            atom[cx:cx+3] = XYZ
+                            atom[cx+3] = str(((Opr+1)+100*Cent)*(1-2*Inv))+'+'+ \
+                                str(int(Cell[0]))+str(int(Cell[1]))+str(int(Cell[2]))
+                            if atom[cuia] == 'A':
+                                Uij = atom[cuij:cuij+6]
+                                U = G2spc.Uij2U(Uij)
+                                U = np.inner(np.inner(M,U),M)
+                                Uij = G2spc.U2Uij(U)
+                                atom[cuij:cuij+6] = Uij
+                            atomData.append(atom)
+            finally:
+                dlg.Destroy()
+            UpdateDrawAtoms()
+            G2plt.PlotStructure(self,data)
+            
+    def TransformSymEquiv(event):
+        indx = drawAtoms.GetSelectedRows()
+        indx.sort()
+        if indx:
+            atomData = data['Drawing']['Atoms']
+            colLabels = [drawAtoms.GetColLabelValue(c) for c in range(drawAtoms.GetNumberCols())]
+            cx = colLabels.index('x')
+            cuia = colLabels.index('I/A')
+            cuij = cuia+2
+            atomData = data['Drawing']['Atoms']
+            generalData = data['General']
+            SGData = generalData['SGData']
+            dlg = SymOpDialog(self,SGData,False)
+            try:
+                if dlg.ShowModal() == wx.ID_OK:
+                    Inv,Cent,Opr,Cell = dlg.GetSelection()
+                    Cell = np.array(Cell)
+                    cent = SGData['SGCen'][Cent]
+                    M,T = SGData['SGOps'][Opr]
+                    for ind in indx:
+                        XYZ = np.array(atomData[ind][cx:cx+3])
+                        XYZ = np.inner(M,XYZ)+T
+                        if Inv:
+                            XYZ = -XYZ
+                        XYZ = XYZ+cent+Cell
+                        atom = atomData[ind]
+                        atom[cx:cx+3] = XYZ
+                        atom[cx+3] = str(((Opr+1)+100*Cent)*(1-2*Inv))+'+'+ \
+                            str(int(Cell[0]))+str(int(Cell[1]))+str(int(Cell[2]))
+                        if atom[cuia] == 'A':
+                            Uij = atom[cuij:cuij+6]
+                            U = G2spc.Uij2U(Uij)
+                            U = np.inner(np.inner(M,U),M)
+                            Uij = G2spc.U2Uij(U)
+                            atom[cuij:cuij+6] = Uij
+                    data['Drawing']['Atoms'] = atomData
+            finally:
+                dlg.Destroy()
+            UpdateDrawAtoms()
+            G2plt.PlotStructure(self,data)
+            
+    def FillCoordSphere(event):
+        generalData = data['General']
+        Amat,Bmat = G2lat.cell2AB(generalData['Cell'][1:7])
+        radii = generalData['BondRadii']
+        atomTypes = generalData['AtomTypes']
+        try:
+            indH = atomTypes.index('H')
+            radii[indH] = 0.5
+        except:
+            pass            
+        indx = drawAtoms.GetSelectedRows()
+        if indx:
+            indx.sort()
+            atomData = data['Drawing']['Atoms']
+            numAtoms = len(atomData)
+            cx,ct,cs = data['Drawing']['atomPtrs']
+            generalData = data['General']
+            SGData = generalData['SGData']
+            cellArray = G2lat.CellBlock(1)
+            for ind in indx:
+                atomA = atomData[ind]
+                xyzA = np.array(atomA[cx:cx+3])
+                indA = atomTypes.index(atomA[ct])
+                for atomB in atomData[:numAtoms]:
+                    indB = atomTypes.index(atomB[ct])
+                    sumR = radii[indA]+radii[indB]
+                    xyzB = np.array(atomB[cx:cx+3])
+                    for xyz in cellArray+xyzB:
+                        dist = np.sqrt(np.sum(np.inner(Amat,xyz-xyzA)**2))
+                        if 0 < dist <= 0.85*sumR:
+                            if noDuplicate(xyz,atomData):
+                                newAtom = atomB[:]
+                                newAtom[cx:cx+3] = xyz
+                                atomData.append(newAtom)
+            data['Drawing']['Atoms'] = atomData
+            UpdateDrawAtoms()
+            FindBonds()
+            G2plt.PlotStructure(self,data)
+            
+    def FillUnitCell(event):
+        indx = drawAtoms.GetSelectedRows()
+        indx.sort()
+        if indx:
+            atomData = data['Drawing']['Atoms']
+            colLabels = [drawAtoms.GetColLabelValue(c) for c in range(drawAtoms.GetNumberCols())]
+            cx = colLabels.index('x')
+            cuia = colLabels.index('I/A')
+            cuij = cuia+2
+            generalData = data['General']
+            SGData = generalData['SGData']
+            for ind in indx:
+                atom = atomData[ind]
+                XYZ = np.array(atom[cx:cx+3])
+                if atom[cuia] == 'A':
+                    Uij = atom[cuij:cuij+6]
+                    result = G2spc.GenAtom(XYZ,SGData,False,Uij)
+                    for item in result:
+                        atom = copy.copy(atomData[ind])
+                        atom[cx:cx+3] = item[0]
+                        atom[cx+3] = str(item[2])+'+000'
+                        atom[cuij:cuij+6] = item[1]
+                        Opp = G2spc.Opposite(item[0])
+                        for xyz in Opp:
+                            if noDuplicate(xyz,atomData):
+                                atom[cx:cx+3] = xyz
+                                atomData.append(atom[:])
+                else:
+                    result = G2spc.GenAtom(XYZ,SGData,False)
+                    for item in result:
+                        atom = copy.copy(atomData[ind])
+                        atom[cx:cx+3] = item[0]
+                        atom[cx+3] = str(item[1])+'+000'
+                        Opp = G2spc.Opposite(item[0])
+                        for xyz in Opp:
+                            if noDuplicate(xyz,atomData):
+                                atom[cx:cx+3] = xyz
+                                atomData.append(atom[:])               
+                data['Drawing']['Atoms'] = atomData
+                
+            UpdateDrawAtoms()
+            G2plt.PlotStructure(self,data)
+            
+    def FindBonds6():
+        cx,ct,cs = data['Drawing']['atomPtrs']
+        atomData = data['Drawing']['Atoms']
+        generalData = data['General']
+        Amat,Bmat = G2lat.cell2AB(generalData['Cell'][1:7])
+        radii = generalData['BondRadii']
+        atomTypes = generalData['AtomTypes']
+        try:
+            indH = atomTypes.index('H')
+            radii[indH] = 0.5
+        except:
+            pass            
+        for atom in atomData:
+            atom[-1] = []               #clear out old bonds
         
-    def UpdateDrawing():
-        print 'Drawing'
+            
+    def FindBonds():
+        cx,ct,cs = data['Drawing']['atomPtrs']
+        atomData = data['Drawing']['Atoms']
+        generalData = data['General']
+        Amat,Bmat = G2lat.cell2AB(generalData['Cell'][1:7])
+        radii = generalData['BondRadii']
+        atomTypes = generalData['AtomTypes']
+        try:
+            indH = atomTypes.index('H')
+            radii[indH] = 0.5
+        except:
+            pass            
+        for atom in atomData:
+            atom[-1] = []               #clear out old bonds
+        for i,atomA in enumerate(atomData):
+            if atomA[cs] in ['lines','sticks','ellipsoids','balls & sticks','polyhedra']:
+                xyzA = np.array(atomA[cx:cx+3])
+                indA = atomTypes.index(atomA[ct])
+                for j,atomB in enumerate(atomData):
+                    xyzB = np.array(atomB[cx:cx+3])
+                    indB = atomTypes.index(atomB[ct])
+                    Dx = xyzB-xyzA
+                    DX = np.inner(Amat,Dx)
+                    dist = np.sqrt(np.sum(DX**2))
+                    sumR = radii[indA]+radii[indB]
+                    if 0 < dist <= 0.85*sumR:
+                        inc = i+1
+                        if atomA[cs] == 'polyhedra':
+                            atomA[-1].append(np.inner(Amat,Dx))
+                        elif atomB[cs] != 'polyhedra':
+                            atomA[-1].append(Dx*radii[indA]/sumR)
+                            atomB[-1].append(-Dx*radii[indB]/sumR)
+
+    def DrawAtomsDelete(event):   
+        indx = drawAtoms.GetSelectedRows()
+        indx.sort()
+        if indx:
+            atomData = data['Drawing']['Atoms']
+            indx.reverse()
+            for ind in indx:
+                atom = atomData[ind]
+                del atomData[ind]
+            UpdateDrawAtoms()
+            G2plt.PlotStructure(self,data)
+        event.StopPropagation()
+
+    def UpdateDrawOptions():
+        import copy
+        import wx.lib.colourselect as wcs
+        self.dataFrame.setSizePosLeft([300,470])
+        generalData = data['General']
+        SetupDrawingData()
+        drawingData = data['Drawing']
+        if generalData['Type'] == 'nuclear':
+            pickChoice = ['Atoms','Bonds','Torsions','Planes']
+        elif generalData['Type'] == 'macromolecular':
+            pickChoice = ['Atoms','Residues','Chains','Bonds','Torsions','Planes','phi/psi']
+
+        def OnZclip(event):
+            drawingData['Zclip'] = Zclip.GetValue()
+            ZclipTxt.SetLabel('Z clipping: '+'%.2fA'%(drawingData['Zclip']*drawingData['cameraPos']/100.))
+            G2plt.PlotStructure(self,data)
+            
+        def OnCameraPos(event):
+            drawingData['cameraPos'] = cameraPos.GetValue()
+            cameraPosTxt.SetLabel('Camera Position: '+'%.2f'%(drawingData['cameraPos']))
+            ZclipTxt.SetLabel('Z clipping: '+'%.2fA'%(drawingData['Zclip']*drawingData['cameraPos']/100.))
+            G2plt.PlotStructure(self,data)
+
+        def OnBackColor(event):
+            drawingData['backColor'] = event.GetValue()
+            G2plt.PlotStructure(self,data)
+
+        def OnDepthFog(event):
+            drawingData['depthFog'] = depthFog.GetValue()
+            G2plt.PlotStructure(self,data)
+
+        def OnFogFactor(event):
+            drawingData['fogFactor'] = fogFactor.GetValue()/100.
+            fogFactorTxt.SetLabel('Fog factor: '+'%.2f'%(drawingData['fogFactor']))
+            G2plt.PlotStructure(self,data)
+
+        def OnBallScale(event):
+            drawingData['ballScale'] = ballScale.GetValue()/100.
+            ballScaleTxt.SetLabel('Ball scale: '+'%.2f'%(drawingData['ballScale']))
+            G2plt.PlotStructure(self,data)
+
+        def OnVdWScale(event):
+            drawingData['vdwScale'] = vdwScale.GetValue()/100.
+            vdwScaleTxt.SetLabel('van der Waals scale: '+'%.2f'%(drawingData['vdwScale']))
+            G2plt.PlotStructure(self,data)
+
+        def OnEllipseProb(event):
+            drawingData['ellipseProb'] = ellipseProb.GetValue()
+            ellipseProbTxt.SetLabel('Ellipsoid probability: '+'%d%%'%(drawingData['ellipseProb']))
+            G2plt.PlotStructure(self,data)
+
+        def OnBondRadius(event):
+            drawingData['bondRadius'] = bondRadius.GetValue()/100.
+            bondRadiusTxt.SetLabel('Bond radius, A: '+'%.2f'%(drawingData['bondRadius']))
+            G2plt.PlotStructure(self,data)
+
+        def OnShowABC(event):
+            drawingData['showABC'] = showABC.GetValue()
+            G2plt.PlotStructure(self,data)
+
+        def OnShowUnitCell(event):
+            drawingData['unitCellBox'] = unitCellBox.GetValue()
+            G2plt.PlotStructure(self,data)
+
+        def OnPacking(event):
+            drawingData['packing'] = packing.GetValue()
+
+        def OnShowBadContacts(event):
+            drawingData['showBadContacts'] = showBadContacts.GetValue()
+
+        def OnShowSymElem(event):
+            drawingData['showSymElem'] = showSymElem.GetValue()
+
+        def OnShowHyd(event):
+            drawingData['showHydrogen'] = showHydrogen.GetValue()
+            G2plt.PlotStructure(self,data)
+
+        def OnSizeHatoms(event):
+            try:
+                value = max(0.1,min(1.2,float(sizeH.GetValue())))
+            except ValueError:
+                value = 0.5
+            drawingData['sizeH'] = value
+            sizeH.SetValue("%.2f"%(value))
+            G2plt.PlotStructure(self,data)
+
+        def OnPickItem(event):
+            drawingData['pickItem'] = pickChoice[pickItem.GetSelection()]
+
+        dataDisplay = wx.Panel(drawOptions)
+        mainSizer = wx.BoxSizer(wx.VERTICAL)
+        mainSizer.Add((5,5),0)
+        mainSizer.Add(wx.StaticText(dataDisplay,-1,'Drawing controls:'),0,wx.ALIGN_CENTER_VERTICAL)
+        mainSizer.Add((5,5),0)
         
+        slopSizer = wx.BoxSizer(wx.HORIZONTAL)
+        slideSizer = wx.FlexGridSizer(7,2,5,0)
+        slideSizer.AddGrowableCol(1,1)
+
+        cameraPosTxt = wx.StaticText(dataDisplay,-1,
+            'Camera Position: '+'%.2f'%(drawingData['cameraPos']),name='cameraPos')
+        slideSizer.Add(cameraPosTxt,0,wx.ALIGN_CENTER_VERTICAL)
+        cameraPos = wx.Slider(dataDisplay,style=wx.SL_HORIZONTAL,value=drawingData['cameraPos'],name='cameraSlider')
+        cameraPos.SetRange(10,500)
+        cameraPos.Bind(wx.EVT_SLIDER, OnCameraPos)
+        slideSizer.Add(cameraPos,1,wx.EXPAND|wx.RIGHT)
+        
+        ZclipTxt = wx.StaticText(dataDisplay,-1,'Z clipping: '+'%.2fA'%(drawingData['Zclip']*drawingData['cameraPos']/100.))
+        slideSizer.Add(ZclipTxt,0,wx.ALIGN_CENTER_VERTICAL)
+        Zclip = wx.Slider(dataDisplay,style=wx.SL_HORIZONTAL,value=drawingData['Zclip'])
+        Zclip.SetRange(1,99)
+        Zclip.Bind(wx.EVT_SLIDER, OnZclip)
+        slideSizer.Add(Zclip,1,wx.EXPAND|wx.RIGHT)
+        
+        vdwScaleTxt = wx.StaticText(dataDisplay,-1,'van der Waals scale: '+'%.2f'%(drawingData['vdwScale']))
+        slideSizer.Add(vdwScaleTxt,0,wx.ALIGN_CENTER_VERTICAL)
+        vdwScale = wx.Slider(dataDisplay,style=wx.SL_HORIZONTAL,value=int(100*drawingData['vdwScale']))
+        vdwScale.Bind(wx.EVT_SLIDER, OnVdWScale)
+        slideSizer.Add(vdwScale,1,wx.EXPAND|wx.RIGHT)
+
+        ellipseProbTxt = wx.StaticText(dataDisplay,-1,'Ellipsoid probability: '+'%d%%'%(drawingData['ellipseProb']))
+        slideSizer.Add(ellipseProbTxt,0,wx.ALIGN_CENTER_VERTICAL)
+        ellipseProb = wx.Slider(dataDisplay,style=wx.SL_HORIZONTAL,value=drawingData['ellipseProb'])
+        ellipseProb.SetRange(1,99)
+        ellipseProb.Bind(wx.EVT_SLIDER, OnEllipseProb)
+        slideSizer.Add(ellipseProb,1,wx.EXPAND|wx.RIGHT)
+
+        ballScaleTxt = wx.StaticText(dataDisplay,-1,'Ball scale: '+'%.2f'%(drawingData['ballScale']))
+        slideSizer.Add(ballScaleTxt,0,wx.ALIGN_CENTER_VERTICAL)
+        ballScale = wx.Slider(dataDisplay,style=wx.SL_HORIZONTAL,value=int(100*drawingData['ballScale']))
+        ballScale.Bind(wx.EVT_SLIDER, OnBallScale)
+        slideSizer.Add(ballScale,1,wx.EXPAND|wx.RIGHT)
+
+        bondRadiusTxt = wx.StaticText(dataDisplay,-1,'Bond radius, A: '+'%.2f'%(drawingData['bondRadius']))
+        slideSizer.Add(bondRadiusTxt,0,wx.ALIGN_CENTER_VERTICAL)
+        bondRadius = wx.Slider(dataDisplay,style=wx.SL_HORIZONTAL,value=int(100*drawingData['bondRadius']))
+        bondRadius.SetRange(1,25)
+        bondRadius.Bind(wx.EVT_SLIDER, OnBondRadius)
+        slideSizer.Add(bondRadius,1,wx.EXPAND|wx.RIGHT)
+        
+        fogFactorTxt = wx.StaticText(dataDisplay,-1,'Fog factor: '+'%.2f'%(drawingData['fogFactor']))
+        slideSizer.Add(fogFactorTxt,0,wx.ALIGN_CENTER_VERTICAL)
+        fogFactor = wx.Slider(dataDisplay,style=wx.SL_HORIZONTAL,value=int(100*drawingData['fogFactor']))
+        fogFactor.Bind(wx.EVT_SLIDER, OnFogFactor)
+        slideSizer.Add(fogFactor,1,wx.EXPAND|wx.RIGHT)
+
+        slopSizer.Add(slideSizer,1,wx.EXPAND|wx.RIGHT)
+        slopSizer.Add((10,5),0)
+        mainSizer.Add(slopSizer,1,wx.EXPAND)
+
+        flexSizer = wx.FlexGridSizer(7,2,5,0)
+        flexSizer.Add(wx.StaticText(dataDisplay,-1,'View Point:  '),0,wx.ALIGN_CENTER_VERTICAL)
+        VP = drawingData['viewPoint'][0]
+        viewPoint = wx.TextCtrl(dataDisplay,value='%.3f, %.3f, %.3f'%(VP[0],VP[1],VP[2]),
+            style=wx.TE_READONLY,size=wx.Size(120,20),name='viewPoint')
+        viewPoint.SetBackgroundColour(VERY_LIGHT_GREY)
+        flexSizer.Add(viewPoint,0,wx.ALIGN_CENTER_VERTICAL)
+        
+        depthFog = wx.CheckBox(dataDisplay,-1,label='Use depth fog?')
+        depthFog.Bind(wx.EVT_CHECKBOX, OnDepthFog)
+        depthFog.SetValue(drawingData['depthFog'])
+        flexSizer.Add(depthFog,0,wx.ALIGN_CENTER_VERTICAL)
+        lineSizer = wx.BoxSizer(wx.HORIZONTAL)
+        lineSizer.Add(wx.StaticText(dataDisplay,-1,'Background color:'),0,wx.ALIGN_CENTER_VERTICAL)
+        backColor = wcs.ColourSelect(dataDisplay, -1,colour=drawingData['backColor'],size=wx.Size(25,25))
+        backColor.Bind(wcs.EVT_COLOURSELECT, OnBackColor)
+        lineSizer.Add(backColor,0,wx.ALIGN_CENTER_VERTICAL)
+        flexSizer.Add(lineSizer,0,)
+
+        showABC = wx.CheckBox(dataDisplay,-1,label='Show cell vectors?')
+        showABC.Bind(wx.EVT_CHECKBOX, OnShowABC)
+        showABC.SetValue(drawingData['showABC'])
+        flexSizer.Add(showABC,0,wx.ALIGN_CENTER_VERTICAL)
+
+        unitCellBox = wx.CheckBox(dataDisplay,-1,label='Show unit cell?')
+        unitCellBox.Bind(wx.EVT_CHECKBOX, OnShowUnitCell)
+        unitCellBox.SetValue(drawingData['unitCellBox'])
+        flexSizer.Add(unitCellBox,0,wx.ALIGN_CENTER_VERTICAL)
+
+        packing = wx.CheckBox(dataDisplay,-1,label='Packing diagram?')
+        packing.Bind(wx.EVT_CHECKBOX, OnPacking)
+        packing.SetValue(drawingData['packing'])
+        flexSizer.Add(packing,0,wx.ALIGN_CENTER_VERTICAL)
+
+        showBadContacts = wx.CheckBox(dataDisplay,-1,label='Show bad contacts?')
+        showBadContacts.Bind(wx.EVT_CHECKBOX, OnShowBadContacts)
+        showBadContacts.SetValue(drawingData['showBadContacts'])
+        flexSizer.Add(showBadContacts,0,wx.ALIGN_CENTER_VERTICAL)
+
+        showSymElem = wx.CheckBox(dataDisplay,-1,label='Show sym. elem.?')
+        showSymElem.Bind(wx.EVT_CHECKBOX, OnShowSymElem)
+        showSymElem.SetValue(drawingData['showSymElem'])
+        flexSizer.Add(showSymElem,0,wx.ALIGN_CENTER_VERTICAL)
+
+        showHydrogen = wx.CheckBox(dataDisplay,-1,label='Show hydrogens?')
+        showHydrogen.Bind(wx.EVT_CHECKBOX, OnShowHyd)
+        showHydrogen.SetValue(drawingData['showHydrogen'])
+        flexSizer.Add(showHydrogen,0,wx.ALIGN_CENTER_VERTICAL)
+
+        flexSizer.Add(wx.StaticText(dataDisplay,-1,'Hydrogen radius, A:  '),0,wx.ALIGN_CENTER_VERTICAL)
+        sizeH = wx.TextCtrl(dataDisplay,-1,value='%.2f'%(drawingData['sizeH']),style=wx.TE_PROCESS_ENTER)
+        sizeH.Bind(wx.EVT_TEXT_ENTER,OnSizeHatoms)
+        sizeH.Bind(wx.EVT_KILL_FOCUS,OnSizeHatoms)
+        flexSizer.Add(sizeH,0,wx.ALIGN_CENTER_VERTICAL)
+
+        flexSizer.Add(wx.StaticText(dataDisplay,-1,'Pick items on drawing by:  '),0,wx.ALIGN_CENTER_VERTICAL)
+        pickItem = wx.Choice(dataDisplay,-1,choices=pickChoice)
+        pickItem.Bind(wx.EVT_CHOICE, OnPickItem)
+        pickItem.SetSelection(pickChoice.index(drawingData['pickItem']))
+        flexSizer.Add(pickItem,0,wx.ALIGN_CENTER_VERTICAL)
+        mainSizer.Add(flexSizer,0,)
+        mainSizer.SetMinSize(wx.Size(300,370))
+
+        dataDisplay.SetSizer(mainSizer)
+        self.dataFrame.SetSize(dataDisplay.Fit())
+
     def FillPawleyReflectionsGrid():
         generalData = data['General']
-        
+
         print 'Pawley reflections'
-        
+
     def OnPageChanged(event):
         page = event.GetSelection()
@@ -712 +1444 @@
             FillAtomsGrid()
         elif text == 'General':
-            FillGeneralGrid()                    
+            FillGeneralGrid()
             self.dataFrame.SetMenuBar(self.dataFrame.BlankMenu)
+        elif text == 'Draw Options':
+            self.dataFrame.SetMenuBar(self.dataFrame.BlankMenu)
+            UpdateDrawOptions()
+            G2plt.PlotStructure(self,data)
+        elif text == 'Draw Atoms':
+            self.dataFrame.SetMenuBar(self.dataFrame.DrawAtomsMenu)
+            self.dataFrame.Bind(wx.EVT_MENU, DrawAtomStyle, id=G2gd.wxID_DRAWATOMSTYLE)
+            self.dataFrame.Bind(wx.EVT_MENU, DrawAtomLabel, id=G2gd.wxID_DRAWATOMLABEL)
+            self.dataFrame.Bind(wx.EVT_MENU, SetViewPoint, id=G2gd.wxID_DRAWVIEWPOINT)
+            self.dataFrame.Bind(wx.EVT_MENU, AddSymEquiv, id=G2gd.wxID_DRAWADDEQUIV)
+            self.dataFrame.Bind(wx.EVT_MENU, TransformSymEquiv, id=G2gd.wxID_DRAWTRANSFORM)
+            self.dataFrame.Bind(wx.EVT_MENU, FillCoordSphere, id=G2gd.wxID_DRAWFILLCOORD)            
+            self.dataFrame.Bind(wx.EVT_MENU, FillUnitCell, id=G2gd.wxID_DRAWFILLCELL)
+            self.dataFrame.Bind(wx.EVT_MENU, DrawAtomsDelete, id=G2gd.wxID_DRAWDELETE)
+            UpdateDrawAtoms()
+            G2plt.PlotStructure(self,data)
         else:
             self.dataFrame.SetMenuBar(self.dataFrame.BlankMenu)
         event.Skip()
-        
+
     if self.dataDisplay:
-        self.dataDisplay.Destroy()                    
+        self.dataDisplay.Destroy()
     PhaseName = self.PatternTree.GetItemText(item)
     self.dataFrame.SetMenuBar(self.dataFrame.BlankMenu)
@@ -725 +1473 @@
     self.dataFrame.CreateStatusBar()
     self.dataDisplay = G2gd.GSNoteBook(parent=self.dataFrame,size=self.dataFrame.GetClientSize())
-    
+
     General = G2gd.GSGrid(self.dataDisplay)
     FillGeneralGrid()
     self.dataDisplay.AddPage(General,'General')
-     
+
     GeneralData = data['General']
     if GeneralData['Type'] == 'Pawley':
@@ -737 +1485 @@
         Atoms = G2gd.GSGrid(self.dataDisplay)
         self.dataDisplay.AddPage(Atoms,'Atoms')
-        Drawing = wx.Window(self.dataDisplay)
-        self.dataDisplay.AddPage(Drawing,'Drawing')
-   
+        drawOptions = wx.Window(self.dataDisplay)
+        self.dataDisplay.AddPage(drawOptions,'Draw Options')
+        drawAtoms = G2gd.GSGrid(self.dataDisplay)
+        self.dataDisplay.AddPage(drawAtoms,'Draw Atoms')
+
     self.dataDisplay.Bind(wx.EVT_NOTEBOOK_PAGE_CHANGED, OnPageChanged)
     self.dataDisplay.SetSelection(oldPage)
     
+            

trunk/GSASIIplot.py

@@ -3 +3 @@
 import copy
 import numpy as np
+import numpy.linalg as nl
 import wx
 import wx.aui
+import wx.glcanvas
 import matplotlib as mpl
 import GSASIIpath
@@ -12 +14 @@
 import GSASIIpwdGUI as G2pdG
 import GSASIIimgGUI as G2imG
+import GSASIIphsGUI as G2phG
+import GSASIIlattice as G2lat
+import GSASIIspc as G2spc
+from  OpenGL.GL import *
+from OpenGL.GLU import *
+from OpenGL.GLUT import *
 from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as Canvas
 from matplotlib.backends.backend_wxagg import NavigationToolbar2Wx as Toolbar
@@ -24 +32 @@
 atand = lambda x: 180.*math.atan(x)/math.pi
     
-class G2Plot(wx.Panel):
-    
+class G2PlotMpl(wx.Panel):    
     def __init__(self,parent,id=-1,dpi=None,**kwargs):
         wx.Panel.__init__(self,parent,id=id,**kwargs)
@@ -38 +45 @@
         sizer.Add(self.toolbar,0,wx.LEFT|wx.EXPAND)
         self.SetSizer(sizer)
+        
+class G2PlotOgl(wx.Panel):
+    def __init__(self,parent,id=-1,dpi=None,**kwargs):
+        self.figure = wx.Panel.__init__(self,parent,id=id,**kwargs)
+        self.canvas = wx.glcanvas.GLCanvas(self,-1,**kwargs)
+        self.camera = {}
+        sizer=wx.BoxSizer(wx.VERTICAL)
+        sizer.Add(self.canvas,1,wx.EXPAND)
+        self.SetSizer(sizer)           
                 
 class G2PlotNoteBook(wx.Panel):
@@ -55 +71 @@
         self.plotList = []
             
-    def add(self,name=""):
-        page = G2Plot(self.nb)
+    def addMpl(self,name=""):
+        page = G2PlotMpl(self.nb)
         self.nb.AddPage(page,name)
         
@@ -63 +79 @@
         return page.figure
         
+    def addOgl(self,name=""):
+        page = G2PlotOgl(self.nb)
+        self.nb.AddPage(page,name)
+        
+        self.plotList.append(name)
+        
+        return page.figure
+        
+    def Delete(self,name):
+        try:
+            item = self.plotList.index(name)
+            del self.plotList[item]
+            self.nb.DeletePage(item)
+        except ValueError:          #no plot of this name - do nothing
+            return      
+                
     def clear(self):
         while self.nb.GetPageCount():
@@ -68 +100 @@
         self.plotList = []
         self.status.DestroyChildren()
+        
+    def Rename(self,oldName,newName):
+        try:
+            item = self.plotList.index(oldName)
+            self.plotList[item] = newName
+            self.nb.SetPageText(item,newName)
+        except ValueError:          #no plot of this name - do nothing
+            return      
         
     def OnPageChanged(self,event):
@@ -122 +162 @@
         Plot = Page.figure.gca()          #get a fresh plot after clf()
     except ValueError,error:
-        Plot = self.G2plotNB.add('Structure Factors').gca()
+        Plot = self.G2plotNB.addMpl('Structure Factors').gca()
         plotNum = self.G2plotNB.plotList.index('Structure Factors')
         Page = self.G2plotNB.nb.GetPage(plotNum)
@@ -338 +378 @@
     except ValueError,error:
         newPlot = True
-        Plot = self.G2plotNB.add('Powder Patterns').gca()
+        Plot = self.G2plotNB.addMpl('Powder Patterns').gca()
         plotNum = self.G2plotNB.plotList.index('Powder Patterns')
         Page = self.G2plotNB.nb.GetPage(plotNum)
@@ -476 +516 @@
         Plot = Page.figure.gca()
     except ValueError,error:
-        Plot = self.G2plotNB.add('Powder Lines').gca()
+        Plot = self.G2plotNB.addMpl('Powder Lines').gca()
         plotNum = self.G2plotNB.plotList.index('Powder Lines')
         Page = self.G2plotNB.nb.GetPage(plotNum)
@@ -526 +566 @@
         Plot = Page.figure.gca()
     except ValueError,error:
-        Plot = self.G2plotNB.add('Peak Widths').gca()
+        Plot = self.G2plotNB.addMpl('Peak Widths').gca()
         plotNum = self.G2plotNB.plotList.index('Peak Widths')
         Page = self.G2plotNB.nb.GetPage(plotNum)
@@ -809 +849 @@
         
     except ValueError,error:
-        Plot = self.G2plotNB.add('2D Powder Image').gca()
+        Plot = self.G2plotNB.addMpl('2D Powder Image').gca()
         plotNum = self.G2plotNB.plotList.index('2D Powder Image')
         Page = self.G2plotNB.nb.GetPage(plotNum)
@@ -962 +1002 @@
         
     except ValueError,error:
-        Plot = self.G2plotNB.add('2D Integration').gca()
+        Plot = self.G2plotNB.addMpl('2D Integration').gca()
         plotNum = self.G2plotNB.plotList.index('2D Integration')
         Page = self.G2plotNB.nb.GetPage(plotNum)
@@ -1004 +1044 @@
     else:
         Page.canvas.draw()
-        
-        
+                
 def PlotTRImage(self,tax,tay,taz,newPlot=False):
     #a test plot routine - not normally used 
@@ -1028 +1067 @@
         
     except ValueError,error:
-        Plot = self.G2plotNB.add('2D Transformed Powder Image').gca()
+        Plot = self.G2plotNB.addMpl('2D Transformed Powder Image').gca()
         plotNum = self.G2plotNB.plotList.index('2D Transformed Powder Image')
         Page = self.G2plotNB.nb.GetPage(plotNum)
@@ -1078 +1117 @@
         Page.canvas.draw()
         
-        
+def PlotStructure(self,data):
+    generalData = data['General']
+    atomData = data['Atoms']
+    drawingData = data['Drawing']
+    drawAtoms = drawingData['Atoms']
+    Wt = [255,255,255,255]
+    Rd = [255,0,0,255]
+    Gr = [0,255,0,255]
+    Bl = [0,0,255,255]
+    uBox = np.array([[0,0,0],[1,0,0],[1,1,0],[0,1,0],[0,0,1],[1,0,1],[1,1,1],[0,1,1]])
+    uEdges = np.array([
+        [uBox[0],uBox[1]],[uBox[0],uBox[3]],[uBox[0],uBox[4]],[uBox[1],uBox[2]], 
+        [uBox[2],uBox[3]],[uBox[1],uBox[5]],[uBox[2],uBox[6]],[uBox[3],uBox[7]], 
+        [uBox[4],uBox[5]],[uBox[5],uBox[6]],[uBox[6],uBox[7]],[uBox[7],uBox[4]]])
+    uColors = [Rd,Gr,Bl,Wt, Wt,Wt,Wt,Wt, Wt,Wt,Wt,Wt]
+    
+    def OnMouseDown(event):
+        drawingData['Rotation'][3] = event.GetPosition()
+    def OnMouseWheel(event):
+        drawingData['cameraPos'] += event.GetWheelRotation()/24
+        drawingData['cameraPos'] = max(10,min(500,drawingData['cameraPos']))
+        page = self.dataDisplay.GetSelection()
+        if self.dataDisplay.GetPageText(page) == 'Draw Options':
+            panel = self.dataDisplay.GetPage(page).GetChildren()[0].GetChildren()
+            names = [child.GetName() for child in panel]
+            panel[names.index('cameraPos')].SetLabel('Camera Position: '+'%.2f'%(drawingData['cameraPos']))
+            panel[names.index('cameraSlider')].SetValue(drawingData['cameraPos'])
+        Draw()
+            
+    def SetViewPointText(VP):
+        page = self.dataDisplay.GetSelection()
+        if self.dataDisplay.GetPageText(page) == 'Draw Options':
+            panel = self.dataDisplay.GetPage(page).GetChildren()[0].GetChildren()
+            names = [child.GetName() for child in panel]
+            panel[names.index('viewPoint')].SetValue('%.3f, %.3f, %.3f'%(VP[0],VP[1],VP[2]))
+                            
+    def OnKey(event):
+        keyCode = event.GetKeyCode()
+        key,xyz = chr(keyCode),event.GetPosition()
+        indx = drawingData['selectedAtoms']
+        cx,ct,cs = drawingData['atomPtrs']
+        if key in ['c','C']:
+            drawingData['viewPoint'] = [[.5,.5,.5],[0,0]]
+            drawingData['Rotation'] = [0.0,0.0,0.0,np.array([0,0])]
+            SetViewPointText(drawingData['viewPoint'][0])
+        elif key in ['n','N']:
+            drawAtoms = drawingData['Atoms']
+            pI = drawingData['viewPoint'][1]
+            if indx:
+                pI[0] = indx[pI[1]]
+                Tx,Ty,Tz = drawAtoms[pI[0]][cx:cx+3]
+                pI[1] += 1
+                if pI[1] >= len(indx):
+                    pI[1] = 0
+            else:
+                Tx,Ty,Tz = drawAtoms[pI[0]][cx:cx+3]                
+                pI[0] += 1
+                if pI[0] >= len(drawAtoms):
+                    pI[0] = 0
+            drawingData['viewPoint'] = [[Tx,Ty,Tz],pI]
+            SetViewPointText(drawingData['viewPoint'][0])
+                
+        elif key in ['p','P']:
+            drawAtoms = drawingData['Atoms']
+            pI = drawingData['viewPoint'][1]
+            if indx:
+                pI[0] = indx[pI[1]]
+                Tx,Ty,Tz = drawAtoms[pI[0]][cx:cx+3]
+                pI[1] -= 1
+                if pI[1] < 0:
+                    pI[1] = len(indx)-1
+            else:
+                Tx,Ty,Tz = drawAtoms[pI[0]][cx:cx+3]                
+                pI[0] -= 1
+                if pI[0] < 0:
+                    pI[0] = len(drawAtoms)-1
+            drawingData['viewPoint'] = [[Tx,Ty,Tz],pI]
+            SetViewPointText(drawingData['viewPoint'][0])
+            
+        elif key in ['a','A']:
+            print xyz,GetTruePosition(xyz)
+        Draw()
+            
+    def OnMouseMove(event):
+        newxy = event.GetPosition()
+        if event.Dragging():
+            if event.LeftIsDown():
+                SetRotation(newxy)
+            elif event.RightIsDown():
+                SetTranslation(newxy)
+            elif event.MiddleIsDown():
+                SetRotationZ(newxy)
+            Draw()
+        
+    def GetTruePosition(xy):
+        View = glGetIntegerv(GL_VIEWPORT)
+        x,y,z = gluUnProject(xy[0],xy[1],0,view=View)
+        return x,y,z
+        
+    def SetBackground():
+        R,G,B,A = Page.camera['backColor']
+        glClearColor(R,G,B,A)
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+        
+    def SetLights():
+        glEnable(GL_DEPTH_TEST)
+        glShadeModel(GL_SMOOTH)
+        glEnable(GL_LIGHTING)
+        glEnable(GL_LIGHT0)
+        glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,0)
+        glLightfv(GL_LIGHT0,GL_AMBIENT,[1,1,1,.8])
+        glLightfv(GL_LIGHT0,GL_DIFFUSE,[1,1,1,1])
+        
+    def SetFog():       #doesn't work for some reason
+        cPos = drawingData['cameraPos']
+        Zclip = drawingData['Zclip']*cPos/200.
+        glFogi(GL_FOG_MODE,GL_LINEAR)
+        glFogfv(GL_FOG_COLOR,Page.camera['backColor'])
+        glFogf(GL_FOG_START,cPos-Zclip)
+        glFogf(GL_FOG_END,cPos+Zclip)
+        glFogf(GL_FOG_DENSITY,drawingData['fogFactor'])
+                  
+    def SetTranslation(newxy):
+        Tx,Ty,Tz = drawingData['viewPoint'][0]
+        oldxy = drawingData['Rotation'][3]
+        dxy = newxy-oldxy
+        Tx += dxy[0]*0.01
+        Ty -= dxy[1]*0.01
+        drawingData['Rotation'][3] = newxy
+        drawingData['viewPoint'][0] =  Tx,Ty,Tz
+               
+    def SetRotation(newxy):        
+        anglex,angley,anglez,oldxy = drawingData['Rotation']
+        dxy = newxy-oldxy
+        anglex += dxy[1]
+        angley += dxy[0]
+        oldxy = newxy
+        drawingData['Rotation'] = [anglex,angley,anglez,oldxy]
+        
+    def SetRotationZ(newxy):
+        def sign(x):
+            if x < 0:
+                return -1
+            else:
+                return 1
+                        
+        anglex,angley,anglez,oldxy = drawingData['Rotation']
+        dxy = newxy-oldxy
+        anglez += dxy[0]+dxy[1]
+        oldxy = newxy
+        drawingData['Rotation'] = [anglex,angley,anglez,oldxy]
+        
+    def RenderBox():
+        glEnable(GL_COLOR_MATERIAL)
+        glBegin(GL_LINES)
+        for line,color in zip(uEdges,uColors):
+            glColor4ubv(color)
+            glVertex3fv(line[0])
+            glVertex3fv(line[1])
+        glEnd()
+        glColor4ubv([0,0,0,0])
+        glDisable(GL_COLOR_MATERIAL)
+        
+    def RenderUnitVectors():
+        glEnable(GL_COLOR_MATERIAL)
+        glBegin(GL_LINES)
+        for line,color in zip(uEdges,uColors)[:3]:
+            glColor4ubv(color)
+            glVertex3fv(line[0])
+            glVertex3fv(line[1])
+        glEnd()
+        glColor4ubv([0,0,0,0])
+        glDisable(GL_COLOR_MATERIAL)
+                
+    def RenderSphere(x,y,z,radius,color):
+        glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,color)
+        glPushMatrix()
+        glTranslate(x,y,z)
+        glMultMatrixf(B4mat.T)
+        q = gluNewQuadric()
+        gluSphere(q,radius,20,20)
+        glPopMatrix()
+        
+    def RenderEllipsoid(x,y,z,ellipseProb,E,R4,color):
+        s1,s2,s3 = E
+        glLightfv(GL_LIGHT0,GL_DIFFUSE,[.7,.7,.7,1])        
+        glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,color)
+        glPushMatrix()
+        glTranslate(x,y,z)
+        glMultMatrixf(B4mat.T)
+        glMultMatrixf(R4.T)
+        glEnable(GL_RESCALE_NORMAL)
+        glScale(s1,s2,s3)
+        q = gluNewQuadric()
+        gluSphere(q,ellipseProb,20,20)
+        glDisable(GL_RESCALE_NORMAL)
+        glPopMatrix()
+        glLightfv(GL_LIGHT0,GL_DIFFUSE,[1,1,1,1])        
+        
+    def RenderBonds(x,y,z,Bonds,radius,color):
+        glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,color)
+        glPushMatrix()
+        glTranslate(x,y,z)
+        glMultMatrixf(B4mat.T)
+        for bond in Bonds:
+            glPushMatrix()
+            Dx = np.inner(Amat,bond)
+            Z = np.sqrt(np.sum(Dx**2))
+            azm = atan2d(-Dx[1],-Dx[0])
+            phi = acosd(Dx[2]/Z)
+            glRotate(-azm,0,0,1)
+            glRotate(phi,1,0,0)
+            q = gluNewQuadric()
+            gluCylinder(q,radius,radius,Z,20,2)
+            glPopMatrix()            
+        glPopMatrix()
+        
+    def RenderLines(x,y,z,Bonds,color):
+        glEnable(GL_COLOR_MATERIAL)
+        glPushMatrix()
+        glTranslate(x,y,z)
+        glBegin(GL_LINES)
+        for bond in Bonds:
+            glColor4fv(color)
+            glVertex3fv([0,0,0])
+            glVertex3fv(bond)
+        glEnd()
+        glColor4ubv([0,0,0,0])
+        glPopMatrix()
+        glDisable(GL_COLOR_MATERIAL)
+        
+    def RenderPolyhedra(x,y,z,Faces,color):
+        glPushMatrix()
+        glTranslate(x,y,z)
+        glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,color)
+        glShadeModel(GL_SMOOTH)
+        glMultMatrixf(B4mat.T)
+        for face,norm in Faces:
+            glPolygonMode(GL_FRONT,GL_FILL)
+            glColor3fv(color[:3])
+            glBegin(GL_TRIANGLES)
+            glNormal3fv(norm)
+            for vert in face:
+                glVertex3fv(vert)
+            glEnd()
+        glPopMatrix()
+        
+    def RenderLabel(x,y,z,label,r):       
+        glPushMatrix()
+        glTranslate(x,y,z)
+        glMultMatrixf(B4mat.T)
+        glDisable(GL_LIGHTING)
+        glColor3f(0,1.,0)
+        glRasterPos3f(r,r,r)
+        for c in list(label):
+            glutBitmapCharacter(GLUT_BITMAP_8_BY_13,ord(c))
+        glEnable(GL_LIGHTING)
+        glPopMatrix()
+                            
+    def Draw():
+        import numpy.linalg as nl
+        VS = np.array(Page.canvas.GetSize())
+        aspect = float(VS[0])/float(VS[1])
+        cPos = drawingData['cameraPos']
+        Zclip = drawingData['Zclip']*cPos/200.
+        anglex,angley,anglez, = drawingData['Rotation'][:3]
+        Tx,Ty,Tz = drawingData['viewPoint'][0]
+        cx,ct,cs = drawingData['atomPtrs']
+        bondR = drawingData['bondRadius']
+        G,g = G2lat.cell2Gmat(cell)
+        GS = G
+        GS[0][1] = GS[1][0] = math.sqrt(GS[0][0]*GS[1][1])
+        GS[0][2] = GS[2][0] = math.sqrt(GS[0][0]*GS[2][2])
+        GS[1][2] = GS[2][1] = math.sqrt(GS[1][1]*GS[2][2])
+        ellipseProb = G2lat.criticalEllipse(drawingData['ellipseProb']/100.)
+        
+        SetBackground()
+        
+        glMatrixMode(GL_PROJECTION)
+        glLoadIdentity()
+        glViewport(0,0,VS[0],VS[1])
+        gluPerspective(20.,aspect,cPos-Zclip,cPos+Zclip)
+        gluLookAt(0,0,cPos,0,0,0,0,1,0)
+        SetLights()            
+        if drawingData['depthFog']:
+            glEnable(GL_FOG)
+            SetFog()
+        else:
+            glDisable(GL_FOG)
+        
+        glMatrixMode(GL_MODELVIEW)
+        glLoadIdentity()
+        glRotate(anglez,0,0,1)
+        glRotate(anglex,1,0,0)
+        glRotate(angley,0,1,0)
+        glMultMatrixf(A4mat.T)
+        glTranslate(-Tx,-Ty,-Tz)
+        if drawingData['unitCellBox']:
+            RenderBox()
+        if drawingData['showABC']:
+            glPushMatrix()
+            glTranslate(-.1,-.1,-.1)
+            glScalef(1/cell[0],1/cell[1],1/cell[2])
+            RenderUnitVectors()
+            glPopMatrix()
+        for iat,atom in enumerate(drawingData['Atoms']):
+            x,y,z = atom[cx:cx+3]
+            Bonds = atom[-1]
+            atNum = generalData['AtomTypes'].index(atom[ct])
+            CL = list(generalData['Color'][atNum])
+            CL.extend([255,])
+            color = np.array(CL)/255.
+            radius = 0.5
+            if 'balls' in atom[cs]:
+                vdwScale = drawingData['vdwScale']
+                ballScale = drawingData['ballScale']
+                if 'H' == atom[ct]:
+                    if drawingData['showHydrogen']:
+                        if 'vdW' in atom[cs]:
+                            radius = vdwScale*generalData['vdWRadii'][atNum]
+                        else:
+                            radius = ballScale*drawingData['sizeH']
+                    else:
+                        radius = 0.0
+                else:
+                    if 'vdW' in atom[cs]:
+                        radius = vdwScale*generalData['vdWRadii'][atNum]
+                    else:
+                        radius = ballScale*generalData['BondRadii'][atNum]
+                RenderSphere(x,y,z,radius,color)
+                if 'sticks' in atom[cs]:
+                    RenderBonds(x,y,z,Bonds,bondR,color)
+            elif 'ellipsoids' in atom[cs]:
+                RenderBonds(x,y,z,Bonds,bondR,color)
+                if atom[cs+2] == 'A':                    
+                    Uij = atom[cs+4:cs+10]
+                    U = np.multiply(G2spc.Uij2U(Uij),GS)
+                    U = np.inner(Amat,np.inner(U,Amat).T)
+                    E,R = nl.eigh(U)
+                    R4 = np.concatenate((np.concatenate((R,[[0],[0],[0]]),axis=1),[[0,0,0,1],]),axis=0)
+                    E = np.sqrt(E)
+                    RenderEllipsoid(x,y,z,ellipseProb,E,R4,color)
+                else:
+                    radius = ellipseProb*math.sqrt(abs(atom[cs+3]))
+                    RenderSphere(x,y,z,radius,color)
+            elif 'lines' in atom[cs]:
+                radius = 0.5
+                RenderLines(x,y,z,Bonds,color)
+            elif atom[cs] == 'sticks':
+                radius = 0.5
+                RenderBonds(x,y,z,Bonds,bondR,color)
+            elif atom[cs] == 'polyhedra':
+                if len(Bonds) > 2:
+                    FaceGen = G2lat.uniqueCombinations(Bonds,3)     #N.B. this is a generator
+                    Faces = []
+                    for face in FaceGen:
+                        vol = nl.det(face)
+                        if abs(vol) > 1.:
+                            if vol < 0.:
+                                face = [face[0],face[2],face[1]]
+                            norm = np.cross(face[1]-face[0],face[2]-face[0])
+                            norm /= np.sqrt(np.sum(norm**2))
+                            Faces.append([face,norm])
+                    RenderPolyhedra(x,y,z,Faces,color)
+            if atom[cs+1] == 'type':
+                RenderLabel(x,y,z,atom[ct],radius)
+            elif atom[cs+1] == 'name':
+                RenderLabel(x,y,z,atom[ct-1],radius)
+            elif atom[cs+1] == 'number':
+                RenderLabel(x,y,z,str(iat+1),radius)
+            elif atom[cs+1] == 'residue' and atom[ct-1] == 'CA':
+                RenderLabel(x,y,z,atom[ct-4],radius)
+            elif atom[cs+1] == '1-letter' and atom[ct-1] == 'CA':
+                RenderLabel(x,y,z,atom[ct-3],radius)
+            elif atom[cs+1] == 'chain' and atom[ct-1] == 'CA':
+                RenderLabel(x,y,z,atom[ct-2],radius)
+            
+        Page.canvas.SwapBuffers()
+       
+    def OnSize(event):
+        Draw()
+        
+    try:
+        plotNum = self.G2plotNB.plotList.index(generalData['Name'])
+        Page = self.G2plotNB.nb.GetPage(plotNum)        
+    except ValueError,error:
+        Plot = self.G2plotNB.addOgl(generalData['Name'])
+        plotNum = self.G2plotNB.plotList.index(generalData['Name'])
+        Page = self.G2plotNB.nb.GetPage(plotNum)
+        Page.views = False
+        view = False
+    Page.SetFocus()
+    Page.canvas.Bind(wx.EVT_MOUSEWHEEL, OnMouseWheel)
+    Page.canvas.Bind(wx.EVT_LEFT_DOWN, OnMouseDown)
+    Page.canvas.Bind(wx.EVT_RIGHT_DOWN, OnMouseDown)
+    Page.canvas.Bind(wx.EVT_MIDDLE_DOWN, OnMouseDown)
+    Page.canvas.Bind(wx.EVT_KEY_UP, OnKey)
+    Page.canvas.Bind(wx.EVT_MOTION, OnMouseMove)
+    Page.canvas.Bind(wx.EVT_SIZE, OnSize)
+    cell = generalData['Cell'][1:7]
+    Amat,Bmat = G2lat.cell2AB(cell)         #Amat - crystal to cartesian, Bmat - inverse
+    A4mat = np.concatenate((np.concatenate((Amat,[[0],[0],[0]]),axis=1),[[0,0,0,1],]),axis=0)
+    B4mat = np.concatenate((np.concatenate((Bmat,[[0],[0],[0]]),axis=1),[[0,0,0,1],]),axis=0)
+    Page.camera['position'] = drawingData['cameraPos']
+    Page.camera['viewPoint'] = np.inner(Amat,drawingData['viewPoint'][0])
+    Page.camera['backColor'] = np.array(list(drawingData['backColor'])+[0,])/255.
+    Page.canvas.SetCurrent()
+    Draw()
+        

trunk/GSASIIspc.py

@@ -2 +2 @@
 
 import numpy as np
+import math
 import sys
 import os.path as ospath
@@ -198 +199 @@
     '''
     Translates a set of coordinates so that all values are >=0 and < 1 
-      input: a list or numpy array of any length. Note that the object is modified  in place.
-      output: none
+      input: a list or numpy array of any length.
+      output: none; the object is modified in place.
     '''
     for i,x in enumerate(XYZ):
-        x = ((x % 1.0)+1.0) % 1.0
-        if x > 0.9999: x = 0.0
-        XYZ[i] = x
+        XYZ[i] = (x-int(x))%1.0
         
-def GenAtom(XYZ,SGData,ifAll=False):
+def Opposite(XYZ,toler=0.0002):
+    '''
+    Gives opposite corner, edge or face of unit cell for position within tolerance. 
+        Result may be just outside the cell within tolerance 
+    input:
+        XYZ: 0 >= np.array[x,y,z] > 1 as by MoveToUnitCell
+        toler: unit cell fraction tolerance making opposite
+    returns:
+        XYZ: array of opposite positions; always contains XYZ
+    '''
+    perm3 = [[1,1,1],[0,1,1],[1,0,1],[1,1,0],[1,0,0],[0,1,0],[0,0,1],[0,0,0]]
+    TB = np.where(abs(XYZ-1)<toler,-1,0)+np.where(abs(XYZ)<toler,1,0)
+    perm = TB*perm3
+    cperm = ['%d%d%d'%(i,j,k) for i,j,k in perm]
+    D = dict(zip(cperm,perm))
+    new = []
+    for key in D:
+        new.append(np.array(D[key])+np.array(XYZ))
+    return new
+        
+def GenAtom(XYZ,SGData,All=False,Uij=[]):
     '''
     Generates the equivalent positions for a specified coordinate and space group
     input:  
-       XYZ an array, tuple or list containing 3 elements: x, y & z
-       SGData, from SpcGroup
-       ifAll=True causes the return to provide the unique set of 
-                  equivalent positions
-            =False causes the input position to be repeated. This is the default,
-                   but why someone would want this, I am not sure.
-    Returns a list of two element tuples: 
-       The first element is the coordinate as a three-element array and 
-       the second describes the symmetry used to generate the site, of form [-][C]SS
-          C indicates a centering operation was used (omitted if the 1st, [0,0,0])
-          SS is the symmetry operator number (1-24)
-          - indicates the center of symmetry was used (omitted otherwise)      
+        XYZ an array, tuple or list containing 3 elements: x, y & z
+        SGData, from SpcGroup
+        All  = True return all equivalent positions including duplicates
+             = False return only unique positions
+        Uij  = [U11,U22,U33,U12,U13,U23] or [] if no Uij       
+    return: [[XYZEquiv],Idup,[UijEquiv]]
+        [XYZEquiv] is list of equivalent positions (XYZ is first entry)
+        Idup = [-][C]SS where SS is the symmetry operator number (1-24), C (if not 0,0,0)
+        is centering operator number (1-4) and - is for inversion
+        [UijEquiv] - equivalent Uij; absent if no Uij given
     '''
     XYZEquiv = []
+    UijEquiv = []
     Idup = []
     X = np.array(XYZ)
     MoveToUnitCell(X)
-    XYZEquiv.append(np.array(X))
-    Idup.append(1)
     for ic,cen in enumerate(SGData['SGCen']):
         C = np.array(cen)
@@ -236 +252 @@
                 T = np.array(ops[1])
                 M =  np.array(ops[0])
-                newX = np.sum(M*X,axis=1)+T
+                newX = np.inner(M,X)+T
+                if len(Uij):
+                    U = Uij2U(Uij)
+                    U = np.inner(M,np.inner(U,M).T)
+                    newUij = U2Uij(U)
                 if invers:
                     newX = -newX
                 newX += C
                 MoveToUnitCell(newX)
-                New = True
-                if ifAll:
+                if All:
                     if np.allclose(newX,X,atol=0.0002):
-                        New = False
-                        idup = 0                    
+                        idup = 0
+                else:
+                    if True in [np.allclose(newX,X,atol=0.0002) for oldX in XYZEquiv]:
+                        idup = 0
+                if All or idup:
                     XYZEquiv.append(newX)
-                else:
-                    for oldX in XYZEquiv[:-1]:
-                        if np.allclose(newX,oldX,atol=0.0002):
-                            New = False
-                            idup = 0
-                    if New or ifAll:
-                        XYZEquiv.append(newX)
-                if ifAll and len(XYZEquiv) == 2:
-                    Idup.append(1)
-                else:
                     Idup.append(idup)
-    if ifAll:
-        return zip(XYZEquiv[1:],Idup[1:])                  #eliminate duplicate initial entry 
+                    if len(Uij):
+                        UijEquiv.append(newUij)                    
+    if len(Uij):
+        return zip(XYZEquiv,UijEquiv,Idup)
     else:
         return zip(XYZEquiv,Idup)
@@ -454 +468 @@
        SGData: from SpcGroup
     Returns a two element tuple:
-       The 1st element is a code for the site symmetry (see GetOprPtrName)
+       The 1st element is a code for the site symmetry (see GetKNsym)
        The 2nd element is the site multiplicity
     '''
@@ -474 +488 @@
     if SGData['SGLaue'] in ['3','3m1','31m','6/m','6/mmm']:
         Isym = 1073741824
-    Jdup = 1
+    Jdup = 0
     Xeqv = GenAtom(XYZ,SGData,True)
     IRT = PackRot(SGData['SGOps'])