Creating Apps & Python

Chemical engineering is a field currently finding itself at the forefront of the energy transition. Single breakthroughs in many chemistry branches concerned with matters like process emission, water pollution or carbon capture could save significant human life and quality of life. In this field, programmers are scarce and thus any working program or piece of code should be scaled to its ultimate efficacy. VIKTOR can help bring programmers and non-programmers closer together with an easy web app development platform so that progress is developed at a higher speed.  

In this article, we present two of such applications developed on the VIKTOR platform. One for the automated generation of basic chemical operations and the corresponding visualizations. The other for the automated visualization of profiles caused by various differential equations. 

## Sample app molecule visualization 

This sample app shows some basic chemical operations and visualizations that are possible in VIKTOR.  

### Using the functionality 

There are two ways in which you can use the functionality: 

1. With VIKTOR, out-of-the-box, using our [free version]( https://www.viktor.ai/start-building-apps) 

2. Without VIKTOR, in that case you integrate the open-source code with your own Python code. 

 Below is a snippet of the functionality’s code from app/Chemistry/controller.py: 

```python 
@GeometryView('3D', duration_guess=2) 
def get_3D(self, params, **kwargs): #to make a 3D representation corresponding to a smile 
	molecule = Chem.MolFromSmiles(params.smile.smile) 
	molecule = Chem.AddHs(molecule) 
	AllChem = Chem.MolToMolBlock(molecule) 
	atoms, atoms_list, bonds = get+positions(block) 
 
	geometries = self.make_volumes(atoms, atom_list, bonds) 
 
	return GeometryResult(geometries) 
``` 

With this function, a smile is made into an RDkit molecule. RDkit finds the most likely position of the atoms. The function handles the reading of positions and bonds, and VIKTOR makes a 3D object out of these. 

In the video you can see that the sample app contains an input field for chemical elements, that can be linked to specific properties. It contains another input table for reactants and products that are used to balance reactions. It also has a field for SMILEs, which are strings to represent chemicals, that can be turned into 2D and 3D representations.  

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/708973413?h=e7f114e707&amp;badge=0&amp;autopause=0&amp;player_id=0&amp;app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture" allowfullscreen style="position:absolute;top:0;left:0;width:100%;height:100%;" title="Sample app molecule visualization"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script> 

</br> 

</br> 

**Apply for a [demo account](https://www.viktor.ai/demo-environment) to get access to this and all other VIKTOR sample apps.** 

</br> 

### Molecule visualization in 3 steps 

Visualizing a molecule in VIKTOR can be done in three easy steps: 

1. **Define input** on elements, reactions, and SMILEs. On the right side under the tab ‘Element properties’ you can find the properties of elements from the RDkit library. This shows how VIKTOR cloud display information from databases or internal data sheet.  

2. **Balance chemical reactions.** Under the tab ‘Reaction properties’, you can find information on the balanced reaction based on the input. This shows how simple operations that are complex for non-programmers can be reduced in complexity through interfaces. 

3. **Visualize SMILES** in 2D or 3D (see pictures below). Having visualizations alongside the functionalities that resident programmers can build saves a lot of time clicking back and forth.   

![blog_sample_app_chemical_engineering_2](https://cms.viktor.ai/uploads/blog_sample_app_chemical_engineering_2_9b5491868b.png)

*SMILEs visualized in 2D*
</br>

![blog_sample_app_chemical_engineering_3](https://cms.viktor.ai/uploads/blog_sample_app_chemical_engineering_3_3bb4837189.png)

*SMILEs visualized in 3D*
</br>

## Sample app initial value problems 

This sample app shows how profiles caused by various differential equations are visualized.  

### Using the functionality 

There are two ways in which you can use the functionality:  

1. With VIKTOR, out-of-the-box, using our [free version]( https://www.viktor.ai/start-building-apps) 

2. Without VIKTOR, in that case you integrate the open-source code with your own Python code. 

 Below is a snippet of the functionality’s code from app/ODE/controller.py 

```python 
def executeODE(self, params): # function for solving the differential profiles based on user input 
	time = [params.time.begin, params.time.end] 
	timespan = np.linspace(params.time.begin, params.time.end, params.time.resolution) 
 
	initial_conc = get_variable_list(params.species_array.species, ‘concentration’) 
	applied_reactions = get_variable_list(params.species_array.species, ‘matrix’) 
	reactions = get_variable_list(params.section_reaction_array.reactions, ‘reaction’) 
	names = get_variable_dict(params.species_array.species, ‘name’) 
	constants = get_variable_dict(params.section_reaction_array.reactions, ‘rate_constant’) 
 
	names = {name[‘name’]: name[‘index’] for name in names} 
 
	sol = solve_ivp(ODEfunx, time, initial_concs, t_eval=timespan, args=[constants, reactions, applied_reactions, names]) 
 
	return sol 
``` 
 
Here the table inputs conveniently get made into executable differentials, even though the inputs are strings. The program shows that you don’t have to be a programmer to solve initial value problems with Python when the right infrastructure is in place. 

In the video you can see that with the sample app it is easy to simulate profiles of various differentials. The application was originally created to predict chemical reaction profiles, but more applications in which initial value problems require solving can qualify as well.  

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/708973475?h=bc3e682143&amp;badge=0&amp;autopause=0&amp;player_id=0&amp;app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture" allowfullscreen style="position:absolute;top:0;left:0;width:100%;height:100%;" title="Sample app initial value problems"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script> 

</br> 
</br> 

The sample app contains two tables, one to define the reactions (notation = Reaction: k1*A*B/k2*B*clorine**2, Rate constant: 0.1/0.542) and one to define the species (notation = Name: A/chlorine, Species concentration: 1/3.56, Applicable reactions: -r1+r2/r4-r3+r6*3). 

There are also input fields to define reaction time, and plot resolution. Since the program finds and matches strings it can be easy to use abbreviations for the reaction input table. There is one last table where these abbreviations can be subsituted with their full names for the plot legend. 

 
**Apply for a [demo account](https://www.viktor.ai/start-building-apps) to get access to this and all other VIKTOR sample apps.** 

</br> 

### Initial value problems in X steps 

Initial value problems can get complicated quite quickly. You require the changing variables, their initial values, the way their equations change based on all other factors, and the constants for those equations – with chemistry having the added complexity that multiple reactions can influence a species. Luckily, VIKTOR has tables that make this bulky operation as visually digestible as it would be in Excel.  

1. In the **reaction field**, all reactions can be inserted (support multiplication (*), and powers (**)). Users can name species themselves, instead of having to work with Ca and Cb, which can quickly become confusing. All constants k1-kx get a user-defined value.  

2. In the **species table**, all participating species are inserted, with accompanying initial concentrations. In the third column, the reactions that a species undergoes are inserted as well (supports addition (+), subtraction (-), and multiplication (*)), as well as whether it reacts or is formed.  

![Blog_sample_app_chemical_engineering_4](https://cms.viktor.ai/uploads/Blog_sample_app_chemical_engineering_4_18e9d06532.png)

*Species table*
</br>

3. The results from this input yield a **graph of the predicted reaction.** 

![Blog_sample_app_chemical_engineering_5](https://cms.viktor.ai/uploads/Blog_sample_app_chemical_engineering_5_437f26367b.png)

*Graph of predicted reaction*
</br>



automate chemical engineering web application

Blog_sample_apps_chemical_engineering

Bring programmers and non-programmers in the field of chemical engineering together with a web app. Read more on VIKTOR.ai

Molecule visualization and initial value problems web application

Molecule visualization and initial value problems sample apps

1. An introduction to Artificial Intelligence
2. Artificial Intelligence vs Machine Learning
3. AI and ML in organizations
4. Building a Machine Learning application
5. About VIKTOR

artificial intelligence AI machine learning ML engineering construction

medium_A4 - White Paper COVERwp ai cover.png

small_A4 - White Paper COVERwp ai cover.png

thumbnail_A4 - White Paper COVERwp ai cover.png

WP_green

artificial intelligence machine learning engineering construction

large_artificial intelligence machine learning engineering construction

medium_artificial intelligence machine learning engineering construction

small_artificial intelligence machine learning engineering construction

thumbnail_artificial intelligence machine learning engineering construction

Blog_AI_and_Machine_learning_engineering_construction_1

What exactly is artificial intelligence? 
What are the four types of AI? 
How does artificial intelligence differ from machine learning? 
And what are the different types of ML?

In this White Paper, we will answer all of these questions and more about the topic.

Find out how you can use AI to improve and automate (engineering) processes within your organization and learn how to build a machine learning application yourself as we guide you through the following chapters:

1. An introduction to Artificial Intelligence
2. Artificial Intelligence and Machine Learning
3. AI and ML in organizations
4. Building a Machine Learning application
5. About VIKTOR

Find out how you can use Artificial Intelligence and Machine Learning to automate engineering processes!

Download the White Paper and get INSPIRED

Artificial Intelligence in Engineering and Construction

Artificial Intelligence

## Using the functionality 

There are two ways in which you can use the functionality: 

- With VIKTOR, out-of-the-box, using our [free version]( https://www.viktor.ai/start-building-apps). 
- Without VIKTOR, in that case you integrate with your own Python code. 

This is a snippet of the functionality’s code. The whole code can be found and downloaded in the VIKTOR [GitHub repository](https://github.com/viktor-platform/sample-automatic-machine-learning):

```python 
@PlotlyView('Models', duration_guess, = 20) #for visualizing the model scores 
def calculate_models(self, params, entity_id, **kwargs): 
	comparison = get_model(params.dataset.data, params.dataset.target, params.choice.toggle) 
	comparison = pd.DataFrame(comparison) 
	cells = [comparison[col] for col in comparison.columns] 
 
fig = go.Figure(data=go.Table(header=dict(values=list(comparison.columns)), cells=dict(values=cells))) 
 
return__PlotlyResult(fig.to_json()) 
``` 

From the code snippet you can see that as little as three parameters can be used to make a machine learning model.  

In the video, you can see how a dataset is uploaded, different models and analysis plots are generated and viewed, and how this data is labeled in a VIKTOR application in the [demo environment](https://www.viktor.ai/demo-environment). 

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/708115759?h=77bf62082e&amp;badge=0&amp;autopause=0&amp;player_id=0&amp;app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture" allowfullscreen style="position:absolute;top:0;left:0;width:100%;height:100%;" title="Sample app Automatic Machine Learning"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

</br> 

The application contains a toggle to distinguish between classification and regression, an input field for the name/path of your .csv file so it can easily find it, a target where the column needs to be learned and distinguished, different analysis plots that can be visualized, and a table input where data ca be inserted, after which the model predicts the new property.  

</br> 

**Apply for a [demo account](https://www.viktor.ai/demo-environment) to get access to this and all other VIKTOR sample applications.** 

</br> 

## AI for everyone 
 
From the video, you can see that using the machine learning application is easily done in a couple of steps. 

1. In the app, the user can give the path to their .csv file, and which column they would like to predict. 
2. The back-end then handles everything and conveniently shows users the result for all tested models. 
3. Users can then see some plots to evaluate the model performance. The dataset is then labelled according to the model predictions so that outcomes can be compared.  
4. Finally, users can see what outcomes prediction on their new data will yield. 

Use the [free version](https://www.viktor.ai/start-building-apps) or apply for a [demo account](https://www.viktor.ai/demo-environment) to try the functionality yourself! 

Blog_sample_app_auto_machine_learning

With this open-source Python code you can use different machine learning models to automatically classify and analyze data. More on VIKTOR.ai.

Use machine learning in a web-based application

Sample app automatic machine learning

Parametric design

## Pros and cons of Grasshopper

Grasshopper is a strong tool when it comes to 3D modelling and quickly developing scripts to manipulate geometries. Grasshopper seamlessly integrates with Rhino, which makes it possible to visualize changes in 3D models immediately, and is famous when it comes to architecture and BIM. Over the past years, different plug-ins have made it possible to integrate Grasshopper software with other software as well. 

However, sharing Grasshopper scripts internally is difficult, and externally impossible without revealing any of your source code. Additionally, managing and processing large amounts of data or performing numerical calculations and matrix operations for the optimization of designs can be difficult as well. 

## A Grasshopper web app 

That is why VIKTOR enables the development of web applications that you can use to link Grasshopper models to an interface and share these with internal and external users without requiring any downloads or knowledge about Grasshopper.

In this article, we give an example of such an application that is immediately available for trying out in the VIKTOR [demo environment](https://www.viktor.ai/demo-environment). You can also find the open-source Python code in our [GitHub repository](https://github.com/viktor-platform).

## Using the functionality 

You can use the code out-of-the-box with VIKTOR or try the app directly through the [demo environment](https://www.viktor.ai/demo-environment).

When using the sample app with VIKTOR, you should:

1. Make sure you have Rhino installed at ``C:\Program Files\Rhino 7\System\Rhino.exe``
2. Install a generic worker found on https://docs.viktor.ai/docs/worker. Make sure you select ``generic``.
3. Replace the config.yaml file in your worker folder with the file found at ``app/grasshopper/data/config.yaml``.
4. Copy the file found at ``app/grasshopper/data/run_grasshopper.bat`` in the same worker folder.

Below, you see a snippet of the Python code that shows how little lines of code are needed to run Grasshopper analysis and retrieve files. 

```python
# Run the analysis on grasshopper
generic_analysis = GenericAnalysis(files=files, executable_key="run_grasshopper,output_filenames=["output.txt", "output.obj", "output.mtl"])
generic_analysis.execute(timeout=300)

# Retrieve all files from the analysis
grass_hopper_data_bytes = generic_analysis.get_output_file("output.txt")
object_file = generic_analysis.get_output_file("output.obj")
material_file = generic_analysis.get_output_file("output.mtl")
```

In the video, you can see how a football stadium is [parametrically created](https://www.viktor.ai/blog/46/parametric-design-cloud-engineering-construction) through an integration with Grasshopper. On the left side of the application are all input parameters and a download button, in the middle you can see a 3D view of the mesh, and on the right side you can find all calculated information.

<div style="padding:48.75% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/706022495?h=9bdfe52a5e&amp;badge=0&amp;autopause=0&amp;player_id=0&amp;app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture" allowfullscreen style="position:absolute;top:0;left:0;width:100%;height:100%;" title="Sample app parametric football stadium with Grasshopper"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

</br>
</br>

**Apply for a [demo account](https://www.viktor.ai/demo-environment) to get access to this and all other VIKTOR sample applications.**

</br>
</br>

## Parametric football stadium in 3 steps

Complete the following three steps to parametrically design a football stadium with Grasshopper using the sample application. 

1. **Define input parameters**, such as the shape, pitch width, offset from pitch, depth factor, asymmetrie along length and width, and height. 
2. **Create a 3D model**. Based on the input parameters, the field width, field length, and number of seats are calculated. 
3. **Download the 3D model**. Unfold 'downloads' to download a .glb (Graphic Language Bytes) file of the design. 

![Parametrically design football stadium grasshopper](https://cms.viktor.ai/uploads/Blog_sample_app_parametric_stadium_grasshopper_98ab0e1008.png)

</br>

Use the [free version](https://www.viktor.ai/try-for-free) or apply for a [demo account](https://www.viktor.ai/try-for-free) to try the functionality yourself! 




Blog_sample_app_grasshopper

Discover how you can make your Grasshopper scripts more accessible with this open-source web app. Read more on VIKTOR.ai.

Parametric design of football stadium with Grasshopper

Sample app parametric football stadium with Grasshopper

1. What is parametric design, and how is it evolving
2. Collaborative parametric design: working together for better results
3. How to make tools available to others
4. Active collaboration on parametric design tools
5. Parametric design in a billion-euro project
6. What collaborative parametric design means for you



large_Viktor White Paper The future of parametric design is_ COLLABORATION.jpg

medium_Viktor White Paper The future of parametric design is_ COLLABORATION.jpg

small_Viktor White Paper The future of parametric design is_ COLLABORATION.jpg

thumbnail_Viktor White Paper The future of parametric design is_ COLLABORATION.jpg

WP_white

large_parametric_steel_structure.png

medium_parametric_steel_structure.png

small_parametric_steel_structure.png

thumbnail_parametric_steel_structure.png

WP_white_2

The adoption of parametric design grows exponentially thanks to friendly programming languages like Python or visual programming packages like Dynamo or Grasshopper.
 
Our perception is changing. We no longer see parametric design as a model to solve specific technical problems, but rather as a new way of working, in which stakeholders collaborate to find the best solution for a project.

Learn about the latest trends and the future of parametric design in this white paper

Collaborative parametric design models allow you to work together for better solutions

Download the white paper and get INSPIRED

Did you know parametric design models are no longer just used to solve specific technical problems, but rather as a new way of working? Read here how stakeholders use parametric design to collaborate and find the best solutions for their projects!

The Future of Parametric Design is COLLABORATION

## Using the functionality

There are two ways in which you can use the functionality: 

- With VIKTOR, out-of-the-box, using our [free version](https://www.viktor.ai/start-building-apps). 
- Without VIKTOR, in that case you integrate the open-source code with your own Python code 

For a full tutorial on this sample app click [here](https://docs.viktor.ai/docs/guides/tutorials/calculation-spreadsheet). 

This is a snippet of the functionality’s code from the VIKTOR [GitHub repository](https://github.com/viktor-platform/sample-spreadsheet): 

```python
def get_evaluated_spreadsheet(self, params): 
  inputs = [ 
     SpreadsheetCalculationInput('L', params['general']['beam']['length']), 
     SpreadsheetCalculationInput('W', params['general']['beam']['width']), 
     SpreadsheetCalculationInput('H', params['general']['beam']['height']),
     SpreadsheetCalculationInput('E', params['general']['beam']['E']),
     SpreadsheetCalculationInput('aw', params['general']['beam']['aw']), 
     SpreadsheetCalculationInput('wa', params['general']['beam']['wa']),
  ] 
  sheet_path = Path(__file__).parent / 'beam_calculation.xls'
  sheet = SpreadsheetCalculation.from_path(sheet_path, inputs=inputs) 
  result = sheet.evaluate(include_filled_file=True) 
  
  return result 
```

Here you can see it is very easy to send input to your Excel sheet. It is required to have a tab in Excel called ‘viktor-input-sheet'. To get results, you use the evaluate() method. Here, VIKTOR retrieves output from the ‘viktor-output-sheet' Excel tab. 
 
The documentation for the `SpreadsheetCalculation` class can be found [here](https://docs.viktor.ai/docs/guides/services/spreadsheet-calculator) 

In the video, you can see how a simply supported beam under load is calculated through an integration with a spreadsheet in a VIKTOR application in the [demo environment](https://www.viktor.ai/demo-environment). 

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/703176976?h=c6d27796c9&amp;badge=0&amp;autopause=0&amp;player_id=0&amp;app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture" allowfullscreen style="position:absolute;top:0;left:0;width:100%;height:100%;" title="Automating calculations in Excel with Python in VIKTOR"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

</br> 

**Apply for a [demo account](https://www.viktor.ai/demo-environment) to get access to this and all other VIKTOR sample applications.** 

</br> 

## Calculating a beam in 3 steps 

As you can see in the video, the process of automatically calculating a simply supported beam under load consists of 3 steps. 

1. **Insert general information**. Provide information about the beam (length, the width, height, and modulus of elasticity) and loads (starting point and distributed load amplitude).   
2. **Generate results**. View the maximum deflection and maximum bending stress, a schematic visualization, and a 3D visualization of the beam and loads.

</br>
 
![schematic visualization of a beam in Excel](https://cms.viktor.ai/uploads/Blog_sample_app_Excel_73a3917fda.svg)

*Schematic visualization of a simply supported beam under load.* 

 </br>

![3D visualization of a beam in Excel](https://cms.viktor.ai/uploads/Blog_sample_app_Excel_2c9ec5c3b5.png)

*3D visualization of a simply supported beam under load.* 

</br>

3. **Download the report**. Download the calculation sheet to view on your device. 

</br>

Use the [free version](https://www.viktor.ai/start-building-apps) or apply for a [demo account](https://www.viktor.ai/demo-environment) to try the functionality yourself! 

Blog_sample_app_Excel_Python

Use this open-source sample application to automate calculations with Excel and Python. Read more on VIKTOR.ai.

Automate Excel calculations with this open-source application. VIKTOR.ai.

Sample app automating calculations in Excel

### Content: 

1. An introduction to developing successful applications
2. Designing and planning your application
3. How to start coding
4. Gathering and processing feedback
5. Increasing the adoption of your app



How to create successful application that ensure adoption

medium_White Papers & guides - Building succesful applications.jpg

small_White Papers & guides - Building succesful applications.jpg

thumbnail_White Papers & guides - Building succesful applications.jpg

WP_pink

How to create a succesful that people will adopt

large_White Papers & Guides - Building Succesful applications

medium_White Papers & Guides - Building Succesful applications

small_White Papers & Guides - Building Succesful applications

thumbnail_White Papers & Guides - Building Succesful applications

WP_pink_2

Do you want to build a successful application? This guide is here to help you make apps that provide real value to your work and that other people will definitely want to use too!

Over the past years, we, the application developers at VIKTOR, have built many apps for many different industries. We have learned a lot from that and now want to share our experiences with you. 

The principles and processes we explain in this guide are the same as we apply daily. They have helped us build anything from simple apps designed to save time to advanced engineering applications that are used to automatically calculate underground tunnels, dikes, and other large structures. 

This guide will provide actionable insights that are useful for anyone involved in creating custom software tools. For example:

- People developing the tools (developers, engineers, data scientists, etc..)
- End-users, who will use the tools when they are released
- Project managers who are interested in workflow automation/optimization
- Program managers, who oversee and stimulate digital transformation initiatives
- Domain experts, who provide their expertise to people creating software tools
- And anyone else interesting in the process of creating awesome software tools

Learn the process to build apps that provide real value to your work and that other people will definitely want to use as well.

Build successful applications

Learn how to build apps that provide real value to your work and that other people will definitely want to use as well.

Building Successful Applications

VIKTOR updates

![SDK v13](https://cms.viktor.ai/uploads/Blog_newsletter_SDK_v13_0636b26c32.gif)
</br>

## Easily upload files inside the editor

You can now make it easier for users to upload and manage files in your application by adding a `FileField` to the parametrization.

From now on, users can use the file manager in the editor to upload all files, which can then be selected in the FileField. This means that there is no longer the need to create separate file entities below an entity to enable file uploading. 

Visit the documentation for [more info](https://docs.viktor.ai/docs/guides/topics/files#upload-using-filefield).

![File transfer modal](https://cms.viktor.ai/uploads/Blog_newsletter_File_Field_cdcc9b9df6.png)
*File transfer modal*

</br>
</br>

## Store data and files in your app

The new `Storage` feature lets you permanently store files and data, and use it anywhere in your app.

You can use the storage for multiple purposes, such as storing calculation results, using the data to generate a view or report without rerunning the calculation, or storing data that you don’t want to expose to users of your app.

This new feature provides many new opportunities, and we are looking forward to seeing how you will implement it!

[Read more](https://docs.viktor.ai/docs/guides/topics/persistent-storage) about easier data storage and retrieval in the documentation.

</br>
</br>

## Easily select entities inside the editor

You can now easily select entities from anywhere in the entity tree inside your editor.

Previously, selecting entities was only possible for child and sibling entity fields, or you would have to write the implementation yourself using the API module. With the introduction of `EntityOptionField` or `EntityMultiSelectField` it becomes possible to more efficiently retrieve data from any entity in the entity tree and allow end-users to intuitively select entities. 

Go to the documentation to [find out more](https://docs.viktor.ai/docs/guides/topics/share-information-using-api#entity-selection-fields) about the extended entity fields.  

![Select mutiple objects modal](https://cms.viktor.ai/uploads/Blog_newsletter_Entity_Field_7b76299d5e.png)
*MultiSelect*

</br>
</br>

# Everyone can develop apps for free!

Have you ever thought: "Hey, I know someone that should use VIKTOR!"? We have good news! We also believe that everyone should get the chance to build awesome apps. That is why everyone can now develop VIKTOR apps for free.

 

Help expand the VIKTOR Community! Share the good news, and send your colleagues or friends [this page](https://www.viktor.ai/start-building-apps). After submitting the form, they will get their developer account.

![Group 21.png](https://cms.viktor.ai/uploads/Group_21_0ff9c8f919.png)
*Invite a friend!*

</br>
</br>

## Track your application's activity

Did you want to monitor your organization's usage of apps? Good news! On the new Activity Dashboard, admins can keep track of:

- The number of users in your Cloud environment and on each workspace
- User activity
- The most used workspaces

We hope this new feature will help you understand which app provides the most value to your organization and how you can improve adoption.

 
![Activity dashboard](https://cms.viktor.ai/uploads/Blog_newsletter_Activity_dashboard_6f9a25e740.png)
*Activity dashboard*

</br>
</br>

## Automate app publishing

You can now use the new CLI command `ci-publish` to automatically publish a new app to VIKTOR in your CI pipeline after merging changes or creating a tag on the repository. This way you make sure your app always runs the latest code. Additionally, it makes publishing VIKTOR apps a lot easier, as it no longer requires any manual steps!

Visit the documentation for [more info](https://docs.viktor.ai/docs/guides/tools/ci).

![ci-publish command.png](https://cms.viktor.ai/uploads/ci_publish_command_a6a8b65675.png)
*ci-publish*

</br>
</br>

# Coming soon...

**Create basic apps with CLI command:** To make it faster and easier to set up new apps from scratch, we are adding a command to the CLI that generates a basic app for you. 

**Developer environment consolidation & self-servicing of tokens:** Your developer environment will be moved to your company's environment, so you will be able to create and use apps in a single place. Here, you will also be able to generate your own developer token.

**Workspace-specific workers:** We are building a feature that enables assigning a worker to a specific workspace so that apps from different workspaces that depend on the same integration can no longer block each other's tasks. 

</br>
</br>

# Other Changes

### SDK

- New version v13.0.0 is now available! 

### PLATFORM

- Fixed issue with PlotlyAndDataView not taking full height 
- Added fixed-size MapLabels
- Added support for defining up-axis in GeometryView
- Fixed the workspace invitation email to show the invitee name
- Updated app clearing to not delete the workspace image in development environments
- Fixed MapPoint 'wye' icon not showing color 
- Fixed the data view error state not clearing properly and improved text readability 
- Removed invalid `dseries` integration type from supported workers 
- Fixed param changes not being picked up in dynamic array tables in some cases 
- Fixed issue with stepwise editor missing a bottom border 
- Improve markdown rendering performance 
- Allowed deselection in the single file field 
- Updated the toggle button to use the primary color 


### CLI

- Support for development workspaces in primary environments
- Validation of credentials for easier debugging
- Use existing credentials as default values when reconfiguring the CLI




Blog_newsletter_april_2022

Discover what is new in the VIKTOR platorm for April 2022.

VIKTOR platform updates | April 2022

What's new in VIKTOR (April 2022)

## Pros and cons of Dynamo 

Dynamo is a great tool for designers to create visual logic that you can use to easily calculate and visualize a parametric design of a structure. With Dynamo, designers can automate repetitive design tasks in order to use their productive time more wisely.  
 
However, the visual logic of Dynamo can be difficult to read for any other person than the one who created it. The logic quickly becomes ‘messy’, which reduces the usability. Especially for longer running projects this can become a problem when certain people leave or get assigned to a different project. Additionally, sharing Dynamo models is difficult, because an installation of Dynamo is required on each individual device to open the drawings.  
 
## A Dynamo web app  

With VIKTOR, you can develop user-friendly web applications that integrate with all kinds of software programs, such as Dynamo. VIKTOR apps have a clear and intuitive user interface in which users only see the adjustable parameters, which improves the usability of Dynamo software. VIKTOR also enables connecting Dynamo drawings to other computational programs through integrations, for example to calculate the strength of the structure. Additionally, everything runs in the Cloud, making your data always accessible to anyone with an internet connection! 

In this article, we give an example of such an application. Continue reading to learn more, or try the app immediately in the VIKTOR [demo environment](https://www.viktor.ai/demo-environment). You can also find the open-source code in our [GitHub repository](https://github.com/viktor-platform). 

## Using the functionality 

You can use the code out-of-the-box with VIKTOR.

Here, you see a snippet of the Python code that shows how little lines of code are needed to edit, compute and visualize your Dynamo model within VIKTOR.   

```python
file = File.from_path(Path(__file__).parent.parent / "lib" / "files" / "dynamo_model_sample_app.dyn") 
input_file = DynamoFile(file) 
 
input_file.update("Height roof", params.step_2.height_roof) 
 
# Generate updated dynamo file and load into memory 
input_file = input_file.generate() 
files = [('input.dyn', BytesIO(input_file.getvalue_binary()))] 
 
# Run the analysis and obtain the output file 
generic_analysis = GenericAnalysis(files=files, executable_key="dynamo", 
                                   output_filenames=["output.xml", "geometry.json"]) 
generic_analysis.execute(timeout=60) 
 
# Generate output file and set up data for the DataViewer 
output_file = generic_analysis.get_output_file("output.xml", as_file=True) 
 
```

- In row 1 and 2 the dynamo model is loaded 
- In row 4 the dynamo model is updated  
- In row 7 and 8 the dynamo model is updated with your input parameter
- In row 11 to 13 the dynamo model is computed by the worker and sent back to the application 

And that’s it! Your model is now computed and visualized within the VIKTOR platform. 

The necessary modules are included in this sample app. All that needs to be done is import them, call them and let them do their work for you!

In the video you can see the functionality being used in an applicaton on the VIKTOR platform.

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/698906446?h=5ff0ca5cc4&amp;badge=0&amp;autopause=0&amp;player_id=0&amp;app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture" allowfullscreen style="position:absolute;top:0;left:0;width:100%;height:100%;" title="Sample app Dynamo"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

</br>

**Apply for a [demo account](https://www.viktor.ai/demo-environment) to get access to this and all other sample applications!**


## Dynamo in 3 steps 

The process of using the Dynamo sample app consists of 3 steps.  

1. **Defining the location.** As a first step you can choose the location of you project on the map. In the example the construction of a residential block is used. By clicking on the map the necessary required space for the project is shown on the map. When the input parameters are adjusted, they are also adjusted on the map 

![Define location on the map](https://cms.viktor.ai/uploads/Blog_sample_Dynamo_1_5bf72b8656.png)
</br>

2. **3D dynamo model.** In this step the input parameters for your project are required. For this example the parameters are used such as the dimensions of the house and the number of houses. When the update button is pressed, the model is computed and vizualized. 

![Generate 3D model](https://cms.viktor.ai/uploads/Blog_sample_Dynamo_2_2bec3c873d.png)
</br>

3. **Report.** It is possible to compute additional information related to your project, such as the cost of construction or the impact on the environment. Using the Report functionality from VIKTOR a report is generated automatically, in which all this information is presented. It is of course possible to edit the template of this report to your taste. 

![Download report](https://cms.viktor.ai/uploads/Blog_sample_Dynamo_3_5d9bc8427f.png)


Use the [free version](https://www.viktor.ai/try-for-free) or apply for a [demo account](https://www.viktor.ai/demo-environment) to try VIKTOR apps yourself!
 

medium_dynamo resize.jpg

small_dynamo resize.jpg

thumbnail_dynamo resize.jpg

Blog_sample_app_Dynamo

Use this open-source sample application to make your Dynamo models more accessible. Read more on VIKTOR.ai.

Make Dynamo models more accessible with open-source sample app

Sample app Dynamo

## Why a hackathon?

Knowledge development is one reason for the IB decided to organize a hackathon. Addiotionally, besides getting acquainted with programming hands-on, they also wanted to experience what it is like working with VIKTOR. 

As some structural engineers, such as Lester Neijzing, are currenlty part of a pilot project by the Gemeente Amsterdam in which VIKTOR is also being used, some are already a bit familiar with the platform. Now, the hackathon offers a great opportunity for the other structural engineers to get introduced to VIKTOR as well, and for those who are already acquainted to improve their programming skills. 

> "Participating in the hackathon is a fun way to get to know VIKTOR and learn more about programming with Python." - Lester Neijzing

![blog_hackathon_amsterdam](https://cms.viktor.ai/uploads/blog_hackathon_amsterdam_ae737a634c.jpg)

</br>
</br>

## Quay wall applications

During the two-day hackathon, three teams used Python to develop applications on the VIKTOR platform. All of the apps are to some extend related to the parametric design application that Amsterdam is currenlty developing for the renovation of their quay walls. 

The stakes were high during the event: In total, three apps were developed, but only one could be the winner and would thus be further developed eventually. Next, each app will be described in more detail.

![kademuur renoveren.jpg](https://cms.viktor.ai/uploads/kademuur_renoveren_7f4840c190.jpg)

</br>
</br>

### Application 1

Currently, structural engineers at the IB gather data about the state of quay walls in Excel sheets. Even though this process works well for the people who work with these sheets on a daily basis, it is difficult for other to interpret the data. For that reason, team 1 developed an application to make this data more transparent and easily adjustable. 

Of course, the IB could ask their GIS-department to visualize their data for them, but even then it would still remain a static process. With this application, engineers can visualize and adjust project data using different colors on a graphical map themselves. This also helps make it easier to explain to others why the work of the structural engineers is important and how they, for example, estimate workload and project duration.

### Application 2

Justl ike team 1, team 2 also worked on an application for the visualization of project data. With their app, it becomes easier and faster to project geometries on a map view and translate these to the calculation program SCIA, and after that to Word to generate downloadable reports.

Because this app includes a rather far-reaching integration, it was not unfortunately yet at a usable level at the end of the hackathon. On the flip side, this does mean that there is still a lot of room to improve and expand the tool. 

### Application 3

Opposing team 1 and 2, team 3 developed an application not aimed at the visualization of project data, but for the automated design and modelling of foundation piles, channels, and the surrounding soil. For this, the team integrated an Excel calculation sheet with an export to the calculation program SCIA to their VIKTOR application.

Just like with team 2's application, there was still some work to be done before team 3's app was ready to be used on real projects. However, the results were promising so far and made for an interesting concept for further developments.

## Choosing a winner

Based on the judge's critiques, a winner was chosen at the end of the second hackathon day: Application 1. Where the other apps mainly focused on integrating with pre-existing calculation software, application 1 stood out due to its unique use of data-processing and visualization - a nice use of VIKTOR that had not been done that often yet. 

> "I think it was this tool that won the hackathon because the rough outlines were already finished - the application worked in such a way that it produced the results that we were looking for. According to the jury, it was a unique tool, especially thanks to the maps and the visualizations." - Lester Neijzing

## Putting the pieces together

According to team 1 participants Rick and Lester, even though they were part of the same team, they were constantly programming completely different parts of the application. Only within the last few hours of the hackathon, when they began putting all the parts together, it felt like "it magically turned into a working product".

The application consists of several different parts, For example, it shows a graphical map and Excel sheet with risk drilling and assessments of quay walls, using different colors to indicate wether a wall is still sufficient or needs reinforcement. Team 1: "The map view really makes the data come to life". Within the application, it is also possible to adjust source data, link it immediately back to Excel (or the other way around), and export overview reports.

> "We knew what our vision was but did not yet realize how incredible it would be until we put everything together and it actually started working the way we envisioned." - Rick Voortman

![hackathon artikel 2.jpg](https://cms.viktor.ai/uploads/hackathon_artikel_2_b764fb081e.jpg)


</br>
</br>

## What's next?

Following the hackathon, two things are certain:

1. The further development of team 1's winning application
2. A second edition of the hackathon

**Are you also interested in organizing a hackathon with your organization? Don't hesitate to contact us at contact@viktor.ai!**



large_Blog_hackathon_amsterdam_header

medium_Blog_hackathon_amsterdam_header

small_Blog_hackathon_amsterdam_header

thumbnail_Blog_hackathon_amsterdam_header

Blog_hackathon_amsterdam_header

Structural engineers at the engineering firm of the municipality of Amsterdam organized a hackathon to boost their programming skills and learn about building apps with VIKTOR.

VIKTOR Blog

Hackathon stimulates knowledge development