Content of the first page

[jan-janssen]

Based on our recent discussions I was wondering if it makes sense to formulate the start page a bit more general, while still maintaining the focus on atomistic simulation:

Slogan:

pyiron - complex workflows made easy from rapid prototyping to high performance computing in material science

Three key points:

• object model
  • jupyter based user interface - like visualising atomistic structures
  • hierarchical data storage - based on the HDF5 file format optimised for atomistic trajectories
  • extensive simulation code interfaces - VASP, LAMMPS, Sphinx, GPAW, Phonopy, ...
• Infrastructure
  • Easy installation via conda - active contribution to condaforge including over 100+ material science codes
  • support for HPC clusters - running pyiron either on the cluster or communicating with the cluster via SSH
  • transferable and reproducible simulation protocols - independent of the local pyiron configuration
• easy to integrate new codes
  • file and python bindings based communication - based on write_input() and collect_output() function
  • Manage multiple executable version - executables are interfaced by simple shell scripts
  • Reuse built-in data aggregation methods - generate pandas data frames based on the pyiron objects model

[ashtonmv]

That looks great to me. I will certainly trust your judgment as to which features/abilities we should highlight.

If you can draft this as a pull request, I think it would also resolve #50 that we no longer need an about page.

And in case you want to update the images on the homepage to better fit those bullet points, I previously used flaticon.com and really like their resources (e.g. https://www.flaticon.com/packs/charts-and-diagrams-26). In #60 I added their attribution to our "license" page as they request, so we are able to use any of their free icons.

[jan-janssen]

I have to admit I currently see directly how you got from the icon pack you linked to the ones we have on the website. I am really not so gifted when it comes to designs.

What I was thinking about:

• For the object model something similar to the figure in the paper https://www.sciencedirect.com/science/article/pii/S0927025618304786#f0010 - just a bit more abstract without the text.
• For the infrastructure we can use the first icon that is currently on the website.
• For the app creation I was thinking about something like a conveyor belt, where a gear is packaged in a box and then the box is moved on the conveyor belt. Maybe similar to https://www.flaticon.com/premium-icon/conveyor-belt_2120145 - but that one is paid unfortunately. My thinking was that the gear is the simulation code, the box is the pyiron object and the conveyor belt is the high throughput tools inside pyiron.

Unfortunately I am not really sure how to create logos based on these ideas. But I can definitely write the corresponding texts.

[jan-janssen]

I wrote some first drafts, but those are definitely too theoretical, so we should find a mix between the current version and these:

Pyiron objects The pyiron IDE is based on an abstract class of objects - called pyiron objects. The pyiron objects combine the Jupyter based user interface, with the hierarchical HDF5 based data storage and an interface to the computing resources. These objects allow the pyiron users to focus on the scientific complexity rather than the technical implementation by combining atomistic structures, simulation codes and simulation protocols like building blocks. The details of the pyiron object model are explained in the pyiron paper.

Infrastructure By separating the technical implementation and the scientific content of the pyiron simulation protocols, they are both reproducible and transferable. To simplify the administration all computing system specific settings are stored in a central resource directory separated from the individual simulation protocols, using shell script based templates to manage executables and queue submission. In addition the pyiron developers collaborate with the conda-forge community to provide materials science simulation codes and utilities via the conda package manager. By combining the simulation protocol and the corresponding conda environment the whole software stack can be archived. Learn more about the pyiron infrastructure in the documentation.

Extendability While pyiron was originally developed for ab initio thermodynamics, the pyiron concepts are not restricted to the atomistic simulation or simulation in general. Moreover the pyiron object model with the pyiron infrastructure and pyiron IDE are released as a standalone software package without the atomistic module. Integrating your own code is as simple as defining a write_input and a collect_output function and the interface can be extended step by step to support more features later on. With the map-reduce based pyiron tables module, high-throughput parameter studies can be up-scaled to run on HPC clusters with minimal modifications. Learn more about the pyiron base class.

[jan-janssen]

Second try:

Generic Interface The pyiron IDE is build on top of an abstract class of Python objects, which can be combined like building blocks. So switching from density functional theory (VASP, SPHInX) to interatomic potentials (LAMMPS) is as easy as changing one variable, see an example.

Infrastructure Inside the pyiron IDE simulation protocols are developed in Jupyter notebooks, which can be submitted to an remote HPC cluster as ScriptJobs. This enables studying trends in the periodic table following the map-reduce pattern using the pyironTable object to aggregate the results in a single pandas Dataframe, see an example.

Extendability The pyiron IDE is developed with advanced users in mind, therefore both the input and the output of the underlying simulation codes are accessible. Finally new simulation codes can be added to the pyiron IDE by defining a write_input and a collect_output function for file based communication or a single run_static function for simulation codes with python bindings, see an example.

[ashtonmv]

My 2 cents:

Generic Interface The pyiron IDE is built on top of an abstract class of Python objects, which can be combined like building blocks. So switching from density functional theory (VASP, SPHInX) to interatomic potentials (LAMMPS) is as easy as changing a variable.

Maybe we can directly include code snippets here instad of links??

See an example

---

Infrastructure Inside the pyiron IDE, simulation protocols are developed in Jupyter notebooks, which can be submitted to a remote HPC cluster as ScriptJobs. This enables studying trends in the periodic table following the map-reduce pattern using the pyironTable object to aggregate the results in a single pandas Dataframe.

See an example

---

Extendability The pyiron IDE is developed with advanced users in mind, exposing direct access to all the inputs and outputs of the underlying simulation codes. New simulation codes can be added to the pyiron IDE by defining a write_input and a collect_output function for file-based communication or a single run_static function for simulation codes with python bindings.

See an example

[jan-janssen]

Two more updates about the text:

Generic Interface The pyiron IDE is built on top of an abstract class of Python objects, which can be combined like building blocks. So switching from density functional theory (VASP, SPHInX) to interatomic potentials (LAMMPS) is as easy as changing a variable.

Extendability New simulation codes can be added easily to the pyiron IDE. The pyiron IDE also supports advanced users, exposing direct access to all the inputs and outputs of the underlying simulation codes.

But I guess everything becomes more clear once we have the corresponding code examples, so I am going to work on those.

[jan-janssen]

Generic Interface The pyiron IDE is built on top of an abstract class of Python objects, which can be combined like building blocks. So switching from density functional theory (VASP, SPHInX) to interatomic potentials (LAMMPS) is as easy as changing a variable.

from pyiron import Project # Import Project object 

pr = Project("demonstration")  # Create a project/folder 
structure = pr.create_ase_bulk("Al")  # Create an aluminium bulk structure
for job_type in ["GpawJob", "Lammps", "Sphinx"]:  # Iterate over simulation codes
    job = pr.create_job(  # Create a job object
        job_type=job_type, 
        job_name=job_type
    )
    job.structure = structure  # assign the structure 
    # job.server.queue = "my_queue"  # uncomment to up-scale to HPC 
    # job.server.cores = 4  # Set number of cores
    job.run()  # Execute the calculation

Up-scaling To up-scale the interactive calculation to HPC pyiron implements the server object. This enables studying trends e.g. in the periodic table. The resulting large datasets can be quickly analyzed using the map-reduce pattern: The pyironTable object aggregates the results in a single pandas Dataframe.

table = pr.create_table()  # Create analysis object 
table.add.get_energy_tot  # Define analysis functions 
table.add.get_volume  # get the volume and total energy
table.add["job_type"] = lambda job: job.__name__  # Add custom analysis function
table.run()  # Execute the analysis 
print(table.get_dataframe())  # Results are summarized in DataFrame

Extendability New simulation codes can be added easily to the pyiron IDE either by using the Python bindings (see example below) or by defining a write_input and a collect_output function to parse the input and output files of the executable.

from pyiron_base.job.template import TemplateJob

class ToyJob(PythonTemplateJob):  # Create a custom 
    def __init__(self, project, job_name):
        super().__init__(project, job_name) 
        self.input['input_energy'] = 100  # Define default input

    def run_static(self):  # Call a python function 
        self["user/result"] = self.input["input_energy"]
        self.status.finished = True  

job = pr.create_job(job_type=ToyJob, job_name="toy")  # Create job instance
job.run()  # Execute Custom job class