https://community.wolfram.com RSS Feed for Wolfram Community showing ideas tagged with Material Sciences sorted by most likes. https://community.wolfram.com/groups/-/m/t/787142 ## General information and download links ## If you're interested in crystal structures, you can now download the Crystallica application from the Wolfram Library Archive, and then you can do things like this: Needs["Crystallica`"]; CrystalPlot[ {{5.4,0,0},{0,5.4,0},{0,0,5.4}}, {{0,0,0},{0,0,.5},{0,.5,0},{.5,0,0},{.24,.24,.24},{.24,.76,.76},{.76,.24,.76},{.76,.76,.24}}, {1,2,2,2,3,3,3,3}, AtomCol->{"Firebrick","YellowGreen",White},AtomRad->.4, BondStyle->2,BondDist->3, CellLineStyle->False,AddQ->True,Lighting->{{"Directional",White,ImageScaled[{0,0,1}]}},Background->Black] ![enter image description here][1] Here are the download links for Crystallica and two other packages you may need: [Crystallica][2] - contains the functions `CrystalPlot` and `CrystalChange` [CifImport][3] - contains an import function for CIF files [VaspImport][4] - contains an import function for files related to [VASP][5] Once you've installed Crystallica (by saving the entire Crystallica folder - not the zip archive - to `$USerBaseDirectory/Applications` and re-starting the Kernel), you can enter Crystallica into the Documentation Center and you'll find lots of useful examples. Most of the examples in this post are taken from the Documentation. For the other two packages, just install them and evaluate this: ?CifImport ?VaspImport I'll first show you a few things the `CrystalPlot` function can do when you already have crystal structure data inside Mathematica, wherever it may have come from. Then we'll take a look at how to get the data into Mathematica in the first place, which is where `CifImport` and `VaspImport` will come into play - but we'll get data from other sources as well. I'll cover the different import solutions in separate replies to this thread, because I have a feeling that I'll be rambling on and on and on... ## Simple plot ## Traditional ball-and-stick plots are usually just fine, so the simplest thing you can do is this: CrystalPlot[ {{4.5,0,0},{0,4.5,0},{0,0,3}}, {{0,0,0},{.5,.5,.5},{.2,.8,.5},{.3,.3,0},{.7,.7,0},{.8,.2,.5}}, {1,1,2,2,2,2}] ![enter image description here][6] As you can see, `CrystalPlot` expects three arguments. The first one contains the lattice vectors, which are simply the three vectors that create the parallelepiped that constitutes the cell. The second argument contains the atomic coordinates, but they're given in the basis of the lattice vectors (which is quite useful in crystallography). The third argument is a list of integers that gives the atom types, with one entry for each atom. If you want to plot a molecule instead, you can call `CrystalPlot` with just two arguments: A list of atom coordinates in cartesian space, and a list of atom types. Everything else you see in the plot - the atoms, bonds, colours, arrows etc. - represents the default settings of various layout options. ## Advanced atoms and bonds ## Let's take a look at some more advanced options just for fun. For instance, atoms and bonds can look any way you need them to, because you can specify your own functions for them. You can also fine-tune where to put bonds and what to do with their thickness and colour in a physically (or chemically) meaningful way, but I won't show that here. So here are some customized atoms and bonds: Row[Table[ CrystalPlot[{{4,0,0},{0,4,0},{0,0,4}},{{0,0,0},{.4,.4,.4},{.8,.8,.8}},{1,2,3}, AtomRad->{.4,1.2,.7},AtomFunction->style,ImageSize->400], {style,{ (Ball[#1,#2]&), (Scale[Sphere[#1,#2],{1,1,.5}]&), ({EdgeForm[Thick],Opacity[.7],Cuboid[#1-.5*#2,#1+.5*#2]}&) }}]] ![enter image description here][7] Row[Table[ CrystalPlot[{{0,0,0},{5,0,0},{2.5,4,0}},{1,2,3},BondDist->6,BondStyle->style,ImageSize->400], {style,{ 1, Function[{bonds,partcol},Table[{If[ii<.5,partcol[#,1],partcol[#,2]],Sphere[bonds[[#,1]]+ii*(bonds[[#,2]]-bonds[[#,1]]),.15]},{ii,0,1,1/9}]&/@Range[Length[bonds]]], Function[{bonds,partcol},Module[{spiral,points,rad=.05}, spiral[atoms_]:=Module[{scale=.5,dist=atoms[[2]]-atoms[[1]],curls=60,normal,rot,scaled}, normal=Table[{scale*Cos[ii],scale*Sin[ii],.1*ii},{ii,0,curls,\[Pi]/10}]; scaled={#[[1]],#[[2]],10*Norm[dist]/curls*#[[3]]}&/@normal; rot=scaled.Quiet[RotationMatrix[{dist,{0,0,1}}]]; Join[{atoms[[1]]},#+atoms[[1]]&/@(rot[[25;;-25]]),{atoms[[2]]}]]; points=spiral/@bonds; {partcol[#,1],Tube[BSplineCurve[points[[#,;;Round[Length[points[[#]]]/2]]],rad]],partcol[#,2],Tube[BSplineCurve[points[[#,Round[Length[points[[#]]]/2];;]],rad]]}&/@Range[Length[bonds]] ]] }}]] ![enter image description here][8] ## Lattice planes ## Crystallica can also add lattice planes to the plot. You can specify them using [h,k,l] Miller indices and distance to the origin. CrystalPlot[{{3,0,0},{0,3,0},{0,0,3}},{{0,0,0}},{1}, AddQ->True,AtomRad->.3,AtomCol->"CadmiumYellow",Sysdim->2,CellLineStyle->2, LatticePlanes->Table[{{1,1,1},dist},{dist,1,5}],ContourStyle->{"TerreVerte",Opacity[.7]},BoundaryStyle->Thick] ![enter image description here][9] ## Coordination polyhedra ## You can automatically search for and plot coordination polyhedra. This is not limited to the commonly occurring tetrahedra and octahedra - you can actually look for polyhedra with arbitrary numbers of corners. There are also options to fine-tune both the searching and the rendering. plot[corners_,mixed_]:=CrystalPlot[{{0,0,0},{0,0,1.8},{-.9,-1.5,-.6},{-.9,1.5,-.6},{1.7,0,-.6},{.8,.8,.8}},{1,2,2,2,2,3}, BondStyle->False,ImageSize->250, PolyMode[corners]->{"Show"->All,"AllowMixed"->mixed},PolyStyle[corners]->Directive[Opacity[.5],EdgeForm[Thick]]]; Grid[{{ "", "Search for polyhedra with \n4 corners", "Search for polyhedra with \n5 corners" },{ "Allow \nmixed corners", plot[4,True], plot[5,True] },{ "Don't allow \nmixed corners", plot[4,False], plot[5,False] }},Dividers->All] ![enter image description here][10] CrystalPlot[{{2.5,-4.3,0},{2.5,4.3,0},{0,0,5.5}}, {{.5,0,0},{0,.5,.7},{.5,.5,.3},{.2,.4,.5},{.6,.8,.2},{.2,.8,.8},{.8,.6,.5},{.4,.2,.2},{.8,.2,.8}},{1,1,1,2,2,2,2,2,2}, PolyMode[4]->True,PolyStyle[4]->EdgeForm[None],AddQ->True, Sysdim->2,AtomRad->0,CellLineStyle->False,AtomCol->{"SlateGray","Firebrick"}, ViewAngle->.4,ViewPoint->{3.2,0,1.1},ViewVertical->{.5,0,1.2}] ![enter image description here][11] ## Other things ## Visualization aside, you can also build supercells, change cell shapes, or add, remove and sort atoms... but that's a bit boring to read, so I'll refer you to the Documentation page of the `CrystalChange` function instead. If you're interested, we can use this thread to talk about any questions you may have, or you can share your use of the package (if you decide to use it). I'm not offering full support here, but I'll be floating around, and I'd like to hear your feedback. We don't have any intentions to be involved in further development. But if you have a good idea and some time, then by all means, work on it for yourself, or host it on your favourite code collaboration site. Bianca Eifert and Christian Heiliger [1]: http://community.wolfram.com//c/portal/getImageAttachment?filename=teaser.png&userId=69107 [2]: http://library.wolfram.com/infocenter/MathSource/9372/ [3]: http://library.wolfram.com/infocenter/MathSource/9373/ [4]: http://library.wolfram.com/infocenter/MathSource/9375/ [5]: http://vasp.at/ [6]: http://community.wolfram.com//c/portal/getImageAttachment?filename=9692simple.png&userId=69107 [7]: http://community.wolfram.com//c/portal/getImageAttachment?filename=atoms.png&userId=69107 [8]: http://community.wolfram.com//c/portal/getImageAttachment?filename=bonds.png&userId=69107 [9]: http://community.wolfram.com//c/portal/getImageAttachment?filename=planes.png&userId=69107 [10]: http://community.wolfram.com//c/portal/getImageAttachment?filename=polys.png&userId=69107 [11]: http://community.wolfram.com//c/portal/getImageAttachment?filename=polys2.png&userId=69107 [12]: http://rruff.geo.arizona.edu/AMS/CIF_text_files/13532_cif.txt [13]: http://cms.mpi.univie.ac.at/vasp/vasp/POSCAR_file.html [14]: http://wiki.jmol.org/index.php/File:Caffeine.mol Bianca Eifert 2016-02-05T18:43:18Z https://community.wolfram.com/groups/-/m/t/2027803 ![Examples of 3D Lattices and CA on them][1] &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=imgleading.jpg&userId=1971688 [2]: https://www.wolframcloud.com/obj/b5a12940-5871-4006-b168-745737090965 Radhika Prasad 2020-07-14T11:43:23Z https://community.wolfram.com/groups/-/m/t/3501343 ![Interlocked: computational chainmail engineering][1] &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Screenshot2025-07-10at4.03.37%E2%80%AFPM.png&userId=3489769 [2]: https://www.wolframcloud.com/obj/05eb3d4b-bac8-468c-be6f-952fb37a1284 Rakhi Jain 2025-07-10T20:08:50Z https://community.wolfram.com/groups/-/m/t/2305648 ![enter image description here][1] Hello All, (I have set Independence Day (Observed) as my pencils-down moment to publicize a Wolfram Language/Mathematica package for performing computations and visualizing results from Quantum Theory of Atoms In Molecules (QTAIM) calculations on electronic structure theory wave functions. QTAIM endeavors the answer the question, "Are there discernable atoms inside of molecules?" The answer according to Bader and co-workers is yes, if you define an atom as the basin/union of all steepest ascent paths and a nucleus, which is the attractor. Since there is zero-flux between these regions, they are proper quantum subsystems, just like the molecule/crystal is. Here is the water molecule (H2O) in this representation: ![Atomic Basins][2] What motivated me to get going on creating a package was the new SliceVectorPlot3D routines, which make plotting these quantities a dream: ![Gradient Field on Planes of Symmetr][3] The code is hosted here: https://github.com/ecbrown/QTAIM.wl which has this code and more extensive discussion. Wolfram Language/Mathematica is great for this. Great algorithms like ABM differential equation solver, and excellent graphics for 2D/3D fields. I t features several ways to get data in, so it can be file-based or scripted from PySCF. Well, I should keep it brief, and I look forward to any comments you have. Best regards, Eric An overview of the methods and results can be found here: &[Wolfram Notebook][4] [DON'T DELETE: Original notebook]: https://www.wolframcloud.com/obj/c70b8f04-b2fd-45f1-9077-f9827fe82357 [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=QTAIM_hero.jpg&userId=20103 [2]: https://community.wolfram.com//c/portal/getImageAttachment?filename=7578atoms-are-defined-as-the-union-of-gradient-paths-and-attractor.png&userId=62741 [3]: https://community.wolfram.com//c/portal/getImageAttachment?filename=stream-plot-3d-of-electron-density-gradient-of-water.png&userId=62741 [4]: https://www.wolframcloud.com/obj/71988d27-d090-4df4-84b6-ec3fd7564308 Eric Brown 2021-07-05T17:39:53Z https://community.wolfram.com/groups/-/m/t/2415323 *WOLFRAM MATERIALS for the ARTICLE:* > Fraternali, F., Singh, N., Amendola, A., Benzoni, G., Milton, G.W. > A biomimetic sliding-stretching approach to seismic isolation. > NONLINEAR DYNAMICS (2021), DOI: https://doi.org/10.1007/s11071-021-06980-5 > NATURE, Research Highlights: https://www.nature.com/articles/d41586-021-03506-2 > [Full article in PDF][1] ![enter image description here][2] &[Wolfram Notebook][3] [1]: https://link.springer.com/content/pdf/10.1007/s11071-021-06980-5.pdf [2]: https://community.wolfram.com//c/portal/getImageAttachment?filename=d41586-021-03506-2_19896092.gif&userId=20103 [3]: https://www.wolframcloud.com/obj/e97c56e0-8896-44ef-aa0c-ab291da4c73d Fernando Fraternali 2021-11-29T18:52:25Z https://community.wolfram.com/groups/-/m/t/828033 You may remember that I've already posted [packages for crystal structure plots][1]. I just wanted to dump a piece of code here that's based on these packages and will let you plot crystal structures from [VASP][2] input/output files on a webpage... in case anyone else is using VASP. For anyone who wants to try the app but doesn't have a VASP file handy, here's a sample you can copy and paste into a plain text file: Rutile 1.00000000000000 4.5937300000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 4.5937300000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 2.9581200000000000 Ti O 2 4 Direct 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.5000000000000000 0.5000000000000000 0.5000000000000000 0.3053000000000000 0.3053000000000000 0.0000000000000000 0.6947000000000000 0.6947000000000000 0.0000000000000000 0.8053000000000000 0.1947000000000000 0.5000000000000000 0.1947000000000000 0.8053000000000000 0.5000000000000000 The actual code is below the image. Have fun! ![enter image description here][3] CloudDeploy[FormFunction[{ {{"file", "Upload a VASP POSCAR or CONTCAR file here:"} -> <| "Interpreter" -> "UploadedFile"|>}, { {"sysdim", "Periodic repetitions"} -> <| "Interpreter" -> Restricted[ DelimitedSequence["Integer", " " | "," | ";" | "/" | "x" | "X"], 3], "Input" -> "1x1x1"|>, {"retractq", "Retract atoms to cell?"} -> <| "Interpreter" -> "Boolean", "Input" -> False|>, {"addq", "Add periodic duplicates of atoms?"} -> <| "Interpreter" -> "Boolean", "Input" -> False|>, {"atomrad", "Atom radius"} -> <|"Interpreter" -> "ComputedReal", "Input" -> 0.4|>, {"bonddist", "Maximum bond length"} -> <| "Interpreter" -> "ComputedReal", "Input" -> 2.1|>, {"monobond", "Want to pick your own bond color?"} -> <| "Interpreter" -> "Boolean", "Input" -> False|>, {"bondcol", "Bond color"} -> <|"Interpreter" -> "ComputedColor", "Input" -> GrayLevel[.8]|>, {"bondrad", "Bond radius"} -> <|"Interpreter" -> "ComputedReal", "Input" -> 0.1|>, {"linecol", "Cell outline color"} -> <| "Interpreter" -> "ComputedColor", "Input" -> Black|>, {"linerad", "Cell outline radius"} -> <| "Interpreter" -> "ComputedReal", "Input" -> 0.02|> }}, Module[{file, sysdim, retractq, addq, atomrad, bonddist, monobond, bondcol, bondrad, linecol, linerad, data, speciesQ, atomcol, chemoffset, chgoffset, lattscale, lattvec, coord, conf, coordP, confP, new, tubearrow, lines, atoms, tuples, bonds}, file = #file; sysdim = #sysdim; retractq = #retractq; addq = #addq; atomrad = #atomrad; bonddist = #bonddist; monobond = #monobond; bondcol = #bondcol; bondrad = #bondrad; linecol = #linecol; linerad = #linerad; (*import: *) data = Import[file, "Table"]; (*offset if chemical species are given: *) speciesQ = MatchQ[data[[6]], {_String ..}]; atomcol[type_] := If[speciesQ, ColorData["Atoms", data[[6, type]]], ColorData[97, type]]; chemoffset = If[speciesQ, 1, 0]; (*offset for missing "Selective Dynamics" line as is common in \ CHG/CHGCAR: *) chgoffset = If[TrueQ[Length[data[[chemoffset + 8]]] > 0] && MatchQ[data[[chemoffset + 8, 1]], _?NumericQ], -1, 0]; (*lattice vectors and atoms: *) lattvec = data[[3 ;; 5]]; lattscale = data[[2]]; If[TrueQ[Length[lattscale] == 1], lattscale = lattscale[[1]]]; If[TrueQ[Sign[lattscale] == -1], lattscale = (-lattscale/Det[lattvec])^(1/3)]; lattvec = If[TrueQ[Length[lattscale] == 3], N[lattscale[[#]]*lattvec[[#]]] & /@ Range[3], N[lattscale*lattvec]]; conf = Flatten[Join[ ConstantArray[#, data[[chemoffset + 6, #]]] & /@ Range[Length[data[[chemoffset + 6]]]]]]; coord = N[data[[chemoffset + chgoffset + 9 ;; (chemoffset + chgoffset + 8 + Total[data[[chemoffset + 6]]]), 1 ;; 3]]]; (*reprojection for cartesian coordinates: *) If[TrueQ[Length[data[[chemoffset + chgoffset + 8]]] > 0] && StringMatchQ[ToString[data[[chemoffset + chgoffset + 8, 1]]], "c*" | "k*", IgnoreCase -> True], If[TrueQ[Length[lattscale] == 3], coord = #*lattscale & /@ coord, coord = coord*lattscale]; coord = coord.Inverse[lattvec]]; {coordP, confP} = {coord, conf}; (*retraction, moving all atoms back into the cell: *) If[retractq, With[{retracttol = 10^-4}, coordP = Partition[ If[# > (1 - retracttol), # - 1, #] & /@ Flatten[# - Floor[#] & /@ coordP], 3]; new = DeleteDuplicates[Transpose[{coordP, confP}], (Norm[ Round[#1[[1]], retracttol] - Round[#2[[1]], retracttol] - Floor[Round[#1[[1]], retracttol]] + Floor[Round[#2[[1]], retracttol]]] < retracttol) && (#1[[2]] == #2[[2]]) &]; {coordP, confP} = Transpose[new]]]; (*periodic repetition: *) coordP = Flatten[Table[(# + {a, b, c}) & /@ coordP, {a, 0, sysdim[[1]] - 1}, {b, 0, sysdim[[2]] - 1}, {c, 0, sysdim[[3]] - 1}], 3]; confP = Flatten[ConstantArray[confP, Times @@ sysdim]]; (*add peridic duplicates if desired: *) If[TrueQ[addq], new = Transpose[{coordP, confP}]; new = Join[new, # + {{sysdim[[1]], 0, 0}, 0} & /@ Select[new, Abs[#[[1, 1]]] < 0.01 &], # + {{-sysdim[[1]], 0, 0}, 0} & /@ Select[new, Abs[#[[1, 1]]] > 0.99*sysdim[[1]] &]]; new = Join[new, # + {{0, sysdim[[2]], 0}, 0} & /@ Select[new, Abs[#[[1, 2]]] < 0.01 &], # + {{0, -sysdim[[2]], 0}, 0} & /@ Select[new, Abs[#[[1, 2]]] > 0.99*sysdim[[2]] &]]; new = Join[new, # + {{0, 0, sysdim[[3]]}, 0} & /@ Select[new, Abs[#[[1, 3]]] < 0.01 &], # + {{0, 0, -sysdim[[3]]}, 0} & /@ Select[new, Abs[#[[1, 3]]] > 0.99*sysdim[[3]] &]]; {coordP, confP} = Transpose[new]; ]; (*cell lines: *) tubearrow[{tail_, head_}] := With[{scale = .5*Sqrt[Mean[Norm /@ lattvec]*linerad]}, Tube[{tail, head - 4*scale*Normalize[head - tail], head - 4*scale*Normalize[head - tail], head}, {linerad, linerad, scale, 0}]]; lines = {linecol, Tube[#.lattvec, linerad] & /@ { {{0, 0, #}, {1, 0, #}, {1, 1, #}, {0, 1, #}, {0, 0, #}} & /@ {0, 1}, {{0, 0, #} & /@ {0, 1}, {1, 0, #} & /@ {0, 1}, {1, 1, #} & /@ {0, 1}, {0, 1, #} & /@ {0, 1}} }, tubearrow[{{0, 0, 0}, #}] & /@ lattvec}; (*atoms: *) atoms = Tooltip[{atomcol[confP[[#]]], Sphere[coordP[[#]].lattvec, atomrad]}, #] & /@ Range[Length[confP]]; (*bonds: *) tuples = Select[Subsets[Range[Length[confP]], {2}], Norm[(coordP[[#]].lattvec)[[1]] - (coordP[[#]].lattvec)[[2]]] < bonddist &]; bonds = If[TrueQ[tuples == {}], {}, If[monobond, {bondcol, Tube[coordP[[#]].lattvec, bondrad]}, Table[{atomcol[confP[[#[[ii]]]]], Tube[{coordP[[#[[ii]]]].lattvec, Total[coordP[[#]].lattvec]*.5}, bondrad]}, {ii, 1, 2}] ] & /@ tuples]; (*return the plot: *) Graphics3D[{lines, bonds, atoms}, ImageSize -> Large, BaseStyle -> {Specularity[Gray, 100]}, Boxed -> False, SphericalRegion -> True, Lighting -> "Neutral"] ] &, "PNG", AppearanceRules -> <| "Title" -> "Crystal Structure Viewer for VASP"|>], Permissions -> "Public"] [at0]: http://community.wolfram.com/web/chrishaydock137 [1]: http://community.wolfram.com/groups/-/m/t/787142 [2]: http://vasp.at/ [3]: http://community.wolfram.com//c/portal/getImageAttachment?filename=sdf4562y4thrwbdfva.gif&userId=11733 Bianca Eifert 2016-03-23T08:59:33Z https://community.wolfram.com/groups/-/m/t/2062346 ![enter image description here][1] &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Sathvik.gif&userId=2024676 [2]: https://www.wolframcloud.com/obj/588b63ed-2065-42f6-8250-16f837ea767b Sathvik Ajay Iyengar 2020-08-20T15:37:32Z https://community.wolfram.com/groups/-/m/t/2388782 *SUPPLEMENTARY WOLFRAM MATERIALS for the ARTICLE:* > Itay Griniasty, Cyrus Mostajeran, and Itai Cohen, (2021). > Multivalued Inverse Design: Multiple Surface Geometries from One Flat Sheet. > PHYSICAL REVIEW LETTERS **127**, 128001. > https://doi.org/10.1103/PhysRevLett.127.128001 ![enter image description here][1] &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Surfaces_hero3.jpg&userId=20103 [2]: https://www.wolframcloud.com/obj/fa2fd8f8-dcce-4d74-9edd-25d208d78813 Itay Griniasty 2021-10-19T19:36:14Z https://community.wolfram.com/groups/-/m/t/1374495 My WSS project is to study packing of Bidisperse circles, i.e., circles of 2 different radii. To do so, I implemented the [Lubachevsky-Stillinger algorithm][1] with an Event Driven approach, based on the algorithmic details [here][2] and [here][3], and the C++ implementation [here][4]. As for a heuristic algorithmic description, check out this gif: ![Cool Packing Gif][5] The disks are randomly initialized, and grow with time while colliding and bouncing around. Collisions are processed, new events are computed, and the simulation progresses until jamming (or a event error is flagged and the simulation aborts). As for the implementation, I segmented it into 9 sections: Constraints, Initialization, Cell Method, Augmented MinHeap, Collisions, Transfers, Procedure, Visualization and Analysis. Each section has its own functions and description (43 functions total!), and I'll try to explain some of them here (I won't comment on Constraints because they are quite straightforward, nor the MinHeap, because it will get its own [post][6]). ##Initialization Here is where the initial radii, positions and velocities are defined. The initial positions need to satisfy the constraint functions, and to place another circle entails not overlapping any of the previously input circles, nor the square boundary. The function to do so is createDisk, below. It randomly tries circle coordinates, given a partial list of coordinates (circles) and a full list of radii (radii) which define the constraints. createDisk[circles_List,radii_List, size_]:=Module[ {cnumber=circles//Length, position, riffled, count=0, insert=False, rc, r}, (*splice radii list, select next radius, riffle coordinates and radii for constraint functions*) rc=radii[[;;cnumber]]; r=radii[[cnumber+1]]; riffled=Riffle[circles,rc]//Partition[#, 2]&; (*testing loop*) While[ (*stop when inserted or overcount*) And[count<200, !insert ], (*randomly try next coordinate*) position=RandomReal[{0, size}, 2]; (*if doesn't overlap border or overlap anyother circle*) If[And[ borderC[position,r], And@@(overlapC[{position, r}, #]&/@riffled) ], insert=True]; count=count+1; ]; If[count==200, Print["fail"]]; position ] ![createDisks][7] Nested application of createDisk. ## Cell Method Eventually, we will need to calculate the next collision time for some particle *i* . The easiest way to do so would be to calculate the times for all particles and take the minimum, but that would be computationally expensive for many body systems. Instead, I implemented *the Cell Method*, essentially segmenting the space into a grid, and placing each particle into bins (stored with a Matrix/Association pair). Now, instead of iterating over all particles to find the minimum collision time, just look at the particles in the neighboring bins. The functions below are 2 of the most important for this method: nearestCells and updateCell. ###nearestCells nearestCells takes a list of coordinates, number of rows and size and returns a matrix *(rows, rows)* of lists, where cellMatrix[[i, j]] stores the particle indices in that bin. nearestCells[coordinates_, nrows_, size_]:= Module[ {nf=Nearest[coordinates->Range@Length@coordinates, DistanceFunction->ChessboardDistance]}, nf[binCenters[nrows, size], {Infinity, size/(2 nrows)}] ] Where binCenters[nrows, size] returns a list of grid center coordinates. The visual representation: ![nearestCells in action][8] ###updateCell As the disks move around, inevitably they will *transfer* between bins, and the correspondent *cellMatrix* (result of function above) and *cellA* (association mapping particle index to bin index pair) have to be updated. updateCell does exactly that: updateCell[i_, newcell_] := Module[{currentk, currentj, oldk, oldj}, (*initialize variables*) {currentk, currentj} = newcell; {oldk, oldj} = cellA[i]; (*delete and reinsert element from cellMat*) cellMatrix[[oldk, oldj]] = Select[cellMatrix[[oldk, oldj]], # != i &] AppendTo[cellMatrix[[currentk, currentj]], i]; (*reset element in association*) cellA[i] = {currentk, currentj}; ] ##Collisions Here is where I implemented all collision-related functions: calculateCollision, predictCollision, findNextCollision, collisionCheck and processCollision. The first 3 are related to calculating the next collision for particle *i*, the 4^th enforces the collision is valid and symmetric (if *i* collides with *j*, *j* has to collide with *i*) and the last processes a collision *event*, through conservation of momentum. Here, *events* are parametrized by triples: *{te, i, p}*: *te* is the time of the event, *i* is the particle index, and *p_Integer* the event partner: if 0 < p < N+1, the event is a collision with particle *p*. Take a look at the 2 most important of them: ### calculateCollision This function calculates the collision time, if it exists (else, infinity). Additionally, this function aborts the program if there is considerable overlap between particles, and prints an error statement. calculateCollision[i_, j_]:= Module[ {nRi, nRj, d, \[Sigma], \[CapitalDelta]R, \[CapitalDelta]V, A, B, C, t}, (*sets positions and radii to current time*) nRi=positions[[i]]+(gtime-lastupdates[[i]])velocities[[i]]; nRj=positions[[j]]+(gtime-lastupdates[[j]])velocities[[j]]; \[Sigma]=(radii[[i]]+radii[[j]])^2; (*define helper variables*) \[CapitalDelta]R=nRi-nRj; \[CapitalDelta]V=velocities[[i]]-velocities[[j]]; A=\[CapitalDelta]V.\[CapitalDelta]V-rate^2 \[Sigma]; B=\[CapitalDelta]V.\[CapitalDelta]R-rate(1+rate gtime)\[Sigma]; C=\[CapitalDelta]R.\[CapitalDelta]R-\[Sigma] (1+rate gtime)^2; d=B^2-A C; (*debugging tests*) If[C<-10^(-2)(radii[[i]]+radii[[j]])(1+gtime rate), Print["After ", totalevents, " events, overlap."]; Abort[]]; (*calculate time*) Which[ C <-10^(-4)(radii[[i]]+radii[[j]])(1+gtime rate) && B < 0, Print["spheres are already overlapping ", C]; Infinity, d <= 0, Infinity, True, -(B+Sqrt[d])/(A) ] ] ###collisionCheck collisionCheck enforces collisions are symmetric, as well as updating *p*'s event partner's events if necessary (see Procedure section for further details): collisionCheck[collision_] := Module[ {tc, i, j, symcol, k, n = nextevents // Length, ek}, {tc, i, j} = collision; symcol = {tc, j, i}; k = nextevents[[j]][[3]]; (*j cannot have event before colliding with i*) If[tc > nextevents[[j]][[1]], Print["big mistake"]; Abort[]]; (*if j's next event was collision, give k a check*) If[(k <= n) && (k != i) && (k >= 1), ek = nextevents[[k]]; nextevents[[k]] = {ek[[1]], k, Infinity};]; (*set symmetric collision as j's next event*) nextevents[[j]] = symcol; (*update Heap*) decreaseKey[j, tc]; ] Ignore the heap stuff for now, I'll explain in a bit. ## Transfers This section is related specifically to *transfers*: events corresponding to movement between cell walls. Each transfer event can be parametrized using the same triples, now, with *N < p < N+5*, where *p-N* indicates the specific cell wall: 1 for the right wall, 2 for the left, 3 for the top, 4 for the bottom. There are 2 functions in this section: findNextTransfer and processTransfer. The second is quite straightforward, and is basically a set of Which cases and updateCell calls. findNextTransfer, however, is just slightly more elaborated. ###findNextTransfer This function is also a set of Which cases, for each direction (1,2, 3 or 4), now considering radii growth if colliding with a hard boundary. See below: findNextTransfer[i_]:= Module[ {r, rx, ry, vx, vy, wallindex, binindex, bincenter, step=size/nrows, times=Table[Infinity, {4}]}, (*set positions, set velocities, set radius*) r = radii[[i]]; {rx, ry} = positions[[i]] + velocities[[i]](gtime-lastupdates[[i]]); {vx, vy} = velocities[[i]]; (*obtain bin position*) binindex = cellA[i]; bincenter = step(binindex - {1,1}/2); (*consider x axis*) Which[ vx>0 && binindex[[1]]!=nrows, times[[1]]=(bincenter[[1]]+step/2-rx)/vx;, vx >0 && binindex[[1]] == nrows, times[[1]]=(bincenter[[1]]+step/2-rx-r(1 + gtime rate))/(vx+rate radii[[i]]);, vx<0 && binindex[[1]]!=1, times[[2]]=(bincenter[[1]]-step/2-rx)/vx;, vx <0 && binindex[[1]]==1, times[[2]]=(bincenter[[1]]-step/2-rx+r(1+gtime rate))/(vx-rate radii[[i]]); ]; (*consider y axis*) Which[ vy>0 && binindex[[2]]!=nrows, times[[3]]=(bincenter[[2]]+step/2-ry)/vy;, vy>0 && binindex[[2]] == nrows, times[[3]]=(bincenter[[2]]+step/2-ry-r(1+gtime rate))/(vy+rate radii[[i]]);, vy<0 && binindex[[2]]!=1, times[[4]]=(bincenter[[2]]-step/2-ry)/vy;, vy<0 && binindex[[2]]==1, times[[4]]=(bincenter[[2]]-step/2-ry+r(1+gtime rate))/(vy-rate radii[[i]]); ]; wallindex = Ordering[times][[1]]; (*debugging statement*) If[!(And@@Positive@times), Print["negative time", times, binindex]; Print@borderC[{rx, ry}, r(1+gtime rate)]; Abort[]]; (*return event*) {Min[times]+gtime, i, n+ wallindex} ] ##Procedure This section is where the previous sections come together. This section includes findNextEvent, ProcessEvent, and synchronize, as well as Process, which puts everything together. The first calls findNextTransfer and findNextCollision, and returns the event of lowest start time (with some complications). The second extracts the next event from the *heap*, processes the event, and calls findNextEvent on the particle in question and reinserts the new event into the *heap*. Here, it is worth commenting on how the events are stored overall: a *augmented min-heap* stores tuples *{te, i}*, indicating the time *te* of particle *i*'s next event. A list *nextevents* stores these events, where *nextevents[[i]]* is a event triple . This allows events to be inserted and the minimum time event obtained in a relatively fast time (O(*log n*) complexity for those operations, as well as lookup in O(1) with a association on top). Now, let us take a look at these functions: ###findNextEvent In addition to the explanation above, findNextEvent has to account for and return an extra possibilities: In case particle *i* has outgrown it's own bin size, or will do so before the next collision or transfer, a *p=-Infinity* flag is set as the event partner to be processed later. findNextEvent[i_] := Module[ {outgrowtime, step = size/(nrows), t, c, event,r}, r= radii[[i]]; outgrowtime = gtime+(step/2 - r(1+gtime rate))/(rate r); If[outgrowtime < 0, outgrowtime = 0]; (*obtain transfer and collision events*) t = findNextTransfer[i]; c = findNextCollision[i]; Which[ (*outgrow event*) (outgrowtime < c[[1]]) && (outgrowtime < t[[1]]) && (nrows > 1), event = {outgrowtime, i, -Infinity};, (*next event is collision*) (c[[1]] < t[[1]]), collisionCheck[c]; event = c;, (*next event is transfer*) (t[[1]] <= c[[1]]), event = t; ]; event ] ###processEvent This function processes exactly 1 event, outputting it from the heap and accessing it using nextevents. Then, the event is processed, and the next event for that particle is calculated, and inserted into the heap. Counters are set to sample data as the simulation progresses. If the event is a *check* (parametrized by *p=Infinity*), there is nothing to process and just obtain the next event. Moreover, if the event is an outgrowth (p=-Infinity), rescale the system, update the Cells (ChangeBins) and recommence the simulation. processEvent := Module[ {te, i, j, nextevent, cevent}, (*increment counter, store data*) nevents++; If[Divisible[nevents, Ceiling[steps/20]], dataStore[]]; (*extract event from heap, initialize event variables*) {te, i} = obtainMin[heap]; j = nextevents[[i]][[3]]; cevent = nextevents[[i]]; (*Divide into event cases*) Which[ (*event is a collision*) (j >= 1) && (j <= n), (*process collision*) ncollisions = ncollisions + 1; processCollision[{te, i, j}]; (*make sure event was symmetric and check j*) If[ (nextevents[[j]][[3]] != i) || (nextevents[[j]][[1]] != gtime), Print["Events not symmetric", cevent, nextevents, gtime]; Abort[], nextevents[[j]][[3]] = Infinity; ]; (*set next event*) nextevent = findNextEvent[i]; nextevents[[i]] = nextevent; increaseKey[i, nextevent[[1]]]; If[te >= nextevent[[1]], Print["collision event time error"]]; , (*event is a transfer*) (j > n) && (j < n + 5), (*process transfer*) ntrans = ntrans + 1; processTransfer[{te, i, j}]; (*set next event*) nextevent = findNextEvent[i]; nextevents[[i]] = nextevent; increaseKey[i, nextevent[[1]]]; If[te >= nextevent[[1]], Print["transfer event error", cevent, nextevent]; Abort[]]; , (*event is a check*) j == Infinity, (*process check*) nchecks = nchecks + 1; (*set next event*) nextevent = findNextEvent[i]; nextevents[[i]] = nextevent; increaseKey[i, nextevent[[1]]]; If[te > nextevent[[1]] && nextevent[[3]]!= -Infinity, Print["check event error", cevent, nextevent]; ]; , (*disk outgrew cell, decrease nrows*) j == - Infinity, (*synchronize system*) gtime = te; synchronize[False]; nrows = nrows - 1; (*need to resize system and update parameters*) changeBins[nrows]; setInitialEvents[n]; Process[steps]; ]; ]; ![step 1][9] ![step2][10] Look at the bottom particle colliding with the wall! ##Visualization Here, I built a visualization function to display circles of different radii using Riffle. A couple results have already been shown above. ###displayParticles displayParticles[positions_, radii_, size_]:= Module[ {rifflelist, border, borderg}, border = Line@{{0,0}, {0, size}, {size, size}, {size, 0}, {0 ,0}}; borderg = Graphics[{Thick, Red, border}]; rifflelist = Riffle[positions, radii]//Partition[#, 2]&; Show[Graphics[{Disk[#[[1]], #[[2]]]&/@rifflelist}], borderg] ] ##Analysis Finally, a couple functions to analyze the simulation results. ###packingFraction packingFraction := radii.radii Pi (1 + rate gtime)^2/size^2 ###dataStore Appends position and current radii, for visualization purposes, as well as the current packing fraction. dataStore:=( AppendTo[pf, packingFraction]; nestpositions = AppendTo[nestpositions, positions]; nestradii = AppendTo[nestradii, radii]; ) ![Packing Fraction as Events Progress][11] I attached my full implementation below, with a couple more simulations and plots, and additional documentation for the functions not explained above. There still are precision errors, and I still plan to add further analysis functions and simulations of different systems (different particle number, radii ratio and particle ratio). To optimize the pack, do play around a lot with the initialization constants (initial packing fraction, initial velocities and growth rate). If any optimizations are found, please send me them! [1]: https://en.wikipedia.org/wiki/Lubachevsky%E2%80%93Stillinger_algorithm [2]: https://arxiv.org/abs/cond-mat/0608362 [3]: https://arxiv.org/ftp/physics/papers/0405/0405089.pdf [4]: https://cims.nyu.edu/~donev/Packing/C++/ [5]: http://community.wolfram.com//c/portal/getImageAttachment?filename=coolgif.gif&userId=1363280 [6]: http://community.wolfram.com/groups/-/m/t/1380701?p_p_auth=szaxHa5m [7]: http://community.wolfram.com//c/portal/getImageAttachment?filename=unpacked.png&userId=1363280 [8]: http://community.wolfram.com//c/portal/getImageAttachment?filename=nearestCells.png&userId=1363280 [9]: http://community.wolfram.com//c/portal/getImageAttachment?filename=s1.png&userId=1363280 [10]: http://community.wolfram.com//c/portal/getImageAttachment?filename=s2.png&userId=1363280 [11]: http://community.wolfram.com//c/portal/getImageAttachment?filename=pf1.png&userId=1363280 Thiago Bergamaschi 2018-07-11T07:03:44Z https://community.wolfram.com/groups/-/m/t/1732535 ![Predicted vs Experimental Silver XRD Pattern. Experimental plot obtained from: Koohpeima, Fatemeh & Mokhtari, Mohammad & Samaneh, KHALAFI. (2017). The effect of silver nanoparticles on composite shear bond strength to dentin with different adhesion protocols. Journal of Applied Oral Science. 25. 367-373. 10.1590/1678-7757-2016-0391. ][1] ## A Computational Method to Predict X Ray Diffraction (XRD) Patterns ## ---------- ## Background ## Ever wondered how DNA's double helix structure was discovered? How drugs are investigated? Well, welcome to the world of X-ray diffraction! 13 Nobel prizes were awarded for developments involving this old but effective technique, in fields ranging from physics to medicine. But, how is it so effective? XRD is a powerful technique employed in various domains of science to determine the chemical makeup and thereby physical properties of various structures. Each lattice structure has its own "XRD fingerprint" which keys scientists in to its chemical makeup. This fingerprint is characterized by peaks with different intensities at different angles. Here is a sample for a face-centered cubic copper lattice structure: ![Copper XRD pattern: From X-Ray Diffraction Studies of Copper Nanopowder (arXiv:1003.6068v1 [physics.gen-ph])][2] The first image in this post is a comparison of experimental and predicted results for a Silver crystal structure. However, predicting these fingerprints given little experimental data is a mathematically involved procedure. This summer, as part of the Wolfram High School Summer Camp, I implemented a framework for predicting these fingerprints for various cubic lattice structures. ## Creating the Program ## ---------- ## Getting the Bragg Peak Positions ## You might be wondering what the numbers on the top of the peaks mean. These numbers are Miller indices, which are descriptions of the planes in a unit cell that are producing the peaks. The first step is to use these planes to generate the Bragg peak positions: $$d=\frac{a}{\sqrt{h^2+k^2+l^2}}$$ $$ \theta =2\arcsin{\left(\frac{\lambda}{2 d}\right)} $$ Here, $a$ denotes the lattice constant (length of a side in a cubic unit cell), $(h,k,l)$ denote the Miller indices, and $\lambda$ denotes the wavelength of the X-ray used. This is based on Bragg's law, see https://demonstrations.wolfram.com/BraggsLaw/ . However, certain $(h,k,l)$ are forbidden in some structures. For example, in a body-centered cubic structure, $ h+k+l$ has to be even. The function `PossiblePlanes` accounts for these and has access to an extensive dataset of compounds and their structures. To make coding easier, a list of associations was made with a certain $\theta$ being the key for a list of $hkl$ values. grouped[elementlist_, n_] := GroupBy[ PossiblePlanes[elementlist, n], 1/Sqrt[(#[[1]]^2 + #[[2]]^2 + #[[3]]^2)] &] association[elementlist_, n_, wavelength_] := Sort[MapThread[#1 -> #2 &, {ToTheta[wavelength, elementlist, n], grouped[elementlist, n] // Values}]] ## Atomic Form Factor ## To account for different electron densities, atomic form factors were calculated using a dataset tabulated by the International Tables for Crystallography: http://it.iucr.org/Cb/ch6o1v0001/. These form factors vary by angle; shown below is copper: ![Copper's Atomic Form Factor][3] These atomic form factors are then used in the structure factor calculation, which is directly proportional to the square root of intensity. For unary systems, the structure factor calculation is relatively easy. For binary systems, however, the parity of the Miller indices must be taken into account. evenodd[b_, elementlist_, theta_, w_] := If[b, Total[atomdata[#, theta, w] & /@ elementlist], Differences[atomdata[#, theta, w] & /@ elementlist] // First] Here, `atomdata` gives the atomic form factor at a specific point. This function is mapped to a set of True/False (Even or not) values and returns the structure factor. For a face-centered cubic cell, if the parity of $hkl$ is even, then the atomic form factors are summed, but if the parity is odd, the atomic form factors are subtracted. ## Multiplicities ## Now, back to the Miller indices. Take a look at the following graphic: ![Miller Indices Felix Kling.svg. (n.d.). Retrieved from WikiMedia ][4] You might notice that if we reflect $(100)$ we can get $(010)$ and $(001)$ . We can also get negative indices, usually denoted $\overline{1}$ instead of $-1$. This gives us 6 total planes that are symmetry-equivalent, and correspond to the same peak. Hence, we say that the class of Miller indices $(h00)$ has a multiplicity of 6. These multiplicities range from 6 to 48 for a cubic lattice structure, but can get as low as 2 with less symmetric structures. Therefore, instead of calculating the contributed intensity of each plane, we count them as one plane and multiply the resultant intensity by a specific multiplicity. This multiplicity is then used to calculate peak intensity. ## Intensity Calculation ## $$I_{hkl}=\underbrace{\frac{1+\cos^2 (2\theta)}{\sin^2(\theta)}}_{\text{Lorentz Polarization Correction}} \times \ \ \ \ \ \text{Multiplicity}_{hkl} \ \ \ \times \underbrace{F_{hkl}^2}_{\text{Structure Factor}}$$ The Lorentz polarization correction was introduced to improve accuracy and match experimental conditions as X-rays will not be completely polarized at every angle. intensity[w_, elementlist_, n_] := Transpose@{(association[Flatten @ elementlist, n, w] // Keys), (.5 (1 + (Cos[#])^2)/(Sin[#/2]^2 * Cos[#/2])) & /@ (association[Flatten @ elementlist, n, w] // Keys) * (multiplicity /@ (Last /@ (association[Flatten @ elementlist, n, w] // Values)))*(structurefactor[elementlist, w, (association[Flatten @ elementlist, n, w])]) ^2 } `intensity` gives a list of Bragg peak positions and their respective intensities using the aforementioned formula. This intensity function is then inputed in a function which finally plots the diffraction pattern. peak[{theta_, intensity_}] := intensity * Exp[-10000 Pi (t - theta)^2] Where $t$ is the variable to be plotted against. Here is a comparison of the predicted XRD pattern vs the real diffracted pattern for a Copper FCC structure: ![Experimental vs. Predicted XRD Pattern][5] The absolute intensities have little use, as relative intensities are primarily used to analyze these patterns. ---------- ## Future Research ## For future research, I have many ideas I want to implement. Thanks to Mr. Wolfram, I certainly have a lot to do this summer! Perhaps the most ambitious of my future plans is doing the inverse problem: predicting the lattice structure from a given XRD pattern. ## Acknowledgements ## I would like to thank my mentor, Eryn Gillam, for helping me throughout my project. I would also like to thank the other mentors for their help, and Mohammad Bahrami for his lectures. Wolfram Summer Camp truly gave me an outlet to express my creativity in novel ways, and the two weeks I spent here were invaluable. Wolfram Summer Camp gave me a novel perspective on how to approach all aspects of life, and key insight into how computational thinking can change the world. For these reasons and more, I am beyond grateful to have been a part of this camp, and am looking forward to apply my new skills. ## Computational Essay ## https://github.com/hamza314/WSS-Template/blob/master/Final%20Project/Final%20Submission/Hamza%20Alsamraee%20WSC19.nb [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=main.PNG&userId=1725111 [2]: https://community.wolfram.com//c/portal/getImageAttachment?filename=copperrealxrd.png&userId=1725111 [3]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Capture.PNG&userId=1725111 [4]: https://community.wolfram.com//c/portal/getImageAttachment?filename=360px-Miller_Indices_Felix_Kling.svg.png&userId=1725111 [5]: https://community.wolfram.com//c/portal/getImageAttachment?filename=dual.PNG&userId=1725111 Hamza Alsamraee 2019-07-12T00:56:45Z https://community.wolfram.com/groups/-/m/t/3100855 ![enter image description here][1] &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=wolfram_figure.png&userId=3100811 [2]: https://www.wolframcloud.com/obj/ec852288-d455-42f0-ac09-391dc095583e Tongtong Liu 2024-01-11T21:17:32Z https://community.wolfram.com/groups/-/m/t/3032057 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/1cbfe446-ce8f-4a93-a44c-beda2ec948dc Ali Hashmi 2023-10-11T13:20:32Z https://community.wolfram.com/groups/-/m/t/3010647 ![enter image description here][1] &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=leadimagecolin.png&userId=20103 [2]: https://www.wolframcloud.com/obj/42e5b52b-1e2d-4edb-abb6-989e9231e37d Colin Benjamin 2023-09-11T20:12:14Z https://community.wolfram.com/groups/-/m/t/2914905 ![enter image description here][1] &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=g004.PNG&userId=20103 [2]: https://www.wolframcloud.com/obj/1f924cf1-57ce-4187-ba95-6a3dd457e9e8 Thomas Mayerhöfer 2023-05-04T18:48:02Z https://community.wolfram.com/groups/-/m/t/2825040 ![enter image description here][1] &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=MaXrd.png&userId=20103 [2]: https://www.wolframcloud.com/obj/7459de42-edc6-4afd-92d2-a18e70ed23cf Stian Ramsnes 2023-02-06T19:33:48Z https://community.wolfram.com/groups/-/m/t/2540813 ![enter image description here][1] &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2022-05-30at2.48.12PM.jpg&userId=11733 [2]: https://www.wolframcloud.com/obj/6275c52d-022d-4f21-9694-264d682a7957 Yijie Shen 2022-05-30T17:58:12Z https://community.wolfram.com/groups/-/m/t/3638297 ![Simulating Plastic Polymer Degradation][1] &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=7682image.png&userId=911151 [2]: https://www.wolframcloud.com/obj/cde0818d-a5d1-40b6-88d8-a26734298c8f Wolfram Education Programs 2026-02-11T16:24:46Z https://community.wolfram.com/groups/-/m/t/3528683 ![Hyperbolic spin liquids][1] ![Hyperbolic spin liquids][2] &[Wolfram Notebook][3] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=hyperbolic_spin_liquids-optimize.gif&userId=20103 [2]: https://community.wolfram.com//c/portal/getImageAttachment?filename=2653Main11082025.png&userId=20103 [3]: https://www.wolframcloud.com/obj/2a837a74-c7fd-4d6f-9107-2bee6c0f5283 Patrick M. Lenggenhager 2025-08-11T15:17:47Z https://community.wolfram.com/groups/-/m/t/3314703 ![FEM modeling for plasticity in solid mechanics][1] &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Main04112024.png&userId=20103 [2]: https://www.wolframcloud.com/obj/7948203d-4074-4a57-96ae-f348d59d71c3 Alessandro Mastrofini 2024-11-04T21:03:36Z https://community.wolfram.com/groups/-/m/t/3210091 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/158c2618-22ea-4c32-aada-f997d1d9cbdf Xuelian Liu 2024-07-10T02:19:19Z