Miles Periodic Table with Standard Periodic Table reference

Just uploaded a new version of the Physics Database. Added several new Formulas from Chemspider.  Has the graph tables included as well.  Looking at trying to port the graph tables over to OrientDB that can run on Windows. May also look at Neo4j's Windows community edition if not too limited. Looking for a Graph DB that is free, runs on windows and the query syntax allows "hybrid" (both SQL and Graph query syntax). OrientDB has teleporter which can allow imports from SQL Server: https://orientdb.com/docs/3.0.x/studio/backups-imports-exports/Studio-Teleporter.html 
----------
(294 MBs)
https://mega.nz/file/n8NmyLKa#pIcGxTVKtILrijsG8_rVhwGXVck62TS3H6ynOmwLkg4

By the way, I did a pull of Sb (Antimony) which has a lot of curious single atom to Sb bonds. This one might need a deeper analysis with Slot alignments for the C.F.

In terms of the C.F., Sb has a lot of CH bonds with it along with more discrete TeSb, InSb , AlSb or Gallium. It also has numerous Fluoride bonds which looks unusual. A couple of Atom to Atom bonds that the C.F. may have to account for:
Gallium antimonide | H2GaSb | ChemSpider
indium antimonide | InSb | ChemSpider
Aluminum antimonide | AlSb | ChemSpider
Antimony pentafluoride | F5Sb | ChemSpider
Stibylidynephosphine | PSb | ChemSpider
Algarot | ClOSb | ChemSpider
iodothioxostibine | ISSb | ChemSpider
antimony; nickel | Ni3Sb | ChemSpider
antimony; zinc | SbZn | ChemSpider
Stibylidynesamarium | SbSm | ChemSpider
Aluminum antimonide | AlSb | ChemSpider
Thioxostibinyl | SSb | ChemSpider
Stibylidyneeuropium | EuSb | ChemSpider
Stibylidynecobalt | CoSb | ChemSpider
Stibylidynethallium | SbTl | ChemSpider
Thioxostibine | HSSb | ChemSpider

.
Cr6, Thanks for the memory space utility app recommendation. Another is TreeSize.  https://www.jam-software.com/treesize_free?ca=1
I didn’t end up downloading either. After some remote Quick Assist quality family time my computer’s doing much better - 110 GB free and an up-to-date backup. Please pardon all the kerfluffle.

SQL Alchemy. I’d started looking at Jupyter Notebook ipython-sql then switched to sqlAlchemy as you suggested. Used Anaconda to load the package and have found a possible first tutorial on the subject - it does not look simple.
https://notebook.community/ucsc-astro/coffee/15_01_27_sqlalchemy/Learning%20SQLAlchemy

Post by Chromium6 Today at 8:57 am. We may need to double check these on which are "good" or "bad".  BTW, I'll try and upload a new Physics .bak file this weekend.  
Airman. I’ve still been thinking about what you meant by saying you can show all bonds in the Periodic table. I guess the 353 row output and query in your post includes all the bonds between the slots indicated and the number of times that particular bond occurs out of all our validated bonds over all your molecules. Specifc directions may help. //SMILE//
Cr6 wrote. Just uploaded a new version of the Physics Database. Added several new Formulas from Chemspider.  Has the graph tables included as well. … .
Airman. Thank you Sir, updated ‘Physics’ to your latest 20230318Physics.bak file.

Code:


///////////////////////////// 19 Mar 2023
Graph Tables.
gAtom.118 rows for 118 elements. 9 Cols: $node code, AtomicNumber,AtomicSymbol,Element,
 OrbitalGroup,Protons,Neutrons,GroupNumber,Period.
 As well as
gAtomPeriodicTableAtom. single string, the $node code and eight col labels.
gMathisAtomPeriodicTableAtomLTAMKeyEdge. First 1000 rows. Including [FromLTAMKey] to [ToLTAMKey]
gMathisPeriodicTableAtomLTAM. Familiar data with $node schema info/code
gPeriodicTableAtom. Single string, the $node code and eight col labels.
gPeriodicTableSlots. SELECT TOP (1000) [$node_...],[SlotKey],[LTAMKey]
      ,[SlotNumber],[AlphaType],[SlotSpin],[SlotOrientation],[CanBind]
/////////////////////////////////
Tables.
AllTable.  335 rows -  4 cols. Quantity, Value, Uncertainty, Unit.
 No primary key. 355 atomic constants and relationships. Quantity, value, uncertainty and unit.
AtomicOrbital. Almost 21,161 rows -  46 cols. Molecules and formulas.
AtomicOrbital1. 372,821 rows. 46 cols. ID, ZMolecule, Zitem, … , 9p. 11 seconds to output.
AtomicOrbitalsinMilesDetailSummary. 45,052 rows, 172 columns.
CurrentAtom, NextAtom1, ... , e6zDest. The query took 4 secs.
AtomicRDKit. 92 rows -  38 cols. Each atom’s (1-92) select atomic values.
AtomicSourcesRDKit. 26 rows -  5 cols (PropertyID, property, notes, units and source).
Chemspider. Was 60,431 rows Now 62,670 rows. 5 cols. Chemspider moleculae ID list.  (Property, notes, units and source).  
Circle. 36001 rows - 360 degrees in hundreths. Cols x y and z are NULL.  Just a guess, his table might be used in rotation calculations to replace the sin and cos functions with a lookup table.
Compounds. 262 rows - 3 cols. No, Compound, Formula.
CompoundsSmiles. 1351 rows - 6 cols. SMILES info(PID,id,EntryName,SMILES,MW.Selectivity_Index). ElementAbundance. 78 rows – 9 cols. 78 Elements’ crustal abundances.
ElementAbundance. 78 rows, 9 cols. Why is this new? Broken out of SMILES?
ElementsPositions. 1710 rows – 87 cols. 19 rows x 90 elements. Like the csv version, this one includes a the atomic tuple. A primary key has been added.
EnergyLevel. 6 rows – 7 cols. EnergyLevel,ShellLetter,ElectronCapacity,s,p,d,f.
FormulaSuperConductor. 176 rows of FormulaSuperConductors
GraphMilesAtomNode – 157 rows - Through Atomic number 162. 8 columns (AtomicNumber, AtomicSymbol, Element,
GraphTempAtomNode. 90 rows, Up to Thorium. 8 columns (AtomicNumber, AtomicSymbol, Element,
 OrbitalGroup, Protons, Neutrons, GroupNumber, Period).
Ions. 64 rows – 5 cols. IonID,Ion,Charge,AlphaNm,Name.
Mathis. 1282 rows – 5 cols. UID, AtomicNumber,Position,SlotNumber,AlphaType
MilesMathis. 12 rows – 4 cols. ID,Description,RawCalculation, Set2. Miles calcs.
MilesMathisPeriodicTable. 2983 rows – 18 cols. 163 Atomic numbers x 15 slots.
MilesMathisPeriodicTableOLD. 2983 rows – 18 cols. 163 Atomic numbers x 19 slots. Missing slotlayouts.
MilesMathisPeriodicTableOLD2. 2993 rows, 18 columns.  
nci. 150 rows – 2 cols. Compoundid, smiles.
Numbers. 65,536 rows – 1col, Number. Rows 1 to 65536 containing Number 0 to 65,535.
Orbital1. 344 rows – 27 cols. Atomic electron orbital info.
OrbitalMatrix. 157 rows – 30 cols. 163 elements with atomic electron orbital info.
Orbitals. 172 rows – 13 cols. 172 elements’ atomic electron orbital info.
PeriodicTable. 118 rows – 74 cols. 118 elements’ atomic data.
PeriodicTableGrouping. 110 rows – 30 cols. 110 elements’ atomic data.
PeriodicTableState. 112 rows – 12 cols. 112 elements’ atomic data.      
PeriodType. 10 rows – 2 cols. Atomic types, alkaki metals to noble gases.      
Species. Was 102,209 rows, now 103,773 rows – 4 cols. ID, Molecule, Formula, Detail.      
Species_Stg. 1998 rows (No change) – 3 cols. Molecule, Formula, Detail.      
Species20230212. 103,185 rows. 4 cols. ID, Molecule, Formula, Detail.
sqlmol_bond_type. 0 rows. btid symbol.    
sqlmol_compound. 150 rows. compoundid, smiles  cols.    
sqlmol_compound_bonds. 0 rows. cbid, compoundid, btid, ceid1, ceid2.  
sqlmol_compound_elements. 0 rows. ceid, compoundid, atom, nodeid.    
sqlmol_compound_hfbonds. 0 rows. compoundid, chbid, ceid, cbid, btid, parseid.
sqlmol_element_type. 0 rows. symbol.                                
sqlmol_hfbond_type. 0 rows. btid, symbol.                                
sqlmol_symbol. 28 rows. 3 cols, code, type, Aromaticity.                              
STG_Orbital. 172 rows. 28 cols. 172 elements’ electron orbital data.
/////////////////////////////////
Views.
AtomicOrbitalBonds. 9028 rows. 53 cols. Atomic details and orbitals. All ZmoleculeOrder values equal 1.
AtomicPivotedByAtomicNumber. Was 9021 rows, now 10,247. 92 cols. Atom1-Atom90 cols. Function_Assist_GETDATE. 1 row. 1 col, GetDate. Gives the date and time of the query function.
Function_Assist_RAND. 1 row. 1 col, RAND. Returns a random value between 0 and 1.  
MathisEdgesGraphML. 141,518 rows. 6 cols. RowN, Source, Target, srcElement, trgElement, edges.  
MathisNodesEdgesAllBinds. 0 rows. 38cols. AtomicNumberSrc, … , Color.    
MathisNodesEdgesGraphML. 1000 rows. 1000 node id’s, labels, type.      
MilesMathisCalculus. 50 rows. 5 cols. Z, 2z, z3, NextNumber, MathisCalculus.      
vwAllTable. 335 rows. 4 cols. FloatValue, Quantity, Value, Uncertainty.        
vwAtomic. 86,173 rows. 160 cols. 44 seconds.
vwAtomicOrbital. 35,315 rows. 47 cols. ID, ZMolecule, Zitem, … , 9p.
vwAtomicOrbitalBonds. 14,103 rows. 56 cols. ZMoleculeOrder, CurrentAtom, ... , ZID.
 Atomic details and orbitals. All Zmolecule, Order values equal 1.
vwAtomicOrbitalBonds. 9,028 rows. 55 cols. ZMoleculeOrder, CurrentAtom, … , 9p.
vwAtomicOrbitalPerm. 21,161 rows. 46 cols. ZID, ZMolecule, ZItem, … , 9p.
vwAtomicOrbitalsAllMiles. Was 1784, now 2,678 rows. 7 cols. CurrentAtom, NextAtom1, … , Formula. 39 seconds.
vwAtomicOrbitalsinMiles. Was 1778, now 2,668 rows. 7 cols. CurrentAtom, NextAtom1, … , Formula. vwAtomicOrbitalsinMilesDetail. 12,342 rows. 170 cols. 3 Minutes 26 seconds.  
vwAtomicOrbitalsinMilesDetailAllBonds. 45052 rows. 172 cols. CurrentAtom, NextAtom1, …
     , Formula. Took 7 minutes 17 seconds to run this query, longest by far.
vwAtomicOrbitalsinMilesDetailCarbonFilteredOut. 10,951 rows. 170 cols. CurrentAtom, NextAtom1, … , Formula. Took 3 minutes 20 seconds to run this query.
 Msg 245, Level 16, State 1, Line 1
 Conversion failed when converting the varchar value 'A' to data type tinyint.
vwAtomicOrbitalsinMilesDetailSummary. 38,569 Rows, 172 cols,  CurrentAtom, NextAtom1,
      … , e6zDest. 5 seconds
vwAtomicOrbitalsinMilesDetailSummaryPeriodicDetail. 77,096 rows and 323 columns. 22
     seconds. A lot of info.
vwAtomicOrbitalsinMilesDetailSuperConductors. 3,424 rows, 170 cols, CurrentAtom, NextAtom1, … , e6zDest.
vwAtomicOrbitalsNotinMiles. Was 236, now 546 rows. 8 cols. CurrentAtom, NextAtom1, … , Formula. Took 40 seconds to run this query.
vwAtomicOrbitalsNotinMilesAll. 40 seconds. 829 rows and 9 cols. With reasons: SlotOrientation and BindLogic.
vwAtomicOrbitalsNotinMilesBySlotOrientation. 799 rows and 170 cols.
vwAtomicPeriodicTableLTAMSpins. Was 21,030 rows, now 35,134. 177 cols. ID, ZMolecule,
     … , SL4. Took 5 secs to run this query.
vwAtomicPivoted. Was 21,030 rows, now 35,134. 92 cols. ID, ZMolecule,  … , MolOrder. Took 4 secs to run this query.
vwCircle. 36001 rows. 1 col. Degree. Looks like random rotations (with select *) between
     zero and sequential rotations when using the select top 1000 values.
vwDeutrium. 14 rows. 4 col. ID, Molecule, Formula, Detail.
vwElementsPositions. 1710 rows. 88 cols. AtomicNumber, AtCurrentAtom, NextAtom1, … ,
     Formula. 0 seconds.
vwMathisLTAMMolecules. 397,328 rows. 119 cols. ZID, ZMolecule, … , 9p. 20 seconds. Ties electrons and electron orbitals together?
vwMathisMaxSlotPivoted. 90 rows. 28 cols. AtomicNumber, AtomicSymbol, … , Slot19.
vwMathisMoleculesBindLogic. 35509 rows. 162 cols. AtomicNumberSrc, AtomicNumber
     Dest, … , e6zDest. The query took 3 secs.
vwMathisMoleculesBindLogicXYZ. Was 32541, now 24318 rows. 164 cols. AtomicNumberSrc, AtomicNumber Dest, … , e6zDest. The query took 4 secs.
vwMathisMoleculesFullBindLogic. Was 1,338,332 now 989,012 rows. 255 cols. BondType, AtomicNumber, AtomicSymbol Dest, … , e6zDest. The query took 1 minute 26 secs.
vwMilesMathisElectronBondingMapped, 2983 rows. 179 cols. UID, mOrbitalGroup, mProtons,mNeutrons, , ZSeqNo, ZItem, ZElement, ZFormula, … , 9p.
     From 35 to 1 second runtime. Resembling AtomicOrbitalBonds with plenty of potential
     atomic attributes.
vwMilesMathisPeriodicTable. 2,983 rows. 17 cols. UID, AtomicNumber, AtomicSymbol, … ,
     Color. The query took 8 secs.
vwMilesMathisPeriodicTablePivoted. 2,983 rows. 34 cols. UID, AtomicNumber, AtomicSymbol, … , Color.
vwMolecule. Was 807,801, now 819,875 rows. 8 cols. ID, Molecule, Formula,  Item, RW, ASCIINum, Number, CharPlaceType. The query took 38 secs.
vwMoleculeAtomicWeight. Was 9028, now 14103 rows. 7 cols. ID, MolecularWeight,
     Formula,  Molecule, Number, NistLookup, ChemspiderLookup ,Total1stIonization. 4  
     Seconds.
vwNumbers. 2,476,099 rows. 1 col. n. 0-2476099. 13 Seconds.
vwPeriodicTable. 157 rows. 153 cols. RemainderAlphaLevel1, REM2, REM3, … , 9p.
vwProtonBalanceMathis. 157 rows. 12 cols. Carousel, AlphaProtonCarouselRemainder, Alphas, Element, AtomicSymbol, Period, … , AlphaTypeRemainder.


Used the opportunity to once again review and re-familiarize myself with the Tables, Views and Graph Tables. Identifying a few row and column changes, as well as correcting my previous notes.

Encountered one error when selecting the view, vwAtomicOrbitalsinMilesDetailCarbonFilteredOut.
Msg 245, Level 16, State 1, Line 1
Conversion failed when converting the varchar value 'A' to data type tinyint.


F5Sb. Showing all bonds for a Possible Antimony pentafluoride molecule.

F5Sb. Possible Antimony pentafluoride. Cr6, here’s a random Antimony molecule from your last post. Fluorine (F, 9), and Antimony (Sb, 51).  Assuming Sb is a molecular center makes more sense than stringing a column of F’s and an Sb together. F’s are too big to fit in any hook position slots(16-19). F’s single proton slot2 must bond more readily then F’s proton pair slot3. There’s not a whole lot of options to choose from. And so I believe F’s single proton slot2 must epn bond to five out of the six Sb +/- x, y, and z proton pair extents (T11Z2R), (B13Z2L), (T12Z2L), (B10Z2R), (T14Y2L), (B15Y2R). Last time I reoriented Nickel’s extents to Copper’s slot14. This time Sb is fixed and F’s slot2, F:(T2Y1L) is reoriented to epn bond at each of Sb ‘s extents. F’s (T2Y1L) slot must align along all three of Sb’s X, Y, and Z axes.

Again referring to Diatomic Hydrogen, figure 1. Out of eight possible TL,TR,BL,BR combinations: (TL-BL),(TR-TR),(TR-TL),(BR-BR),(BR-BL),(TR-BL),(BR-TR),(BR-TL). Only 4 result in bonds: (TL-BL), (TR-TR), (BR-BR), and (TR-BL).


Six possible F(T2Y1L) and Sb extents Sb(T11Z2R), Sb(B13Z2L), Sb(T12Z2L), Sb(B10Z2R), (T14Y2L), (B15Y2R).
With z-axis y-y epn bonding, F’s slot2, F(T2Y1L), at Sb’s +/- z extent (Sb(T14Y2L) and Sb(B15Y2R)), either atom can occupy either the +/– y sides of the bond (as in 9,10,11,12,21,22,23,24). Here, we also have F atoms aligning to Sb’s x (bonds 1,2,3,4,13,14,15,16) and y (bonds 5,6,7,8,17,18,19,20) axes. F rotates along with (T2Y1L)’s Y slot to align with Sb’s +/- x or y slot’s Z orientation; where either atom’s slot may occupy either the top or bottom z position. Both alternatives are included.

The first group of possible bonds, 1-12, show both the atoms’ bonding slots are in the same T/B and L/R order.
1. F(T2Y1L) – Sb(T11Z2R). TL – TR is not good.
2. Sb(T11Z2R) – F(T2Y1L). TR – TL is not good.
3. F(T2Y1L) – Sb(B13Z2L). TL – BL is good.
4. Sb(B13Z2L) – F(T2Y1L). BL – TL is not good.
5. F(T2Y1L) – Sb(T12Z2L). TL – TL is good.
6. Sb(T12Z2L) – F(T2Y1L). TL – TL is good.
7. F(T2Y1L) – Sb(B10Z2R). TL – BR is good.
8. Sb(B10Z2R) – F(T2Y1L). BR – TL is not good.
9. F(T2Y1L) – Sb(T14Y2L). TL – TL is good.
10. Sb(T14Y2L) - F(T2Y1L). TL – TL is good.
11. F(T2Y1L) – Sb(B15Y2R). TL – BR is good.
12. Sb(B15Y2R) – F(T2Y1L). BR – TL is not good.
The second group, 13-24 show that F(T2Y1L) slot is rotated about the x or y  axes such that its notation is backwards with respect to each possible Sb bond site. Each of the second group’s F slot2 T/B and R/L data must be reversed in order to properly determine whether the bond is allowed or not.
13. F(T2Y1L) – Sb(T11Z2R). Becomes Br – TR, is not good.
14. Sb(T11Z2R) – F(T2Y1L). Becomes TR – BR, is good.
15. F(T2Y1L) – Sb(B13Z2L). Becomes BR – BL, is not good.
16. Sb(B13Z2L) – F(T2Y1L). Becomes BL – BR, is not good.
17. F(T2Y1L) – Sb(T12Z2L). Becomes BR – TL, is not good.
18. Sb(T12Z2L) – F(T2Y1L). Becomes TL – BR, is good.
19. F(T2Y1L) – Sb(B10Z2R). Becomes BR – BR, is good.
20. Sb(B10Z2R) – F(T2Y1L). Becomes BR – BR, is good.
21. F(T2Y1L) – Sb(T14Y2L). Becomes BR – TL, is not good.
22. Sb(T14Y2L) – F(T2Y1L). Becomes TL – BR, is good.
23. F(T2Y1L) – Sb(B15Y2R). Becomes BR – BR, is good.
24. Sb(B15Y2R) – F(T2Y1L). Becomes BR – BR, is good.

Please pardon the usual errors, I’m sure I’m missing something.
.

Hi LTAM,

To fix the errors in the views, I forgot to run this after adding in the LTAMKeys to the Views. Open a new query window and run the following:

Code:


sp_refreshview '[dbo].[vwAtomicOrbitalsinMilesDetail]'
GO
sp_refreshview '[dbo].[vwAtomicOrbitalsinMilesDetailCarbonFilteredOut]'
GO


.

Ni3Sb. Another Antimony molecule on the 18 March list is Ni3Sb. The most likely bonding sites are the single proton slots Ni(B10Z1R) and Ni(B12Z1L). I guess either of those two slots can epn bond with any of Sb’s proton pair extents. Sb(B10Z2R), Sb(T11Z2R), Sb(T12Z2L), Sb(B13Z2L), Sb(T14Y2L) and Sb(B15Y2R). The image shows four different Ni orientations for possible individual Ni-Sb bonding opportunities with Sb slot14. There are actually two alternatives for each orientation since Ni or Sb can occupy the +y or -y position; eight possible bonding alternatives for Sb slot14 alone. Multiply that times six for every Sb extent, 48 possible alternatives bond sites for a single NiSb bond. Why was Ni3Sb ‘pulled’? I looked for but was unable to find F5Sb in either vwAtomicOrbitalsinMilesDetailSummary or vwAtomicOrbitalsNotinMilesAll views.

Cr6 wrote. To fix the errors in the views, I forgot to run this after adding in the LTAMKeys to the Views. Open a new query window and run the following. ... :
Airman. Thanks Cr6. I've got to say, SQL is the most unusual language I've ever experienced, and I remember coding with Fortran card stacks and machine language in school. Not enough pictures.

Cr6 wrote. We may need to double check these on which are "good" or "bad". ...

Code:


LTAMKeySrc   LTAMKeyDest   counts

A1Z6B   T14Y1L   1220
A1Z6B   B15Y1R   934
T14Y1L   B15Y1R   860
B15Y1R   T14Y1L   841
...
A1Z4A   T12Z1L   1
N16Z1L   B15Y2R   1
T14Y2L   B15Y3R   1
B15Y4R   T12Z2L   1

SELECT  
[LTAMKeySrc]
,[LTAMKeyDest]
, Count(1) as counts
FROM [Physics].[dbo].[vwAtomicOrbitalsinMilesDetailSummary]
Group by       [LTAMKeySrc]
,[LTAMKeyDest]


Airman. Agreed. Looks like both good and bad news. I'll start with some review of slots and bonding a la Miles’ Diatomic Hydrogen * paper.

Each atom is identified by its atomic number, the number of protons it contains. An atom’s protons occupy 1-19 stacks or slots, in an arrangement called the atom’s slot layout diagram, numbered and oriented in alternating positions and directions such that the proton stacks are added up, down and outward from the atom’s center slot1 in a balanced fashion. Usually depicted in alignment with the earth’s +/- z vertical charge field.

Protons, by themselves, cannot bond together. Protons must be accompanied by an electron orbiting either of its two poles. The electron blocks some of the proton’s through charge resulting in a low charge pressure zone at the proton’s opposite pole. The low charge pressure zone is necessary for bonding - to the next proton group – to occur. I believe the presence of a neutron, in effect orbiting the proton’s low charge pressure zone, while not included or mentioned in the DH paper, also helps block the low charge pressure zone, enhancing/reinforcing the low pressure zone and adds to the bond’s strength.

The Proton group or epn, begins with a proton positioned with a z-axis aligned spin and L-left or R-right closest edge spin direction. The electron and neutron orbit opposite top or bottom proton poles. Up to 6 (no more) epn sets can bond in a single proton stack when they: 1. all share the same pole-to-pole charge channel/spin axis and emit charge in parallel (or anti-parallel) equatorial planes; and 2. have good electron position configurations (i.e. T and B combos are good, but B’s and T’s prevent bonding); and 3. compatible proton spin directions (i.e. no more than one spin directional change is allowed in any stack). I’ve been routinely attaching Miles quote identifying which four out of the eight possible TBRL combinations can bond. Since the TBRL data defines any given proton stack or each and every slot layout diagram slot, we’ve added it to the sl diagram.

The five ‘digit’ slot signatures (LTAM? – you calling me a slot?) identifies the following:
1. T, B, A, N. The slot’s electron position configuration. Top, bottom or both top and bottom. Non occupied slots are coded N.
2. 1-19. The slot number.
3. X, Y, or Z. The slot’s proton spin axis.
4. 1-6, Slot’s Proton total.
5. R, L, A or N. SlotSpin. Slot’s Proton groups spin direction, either left, right or both as in an alpha or contra rotating slot with two spin directions. Non occupied slots are coded N.

The Good news.

Row LTAMKeySrc LTAMKeyDest counts
1.   A1Z6B    T14Y1L   1220
2.   A1Z6B    B15Y1R   934
3.   T14Y1L   B15Y1R   860
4.   B15Y1R   T14Y1L   713
…
354.   B15Y4R   A1Z4A   1
Total ‘counts’ equals 34,608.

For discussion’s sake, I’ve added a row column, row total, “Total ‘counts’ equals” label and 34,608 value. You’ve made change(s) to the Physics backup since then, re-running the same query results in a slightly different output.
Row LTAMKeySrc LTAMKeyDest counts
1.   A1Z6B   T14Y1L   1278
2.   A1Z6B B15Y1R   957
3.   T14Y1L   B15Y1R   915
4.   B15Y1R   T14Y1L   899
…
392.   B15Y4R   A1Z4A   1
Total slot occurrences. 38,569.

The number of rows have increased from 354 to 392. If the number of molecules have remained the same, the row increase likely indicates 38 new bond pairs have been identified in the latest version of ‘Physics’.

The number of bond counts have increased from 34,608 to 38,569, (adding 3,961 rows). The total number of rows in vwAtomicOrbitalsinMilesDetailSummary also equals 38,569. I guess that number equals the total number of our initially ‘validated’ periodic table molecular bonds. I believe the number of ‘bonds’ not yet accounted for may be found in vwAtomicOrbitalsNotinMilesAll, the total of which is 829 - that seems too small to be true. Together 38,569 + 829 = 39,398. Does that mean that out of the total number of 39,398 “known molecules”, we’ve failed to validate only 2.1% of them? That’s pretty good. Am I reading the data correctly?

The Bad news. At the top of the list, A1Z6B is not valid signature – there is no B type proton spin direction. A1Z6B occurs 36 times in the list, - which sounds awful close to that 38 new bonding pairs found above.  vwAtomicOrbitalsinMilesDetailSummary associates A1Z6B with Oxygen. O slot1 should be A1Z6A.

Once everything is working, we might try varying – optimizing - the slot signatures. Or let the machines do it. Not confident with the assignments, and guilty for being stingy with alphas (both first and fifth signature positions) except for almost every atom’s slot1.

*
332. Diatomic Hydrogen. My new charge bonding explains this much better than electron sharing. Plus an analysis of spin isomers. 9pp. http://milesmathis.com/diatom.pdf

P.S. Changed 2 TBLF typos to TBRL.
.

Thanks LTAM this is great stuff!

I currently trying to hook up OrientDB (orientdb.org) with the SQL.  Trying to import it via JSON imports.  I think OrientDB looks good with the community edition since it is SQL friendly and can allow the Transitive relationships. Everything else is a bit too commercial (Neo4j) and limits a good graph db. OrientDB also works with Gephi which is open source:
https://orientdb.com/docs/3.0.x/plugins/Gephi.html

Working with this right now to make a Miles' version of an import with Edges-Vertices clean for the slot structures and epn configs:
https://orientdb.com/docs/3.0.x/gettingstarted/tutorials/Import-the-Database-of-Beers.html

Should allow for more flexible bonding and possibly allow the "goal" of showing all atomic bonds with Mathis according to slot structures. Basically, can we show all bonds in the known universe out to 7-8 atoms?  Will update you as this gets going. Dorking hard with this and it has a lot of overhead detail work through. Security with imports is a bit of a pain.

I've imported a couple of hundred new atomic formulas into the latest version. This may have added the new "bond" configs.
This is Ni3Sb below:

 SELECT *
 FROM [Physics].[dbo].[vwAtomicOrbitalsinMilesDetailSummary]
 where Formula = 'Ni3Sb'

SlotDirectionSrc SlotDirectionDest CurrentAtom NextAtom1 NextAtom2 NextAtom3 NextAtom4 NextAtom5 NextAtom6 Formula AtomicNumberSrc AtomicNumberDest ElementSrc ElementDest LTAMKeySrc LTAMKeyDest CanBindSrc CanBindDest
BRY BLZ Ni Sb NULL NULL NULL NULL NULL Ni3Sb 28 51 nickel antimony B15Y2R B18Z1L 1 1
BRY TLY Ni Sb NULL NULL NULL NULL NULL Ni3Sb 51 28 antimony nickel B15Y2R T14Y2L 1 1
TLY BRY Ni Sb NULL NULL NULL NULL NULL Ni3Sb 51 28 antimony nickel T14Y2L B15Y2R 1 1

.
Organizing my thoughts can lead to unexpected places.

Ni3Sb. The Ni3Sb query output is worthy of discussion – an example of one of our ‘validated’ molecules. Good to see three bonds identified. For the time being I’m fine with nickel bonding to antimony’s hook slot 18. Part of the getting started and the lack of ‘transitive function’ limitation. Also, I mentioned not finding F5Sb on the list.

Perhaps the most difficult thing - for me, about working with SQL may be the need to pay close attention to data details. I’ve been referring to the close to 40 thousand rows in vwAtomicOrbitalsinMilesDetailSummary as the number of ‘known molecules’. That is clearly not correct. The Ni3Sb molecule contains 4 atoms with 3 bonds and occupies three rows in the AtomicSummary. So, excluding any odd ‘ring’ configurations or other, a molecule will appear as at least one row, up to a number of rows, one less than the total number of atoms in the molecule. Six or 7 atoms would require 5 or 6 rows. What’s the average number of atoms in a molecule? Around 4 or 5? The AtomicSummary probably contains around ten thousand molecules.  

Well I can do better than guess, as I’m beginning to learn, there’s a query for that. The select query sure does gets a workout.

Code:

SELECT DISTINCT Formula
FROM AtomicOrbitalsinMilesDetailSummary


The output includes 3,064 rows – much smaller than 40 or even ten thousand rows. 39,398/3,064 = 12.86(!?). Scrolled a bit through the list and noted a few curious formulas beginning with a small “a”. Decided to sort the list,

Code:

SELECT DISTINCT Formula
FROM AtomicOrbitalsinMilesDetailSummary
order by Formula

Here are the output’s first 100 rows.

Code:


0.5Gd0.SBa2Cu3O7
10B2O3
115CdCl2
133BaO4S
13C12H2Cl6O2
198AuCl3
1HClO
1HS
2Ba1IJCu12O25
2BaSCu7O2
2CaBa4Cu7O16
2SnBa4Cu5O2
3Ba4Cu7O16
64CuO4S
6Li2O4S
76As2S2
a12ZnO13
a2Sr4Tm2CaCu5O2
a2Sr4Y2CaCu5O2
aBa2O2
Ac2O3
aFeAs
Ag2Au
Ag2C2
Ag2C2O4
Ag2Cl2
Ag2Cr2O7
Ag2F
Ag2H
Ag2MoO4
Ag2Ni-
Ag2O
Ag2O3S2
Ag2O4W
Ag2S
Ag2Se
Ag2SeO3
Ag2Te
Ag3Br2
Ag3I3
Ag3IS
Ag3O4P
Ag8B4F4O8
AgAl
AgAl2O3
AgAuCu
AgAuS
AgBaCeCuO
AgBaCuDyO
AgBaCuGdO
AgBaCuOSm
AgBF4
AgBi
AgBrO
AgCl3Cu2
AgClO3
AgCN
AgCNO
AgCu
AgEu
AgF30NbO6Te6
AgGa
AgGaS
AgHo
AgIn
AgIO
AgKO3S
AgMnO4
AgN2O6Tl
AgN3
AgNa3O6S4
AgNb
AgNbO3
AgNbS
AgNO
AgOSn
AgPF6
AgSNC
AgY
aKFe4As4
Al10La3O51Sr14Ta7
Al24BaO44Sr7
Al2Au
Al2Ba2Mg2O7
Al2Ba2O5
Al2Be3O18Si6
Al2BeO4
Al2Br2O2
Al2Br6
Al2Ca2O5
Al2Cl2O2
Al2Cl6
Al2Cl9K3
Al2Co2O5
Al2Cr3O12
Al2F2O2
Al2F6
Al2F8K-
Al2F8Na-
Al2H2


Formulas identify a molecule’s constituent atoms – each atomic symbol, followed by –the number (if >1), of occurrences of that atom type, followed by the next constituent atom. Correct me if I’m wrong, any molecule that doesn’t fit that format is bad.

Fortunately the order by reveals the sort of problems present in our AtomicSummary view’s formula column.
1. Leading numerals. Sixteen of the first 23 listed.
2. Leading lower-case letters. Five first character ‘a’s as included. Need to test for any leading lower case letter.
3. Formula collisions. The fist value ‘0.5Gd0.SBa2Cu3O7’ may include two or more molecules and maybe another problem. Leading numbers dominate the top of this list, the 48th molecule is Ag8B4F4O8. 8 Silver atoms, 4 Boron, 4 Fluoride, 8 Oxygen, 24 total atoms – more than 3 times larger than 6 or 7 atoms. Two or three molecules have gloomed together. Another ex. Row 513, bGaSr4YCaCu4O2, has a leading 'b'. Has antimony Sb become a sulfur suffix somewhere else?

Are six or seven atoms the limit to our largest molecules? If its Ok with you, I’d like to try listing all the problem molecules in the formula list, beginning with these 3,064, and return it to you so that you can decide how best to make any corrections. Unless you have a better plan?
.

Hi LTAM,

Yeah there is some clean up still needed. To get rid of the bad values and collisions, try this SELECT then Uncomment the "DELETE" and Comment the "SELECT" and run this in a new SQL query. It should just delete stuff that couldn't be parsed properly. Some of the superconductor formulas had bad text outputs after screen-scraping them.

 
--Removes badly formed or parsed molecules -- often has brackets, quotes, pre-fixed numbers or other syntax.

SELECT *
--DELETE
 FROM [Physics].[dbo].Species
 where ASCII(LEFT(Formula,1)) not between 65 and 90

-- Removes concatenated molecules

SELECT *
--DELETE
FROM [Physics].[dbo].[Species]
where ( Formula like '%.%' or Formula like '%(%' )

Then run the procedure:  EXEC  [dbo].[spBuildAtomicOrbitalsinMilesDetailSummary]

We can definitely extend the number of atoms in a Formula beyond 6-7. A lot of the hydrocarbons are long and I filtered them out in a view (where not like 'C%H%'). Everything else is usually under 8 atoms per Formula.

.
Kudos Cr6, your cleanup procedure is simpler and easier than any I could have imagined.

Cr6 wrote. We can definitely extend the number of atoms in a Formula beyond 6-7.
Airman. Wow. Don’t know why I assumed just six or 7 total atoms per molecule. Of course six or 7 atom types per molecule can total 20 to 30 atoms or more. Oh my, H60AlCaKNaO36Si2 has ‘seven atoms’, and 102 total atoms. Identifying all 6 or 7 atomic (type) molecular bonds in the universe is a bigger task than I thought.

Thanks for making me visit ASCII table according to Windows-1252 https://www.ascii-code.com/ in order to find the meaning of - ‘not between 65 and 90’. Noting the efficiency of looking for a left parenthesis, since parentheses always come in pairs. Looking up formulas in wiki I see that the atom types in molecules are listed in alphabetic order. The parentheses may indicate a condensed formula, where a subset of atoms, like (CH3)n can be chained together n times. https://en.wikipedia.org/wiki/Chemical_formula
Hope we don’t toss out any condensed form unless that molecule is replaced with its ‘expanded’ form.

For the record, there are a couple of remaining formula column entries I should bring to your attention.
SELECT DISTINCT Formula
 FROM [Physics].[dbo].AtomicOrbitalsinMilesDetailSummary
where Formula like '%-%'
order by Formula
1. The AtomicSummary view now has 38,569 Rows with 2,965 distinct formulas, 104 of which end in a hyphen. Species has 5,729 formulas with ‘tails’ that end in a ‘-’ or ‘-2’.
2. ID:1050 Cl[14N][16O]. I did a search for the left square bracket, “like ‘%[%’” that didn’t show up in the query output(?)

D’Oh! Should have realized that the Species table is the ‘source’ for our molecules. In my Physics tables/views notes - Species. Was 102,209 rows, now 103,773 rows  – 4 cols. ID, Molecule, Formula, Detail). After cleanup, my Species table contains 103,218 rows/formulas. Surprised to see ions in the Species table. We might need to address them sooner or later. Where ever you get your formulas from - screen scrapping sounds interesting, I guess you must first add them to the Species table. Species might include unused collections of special case molecules.

Species includes 395 molecules including F5. I now see F5Sb is listed as two molecules.
Formula ID
F5Sb 101668
F5Sb 5935  

Made progress with SQL Alchemy, am currently in the Rolling Back section of the Object Relational Tutorial (1.x API) at https://docs.sqlalchemy.org/en/14/orm/tutorial.html. having successfully created and modified ‘some.db’, a database including four pets in my Jupyter notebook data folder.

Also in the In the middle of two videos: "The One-Point-Four-Ening 2021" by: Mike Bayer and Taking a Peek at SQLAlchemy with Megan Amendola. I appreciate some of the alternate command line options, basic engine actions versus Object Relational Mapping, due to the SQL Alchemy migration from 1.3 to 2.0. My notebook version is 1.4.13. Next, they didn’t click the first time, I might be ready to try looking at those notebook community SQL Alchemy examples again.

The entire process of creating an ‘engine’, establishing a ‘connection’, creating a class ‘model’, creating a ‘session’, are all necessary preliminaries for ‘git-like’ ‘Commit’ SQL transactions. When I first saw them, they seemed so strange, my mind went catatonic for a week. Begged to work on cleaning up ‘Physics’ formulas instead.

After completing the initial set of hurdles to reach this point I admit satisfaction, the whole agony ecstasy thing. Please pardon the details. In all honesty, for the time being I think I should continue familiarizing myself with more SQL operations (beyond SELECT) before concentrating on SQL Alchemy. I’ve yet to see how we might implement your mission/vision, a Jupyter notebook – mBuilder, starting with the single column of formulas.
.

.
Mission/vision.  Long version.

Post by Chromium6 Thu Mar 09, 2023 at 3:03 am.
This should be a good approach. Use what is working and stable for layouts. Actually it may be possible to build your jupyter notebook up into a version that can show all of the "bonds" available. May take some work but it is might be possible to add a T-SQL column as Varchar(max) that just renders per your Jupyter notebook in a single column. That way you could query the database for the column and it will render in Juypter as it is coded in the single column. Might allow for showing off "bonding" with atom to atom.  Just a thought really but people do this with reporting systems. Code the layout-structure in a stored procedure and the render result is seen-shown line by line or in our case Formula by Formula. Just something to consider as a rendering option. Might require a lot of intricate T-SQL/quotes/non-quotes to layout the atoms but seen this work effectively in the past. Basically take your notebook and add it as a new column in the dataset, parameterized for each atom to render a layout at one go. Could allow for atom to atom bond formulas as a selection. Once selected, it renders the full layout of atoms "bonding" via slot logic.

And

Post by Chromium6 Fri Mar 17, 2023 12:52 am.
I was trying to get your python-Jupyter notebook code into something that could be rendered at one go using parameters from the SQL views-SQL Functions -- it is possible to add a SQL Function to a Column that takes parameters like a python def function.  Like create a new column with in-line python code that could have passed in parameters from the two-three molecule details. I may not have explained it that well...kind of like column[slot]+column[protons]+proton[x,y,z positions] --> maps to a .py file or .ipynb file that can render the passed database table values in-line.

Mission/vision.  Short version.

Get the python-Jupyter notebook code into something that could be rendered at one go using parameters from the SQL views-SQL Functions.

Airman. Hallelujah Cr6, I believe. I may not see what’s next, but I think its close. Still studying, no longer overwhelmed and beginning to feel comfortable, there’s plenty I do not comprehend in the longer version. Realized I should look up T-SQL; oh, Transact-SQL, sql server extensions.
https://learn.microsoft.com/en-us/sql/t-sql/language-reference?view=sql-server-ver16

Jupyter notebook’s ‘built-in’ available source libraries include sqlite, a ‘small’ database capability, which I hope would be sufficient to handle an extremely trimmed-down working copy of the ‘Physics’ db. https://docs.python.org/3/library/sqlite3.html

SqlAlchemy provides the database management system (DBMS) and allows pandas to read, write, alter and view the database as though it were a dataframe. https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_sql.html#pandas.DataFrame.to_sql

From a user perspective, I’m provided with a list of molecules, each as a formula indicating a molecule’s constituent atom types and total number of atoms of that type within the molecule.

In order to render the molecule, we need to know:

1. The type, position and orientation of every atom within the molecule. The molecular center could be the center of the largest atom, or center of the molecules’ largest atom group.

2. The bonding details. Epn bonding forms by co-locating and aligning two separate proton stacks – one side or the other - into a single slot. We might need molecular before and after slotlayout diagrams showing those changes. Perhaps assigning the resulting slot to the larger atom and removing the slot from the smaller – or delete both atoms’ bonding slots and rendering the resulting single ‘epn shared slot’ bond separately – which could be easier. With m/f bonds between adjacent slots there’s no such shared slot rendering problem.

Formula bonding sequence. Once we’ve ‘validated’ a known molecule against our charge field bonding rules, we might consider creating each molecular formula’s unique bonding code or sequence to go along with the formula. Such a bonding code would provide all the molecule’s bonding details. For example, the bonding code sequence might be a series of slot_string/bond_type/slot_string along the three x y and z dimensions.

Once the formula and its bonding sequences are known, the notebook could render the molecule without any further query.
.

Sorry for being so lame latlely. I have an older relative in hospice...and it was kind of unexpected. Still working on orientdb community edition an expect to get something released shortly. Trying to get a transitive and reliable query worked up. Your xzy epn layouts can be added as edges. May go back to graphx and pandas in jupyter since this could be cooked up there without running  a new server and over head.

Added new Ga molecules via Chemspider to the sql server database.

.
Sorry you've received depressing family news Cr6. Lame? I thought you were being patient with me. Good luck and best wishes for your older relative, your family and yourself.

Please pardon the usual order of business, I was about to post most of the following yesterday, noticed your post and delayed posting till now.

More on 'bonding sequences'. Slot_string/bond_type/slot_string is intended to describe each and every individual valid bond between two atoms, pretty much the same as I’ve been describing them over the last few weeks.

F5Sb. On 21 march I listed 24 most likely bonding possibilities between Fluorine’s single proton slot 2 and any of Sb’s proton pair slot extents. Here are the 14 ‘valid’ bonds I listed. Rearranged slightly, placing the bond types in the middle and correcting previous typos, listed as individual ‘bond sequences’:
3. F(T2Y1L), TL – BL, Sb(B13Z2L)
5. F(T2Y1L), TL – TL, Sb(T12Z2L)
6. Sb(T12Z2L), TL – TL, F(T2Y1L)
7. F(T2Y1L), TL – BR, Sb(B10Z2R)
9. F(T2Y1L), TL – TL, Sb(T14Y2L)
10. Sb(T14Y2L), TL – TL, F(T2Y1L)
11. F(T2Y1L), TL – BR, Sb(B15Y2R)
14. Sb(T11Z2R), TR – BR, F(T2Y1L)
18. Sb(T12Z2L), TL – BR, F(T2Y1L)
19. F(T2Y1L), BR – BR, Sb(B10Z2R)
20. Sb(B10Z2R), BR – BR, F(T2Y1L)
22. Sb(T14Y2L), TL – BR, F(T2Y1L)
23. F(T2Y1L), BR – BR, Sb(B15Y2R)
24 Sb(B15Y2R), BR – BR, F(T2Y1L)

Not included in that post is a similar list of 14 valid bonds between F’s slot 3 proton pair and Sb’s proton pair extents.
2. Sb(T11Z2R), TR – BR, F(B3Y2R)
6. Sb(T12Z2L), TL – BR, F(B3Y2R)
7. F(B3Y2R), BR – BR, Sb(B10Z2R)
8. Sb(B10Z2R), BR – BR, F(B3Y2R)
10. Sb(T14Y2L), TL – BR, F(B3Y2R)
11. F(B3Y2R), BR – BR, Sb(B15Y2R)
12. Sb(B15Y2R), BR – BR, F(B3Y2R)
15. F(B3Y2R), TL – BL, Sb(B13Z2L)
17. F(B3Y2R), TL – TL, Sb(T12Z2L)
18. Sb(T12Z2L), TL – TL, F(B3Y2R)
19. F(B3Y2R), TL – BR, Sb(B10Z2R)
21. F(B3Y2R), TL – TL, Sb(T14Y2L)
22. Sb(T14Y2L), TL – TL, F(B3Y2R)
23. F(B3Y2R), TL – BR, Sb(B15Y2R)
F5Sb, six total atoms with five epn F-Sb bonds; 28 valid sequences to choose from. Any set of five F atoms, slots 2 or 3, occupying 5 of the 6 Sb extents would constitute a valid and complete F5Sb molecular bonding code, sufficient for the notebook rendering of the molecule. F5Sb however is not yet ‘validated’.


Ni3Sb. On Sun Mar 26, I looked at Ni3Sb. I considered the single proton slots Ni(B10Z1R) and Ni(B12Z1L) to be the most likely bonding sites. Either of those two slots can epn bond with any three of Sb’s proton pair extents. Sb(B10Z2R), Sb(T11Z2R), Sb(T12Z2L), Sb(B13Z2L), Sb(T14Y2L) and Sb(B15Y2R). As with F5Sb, given our current bonding rules, any of Ni’s proton pair slots 11,13,14 and 15 are also likely bonding slots.
On Tue Mar 28, I wrote. "The Ni3Sb query output is worthy of discussion – an example of one of our ‘validated’ molecules. Good to see three bonds identified. For the time being I’m fine with nickel bonding to antimony’s hook slot 18. Part of the getting started and the lack of ‘transitive function’ limitation".
I’ll go into some further detail below.

SELECT *
 FROM [Physics].[dbo].[vwAtomicOrbitalsinMilesDetailSummary]
 WHERE Formula like '%Ni3Sb%'

We expect three bonds. Executing this Ni3Sb query does return three rows, each a different Ni-Sb bond. Here are 9 of the output’s 172 columns.

CurrentAtom, NextAtom1, …, Formula, AtomicNumberSrc, AtomicNumberDest, ElementSrc, ElementDest, LTAMKeySrc, LTAMKeyDest, ...
Ni    Sb     Ni3Sb     51     28     antimony nickel   T14Y2L     B15Y2R   ...
Ni    Sb     Ni3Sb     51     28     antimony nickel   B15Y2R     T14Y2L   ...
Ni    Sb     Ni3Sb     28     51     nickel antimony   B15Y2R     B18Z1L   ...

1. Sb(T14Y2L ) - Ni(B15Y2R). If I’m reading the implied y-y (or z-z bottom-top or x-x back-front) negative to positive axis positions correctly, the first row’s source and destination columns indicate a bond between Sb(T14Y2L) on the left and Ni(B15Y2R) on the right and the resulting TL-BR bond in between. Looks good. The single Ni-Sb bond sequence can be described by Sb(T14Y2L), TL-BR, Ni(B15Y2R).  

2. Sb(B15Y2R) - Ni(T14Y2L). As is, reading left to right, BR-TL is not a valid bond. This y-y bond can be made valid if the Ni(T14Y2L) slot was on the left and Sb(B15Y2R) was on the right. The bond sequence would then be Ni(T14Y2L), TL-BR, Sb(B15Y2R). Of course the source and destination data needs to change accordingly. Alternatively, if the Ni atom (at Ni slot T14Y2L) was rotated 180 deg about the z axis through Sb slot15, nickel slot14’s T/B and R/L data would be opposite with respect to Sb slot15 and so must be reversed to Ni(B14Y2R) before the bond can be evaluated. Either of the two resulting bond sequences Sb(B15Y2R), BR-BR, Ni(B14Y2R), or Ni(B14Y2R), BR-BR, Sb(B15Y2R) would be valid.

3. Ni(B15Y2R) - Sb(B18Z1L). BR-BL is not a valid bond. Switching Ni and Sb left and right sides results in Sb(B18Z1L) – Ni(B15Y2R), BL-BR which is also not valid. If Ni(B15Y2R) was rotated 180 deg about z, T/B and R/L is reversed and the slot becomes Ni(T15Y2L); in which we would have what appears to be a good bond, Ni(T15Y2L), TL-BL, Sb(B18Z1L). However, in this case, this bond fails because Ni cannot bond to Sb’s hook slot 18.

Under construction. I’ve yet to glimmer how the molecular bond validation coding works but I understand that, when completed, the AtomicOrbitalSummary view will contain only valid bonds between atoms for every bond in every molecule – the number of molecular rows being equal to the total number of molecular atoms minus one. There are usually many more possible valid bonds then are included in the summary view, a table of all possible bonds for a given formula can be the desired output for a separate query. For the time being, I believe the notebook should be able to render any of the molecules from mBuilder’s current atomic data and the AtomicOrbitalSummary view alone.  

Consider adding two new bonding rules:
New rule 1. No atom may bond to another atom’s occupied hook positions.
New rule 2. Atoms no larger than a single proton stack may m/f bond to another atom’s slot 2 or 3.

Consider adding two new data columns:
New col 1. Example, ‘TR-TR’. The epn bond’s (or row’s) valid electron configuration and proton spin. The notebook code can figure it out but it would be better to obtain that bond data directly from the bond summary, and it would make reading the table data easier as well. For non-epn bonds, ‘F-M’ could indicate the bond betweeen a left side slot center and an adjacent right side slot end. ‘M-F’ would indicate a bond between left side slot end and right side slot center.  
New col 2. Example, ‘y’ (or ‘x’ or ‘z’) Indicating if/when an atom must be rotated 180deg with respect to its +x,+y,+z data notation and show the resulting reversed T/B and R/L slot data in new col 1 when used to find the valid bond.

Cr6 wrote. Your xzy epn layouts can be added as edges. May go back to graphx and pandas in jupyter since this could be cooked up there without running a new server and over head.
Airman. Agreed. Need to start thinking of graphs again. I’m sure we’ll be getting back to sql sooner or later. As far as graph edges go, I guess the only epn bonds I haven’t mentioned yet are x-x aligned, which are treated the same as y-y.

Besides switching to graph thinking, I’ll probably add a csv copy of a portion of the AtomicOrbitalSummary view to mBuilder’s data folder next. Then I should be ready to try rendering molecules.
.

.

Importing new data into mBuilder means another opportunity to review, work and play with pandas. An example of plotting for play’s sake, just for something to look at, the above shows diatomic number pair data from the current ‘Physics’ AtomicOrbitalSummary view, the first 1000 rows out of 4,452 total rows, molecules containing 2 or more total atoms but only two atom types. Atomic numbers on the vertical axis, rows on the horizontal.

Update. Importing data from the ‘Physics’ sql server database AtomicOrbitalSummary view to mBuilder.

1. Changed the code’s pi variable name from piG to piPhi.
phi = (1+sqrt(5))/2  # calculating phi-based-pi, piPhi.
piPhi = 4/sqrt(phi) # piPhi is used instead of pi.
piPhi is nicer and more descriptive than piG.

2. Added two new temporary csv data files taken from the AtomicOrbitalSummary view.
a. AtomicSummaryFirst1000Rows.csv
b. AtomSumT1000TwoAtomTypes.csv.

3. Added pandas code to read the new csv files[/b].

4. Began wondering – again, how to go about coding and rendering molecules anywhere from two to a hundred atoms or more. The task seems extremely complex and perplexing …, this looks like a job for Object Oriented Programming!

Well, to be honest, I wouldn’t know, never having created any OOP code. True, Nevyn converted my Pi=4 animation of balls traveling along straight and circular tracks of length 4 in the same amount of time that got me to think in terms of class parents and children inheriting parent attributes, but that’s pretty much the extent of my understanding. An excellent opportunity to learn. Started working through a couple of OOP tutorials and have begun defining Molecule and Atom classes.      

Code:

class Atom:
   pass

atom1 = Atom()
atom1.atomic_symbol = "H"
atom1.name = "Hydrogen"
atom1.atomic_number = 1
#atom1.slotlayout
#atom1.position
#atom1.orientation
#atom1.rotation

class Molecule:
    def __init__(self, name):
       print(f"Molecule created: {name}")

    """
    def find_number_of_atom_types(self, “formula_string”):
         #parse formula_string
         return value
    def find_names_of_atom types()(self, formula):
         return value
    def determine_number_of_atom_types(self, formula):
         return value
    def find_number_of_atoms_of_each_type(self, formula):
         return value
    def find_total_molecular_atoms()(self, formula):
         return value
    """
molecule1 = Molecule("H2O")
molecule1.name = "H2O"
molecule1.type_atoms = 2

#molecule1.find_number_of_atom_types()
#molecule1.find_names_of_atom types()
#molecule1.find_number_of_atoms_of_each_type()
#molecule1.find_total_molecular_atoms()
#molecule1.atom_position

----------OUTPUT-----------

Molecule created: H2O

------------------------------


That’s all for now.
.

.

https://youtu.be/pNLAEDbK03s

Surprised a week has gone by since my last post. Looking over my notes and new ipynb files, I’ve completed ten object-oriented programming, class objects and instances, inheritance, etc, tutorials from the notebook.community, python.org, python-course.eu as well as transcribing code from random youtube videos on the subject.

Worthy of note is Mark Bakker’s quick and easy video, Exploratory Computing with Python - Object Oriented Programming, with video link above. He includes plenty of math, numpy and matplotlib examples. Its in python2 but I can ignore that detail. He’s also created a jupyter notebook nbviewer example I’ve just run across but must review next at https://nbviewer.org/github/mbakker7/exploratory_computing_with_python/blob/master/notebook12_oop/py_exploratory_comp_12_sol.ipynb
I’m tempted to review all of mbakker7’s work at
https://mbakker7.github.io/exploratory_computing_with_python/

Suffice to say I’ll need another week or two or more for study, but am happy to report this oop stuff is beginning to make sense.

Not yet able to state with complete conviction, it appears that an mBuilder optimum oop coding solution should include an object relational mapping (ORM) application such as SQLAlchemy, and small local sql database like SQLite. In addition to reading the AtomicOrbitalSummary view’s single validated molecular bonding set, SQLAlchemy can also run the query to identify all possible bonds for any given molecular formula.

The most recent Miles update at http://milesmathis.com/updates.html I see is,

NEW PAPER, added 3/3/23, More Proof the Air Force is Faking the Sunspot Numbers. Plus commentary on the butterfly graph.

Can anyone confirm that?
.

Looking good LTAM...thanks for the python links! Was trying to get orientdb set up but it is pretty limited with the freeware version. Moving to apache Age...https://age.apache.org/ will try to build up with this but it is not windows friendly.

.
Reviewing Mark Bakker’s work. I especially like his emphasis on plotting.

Reviewing oop – including Part VI. Classes and OOP, currently in chapter 28 of Learning Python by Mark Lutz, and published by O’Reilly, a book which happens to include many many fine tutorial details and examples.

Atom and Molecule classes. I understand that a fundamental goal of OOP coding was/is to create reusable classes. As evidenced by ten’s of thousands of python’s importable packages and libraries. The software engineer shouldn’t need to redesign everything from scratch, there are many existing/available “design pattern” classes on the shelf to choose or start from, such as has been developed for dealing with personnel or financial, data and methods.

I looked for but failed to find any 3D tinker toy like classes, but then, LloydA posted on a separate thread  
https://milesmathis.forumotion.com/t215-images-of-photons-atoms-etc#7223 and I saw an older - Thu Sep 08, 2016  LloydK posted image (I added the fig number and title as in the paper) http://milesmathis.the-talk.net/t215-images-of-photons-atoms-etc#1426

1. Franklin Hu: Octahedral atoms in octahedral molecule ( http://franklinhu.com/NPA20CubicAtomicModel.pdf )

Thanks Lloyd. Here’s the referenced paper’s first paragraph.

The Cubic Atomic Model
Franklin T. Hu
3521 214th Pl SE, Bothell, WA 98021
Email: franklinhu@yahoo.com
A new atomic model is described which builds atoms out of alternating protons and electrons. Unlike the currently accepted planetary atomic model developed by Bohr and Rutherford, the nucleus is not a compact sphere of protons and neutrons which are surrounded by a cloud of electrons. Rather, the atoms are built up like Lego bricks into octahedral shapes. These shapes give rise to locations on the atoms for other atoms to dock and form molecules. These shapes also explain many of the observed properties of the atoms such as the observed ionization energies, spectra, fission fragments and the allowed isotopes for an atom. This model eliminates the need for the strong force and significantly simplifies our understanding of how atoms are constructed using only the electrostatic force.

Airman. No surprise, the mainstream has conveniently pre-dismissed the Cubic Atomic Model with the advent of quantum mechanics a hundred years ago.

https://en.wikipedia.org/wiki/Cubical_atom

Cubical atom
From Wikipedia, the free encyclopedia
The cubical atom was an early atomic model in which electrons were positioned at the eight corners of a cube in a non-polar atom or molecule. This theory was developed in 1902 by Gilbert N. Lewis and published in 1916 in the article "The Atom and the Molecule" and used to account for the phenomenon of valency.[1] Lewis' theory was based on Abegg's rule. It was further developed in 1919 by Irving Langmuir as the cubical octet atom.[2] The figure below shows structural representations for elements of the second row of the periodic table.

Although the cubical model of the atom was soon abandoned in favor of the quantum mechanical model based on the Schrödinger equation, and is therefore now principally of historical interest, it represented an important step towards the understanding of the chemical bond. The 1916 article by Lewis also introduced the concept of the electron pair in the covalent bond, the octet rule, and the now-called Lewis structure.

Airman. Back in 2016 I probably thought the Cubic Atomic Model was very interesting, but it missed the mark with lego blocks instead of charge field spinning proton stacks.

A new atomic model is described which builds atoms out of alternating protons and electrons.

Today, that opening sentence sounds like it could have come out of Miles’ Diatomic Hydrogen paper.

Final paragraph.

12. Conclusions The Cubic Atomic Model presents an entirely new way to view atomic structure. Instead of a compact nucleus held together by a strong force, the atom is built up by using simple rules and building blocks. The geometric shapes produced by the model explain the many properties of atoms such as chemical reactivity, ionization energies, spectra and fission products.

Adding to my to-do list. With respect to Atom and Molecule classes, integrating additional ‘Physics’ data columns, or possible Machine Learning alternatives, the Cubic Atomic Model needs to be reviewed for possible application to our project.
.

.
Continuing my OOP study. Carefully reading the text and transcribing the code from my hardcopy of Learning Python. Finishing chapter 28, roughly 70 oop pages down and a couple hundred more to go. Most of the more advanced technical details and explanations are beyond me, but I’m ensuring all the class code presented and discussed runs properly in Jupyter Notebook. The various python classes are developed as their own py files, so I’m also using Spyder, a python environment that includes an “interactive” console, good for ‘importing’ the various classes and allowing me to see alternative ‘system’ outputs discussed in the text.

Reviewing Mark Bakker’s work. I've enjoyed the matplotlib examples and exercises, skipped the linear systems notebook for the time being, currently in Notebook 8: Basics of Pandas for data analysis.

The Cubic Atomic Model. I’ve read Franklin Hu’s paper a couple of times and visited a couple of his websites and youtube videos on the subject:
http://franklinhu.com/cubicatom.html
http://franklinhu.com/rutherford.html
Cubic Atomic Model Part 1
https://www.youtube.com/watch?v=gGz-D04iIg4&t=6s
Cubic Atomic Model Part 2 - Nobel Elements
https://www.youtube.com/watch?v=z3DU47QC7pQ

Franklin Hu also posts other work. He’s got my sympathy, defending himself from Gary at DraftScience. https://www.youtube.com/watch?v=D1D6ZKAwI-g
DraftScience Vs. Franklin Hu - What is wrong 2+2+2 physics, Dec 31, 2022

All in all, I’d say the Cubic Atom model is just too incredibly simple. Protons and electrons of equal size, in physical contact, without motion, exactly like alternating colored lego blocks. But I already knew that, the point of the review was to find possible applicability to our project.

I suppose the Cubic Atom’s atomic/molecular class models, assuming oop programming, may be found in LEGO Digital Designer. https://lego-digital-designer.en.softonic.com/
Its free but no longer supported.

Ionization levels. Ionization energy levels might be a ‘Physics’ database column we could add to our project.

So, how does the cubic atom model explain this? We first have to remember that we don't have to explain the existence of "shells" as conventional science would have you believe. What we need to explain is just the experimental evidence of the ionization chart. So let’s look at the shape of the argon atom in the cubic atomic model.

Ok, the number of ionization levels may agree with the number of atomic electrons, but there’s no explanation of ionization. To be picky, I don’t see how the Cubic Atom can lose electrons and maintain its structural integrity.  

Well then, how does the charge field atomic theory explain ‘ionization’ or ‘ionization energies’?

Ions are defined as atoms with missing or excess electrons, but if ionic bonding is a myth *,  then ions, as we understand them, must be unicorns. In any given atom’s slotlayout e-p-n, TBRL structure, the number of protons equals the number of electrons. Granted, a given slot may contain 1 or more (2 or 3) neutrons, or 1 or more (2 or 3) electrons. Except for m/f bonding at an atom’s extents, any given slot missing electrons would mean missing proton bonds.

I’m realizing that an atom’s so-called ionization energy levels probably reflects the energy states and quantized size changes for each and every proton within the atom. All of an atom’s individual proton energy (radius) increases or decreases do not occur at the same ambient energy level. Each individual proton likely changes energy/size sequentially according to its position within the atom and the amount of charge it recycles. The first atomic ionization energy level may indicate a proton radius increase in center slot1. Demonstrating an atom's proton size changes as a function of the atom's ambient charge energy may be a worthy future goal .

Glad to see an update at http://milesmathis.com/updates.html
NEW PAPER, added 4/30/23, “A Return to Bode. I simplify and clarify this old paper from 2009.”  http://milesmathis.com/bode2.pdf

*
http://milesmathis.com/index.html
316. Electron Bonding is a Myth. Molecular bonding explained by the charge field instead. 8pp.
http://milesmathis.com/ionic.pdf
.

.
Continuing my OOP study. Progressing much slower than I would have liked, reviewed the next 50 pages from Learning Python; deep in the thick of ‘Operator Overloading’ - and it certainly feels that way. The current items being presented are special dunder (double-underscore) python available built-in methods that can be included in class objects - each with its own special uses, constraints and considerations. Lowering my goal slightly – shooting for just another 100 pages, I’ll need to go over all the coded material again before it makes sense. I’m learning, but the only thing I know for certain is that OOP is not what I expected. For the first time in my life I considered therapy.

Happy to hear from Anjana Vakil describing her story in overcoming her initial OOP expectations.

A screen capture.
https://www.youtube.com/watch?v=TbP2B1ijWr8

Object Oriented Programming is not what I thought - Talk by Anjana Vakil
freeCodeCamp Talks
94,690 views  Nov 5, 2020
This talk is a historical & philosophical journey deep into the heart of darkness, er, object-oriented programming (OOP). Join me as I have my world shaken by the discovery that objects & classes aren't OOP's most important concepts: messages & late binding are. We'll try to peek inside the heads of Alan Kay & other OOP founders as they created languages like Smalltalk, and find that those "old" ideas seem strikingly relevant today. Our jaws may drop as we realize that OOP & functional programming aren't as different as we may have thought and that the 1st OO language wasn't created in the 60's or 70's, but much, much earlier… What awaits us at the end of this journey? At worst, we'll undergo a brief crisis of faith in everything we ever thought we knew about programming. (A support group will meet after the conference.) At best, we'll shift the way we view this near-ubiquitous but oft-misunderstood paradigm, and walk away with new insights for how we architect & understand our code.

Relieved and grateful, I’m almost back to my usual optimistic self. Unless I’m sadly mistaken, compared to functional code, OOP coding generally results in more adaptable and robust programs.
.

.
Still not much progress to report. Was knocked off my routine by the recent Miles' Model vs. E.U. Models thread, and a two-day household emergency that ended yesterday.

Rather than continue with the book, Learning Python, I decided to go back and work through another python review, a 16 hour video,
Harvard CS50’s Introduction to Programming with Python – Full University Course
freeCodeCamp.org
https://youtu.be/dDRD3c-WAec

Learn Python programming from Harvard University. It dives more deeply into the design and implementation of web apps with Python, JavaScript, and SQL
…
Course Contents
(00:00:00) Introduction
(00:04:48) Lecture 0 - Functions, Variables
(01:50:24) Lecture 1 - Conditionals
(02:46:23) Lecture 2 - Loops
(04:07:10) Lecture 3 - Exceptions
(04:51:45) Lecture 4 - Libraries
(06:09:15) Lecture 5 - Unit Tests
(07:00:22) Lecture 6 - File I/O
(08:32:32) Lecture 7 - Regular Expressions
(10:37:35) Lecture 8 - Object-Oriented Programming
(13:28:47) Lecture 9 - Et Cetera

Of course I’m not participating in the actual ‘CS50 course’, I’m not registered or turning in any assignments, etc. I’m just concentrating on reviewing, transcribing and playing with the code as presented and explained Dr. David J. Malan, duplicating each lecture as its own ipynb and py files. I’m in the middle of lecture 7. The lectures include plenty of new (to me) material justifying the effort.

Nothing is ever that easy, the course requires that one must do all work on the terminal command line and create separate py files. They recommend using Visual Studio. As I mentioned on May 4, Spyder should allow that, except for a spyder issue:
# why doesn't spyder allow a python int(input())?
https://github.com/spyder-ide/spyder/issues/17616

ccordoba12 commented on Apr 5, 2022 •
Hey @EgonHeuson, thanks for reporting. This error is fixed in our latest version (5.3.0).
Since it's still not available in Anaconda, you have two options:
...

Every lecture requires the int(input()) (or input() - same problem) command line code. I’ve tried following the simple directions updating spyder using conda – twice, without a problem yet without success. I'll carry on.

That's enough about my bumpy whatnots. I hope you’re doing Ok.
.

.


Visual Studio Code. Went and clicked on what I thought was more information which instead downloaded Visual Studio Code. In a huff, looked at it for just a few seconds. The free app provides an alternative coding environment that seems to be organized much like Jupyter Notebook. Including numbered individual cell’s input and the resulting output. It opens like and appears to work with ipynb and py files but I’ve seen no evidence of any special rendered outputs. As such, its another possible tool. Anaconda picked up on it automatically and now includes a VS Code launch point.

Finished cs50. No complaints, all examples were presented in simple and straightforward manner. I felt part of a fine Muppet student cohort. Full disclosure, I’ve read the Harry Potter series.

The screen capture moment above was introduced as an example of possibly the most complex code a python programmer might encounter. Written in re, aka regex, a mini-language, the possible use of which is the subject of one of the cs50 lectures, the expression is intended to check whether an internet address entered is valid or not. Several sections within the expression do make perfect sense to me now, but more important, for proper use, a would-be programmer must learn what resources are available, and then to refer and rely on the applicable documentation. The cs50 16hr video provides plenty of welcome insights into how python’s functional and class object types work together and providing good practices.

OOP review. My OOP learning sabbatical is nearly at an end – just one more source to review … . I’m sure I’ll be getting back to the project shortly.
.

Nice work there Airman. I know regex expressions can be major mind-numbing but in some cases they are the only things that can give the flexibility to get something "right" or "extracted". I actually understood a lot of the pic post since I've worked with them over the years. I salute you for sitting through OOP with Python courses. Frankly, I need to do the exact same steps that you have taken. You may want to start an exercise program if you don't have one already. I usually find my mind running through code on a treadmill or during weight lifting.

Sorry, I've been traveling on a vacation recently to Hawaii-Asia and haven't checked-in in awhile. Still working through the graph database challenge and will see what I can hack over the holiday weekend.

By the way, this is something to check out with OOP-Python for Miles' works.   Looks like Microsoft and Google are incorporating "ChatGPT" and "OpenAI" into data-programming type modules. Basically you can just say to ChatGPT-Bing-etc. "Create a python script that can do X, Y and Z" and it can create it for you. Since Miles' work is extremely novel, it won't have the literature to scan and build a Miles'/LTAM/Nevyn style molecular renderer that accurately. This may change over the years though. It is kind of spooky how this has developed this far this fast. Some of the videos on it are pretty cool and sometimes jaw-dropping on what it can do. Basically, you can just ask via voice/typing what you want in terms of python and it will try and create a script for you. Kind of like a chatbot that can help you build your code.  

News on the release of "Fabric" (ChatGPT-CoPilot for data analysis):
https://www.microsoft.com/en-us/microsoft-fabric

Something to keep an eye on. You might want to playback at 1.5/1.75:

AI and the future of humanity | Yuval Noah Harari at the Frontiers Forum
https://www.youtube.com/watch?v=LWiM-LuRe6w



Set of vids on CoPilot for code generation and what is coming for programming:

Learning AI with GitHub Copilot
https://techcommunity.microsoft.com/t5/educator-developer-blog/learning-ai-with-github-copilot/ba-p/3815078



On ChatGPT-4 and Jupyter Notebooks:
Using http://noteable.io


Faking of web visual reality:
https://www.youtube.com/watch?v=sGYWQiU7C70


https://www.youtube.com/watch?v=ucp49z5pQ2s


Details on CoPilot:


Microsoft's Tech stack for GPT-3+ and DeepSpeed ML:  
https://www.youtube.com/watch?v=Rk3nTUfRZmo


Microsoft's fixing Python code with CoPilot:

https://www.youtube.com/watch?v=KMOV1Zy8YeM

'

Thanks for that Geometry and Mechanics link Cr6. It came at just the right moment. If you know of an available euclidean class library you’d like to use, please share that as well.

Building molecules involve properly positioning and orienting atoms which are comprised of protons, neutrons and electrons. If we include: e, p, n, atom, and molecule classes, we should start with the basic euclidean 3D classes: points, locations and vectors.

I bought the book “Hardcore Programming for Mechanical Engineers”, with the intent of converting its 2d geometry class modules to 3d. I then downloaded PyCharm Community and followed the book’s instructions to create the Mechanics project shown.

Another possible alternative, I also downloaded math3d, a python library, but it appears to be geared to accommodate multiple reference points, as might be needed in robotics, much more firepower than needed.  
https://pypi.org/project/math3d/
https://gitlab.com/morlin/pymath3d

http://paulfurgale.info/news/2014/6/9/representing-robot-pose-the-good-the-bad-and-the-ugly
including robot
https://gitlab.com/morlin/pymath3d
# math3d

A simple to use Python math library for SE3 operations useful in computer vision, robotics, and AR/VR
This library draws heavy inspiration from OVR_Math.h within the [Oculus PC SDK](https://developer.oculus.com).
This library includes the basic building blocks of a vector3 (`Vec3`), a quaternion (`Quat`), and a rigid body transform (`Transform`) consisting of a vector3 and quaternion. In my experience, such a representation is expressive enough for all needs and relatively efficient.

...

\///\\\///\\\///\\\///\\\///\\\///\\\///\\\/

Cr6 wrote. By the way, this is something to check out with OOP-Python for Miles' works. … .

And thanks for the heads-up. I'd noticed but had not yet looked at any ChatGPT videos. I see you've added more links.

Its already too late. AI software has been downloaded by millions of people. I viewed four 20 minute-ish ChatGPT/AI subject tutorials, there are many more out there).

https://www.youtube.com/results?search_query=ai+chatgpt

and two news stories from 60 Minutes, and 60 Minutes Australia.


The AI revolution: Google's developers on the future of artificial intelligence | 60 Minutes
https://www.youtube.com/watch?v=880TBXMuzmk


What is AI and why are experts terrified about its future? | 60 Minutes Australia
https://www.youtube.com/watch?v=OTwdrMAq-Fk

Complex software development efforts usually take years to accomplish; Deep Mind, the AI and team developers - now a part of Google, worked for 4-5 years to come up with the software to identify a protein structure. It worked. Deep Mind can now solve protein structures in seconds. Over the last year Deep Mind has solved all 200 million known proteins. That library has since been donated to the public.

AIs can reference all human knowledge. Its a process anyone can use. Have a brief conversation then ask your AI to come up with a few ideas that interest you. The answers lead to more specific details and more interactions and refinements. Finally the AI will come up with something as good, usually better, than anything you’d care to compare it to, in most any subject. The product itself can be either true or false, making it difficult if not impossible to separate fact from fiction.

Oh, and the robots. I especially enjoyed seeing the little AI robots playing soccer, scoring goals and bouncing right back up. Relentless little critters.

Changes are upon us. I may be a bit too old to appreciate it, but there should be an explosion in creativity, how that effects society is the main concern. I agree with everyone else, white collar creative jobs like software developers, engineers, doctors, teachers, ... as currently practiced and understood will become a thing of the past. Mastery of AI apps will be a required asset/skill for any well-motivated worker, contractor or specialist.

Good luck everybody.


P.S. Here's some news posted since yesterday. Given the potential AI threats, including up to imminent human extinction with a triggered nuclear war, there’s a growing alarm and calls to enact regulations as soon as possible.
https://www.youtube.com/watch?v=uRWtmjLHFZI

Artificial Intelligence "Godfathers" Call for Regulation as Rights Groups Warn AI Encodes Oppression
Democracy Now!
.

Just wanted to post this vid on ChatGPT and three.js link for building up from descriptive text.

https://discourse.threejs.org/t/using-chatgpt-ai-and-three-js-to-help-code-3d-games/46369
Another examples by Shane: https://www.shanebrumback.com/threejs-examples/rocket-engine-particle-system.html
https://www.shanebrumback.com/threejs-examples/comet-particle-system.html

https://www.youtube.com/watch?v=bS12mDqgQqI



https://www.youtube.com/watch?v=85xFh2SPWfc

.

Showing a light theme instead of dark, and the start of a geom3d library package.

Cr6 wrote. Just wanted to post this vid on ChatGPT and three.js link for building up from descriptive text.
Airman. Shocking results indeed. If you know what you’re looking for and can provide a good description, such as including a threejs graphics renderer, you can get great results. You’d still need to review the code in order to understand it.  

Here's a good quote from the discourse net link's comment section.

QUOTING
https://discourse.threejs.org/t/using-chatgpt-ai-and-three-js-to-help-code-3d-games/46369

On Dec '22 anidivr wrote.

Its very helpful with generating simple boiler plate code samples. Code is 80 to 90 percent usable. Sometimes it uses threejs coding style from 5 years ago. When asking to generate web xr sample code, it makes a lot of assumptions. Also, asking it to draw a specific shape it usually just ends up drawing a triangle.

However, generally, its great at helping to discover new ways of doing things.

I’ve found the best way to start is have it describe 10 points about the concept you want to build. Then ask it to expand on each point and generate the code from that. Generally get better results this way. Don’t forget to ask it about any limitations about your choices. That’s always an interesting read.

Here’s an interesting prompt that yields a very good result “imagine and describe the architecture for a threejs whiteboard component”. Then ask it to “add code to change the color of the pen” or “add code for a pen to erase” and “add code to undo last draw operation”

I’ve been using ChatGPT to help write the code for a threejs scripting engine. I have a basic interpreter working. The AST can be translated to JavaScript to hopefully load as a runtime script block for faster execution.

I’m thinking of creating a domain specific language using PEG.js to make scripting easier. Hopefully, ChatGPT can help with that.

Repeating my favorite comment.

anidivr wrote. However, generally, its great at helping to discover new ways of doing things.

ChatGPT quality will no doubt improve over time.

As far as ChatGPT threejs renderings go, as you well know, our project is intended to be run on Jupyter Notebook. I was looking forward to eventually including threejs shaders or a particle system, it was a big disappointment when threejs stopped working. I don’t know whether matplotlib will be adequate to display molecules or not, let alone moving particles. Mayavi is something I’ve not yet looked at. Maybe ChatGPT could tell us if there are other rendering or 3d display options.

Project Update. At this point I’ve picked up enough object-oriented programming knowledge, I need to work with geometric classes.

As I mentioned last time, my current sources are the book, “Hardcore Programming for Mechanical Engineers”, and the Mechanical-master python repository. I should have mentioned the book and code were written, presented and explained by Angel Sola Orbaiceta. By the end of the book, the reader/coder should have created their own copy of the 2d, Mechanical-master repository; slightly less extensive, due to the book format's limitations. The material goes through a lot of changes in the course of the text, a fine way to learn how geometric classes are structured and how to use them. It’s great to have the repository reference available while trying to rebuild it.

Learning PyCharm Community is turning out to be easier than expected.

Angel wrote. Because the package name establishes that everything inside is in 2D, we won't repeat this information when giving names to our files and classes. Inside the package we'll use names like point or segment instead of point2d or segment2d. If we wanted to create a three-dimensional geometry package, geom3d, we'd still use point or segment, only with different, three-dimensional implementations.

Airman. He knows his book is used by people like me to create their own 3d class geometry versions.

I’ll Let you know when I hit any obstacles. For the code below I’ve added a couple of details not included in the text or repository such as my own descriptions and the intended file names at the top of each py file.

The first three geom3d py modules are started.

Code:


##############################
# geom3d: a 3D Euclidean class library.
#
# The following includes three py files:
# 1. nums, 2. class Point and 3. class Vector.
##############################

# File nums.py
""" variables a and b are not yet defined
as actual 'points'. Potential points need to
be tested against a minimum separation distance.
If the distance is smaller than tolerance, ... .
According to Angel, that often amounts to being
close to zero or one.  
No 3d conversion needed here.
""""""

import math

def are_close_enough(a, b, tolerance=1e-10):
    return math.fabs(a - b) < tolerance

def is_close_to_zero(a, tolerance=1e-10):
    return are_close_enough(a, 0.0, tolerance)

def is_close_to_one(a, tolerance=1e-10):
    return are_close_enough(a, 1.0, tolerance)
 
##############################

# File point.py
"""
All the methods here needed the (x,y,z) z component.
"""

import math

from geom3d.vector import Vector

class Point(object):
    """2d point"""
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z

    def distance_to(self, other):
        delta_x = other.x - self.x
        delta_y = other.y - self.y
        delta_z = other.z - self.z
        return math.sqrt(delta_x ** 2 + delta_y ** 2 + delta_z ** 2 )

    def __add__(self, other):
        return Point(
            self.x + other.x,
            self.y + other.y,
            self.z + other.z
        )

    def __sub__(self, other):
        # listing 4-7
        return Vector(
            self.x - other.x,
            self.y - other.y,
            self.z - other.z
        )

    def displaced(self, vector: Vector, times=1):
        # listing 4-10
        scaled_vec = vector.scaled_by(times)
        return Point(
            self.x + scaled_vec.u,
            self.y + scaled_vec.v,
            self.z + scaled_vec.w
        )

##############################
 
# File vector.py
""" Vector (u, v, w) can be the difference between
two points, but it can also indicate force direction
and magnitude. All the methods here needed w, the
(u, v, w) z axis component:
"""
import math

class Vector:
    """
    Vector is a direction in 3d space defined by its
    three projections: `u`, `v` and 'w'.
    """
    def __int__(self, u, v, w):
        self.u = u
        self.v = v
        self.w = w

    def __add__(self, other):
        # listing 4-8
        return Vector(
            self.u + other.u,
            self.v + other.v,
            self.w + other.w
        )

    def __sub__(self, other):
        # listing 4-8
        return Vector(
            self.u - other.u,
            self.v - other.v,
            self.w - other.w
        )

    def scaled_by(self, factor):
        # listing 4-9
        return Vector(
            factor * self.u, factor * self.v, factor * self.w)
 


Like your last two links highlight Cr6, another class not included in the text but which is absolutely needed is the Particle class. For Protons, neutrons, electrons and I hope, photons too. A particle has a location, mass, radius, velocity, spin direction, spin velocity. Know any good particle classes?
.

.
I received an extremely pleasant message from a newly registered forum member; complimenting me, mentioning the loss of Nevyn’s site, later asking whether I knew of any other sources? I’m posting Nevyn’s http://www.users.on.net/~Nevyn/science/ link below.  

He indicated he was strong programmer and that there’s a need for “putting Miles's theories into code”. He expressed willingness to support a “comprehensive computational model of Miles's theories”. He’d be able to review this project.

Well, pardon me, by all means. The project this thread documents and journalizes -  still working on molecule part, can be found at:

 Jupyter Notebook, Miles Mathis charge field Atom/Molecule Viewer
https://github.com/LtAirman/ChargeFieldTopics
 

Things are taking forever. The atomic renderings were fine until notebook + pythreejs + ipywidgets stopped working together, as described in the README file. the output’s been converted to matplotlib, but its not the same. If you know of such things, can comment, offer advice or join in, please, feel free.

Nevyn built a fine site and more, and fiercely described himself as a Software Engineer. My guess is Master level or better. I cannot adequately express the loss of his site and company around here.

I on the other hand, would describe myself as a retired engineer functionary type, and wanna-be Miles Mathis charge field modeler. I started coding after retiring. True, I was and am still inspired by Miles Mathis, I knew autocad, and had codded a few things in Pascal many years ago but I was in no way capable of modeling Miles ideas. Nevyn was kind enough to encourage and help me along, but I remain a slow learner. To the best of my knowledge, Nevyn coded using class based object oriented programming, which was too foreign for me to grasp, and so I never studied it or tried to replicate any of his work. I’ve only recently begun learning to appreciate OOP programming with respect to the goal of developing a quality Charge Field Atom/Molecule Viewer.

I decided I had better not post the message, but I'd describe it as a bit unusual. Detailed and ambiguous at the same time, extremely good English, no spelling mistakes, effusive praise pour moi. A desire to do the same things as we are doing.

Then an awful thought occurred to me. May the Goddess forgive me if I’m wrong. The last few posts above give me plenty of reason to doubt. This letter was written by ChatGPT!

Human, AI, or Human with AI assistance. You're welcome here.  


A link I’d forgotten, thank you Cr6 for reminding me.

Five old Nevyn projects:
http://www.users.on.net/~Nevyn/science/ with five threejs projects:
1. AtomicWebViewer. http://www.users.on.net/~Nevyn/science/physics/AtomicWebViewer
2. PeriodicTable. http://www.users.on.net/~Nevyn/science/physics/PeriodicTable
3. PhotonSpinViewer. http://www.users.on.net/~Nevyn/science/physics/PhotonSpinViewer
4. ProtonViewer. http://www.users.on.net/~Nevyn/science/physics/ProtonViewer
5. SolarSystem. http://www.users.on.net/~Nevyn/science/physics/SolarSystem
Please be patient, these old threejs files and whatever it is that runs the site may take a few minutes to load.

.

Thanks for the welcome Airman and hello to everyone! Apologies for the overly formal message -- hopefully this reply will pass the Turing test.

Thanks for posting the Nevyn site - it will be very useful as I'm still wrapping my head around the periodic table and spin concepts.

I'll have a look at your repo and see if there's anything I can contribute. Sorry to hear you're having issues with the dependencies - a common occurrence in programming. If I can figure out the issue, it might be a good idea to create a Docker container for the project. This would specify all the packages with their version number and make it easier for anyone to get it up and running quickly.

I've been working for the past week or so on a short article condensing some of the Mathis relativity concepts along with some 2d animations. It looks like Nevyn had something similar on his lab site, but I was unable to view it in the Wayback Machine. I'll post a link here when I finish it. This is really what got me dedicated to reading all of Miles's papers. The Twin Paradox was always confusing to me, and the relativity papers provided an explanation (or debunking) that made sense.

Here are some other ideas I had for modeling Mathis concepts:

- Game of Life photon simulator. (Look up Conway's Game of Life on Wikipedia - it won't let me post links because I have a new account). I don't have many concrete thoughts on this, but it might be interesting to simulate a bunch of random photons in a little 3d box and see if it can at least create a cool visual.

- Atomic bonding simulator. This is what I am thinking of focusing on primarily after I finish the relativity article. It would be incredible if it is possible to simulate a chemical reaction based purely on the charge field/gravity of the baryons.

Thanks again for the links and all the great work you guys have done so far!

.

A starting notebook’s current cell’s 9 and 10. The long column list output – Out[10], is transcribed, reformatted and added as the six # , commented out lines at the bottom of In[10] for easy reference. The new Point and Vector classes, nums.py’s close_to functions as well as point and vector class objects p, q, p_prime and v are highlighted.

BasedPhysics, this is intended to be a pro charge field forum, thanks for the compliments. You don’t need to prove anything. I must admit I’m glad you’re human. Feel free to wrap your head as you see fit, I’m sure we’d be delighted to help, charge spinning into poles immediately comes to my mind.  

As far as the project repository goes, waiting for whatever’s latest version to come along hasn’t helped. I still get github jupyter-widgets/pythreejs updates indicating the same problems. I certainly agree that version control is needed to restore AtomBuilder to its full contra spinning glory. I’d be happy to try following any prescription/remedy you may provide and be forever in your debt.

I remember playing with Conway’s Game of Life on graph paper after having read about it in Scientific American – sure enough, gliders glide across the page; the rules are extremely simple. I certainly like rooms with spinning/colliding particles and I would also like to be able to model charge bonding. Seems like common ground.   

Airman wrote. I’ll Let you know when I hit any obstacles.

Hit an obstacle as soon as I started. I was unable to import and use any of the new py files. Three tutorials and three new reference sources - I need to read up more on later, still no change. Apparently Jupyter Notebook is unique in that it expects to find all the necessary py files in the same file directory that the notebook file is in. But that’s not enough. Here’s a good description of the problem as I see it from stackoverflow. https://stackoverflow.com/questions/53049195/importing-custom-module-into-jupyter-notebook

Any solution needs to run on Jupyter Notebook. As far as I can tell there doesn’t appear to be any preferred easy solution.

Cr6, as I’m sure you’ve noticed, when referring to programming you always use the word “script”, and never “code”, while I always use the what I thought was the appropriate word “code” – and never “script”. To be honest, I didn’t know the difference? Maybe its an sql thing? I came across the definition that cleared my confusion.
 

Quoting: https://docs.python.org/3/tutorial/modules.html
6. Modules
If you quit from the Python interpreter and enter it again, the definitions you have made (functions and variables) are lost. Therefore, if you want to write a somewhat longer program, you are better off using a text editor to prepare the input for the interpreter and running it with that file as input instead. This is known as creating a script. As your program gets longer, you may want to split it into several files for easier maintenance. You may also want to use a handy function that you’ve written in several programs without copying its definition into each program.

So a script can be a file that lets a user interact with a module. Most convenient. When I think about it though, I don’t believe my usual programming qualifies as script. In any case, tried using a new py file, messingAbout, a script file which does all the imports. No change - no joy importing the three new py files.

The way forward. We can however, include the contents of each of the three new py files, each in their own separate notebook cell. As such they are read and interpreted but they aren’t 'imported'. After being read, a few class instances are invoked (as script), p, q, p_primed, and v. The image above shows things are working as intended. No different from how the notebook project has been operating up to now  – without separate py files. The only imports needed – aside from the usual python libraries and packages (like Math or pandas, etc.) – are separate csv data files.

I’ll spend some more time working on a possible import option before going back to the notebook only route. Hope to add to and expanding the classes.
.

Hey Airman,

I submitted a pull request to the repo with an additional requirements.txt file.

You'll see that the file includes all of the packages with their version numbers. In case you want to do something similar for another project in the future, you can always run 'pip freeze > requirements.txt' to save your current Python dependencies to a requirements.txt file. If you run 'pip install -r requirements.txt', pip will read all of the dependencies from the file and install them. This should resolve the threejs issues you were having

I can't see the Point or Vector classes in your code, so you might have to commit and push your changes. In general, if you have a file called blah.py in the same directory as a notebook, you should be able to import it in the notebook by running 'from .blah import *' in a notebook cell.

My import comment was incorrect. You'll need another python module to import from.

This directory structure should work:
ChargeFieldTopics
├── jupyter_notebook.ipynb
└── pyfiles
├── __init__.py <-- this can be an empty file but is required
└── regular_python_file.py

Then in jupyter_notebook.ipynb, you can do `from pyfiles.regular_python_file import *`

The indentation in the directory structure didn't show up correctly. __init__.py and regular_python_file.py should be inside the folder called pyfiles (or whatever you want to name it).

Hey guys, long time no see, or hear, or read, whatever!

I do pop in from time to time and see what you guys are up to, and it's good to see that you've been moving along nicely.

I thought I would give you a heads-up because you have shared links to some of my old code. However, I just received an email the other day from my ISP that that site is going to be taken down shortly, so even that will disappear.

If there is anything specific that you wanted then maybe I can dig it out and hopefully it works without a database, and if it does need one, then maybe I can get it at least running on my own machine (which is a new machine since I wrote all that stuff, so the DB was on my prev machine) and get a cut-down copy to you.

I can't promise anything, but I'll try to help if I can.

Hi Nevyn,

Thanks for popping in! I've only been binging Mathis for a short period of time, but I'm a computer programmer, so I'd be happy to look at any code you have. Anything and everything you're willing to provide would be awesome. With your permission, I could even maintain and re-host your old code.

As far as you all know, is this the only place there is any Mathis-related modeling research happening? I'm pretty shocked I can't find anything on Github. Memory-holed, perhaps?

G'day BasedPhysics,

I don't know of any other places for work on Mathis physics, but I haven't looked for a long time, either. Jared Magneson has some videos up on Vimeo. You can find some links around here, but I don't know where (probs in the Projects section under animation type projects). It does surprise me a bit because Miles' work is so easy to code up, well, to an extent, anyway.

I'm not sure about giving my site away. It kind of feels like giving up a child, . I'm not exactly saying no, but not saying yes, either. It does feel like it is going to waste, and that is a shame as I, and others, put in a tonne of work on a lot of stuff. Let me think about it.

For reference, my site required an Apache HTTP server, MySQL DB, and PHP. I think that was all of it. Apart from domain references that would need to be changed, I think it could get up and running again, but it has been a few years since I looked at it. It was all running on a Linux VM, but I think that part would need to be rebuilt since it was a bit specific to the hosting provider I was using. I still have backups but I don't know how that would go in a new hosting environment. I have heard that Oracle now offers free VMs and that is where I would probably look to setting it up again if I was going to do so.

As far as coding goes, most of my site was written in HTML, JS, using JQuery and Bootstrap (version 3 I think) for the UI, PHP when a backend server was needed. My preferred language is Java, but I didn't use that for my site. All of the 3D stuff was written in ThreeJS (it would be a lot of versions behind the latest now though).

I kept my code on BitBucket, so it is accessible through GIT, but they are private repos. The site was a separate repo from the apps on the site which all had their own repo, but they were all made to work together and build into a target environment (local HTTP server).

Were you interested in anything specific? It might be easier to get smaller parts functional again in a new environment. I was quite excited about my language series apps: Atomic Modelling language (AML), Molecular Bonding Language (MBL), and Spinning Particle Language (SPL). It would be good to see those in use again.

Do you have a site of your own? Are you looking to add to it, or to create something new?

Thanks for all the info, Nevyn. I hadn't found Jared's videos yet, they look super helpful. My interactions here have been awesome so far, I'm just surprised the community is so small, especially given how long Mathis has been posting. Hopefully I'll be able to recruit some of my software friends to join our ranks. I found the science site after someone posted one of the conspiracy/history papers on Twitter. I've seen some commentary on the faked events site on the internet but very little related to the physics papers other than this forum.

I've been working on an article condensing the relativity concepts with animations. The article and animations are still a work in progress, but as of yesterday it's live -- I still can't post links for a few more days, but the domain is my forum username and then .com. I'm also preparing to release an accompanying Python package - I have a public repo for it on my Github page (basedphysics).

Once I finish the relativity stuff, I'm planning on working on chemistry. My goal right now is mainly to keep learning the Mathis concepts and hopefully build some useful things to share with the forum. Eventually, I'd like to start an open-source modeling project or even a startup company. I totally understand not wanting to give up your site. The language apps are really cool - I'd be happy to start by trying to get one of them running on my machine. I'm also happy to help getting something hosted again in whatever form you'd be comfortable with. You did a lot of great work, it's a shame to not have it up and running

For more context, I have a full-stack background - experience in C, C++, Rust, Python, Java, web dev (my preferred stack lately is React/Typescript/TailwindCSS). I have experience with ML data pipelines and databases, mostly on Azure and AWS. I'm looking to help lend my technical skills in any way that I can while I catch up on learning the charge field concepts.

Thanks again Nevyn!

I had a couple of Relativity apps on my site. I had a look over the code last night and those ones are just straight HTML/JS, so they can be easily re-hosted. It's not the best code, but it works. The language series apps do use PHP, but they don't seem to use a backend DB that I noticed and I don't see why they would. I did use a DB for my Atomic Modeller app, but I think AML and MBL can be used to cover most of that stuff now. They both use the same rendering system as Atomic Modeller, but are far more flexible and easier to build something with.

.
Hey Nevyn, You're alive! Great to hear from you. I’d forgotten about your language series apps, I need to look at them again. I hope you don't mind me citing your name so often - reverently of course. For the present, I can hardly keep up with BasedPhysics.

BasedPhysics, it’s hard to keep up. Today, last time I looked at GitHub, I'd verified two merges of about 16 commits including adding the requirements.txt, hundreds of code changes and see you’ve got four more commits waiting for review. I really like how you've saved hundreds of lines by using for loops.

Unfortunately, things aren’t going smoothly. We've got problems.

BasedPhysics wrote.
I generated a requirements file for the project. The requirements file lists all of the package dependencies with their version number. I was able to run the notebook successfully with this configuration.

You can install the configuration from the requirements file by running pip install -r requirements.txt in the terminal inside the project directory. This should resolve the issues you were having with the threejs/widgets packages

Thank you for your clear and explicit directions. Used Powershell, and cd’ed to the chargeField Directory. Entered Dir to show the directory contents and Entered:
pip install -r requirements.txt
No joy, received the error shown.

basedphysics wrote: Are those notebooks older versions of the same thing or do they show different plots?

Airman. AtomBuilder and AtomBuilder2 are two earlier editions.
mBuilder was my preferred working platform for developing the molecule viewer.
The latest Point and Vector classes notebook hasn’t been committed yet.

AtomBuilder3 now has errors for input cells 14 onward.  

14 # Build each atom from Cr6-Elements
File "C:\Users\Robert\AppData\Local\Temp\ipykernel_15528\1041973798.py", line 124
   match a:
         ^
SyntaxError: invalid syntax

15 # The rendered scene
NameError: name 'groupA1' is not defined

16. # Atom 1 spin animations.
NameError: name 'stacks_A' is not defined

17. # Second set of spin animations.
NameError: name 'stacks_B' is not defined

18. # The widget tab enclosure.
NameError: name 'renderer' is not defined

/////\\\\\////

AtomBuilder, AtomBuilder2, mBuilder in Notebook2 are all running as usual.

My alternate, non-git directory copy of AtomBuilder3 is running as usual.

Does your copy of AtomBuilder3 have any problem? I suppose I'll need to revert back(?). What do you think?

P.S. Just verifying that AB3 had problems and the rest did not caused a lot of uncommitted notebook count changes and the like which I discarded, as I've done in the past. This time however, an AtomBuilder.ipynb.rej file has been created that I cannot discard from sourcetree. I see in as a new file in the chargeField directory, I'd like to delete it with windows explorer if that's ok with you.  
.

The requirements file issue is my fault. I generated the requirements with anaconda, which is apparently incompatible with pip. I generated a new one that is compatible with pip and added it to my latest pull request.

The other errors you're getting most likely have to do with the version of Python you have on your machine. I'm using the match case syntax which is relatively new, and it seems to be unrecognized by your Python version. I've just reverted that back to if-statements for now.

Both of these changes are in my latest pull request, so if you merge that in, you should be good to go!

Nevyn, sounds great. I can take a look at either the relativity or the AML app. I haven't done much work with PHP, but it sounds like a nice challenge. I was taking a look at the language app threads. I'm still wrapping my head around the nucleus-building stuff, so it's been super helpful.

.


BasedPhysics, after the third merge yesterday, AtomBuilder3 (AB3) is again running as usual. I’m extremely grateful for your expertise and help, sorry we’ve hit a snag or two. Can’t wait to review your changes more closely and attempt to make those and similar changes to the AB, AB2 and mB notebooks.

Pip install. Tried running the “pip install -r requirements.txt”, this time using cmd.exe, and received another error as shown. I edited the image slightly by converting the error’s very long first line - to make a second line, losing a little of the appnope file name number in the process.

Python version. Running windows 10. Here’s my spyder console output showing what Python and Ipython versions I think the chargeField Notebook is running.
Python 3.7.12 | packaged by conda-forge | (default, Oct 26 2021, 05:37:49) [MSC v.1916 64 bit (AMD64)]
Type "copyright", "credits" or "license" for more information.
IPython 7.33.0 -- An enhanced Interactive Python.

AtomBuilder3.ipynb.rej. I incorrectly referred to it as AtomBuilder.ipynb.rej in my last post. As I mentioned yesterday, just running AB3 causes ipynb cell number changes. I guess that means my gitignore needs changing. After my usual practice of discarding those hunks, something new happened, sourcetree created an AtomBuilder3.ipynb.rej file. Here’s the complete file:

Code:


diff a/AtomBuilder3.ipynb b/AtomBuilder3.ipynb (rejected hunks)
@@ -1042,7 +1042,7 @@
     ")\n",
     "\n",
     "# Creating the list of buttons: 19,7,19 and 1.\n",
-    "snbttns = [\n",
+    "snbuttons = [\n",
     "    sn1,\n",
     "    sn2,\n",
     "    sn3,\n",


Can I safely delete it or do I have to do some diff work first?

SourceTree will not start. Today I’ve got a bigger problem. I used Sourcetree quite a bit yesterday, but today it will not open or ‘Run as administrator’. One possible clue, last night, before shutting down, I noticed there was a windows update pending so I did an “update and restart” before shutting down. Doing a internet search on “sourcetree won't open” shows plenty of possible reasons. Maybe the best fix would be to download and reinstall the latest version, hoping that sourcetree will transfer its existing settings to the newer version. Does that sound Ok to you?

P.S.
Here's a positive finding.
https://community.atlassian.com/t5/Sourcetree-questions/SourceTree-failed-to-start/qaq-p/642445

Mike Corsaro wrote.
ATLASSIAN TEAM
Sep 19, 2017
Hello! This is a known issue. Please navigate to the config file location (C:\Users\Guest\AppData\Local\Atlassian\SourceTree.exe_{RANDOM_GUID}\2.3.1.0\user.config) and find the following line:

Code:


<setting name="AutomaticallyCleanUpDictionaryFiles" serializeAs="String">
     <value>True</value>
</setting>

Make sure that value is set to True

I was unable to find the Atlassian\SourceTree.exe_{RAN … \user.config
but I did find the error log at C:\Users\Robert\AppData\Local\Atlassian\SourceTree\sourcetree.log, and viewed many entries for yesterday, likely associated with all those delete hunks.

Feels like my bottom has fallen out.
.

Yeah, I'd recommend trying to uninstall source tree and reinstalling the latest version. I use the command line git, so I don't have much experience with the gui.

I believe the .rej file is indicating a merge conflict. It's safe to delete for now, but it could indicate that git failed to pull the remote changes from Github (if you have conflicting local changes). The easiest way to fix this would be to just completely redownload the repo from Github to make sure you have the latest version. If you want to resolve it manually, SourceTree can probably help. ChatGPT should also be able to help with version control issues like this. You can copy-paste a command line output or a file along with a description of the problem and 80-90% of the time it has a good recommendation for how to fix it.

For the requirements file issue, it looks like it's still referencing the anaconda packages. If I have a chance, I'll see if I can reinstall the dependencies from scratch and freeze them to a new requirements file. You might want to try installing anaconda to help manage the python environments. It's pretty convenient for creating and switching between environments.

You can also just install the dependencies individually with pip. I'm using pythreejs version 2.4.2, ipywidgets 8.0.6, and pandas 1.5.3. For example, you can run `pip install pythreejs==2.4.2 ipywidgets==8.0.6 pandas==1.5.3` to install the packages with specified versions.

I'm going to spend today trying to recreate the project from scratch in Python or JS to try to get a better understanding of how it works. LTAM, I think your idea of abstracting out some of the logic into Python files so it doesn't have to be included in the notebook makes sense. Is this what you're trying to accomplish with the Particle classes?

Hey Airman,

I have no problem with you using my name around here, reverently, of course .

Glad to see you continuing to develop apps. I hope it hasn't been too frustrating for you. I found Python to be a bit frustrating myself because I don't like languages that use indentation for block statements. I thought we got rid of that in the 90's. Even worse is it enforces spaces instead of tabs (a long and never-ending fight in the programming world), but I did get used to that eventually. I haven't worked with Python for a while now, so I would probably be frustrated again if I had to.

Good luck with it all.

.
Nevyn, thanks, good luck would be welcome. I found the directions for removing sourcetree, but haven't started yet. Oh the misery. Block indentations, spaces instead of tabs, such rarefied and refined frustrations. Good luck right back at cha. Thanks for stopping by.

BasedPhysics wrote.
I think your idea of abstracting out some of the logic into Python files so it doesn't have to be included in the notebook makes sense. Is this what you're trying to accomplish with the Particle classes.

Not sure what you mean, I don’t have any previous oop coding experience, although it just occurred to me that my first threejs coding project was copying threejs.birds and converting it to traveling and spinning  rigid spheres colliding with other spheres and the walls of a transparent room, I called “Boids”. Sure acted like a particle class. Anyway, particle classes just seem so natural. Eventually I’d like to see all our particles in “real” motion. AB3 uses spin animations.

Static molecular displays are fine for starters. In my mind, the beauty of particle classes is that you can even add random particles and collisions. You just keep updating, advancing and monitoring the particle positions.
 
Particle types: electrons, protons, neutrons and photons. I suppose a particle class should include: a particle’s: type, radius, position, velocity, spin axis, spin velocity (etc. including spin types (A,X,Y,Z)(?)).

If electrons are overgrown photons then charge should be visible as individual photons at the atomic scale. Ideally we would need a photon class which would include photon’ type specifics. Particle classes, commonly used in today’s parlance usually refers to particle type clouds may make a fine photon particle class - a future goal.

Molecules and atoms are not particles, but they contain groups of particles. That means adding another class, call it a ParticleGroup class – assemblies of particles at a specific position, orientation, … .

Proton stack (or Slot). Slots consist of 1-6 pole-to-pole bonded protons (and electrons and neutrons) in accordance with Miles’ Diatomic Hydrogen paper. Slots are the project’s basic working unit and would also belong to the ParticleGroup class.

The atomic data, Cr6’s idea, identifies each (1-90) atom’s 1-19 slotlayout configuration. Each data row contains each occupied slot’s position and orientation, the number and positions of the particles within each slot as well as the slot’s TBRL (electron-position/proton-spin) configuration data. AB3 assembles the atoms it reads from the atomic data.

The next goal is to display molecules, each including anywhere from two to a hundred atoms. We want to show valid charge field bonding details involving all the particle types. A single molecular bond between two atoms may be just the close proximity and orientation of two adjacent slots, one from each atom; or the bond between two atoms may be a single merged/shared slot.

Those bonding details are provided in the molecular data files, also Cr6’s idea. The program needs to position each atom within the molecule accordingly.

That’s the overall plan as I imagine it. Your feedback would be appreciated.

Cr6, I saw – speed your work 55% with ChatGPT Engineer (or something similar) featured down on the GitHub opening page. There will be no escape.
.

.
Nevyn, thanks, good luck would be welcome. I found the directions for removing sourcetree, but haven't started yet. Oh the misery. Block indentations, spaces instead of tabs, such rarefied and refined frustrations. Good luck right back at cha. Thanks for stopping by.

BasedPhysics wrote.
I think your idea of abstracting out some of the logic into Python files so it doesn't have to be included in the notebook makes sense. Is this what you're trying to accomplish with the Particle classes.

Not sure what you mean, I don’t have any previous oop coding experience, although it just occurred to me that my first threejs coding project was copying threejs.birds and converting it to traveling and spinning rigid spheres colliding with other spheres and the walls of a transparent room, I called “Boids”. Sure acted like a particle class. Anyway, particle classes just seem so natural. Eventually I’d like to see all our particles in “real” motion. AB3 uses spin animations.

Static molecular displays are fine for starters. In my mind, the beauty of particle classes is that you can even add random particles and collisions. You just keep updating, advancing and monitoring the particle positions.

Particle types: electrons, protons, neutrons and photons. I suppose a particle class should include: a particle’s: type, radius, position, velocity, spin axis, spin velocity (etc. including spin types (A,X,Y,Z)(?)).

If electrons are overgrown photons then charge should be visible as individual photons at the atomic scale. Ideally we would need a photon class which would include photon’ type specifics. Particle classes, commonly used in today’s parlance usually refers to particle type clouds may make a fine photon particle class - a future goal.

Molecules and atoms are not particles, but they contain groups of particles. That means adding another class, call it a ParticleGroup class – assemblies of particles at a specific position, orientation, … .

Proton stack (or Slot). Slots consist of 1-6 pole-to-pole bonded protons (and electrons and neutrons) in accordance with Miles’ Diatomic Hydrogen paper. Slots are the project’s basic working unit and would also belong to the ParticleGroup class.

The atomic data, Cr6’s idea, identifies each (1-90) atom’s 1-19 slotlayout configuration. Each data row contains each occupied slot’s position and orientation, the number and positions of the particles within each slot as well as the slot’s TBRL (electron-position/proton-spin) configuration data. AB3 assembles the atoms it reads from the atomic data.

The next goal is to display molecules, each including anywhere from two to a hundred atoms. We want to show valid charge field bonding details involving all the particle types. A single molecular bond between two atoms may be just the close proximity and orientation of two adjacent slots, one from each atom; or the bond between two atoms may be a single merged/shared slot.

Those bonding details are provided in the molecular data files, also Cr6’s idea. The program needs to position each atom within the molecule accordingly.

That’s the overall plan as I imagine it. Your feedback would be appreciated.

Cr6, I saw – speed your work 55% with ChatGPT Engineer (or something similar) featured down on the GitHub opening page. There will be no escape.
.

Hi LTAM,

Thanks for the overview of how you see the project going. All of this makes sense to me. Trying to model individual photons might be extremely computationally intensive at the baryon scale (enormous number of particle motions/collisions to compute), so it might be wise to start with just modeling the charge field's effect on the larger particles. (Although with GPU acceleration it might be doable I'm not sure.) I think a worthy first goal for putting the particles in "real" motion would be to try to simulate a stable alpha particle with just the charge field/gravity effects.

The particle classes are definitely a good idea. I see the code being organized into three pieces which should be kept mostly separate --- general pythreejs code for building the UI/render, particle renderers/collision detection code, and particle classes/charge field logic. In this spirit, I left a PR that starts to abstract some of the rendering logic out of the main notebook into a separate file.

Ultimately, how do you see the project being used? If the final outcome is a python library that people import to render the atomic models, a Jupyter notebook makes sense to me. However, if we just want to publish a frontend to the web, it might make sense to think about using a web framework like Django. (or just a local gui framework like tkinter)

.

BasedPhysics wrote. 1. … just modeling the charge field's effect on the larger particles. (Although with GPU acceleration it might be doable I'm not sure.) I think a worthy first goal for putting the particles in "real" motion would be to try to simulate a stable alpha particle with just the charge field/gravity effects.

For our readers, here’s an example of a possible photon class charge stream that we might ‘attach’ to a proton, a ‘rocket engine’ particle class Cr6 posted on 6 Jun.
https://www.shanebrumback.com/threejs-examples/rocket-engine-particle-system.html
And this links to Shane's many other examples.
https://www.shanebrumback.com/links.html

Looks like that engine burns lots of fuel, creating lots of particles. Tailoring such emissions to mimic a single proton’s charge recycling may take multiple engines – is certainly too much to ask for any atom, let alone molecules. For me, an actual photon class for each particle, not to mention the ambient field - is a distant goal. For the time being I’ll be happy with a circular emission disc or emission cones as proton emission indicators. We may supplement those indicators with small (particle count) particle classes as Nevyn has done. However, proton emission indicators and small photon classes for each of the separate particles in a single alpha is certainly doable. I agree – a worthy first goal.

Demonstrating gravity however may be beyond the scope of a single alpha, just show how a stable alpha can form. I believe that model should also follow Miles’ Diatomic Hydrogen paper. Allowing a user to select different TBRL configurations and seeing how they interact would be interesting; might be like playing with magnets.
 

BasedPhysics wrote. Ultimately, how do you see the project being used? If the final outcome is a python library that people import to render the atomic models, a Jupyter notebook makes sense to me. However, if we just want to publish a frontend to the web, it might make sense to think about using a web framework like Django. (or just a local gui framework like tkinter)

A Jupyter Notebook that could display alphas, atoms and molecules would make a fine and complete molecule package; with your help key in greatly exceeding both Cr6’s and my own expectations. I hadn’t considered any follow-on notebook projects yet but I’d be happy to.

Making a frontend to the web sounds awesome but is something only you can decide. Please consider working another collaborative project or two, here or there, I’d be happy to be part of your development team, although your skills of course are beyond me.
.

.

Proof of past life. The BitBucket repositories I “currently” have access to.

Atomic, molecular, … . This Jupyter Notebook project. There’s plenty of discussion between me and Cr6 in the thread above to get a good idea of our thoughts and intentions and where we’re at. I try to keep myself occupied, but this project should belong to Cr6. It was his idea, such as why we went with jupyter notebook in the first place; its free and open source, largely used by white collar types likely more interested in the charge field. Skipping some details, big picture wise, I want graphic vistas of 3D molecules while Cr6 (I believe) prefers molecular ‘graphs’, as most all molecular diagrams used in the world are today. I think the autocad x, y, and z oriented slot labels might make an acceptable graph compromise(?). I believe Cr6’s imagines this Jupyter Notebook developing into a charge field based SQL Machine Learning app that could better account for various known atomic, chemical, physical and material properties.
     
Progress. Replaced Sourcetree. Uninstalled, then deleted remaining sourcetree files and sub-directories. Downloaded and reinstalled the current sourcetree version. Sourcetree is now waiting for links to repositories.

Old projects. I believe Nevyn mentioned them other day. During sourcetree’s install registration process bitbucket recognized me; had me make a new password and logged me in. Clicked on repositories and saw the image above. Looking at the dates its been almost three years since I've been there. These repositories, were hosted, launched and contributed to by Nevyn and he let me play and make changes to them, (thank you Sir). I can’t say I’m any sort of model student or learner, I can royally screw-up, (my apologies). I certainly enjoyed working on the projects at the time. I’ve already mentioned boids – which needs to have spin components added to the collisions. I don’t remember charged … . Scattering involves arrays of particle emitting ‘guns’, the important thing being the particle paths – based on ‘imaginative’ gun range configurations – but again, I think it lacks spin collisions. Threejs stuff. I’m most happy with pi4; that is, if it’s the version I’m thinking of. There’s a thread around the forum somewhere with lots of pictures. The only change I would make to pi4 is to eliminate parallel circular tracks, the ball in the circular track needs to travel along a single line as through a tube large enough for the ball to fit, as Steven Oostdijk did in his Pi = 4 experiment. I recall Miles thanking his luck, acknowledging that fact

Reviewing SSH. From Sourcetree, I clicked the tiny yellow “new message” flag, which contained a “welcome - get started” option. That ended up leading me to https://bitbucket.org/blog/ssh-host-key-changes - something about ssh key changes needing to be made by today. I read about ssh and got it started once, by golly, need to read up on ssh keys again next. Feel another catatonic fit coming

The GitHub repository. Just to be clear, for the time being I can log into GitHub in order to review or make changes to the project, but I cannot make any changes to the github repository from my machine. Not counting the possibility of using Bash or some other terminal based repository working app. I suppose they need proper SSH keys too. In anticipation of cloning the latest “ChargeField” from github, I renamed my machine’s “ChargeField” folder to “ChargeFieldOld”.

Please pardon the delay.
.

.


Quick update.

With plenty of effort and sure enough learning experiences along the way; starting with the Sourcetree reinstall, and a brand new GitHub generated SSH key, cloned the ChargeFieldTopics repo from GitHub to my machine. With everything as it was last week, after having merged basedphysics’  branch to the master. I’ve not yet caught up with those changes.

Wouldn’t you know I opened Jupyter Notebook and walked through three of the four ipynb files, then closed them and found five changes/pending-commits waiting for me in Sourcetree. The two py caches are something new. This time I did not dare delete them, but went ahead, committed and pushed them.

BasedPhysics, I mentioned the problem last time, and it occurs to me that you have it too(?). I don’t wish to be rude, but after the last couple of days, I must ask, any chance you have or might give any thought to improving the gitignore file?
.

Hey Guys,

I just uploaded an updated Physics database. It is smaller and has the older structures but I added several ETL style tables to build the final result table. There may still be bugs but the new procedure doesn't use the CanBind flag anymore and may have incorrect bonds formed.  

BTW, welcome BasedPhysics!

Old Links (disregard stored proc had a bug):
https://mega.nz/file/uk8mUDAB#Cae7YZEu0DFAQBX2PaY57JZWbsyE4LDDUy1Yt6l2yEk
https://mega.nz/file/39kAHRiR#ndZJOnqoUUVptjxDn0kNhbqqHdJ3f1tQk3rMmsptiRo

Current Link:
https://mega.nz/file/6wEAWBBL#zegKx9ZB8tiFG7vKU8mgdgK74BmIak1jAT8wsF4XBe4 (20230625v2.bak)

File Size is 700MBs. Added more molecules.

New table built from stored procedure: [dbo].[spBuildAtomicMilesMathisOrbitalsDetailAllBonds]
Takes about 20-40minutes to run. Doing more Loading-Transforming to Tables than pulling dynamically from Views.
SELECT * FROM
[Physics].[dbo].[AtomicMilesMathisOrbitalsDetailAllBonds]

.


Hi Cr6, I loaded ‘20230624Physics.bak’ in the

C:\Program Files\Microsoft SQL Server\MSSQL16.MSSQLSERVER\MSSQL\Backup
folder. From the Restore command options I selected ‘20230624Physics.bak’ as the backup, then did the restore and refresh.

I do not see the tables in your image, and the Query,
SELECT * FROM
[Physics].[dbo].[AtomicMilesMathisOrbitalsDetailAllBonds]

Is in error - the table name is an “invalid object name”

Am I doing something wrong? Do you see any option error or other from the two images?

/////\\\\\/////\\\\\/////\\\\\

Having just logged in to post the above - I see '20230624Physics.bak' is bad.

Ok, I downloaded the second "current" 726M, 20230624PhysicsVersion2.bak file.

I'll attempt to restore Physics to it tomorrow.
.