Vortex-Radioss - D3plot convertor and open-source Python post-processing library for OpenRadioss - now released

[Vortex-CAE]

Vortex-Radioss

We are pleased to be announcing a beta release of our open-source Python post-processing library for OpenRadioss. The library currently has three main classes:

1. RadiossReader - A Python class for reading OpenRadioss animation files
2. RadiossTHReader - A Python class for reading OpenRadioss time-history files
3. Anim_to_D3plot - A Python class that converts from OpenRadioss animation files to LS-Dyna's d3plot file format

The Anim_to_D3plot class is a new class that currently supports beam, shell and solid geometry conversion, as well as some common scalar and tensor data for shell elements.

As the library is new we would like to invite developers from the OpenRadioss community to have early access to the library as part of our beta testing - before we open the library to the public. To gain access to the repository please leave a comment below and we will add you.

Thank you to @MarianBulla @elequiniou @sebastienVilleneuve @PaulAltair for their support and assistance in developing the library so far.

Thank you also to Lasso-Python from whom which the library is based.

Below we have a demonstration of the d3plot convertor:

• First we ran a 2020 Nissan Rogue crash simulation using OpenRadioss
• Then we converted the animation files to d3plots using Vortex-Radioss
• Finally we were able to animate the results using LS-Prepost

anim_to_d3plot.mp4

(Model taken from https://www.ccsa.gmu.edu/models/2020-nissan-rogue/ )

We welcome any questions or feedback and we thank you for reading this post.

Edit: 2024-03-13

• Part masses for shell parts has now been added to the convertor, other element types will still return 0
• Optional absent size flags from header_raw now created set to 0 for consistency in referencing. - Thank you @SyazwanSamad

Edit 21-06-24

• There is now some additional documentation which I have created for both developers and users which can be found here:
• https://www.vortex-cae.com/vortex-radioss
• This contains some information on what quantities can be converted, the database requests required to do so etc, as well as some documentation on how the conversion code is structured.
• If you would like to be notified by email of any updates made to the conversion library (we plan on adding data conversion support for solids very soon) you can sign up to be notified by email at the bottom of the page.
• Thank you all for all the supportive and constructive feedback

[elequiniou]

Thanks a lot @Vortex-CAE ! This is a wonderful initiative !

I trust it will drive a lot of interest from the OpenRadioss community and hopefully you'll get a lot of beta testers :-)

Kind Regards,

Eric

[Hyp5891]

Hey,

thanks a lot @Vortex-CAE for puting together this great new library! This exactly what i was looking for. :)
As I am buildling my models in ls pre-post it is just feels natural to also postprocess them there.

Best regards,
Christian

[Vortex-CAE]

Hi @Hyp5891 - Thank you for your interest, you should now have an invite

Kind Regards,
David

[MarianBulla]

Hi @Vortex-CAE, yes indeed, this is a great milestone !!!
Thank you (and all involved, as @sebastienVilleneuve and @PaulAltair and others) very much for all your efforts on this development.
Yes, this will boost the usage of OpenRadioss. :-)

Thanks and best regards,
Marian

[SyazwanSamad]

Hello @Vortex-CAE

Thank you for your contribution! This is a great supporting library for OpenRadioss. Both Paraview and LS prepost supports d3plot, but I prefer LS prepost better. Furthermore, d3plot is a binary file, your library will surely help to reduce the result file size 😁

Just noticed that you also the one who developed lasso-python? This library helps me a lot during my post grad study.

Thanks again
Best regards
Syazwan

[SyazwanSamad]

Hi @Vortex-CAE / David

I've already forked your repository and included the changes that I've made here --> https://github.com/SyazwanSamad/Vortex-Radioss
But, before I merge with the main repository, let me test with a bigger model first. I think I still have my Yaris model implemented with my failure model. I will try that first, if everything works well, then I will upload the changes.

Regards
Syazwan

[Vortex-CAE]

Hi @SyazwanSamad,

Brilliant, We've made some comments directly on the commit - thank you very much for your efforts and support!

Kind regards,
David

[Hyp5891]

@SyazwanSamad Can you please also add von mises stress output for solid elements? This would be really cool! ;)

[SyazwanSamad]

@Hyp5891
Actually, I already have added support to output stresses (LS-PrePost actually calculates von mises based on stress components).

If /ANIM/ELEM/VONM is used instead, then I put the result into history variable #2, provided damage is also defined in history variable #1.

[Hyp5891]

@SyazwanSamad
Just tried it and it works smoothly. Thanks!

[rpth3554]

Could you please check the element status . This wasn't available with lasso python.

[Vortex-CAE]

Hi @rpth3554 ,

Thank you for your question, so I can answer correctly, could you expand on what you mean by "status"?

[rpth3554]

This was about deleted elements in dyna database. once the element gets deleted due to excessive strain etc.

[Vortex-CAE]

Hi @rpth3554 there are truth arrays in both Lasso-Python and Vortex-Radioss called, for example, "element_shell_is_alive". Values of 0 or false mean that the element has been eroded. We use them in the convertor tool. Hope that helps.

[wmcnCG]

I would like access, please!

[Vortex-CAE]

Hi @wmcnCG , No problem, you should now have an invite - thank you,

Kind regards,
David

[wmcnCG]

@Vortex-CAE I accepted the invite but I do not see the repository. Can you please resend the invitation? Thank you!

[FGarelli]

@Vortex-CAE this is an exiting news! I'm preparing my model with LS-Prepost and it would be great to be able to post-process them there! I'm available for the beta testing.

[Vortex-CAE]

Hi @FGarelli, thank-you for your interest - you should now have access,

Kind Regards,
David

[kth7293]

"I'm not familiar with Python or Linux. Is there a plan to release it for win64 as well? I really want to try it out."

[Vortex-CAE]

Hi @kth7293, thank-you also for your interest I've granted access. You can run this on any OS with a python installation. On Windows it may be best for you to download Anaconda to create a separate environment. We have some information on the Git page that may help.

[SyazwanSamad]

Technically, it is possible to generate a binary (exe) from Python code using pyinstaller, like in the example below.
But then, the functionality will be very limited.

[kth7293]

“Is it possible to use LS-PrePost for OpenRADIOSS commercially and for free?”

[Vortex-CAE]

You will be able to use the convertor tool to convert Radioss animation A-files into d3plot files that can be read by LS-Prepost. There is not a conversion tool for the time-history T-files. There is however a Radioss T-file reader in the library so you can use other Python libraries such as matplotlib to display graphs. What this means is that if we were to create an executable, you would be able to convert the animation files, but you would have no way of plotting time-history data from the T-files..

In addition to what @SyazwanSamad has said, the executables that are generated are very large and slow to initialise. Python really doesn't compile in the way C or Fortran does.

We will be putting together a more detailed guide to help those less familiar with Python at some point.

[olosim]

Hi @Vortex-CAE this is great news! Could we also get access to the beta version?

[Vortex-CAE]

Hi @olosim, thank-you! You should now have an invite to the repository.

[sweety2142]

Hello!, I have expected this module for a while. I would like to access to d3plot convert module .! thank you

[Vortex-CAE]

Thank you @sweety2142, you should now have access.

[mnddrk]

Very interesting initiative! I'd like to access to the libraries.
Thanks.

[Vortex-CAE]

Hi @mnddrk, great! You should now have an invite.

[sweety2142]

I saw @Hyp5891 's comments about the request of von mises result for 3d Solid Element. But I cannot find 3d solid convert code in main repository for von mises stresses. Could you help me to let me know 3d solid element stress results convert codes or how to access the repository.

[Vortex-CAE]

Hi @sweety2142, we only have support for some shell scalar and tensor data at present. The library will be expanded over time to include solids but there is no set timeline for that. In D3plot von Mises there isn't a dedicated array as it is a derived stress, only stress tensors would can be output in future updates; however some of the forks are bypassing that by re-purposing and assigning various user defined outputs to some of the additional history variable arrays.

It would be fantastic if you are able to expand the library to include solids for stresses and strains. You should have access according to the collaborator list, please can you try the link below?:

https://github.com/Vortex-CAE/Vortex-Radioss

Kind regards,
David

[sweety2142]

Thanks! @Vortex-CAE @SyazwanSamad I think https://github.com/SyazwanSamad/Vortex-Radioss link is blocked.
Please give some access authority.

[Vortex-CAE]

@SyazwanSamad could you please add @sweety2142 to your fork as a collaborator? I don't have the permissions to do that. Many thanks, David

[SyazwanSamad]

@Vortex-CAE sure, no problem. @sweety2142 I have just invited you.
There's two methods on how to get von mises stress:

1. You need to define both/ANIM/ELEM/VONM and /ANIM/BRICK/DAMA; I stored damage in extra history variable 1 and von mises in history variable 2.
2. Just define /ANIM/BRICK/TENS/STRESS; the result files will be a bit bigger, but all the stress components will be properly be converted to d3plot; you can fringe it properly in lsprepost.

Regards, Syazwan

[sweety2142]

Thank you! I have checked the code and confirmed for very perfect conversion!

[Matincn]

Thanks a lot @Vortex-CAE , awesome! I'd like to access to the libraries.

[Vortex-CAE]

Hi @Matincn,

No problem at all, thank you for your interest! You should now have an access invitation,

Kind regards,
David

[mihe31]

@Vortex-CAE Thanks a lot for these great tools, I would like to have the access.

[Vortex-CAE]

No problem @mihe31, you should now have access.

Thank you,
David

[hdrz]

@Vortex-CAE This sounds like a cool project. I would like to check it out if possible.
Thanks!

[Vortex-CAE]

Hi @hdrz ,

Thank you for your interest, I have given you access,

Many thanks,
David

[hdrz]

Thank you David!

This is beautiful compact coding you did there. Did you consider using the struct module? It is used to read and write binary data, and can make your code even shorter.

Cheers

[Vortex-CAE]

Thank you for your kind words @hdrz - pleased that you like the library, we cannot take all the credit @SebVilleneuve played a major role. We didn't look at the struct module as we already had an excellent IO library from lasso-python put together by @codie3611 - which had already demonstrated very high performance in read-write speeds, we didn't see a need to use anything else.

Many thanks,
David

[Majid-MHZ]

Hello @Vortex-CAE
I hope you are doing well.

Thank you for a great job. Could you please grant me access to this code?

Best regard,
Majid

[Vortex-CAE]

Hi @Majid-MHZ, I am very well thank-you, I hope that you are too? Thank you for your interest - I have granted you access,

Kind regards,
David

[adamRHargreaves]

Hi @Vortex-CAE
Great to see that someone had the fab idea of converting to d3plot - it's such a useful format to work with (if you don't have the Hyperworks post processing)
Would love to try it out, so please could you grant me access?

Very best regards

Adam

[Vortex-CAE]

Hi @adamRHargreaves, thank you for the compliment! Great to have you onboard - I have provided access to you,

Kind regards,
David

[adamRHargreaves]

Thank you so much. Got the code downloaded - will let you know any feedback once I've had a fiddle.

Cheers

Adam

[TermeHansen]

Hi @Vortex-CAE ,

This sounds very interesting, and I would also like to test it out. Can you provide me access to the code?

[Vortex-CAE]

Hi @TermeHansen, OK brilliant, thanks for your interest. You should now have access,

Kind regards,
David

[James-Immanuel]

Hi @Vortex-CAE,

Could you please provide me the access to the code to test it? Thank you.

Best Regards,
James

[Vortex-CAE]

Hi @James-Immanuel, we are public now as of this morning!

https://github.com/Vortex-CAE/Vortex-Radioss

[Vortex-CAE]

We are pleased to announce the public release of Vortex-Radioss, an open source Python library developed for reading #OpenRadioss Animation and Time-History files, and for converting OpenRadioss Animation files into the D3plot format used by LS-Dyna. The library is free for both personal and commercial use.

Our gratitude extends to the OpenRadioss team at Altair for their invaluable assistance and support throughout the development of this library, in particular Marian Bulla, Eric Lequiniou, Sebastien Villeneuve & Paul Sharp. We also extend our thanks to the 36 collaborators who generously contributed their time and expertise to test and validate the library. We would also like to thank Constantin Diez for the lasso-python library from which ours is built upon.

The D3plot conversion feature supports 1D, 2D, and 3D element types and includes conversion of the most commonly used data values for 2D elements. Additionally, we have a developmental release that expands this functionality to 3D elements. We aim to expand this functionality as an on-going project.

We hope that Vortex-Radioss will facilitate the integration of OpenRadioss into existing CAE workflows and foster advanced CAE data science through the extensive Python ecosystem.

The library can be accessed here:

https://github.com/Vortex-CAE/Vortex-Radioss

Additional details on the library and a mailing list for future updates can be found here:

https://www.vortex-cae.com/vortex-radioss

[hrntsm]

Thank you for the excellent work. This will be very helpful for my job.

[PaulAltair]

Thank you for this great enhancement! I have updated the job submission gui: available here: Job Submission guis

So that there is now an option to run the Vortex-Radioss d3plot conversion at the end of a run if it is installed

[gservetti]

Hallo,

I have tried the converter to convert from Anim to D3Plot but I have some issues with Lasso, it says that cannot find 'lasso.dyna.d3plot'

[elequiniou]

Please, have a look at this thread, it might help you to figure out what is missing: https://github.com/orgs/OpenRadioss/discussions/2819
Hope this helps,
Eric

[gservetti]

Hallo,

Thanks for the link. I have found out that the version of python that I was using is still under the "bug-fixing" Python 3.12 which is one of the latest. I have downloaded an earlier version 3.11 and it solved the problem. However I have another message:

Mapping database
No files found..
Please check file stem:
e.g
C:/Folder/ModelA00*
Would be:
C:/Folder/Model*

It seems that it cannot find the anim radioss file to convert in D3plot.

If someone know how to solve this.

Thanks,
Guido

[Vortex-CAE]

Hi @gservetti, would you be able to share the command that you are running? We should be able to get this fixed,

Kind regards,
David

[gservetti]

Hallo,

This is the script that I have as for the converter. I have tried to run it in python but it gives me the error above.

from lasso.dyna.d3plot import D3plot
from lasso.dyna.d3plot import ArrayType

from vortex_radioss.animtod3plot.RadiossReader import RadiossReader

import numpy as np
import os
import time
from tqdm import tqdm
import glob
import re

class convert:
@staticmethod
def global_internal_energy(*data):
# conversion logic for global_internal_energy
return data

@staticmethod
def part_internal_energy(*data):
    # conversion logic for part_internal_energy
    return data

@staticmethod
def global_kinetic_energy(*data):
    # conversion logic for global_kinetic_energy
    return data

@staticmethod
def part_kinetic_energy(*data):
    # conversion logic for part_kinetic_energy
    return data

@staticmethod
def part_shell_mass(*data):
    
    # conversion logic for part_internal_energy
    
    node_coordinates    = data[0]
    shell_node_indexes  = data[1]
    shell_thicknesses   = data[2]
    shell_densities     = data[3]     
    shell_part_indexes  = data[4]
    shell_is_alive      = data[5]
    n_parts             = data[6][0]
    
    n1      = node_coordinates[shell_node_indexes][:,0]
    n2      = node_coordinates[shell_node_indexes][:,1]
    n3      = node_coordinates[shell_node_indexes][:,2]
    n4      = node_coordinates[shell_node_indexes][:,3]      
    ux      = n1[:,0] - n3[:,0]; uy = n1[:,1] - n3[:,1]; uz = n1[:,2] - n3[:,2]
    vx      = n4[:,0] - n2[:,0]; vy = n4[:,1] - n2[:,1]; vz = n4[:,2] - n2[:,2]        
    i       = uy*vz - uz*vy; j = uz*vx - ux*vz; k = ux*vy - uy*vx;
    area    = np.sqrt((i*i)+(j*j)+(k*k))*0.5
    mass    = area * shell_thicknesses * shell_densities * shell_is_alive                     
    _       = np.bincount(shell_part_indexes, mass, minlength = n_parts)        
         
    return _

@staticmethod
def rigid_body_velocity(*data):
    # conversion logic for rigid_body_velocity
    return data

@staticmethod
def sum2Scalars(*data):
    # sum of 2 scalar results
    half_size = len(data) // 2
    data1 = data[:half_size]
    data2 = data[half_size:]
    print(data1)
    print(data2)
    return sum(data1) + sum(data2)

@staticmethod
def element_shell_internal_energy(*data):
        
    # data[0] is shell energy per unit mass (Radioss units)
    # data[1] is shell density
    # out is shell energy per unit volume (LS-Dyna units)

    out = np.multiply(data[0], data[1])
                 
    return out   

@staticmethod
def element_shell_stress(*data):
    
    # Mid-surface stresses if present are not converted
    # Only Upper and Lower stresses are converted 
    # Out of plane stresses not converted
    # Co-ordinate systems not corrected for - should be OK for Von-Mises, Tresca etc and \
    # stress principles
    # [sx, sy, sz, sxy, syz, sxz]
    
    shell_num      = len(data[0])
    nip            = data[2][0] 
    
    out            = np.zeros(shape=(shell_num, nip, 6))              
    
    # Top integration point
    out[:, -1, 0]   = data[0][:, 0]
    out[:, -1, 1]   = data[0][:, 1]
    out[:, -1, 3]   = data[0][:, 2]
        
    # Bottom integration point
    out[:, 0, 0]   = data[1][:, 0]
    out[:, 0, 1]   = data[1][:, 1]
    out[:, 0, 3]   = data[1][:, 2]
    
    return out

@staticmethod
def element_shell_effective_plastic_strain(*data):
    
    # Mid-surface stresses if present are not converted
    # Only Upper and Lower stresses are converted         
    # [sx, sy, sz, sxy, syz, sxz]
    
    shell_num      = len(data[0])
    nip            = data[2][0] 
    
    out            = np.zeros(shape=(shell_num, nip))
        
    # Top integration point
    out[:, -1]   = data[0]

    # Bottom integration point
    out[:, 0]    = data[1]
    
    return out    

class readAndConvert:

def __init__(
    self,
    filepath: str = None,
    use_shell_mask=True,
    use_solid_mask=False,
    use_beam_mask=False,
    silent=False
):
    """Constructor for a readAndConvert

    Parameters
    ----------
    filepath: str
        path to a animation files

    Examples
    --------
        >>> from animtod3plot import Anim_to_D3plot
        >>> # read animation files and build d3plot file
        >>> a2d = Anim_to_D3plot.readAndConvert("path_to_animation_files")"""

    self._start=time.time()
    self._d3plot = D3plot()
    self.A_2_D(filepath, use_shell_mask, use_solid_mask, use_beam_mask, silent)

def sequential(input_array):
    
    "IDs defined as zero need unique, non-zero renumbering"    

    zero_num_start = max(input_array).astype('int64')
    mask = (input_array == np.zeros(len(input_array)))
    new_id = np.cumsum(mask) + zero_num_start
    output = np.where(mask, new_id, input_array)
    
    return output 

def generate_mask_map(input_array):
    
    unique, indices = np.unique(input_array, return_index=True)
    
    if unique[0]:
        mask_map = indices
    else:
        mask_map = indices[1:]
    
    return np.array(mask_map).astype(int)

def generate_display_entity(indexes, names, search_str_arr, show):
    
    if show:
        _ = np.zeros(shape=len(names))
        __ = 1
    else:
        _ = np.ones(shape=len(names))
        __ = 0

    for search_str in search_str_arr:       
        ___ = np.flatnonzero(np.core.defchararray.find(names,search_str)!=-1)

        _[___] = __

    display_array = np.array(_[indexes]).astype(bool)
    
    return display_array           

def generate_sorter(input_array):
       
   return np.argsort(input_array)

def invert_sorter(input_array, length):
    index_tracker = np.zeros(length) - 1
    index_tracker[input_array] = np.arange(0, input_array.size)    
       
    return np.array(index_tracker).astype(int)  

def apply_sorter(input_array, tracker_array):
    
    return input_array[tracker_array]   

def generate_random_name(length, ifile):
    import random
    import string
    # choose from all lowercase letter
    letters = string.ascii_lowercase
    result_str = ''.join(random.choice(letters) for i in range(length))
    return "_" + result_str + str(ifile)    

def LOGGER(self, string, silent):
    if not silent:
        print(string)

@staticmethod
def natural_sort_key(s):
    # Function to sort strings in human order (so file_stemA101 comes before file_stemA1000)
    return [int(text) if text.isdigit() else text.lower() for text in re.split('(\\d+)', s)]

def A_2_D(self,file_stem, use_shell_mask, use_solid_mask, use_beam_mask, silent):

    if os.path.isfile(file_stem + "d3plot"):
        return True

    #file_list = glob.glob(file_stem + "A*[0-1000]")
    file_list = glob.glob(file_stem + "*")
    file_list.sort(key=self.natural_sort_key)
    
    original_node_coordinates       = None
                   
    self.LOGGER("Mapping database", silent)
    
    if not file_list:
        print("No files found..\nPlease check file stem:\ne.g\nC:/Folder/ModelA00*\nWould be:\nC:/Folder/Model*")
        return
    else:
        rr = RadiossReader(file_list[0])  
    
    #rr.raw_header["nbElts1D"] = 0
    
    "We can optionally generate mask arrays that filter out elements that have an ID of zero - These are non-structural and are generated by Radioss for visualisations"
    "We sort the ids into ascending order and generate a mapping function for the scalar and tensor data"

    n_nodes = rr.raw_header["nbNodes"]
    
    n_shell = 0
    nip_shell = 2
    allowable_part_strings = ["_rigid_wall_",  ": RIGIDWALL_"]
    if rr.raw_header["nbFacets"] > 0:
         
        shell_ids_tracker = readAndConvert.generate_sorter(readAndConvert.sequential(rr.arrays["element_shell_ids"]))
        
        if use_shell_mask:
            
            # Masking can remove useful entities such as rigid walls
            # This will search a text array to match a string and return the boolean array to indicate should be shown
            # Changing True to False will generate the inverse array
            display_shell = readAndConvert.generate_display_entity(readAndConvert.apply_sorter(rr.arrays["element_shell_part_indexes"], shell_ids_tracker), rr.raw_arrays["pTextA"], allowable_part_strings, True) 

            # The shell mask function filters out any entity that has a id of zero
            # In order to keep entities from the bool array we employ a trick below
            # we create dummy unique ids that are non-zero for all elements that are active in the display shell array
            # This dummy array is then given to the masking function

            _ = max(rr.arrays["element_shell_ids"])
            dummy_id_offset = (np.cumsum(display_shell) + _)*display_shell.astype(bool)
            shell_mask = readAndConvert.generate_mask_map(readAndConvert.apply_sorter(rr.arrays["element_shell_ids"], shell_ids_tracker) + dummy_id_offset)

        else:
            shell_mask = np.arange(0, len(rr.arrays["element_shell_ids"]))
        
        
        shell_ids_tracker       = shell_ids_tracker[shell_mask]            
        element_shell_ids_out   =   readAndConvert.apply_sorter(readAndConvert.sequential(rr.arrays["element_shell_ids"]), shell_ids_tracker)               
        n_shell = len(element_shell_ids_out)
        
    if rr.raw_header["nbElts1D"] > 0:                                         
        
        beam_ids_tracker = readAndConvert.generate_sorter(readAndConvert.sequential(rr.arrays["element_beam_ids"]))
        element_beam_ids_out    =   readAndConvert.apply_sorter(readAndConvert.sequential(rr.arrays["element_beam_ids"]), beam_ids_tracker)

    if rr.raw_header["nbElts3D"] > 0:
        
        solid_ids_tracker = readAndConvert.generate_sorter(readAndConvert.sequential(rr.arrays["element_solid_ids"]))
        element_solid_ids_out   =   readAndConvert.apply_sorter(readAndConvert.sequential(rr.arrays["element_solid_ids"]), solid_ids_tracker)
           
    _                                                           = readAndConvert.sequential(rr.arrays["node_ids"])
    node_ids_tracker                                            = readAndConvert.generate_sorter(_)                
    inverted_node_ids_tracker                                   = readAndConvert.invert_sorter(node_ids_tracker, len(node_ids_tracker))
    original_node_coordinates                                   = readAndConvert.apply_sorter(rr.arrays["node_coordinates"], node_ids_tracker)
    
    node_ids_out = readAndConvert.apply_sorter(_, node_ids_tracker)
    
    self._d3plot.arrays[ArrayType.node_ids]                       = node_ids_out        
    
    "Parts and geometry"

    # We need to order the PIDs in numerical order - we generate tracking functions to map indexes correctly 
    
    if rr.raw_header["nbFacets"] > 0:
        
        shell_part_ids                                              =  np.array(rr.raw_arrays["pTextA"]).astype("U9").astype(int)
        shell_part_names                                            =  np.char.strip(np.array(list(np.char.split(rr.raw_arrays["pTextA"], sep=":")))[:,1])
        shell_part_num                                              = len(shell_part_ids)

    else:
        shell_part_ids                                              = []
        shell_part_names                                            = []
        shell_part_num                                              = 0
        
    if rr.raw_header["nbElts3D"] > 0:            
        element_solid_node_indexes = rr.arrays["element_solid_node_indexes"]            
        for i_solid, solid in enumerate(rr.arrays["element_solid_node_indexes"]):
            # Correct for tetra node connectivity
            _ = len(np.unique(solid))
            if _ == 4:
                __ = np.array([solid[0], solid[2], solid[4], solid[5], solid[5], solid[5], solid[5], solid[5]])
                if len(np.unique(__)) == 4:
                    element_solid_node_indexes[i_solid] = __
        solid_part_ids                                       =  np.array(rr.raw_arrays["pText3DA"]).astype("U9").astype(int)
        solid_part_names                                     =  np.char.strip(np.array(list(np.char.split(rr.raw_arrays["pText3DA"], sep=":")))[:,1])
    
    else:
        solid_part_ids                                      =   []             
        solid_part_names                                    =   []   
                    
    if rr.raw_header["nbElts1D"] > 0: 
       
        additional_beam_number                                      = rr.raw_header["nbElts1D"] - len(rr.arrays["element_beam_part_indexes"])
        additional_beams                                            = np.zeros(shape=(additional_beam_number))
        additional_beams.fill(max(rr.arrays["element_beam_part_indexes"])+1)
        element_beam_part_indexes                                   = np.concatenate([rr.arrays["element_beam_part_indexes"], additional_beams])
        self._d3plot.arrays[ArrayType.element_beam_ids]             = element_beam_ids_out
        element_beam_node_indexes=np.zeros(shape=(rr.raw_header["nbElts1D"],5))
        element_beam_node_indexes[:,0]                              = rr.arrays["element_beam_node_indexes"][:,0]
        element_beam_node_indexes[:,1]                              = rr.arrays["element_beam_node_indexes"][:,1]
        
        
        "Partless beams exists so we have to generate a dummy one"
        
        dummy_beam_pid = max(np.concatenate([shell_part_ids, np.array(rr.raw_arrays["pText1DA"]).astype("U9").astype(int), solid_part_ids])) +1
        beam_part_ids                                       =   np.concatenate([np.array(rr.raw_arrays["pText1DA"]).astype("U9").astype(int),np.array([dummy_beam_pid])])
        beam_part_num                                       =   len(beam_part_ids) 
       
        beam_part_names                                     =   np.array(list(np.char.split(rr.raw_arrays["pText1DA"], sep=":", maxsplit=1)))
        beam_part_names                                     =   np.char.strip(np.concatenate([beam_part_names[:,1], np.array(["ADDITIONAL VISUALISATION BEAMS"])]))
    else:
        beam_part_ids                                       =   []
        beam_part_names                                     =   []
        beam_part_num                                       =   0              

Generate Part trackers

    # Gather all part ids
    _                                                           = np.concatenate([shell_part_ids, beam_part_ids, solid_part_ids])

    # Gather all part names 
    __                                                          = np.concatenate([shell_part_names, beam_part_names, solid_part_names])        
    # Set all parts with invalid names' PIDS to zero
    
    ____ = np.array([])
    # Allowable part strings was defined under shell mask. As these parts have a PID of 0 we need to generate new PIDs.
    for search_str in allowable_part_strings:       
        ___ = np.flatnonzero(np.core.defchararray.find(__,search_str)!=-1)
        _[___] = 0
        ____ = np.concatenate([____,___]).astype(int)

    # Generate new unique PIDS with smallest value
    currently_valid_pids = (set(_))
    possible_pids = set(np.arange(len(_)+1))
    available_pids = list(possible_pids.difference(currently_valid_pids))
    available_pids.sort()
    # Assign and update the new PIDS
    _[____] = available_pids[:len(____)]
    
    
    # We now generate the first part sorter for this array
    n_parts                                                     = len(_)
    _part_ids_tracker                                            = readAndConvert.generate_sorter(_)
    
    # We need to check if any parts are empty and remove them from the d3plot
    sum_elements_by_part = np.zeros(len(_))
    if rr.raw_header["nbFacets"] > 0:
        _____   = readAndConvert.apply_sorter(rr.arrays["element_shell_part_indexes"], shell_ids_tracker)
        sum_elements_by_part = sum_elements_by_part + np.bincount(_____, np.ones(len(_____)), minlength = len(sum_elements_by_part)) 
    if rr.raw_header["nbElts1D"] > 0:
        _____   = readAndConvert.apply_sorter(element_beam_part_indexes, beam_ids_tracker).astype(int) + shell_part_num 
        sum_elements_by_part = sum_elements_by_part + np.bincount(_____, np.ones(len(_____)), minlength = len(sum_elements_by_part))             
    if rr.raw_header["nbElts3D"] > 0:
        _____   = readAndConvert.apply_sorter(rr.arrays["element_solid_part_indexes"], solid_ids_tracker) + shell_part_num + beam_part_num           
        sum_elements_by_part = sum_elements_by_part + np.bincount(_____, np.ones(len(_____)), minlength = len(sum_elements_by_part))      
    sum_elements_by_part = readAndConvert.apply_sorter(sum_elements_by_part, _part_ids_tracker).astype(int)
    
    # Any parts that have zero elements are removed
    # Generate the empty part tracker
    
    empty_part_tracker = np.array(np.arange(0,len(sum_elements_by_part)))[sum_elements_by_part.astype(bool)]

    invert_part_tracker = np.zeros(len(sum_elements_by_part))-1
    invert_part_tracker[empty_part_tracker] = empty_part_tracker
    
    # Update the part_ids_tracker to remove empty parts from all part arrays
    part_ids_tracker = _part_ids_tracker[empty_part_tracker]

    # Generate the inverse to map the element part index arrays to the new indexing
    inverted_part_ids_tracker                                   = readAndConvert.invert_sorter(part_ids_tracker, len(_))

Generate the main part arrays, titles, ids indexing etc

    # Part arrays these all need defining
    self._d3plot.arrays[ArrayType.part_ids]                     = readAndConvert.apply_sorter(_, part_ids_tracker).astype(int)
    # These are not IDS, this is a FORTRAN INDEX System
    self._d3plot.arrays[ArrayType.part_ids_unordered]           = readAndConvert.apply_sorter(_, part_ids_tracker).astype(int) 
    
    # Part titles are encoded into ascii binary
    __                                                          = np.array(readAndConvert.apply_sorter(__, part_ids_tracker))
    # Replace some strings with new strings
    __[np.where(__=="rby")[0]] = "Rigid elements"        
    
    #__ = ["a" for i in range(0,len(__))]
    
    self._d3plot.arrays[ArrayType.part_titles]                  = np.char.encode(np.array(__), encoding = "UTF-8")
    # Part masses are floats
    self._d3plot.arrays[ArrayType.part_mass]                    = np.array([np.zeros(len(__))]).astype("<f")
    self._d3plot.arrays[ArrayType.part_hourglass_energy]                    = np.array([np.zeros(len(__))]).astype("<f")
    

    self._d3plot.arrays[ArrayType.part_titles_ids]              = readAndConvert.apply_sorter(_, part_ids_tracker).astype(int)
    # Not an ID this is an index in Fortran starting at 1
    self._d3plot.arrays[ArrayType.part_ids_cross_references]    = np.arange(1,len(_) +1).astype("int64")
    

    
    if rr.raw_header["nbFacets"] > 0:
        # Assign the shell part indexes
        _   = readAndConvert.apply_sorter(rr.arrays["element_shell_part_indexes"], shell_ids_tracker)
        self._d3plot.arrays[ArrayType.element_shell_part_indexes]     = inverted_part_ids_tracker[_]
        self._d3plot.arrays[ArrayType.element_shell_ids]              = element_shell_ids_out.astype(int) 
        self._d3plot.arrays[ArrayType.element_shell_node_indexes]     = inverted_node_ids_tracker[readAndConvert.apply_sorter(rr.arrays["element_shell_node_indexes"], shell_ids_tracker).astype(int)  ]
    
    if rr.raw_header["nbElts1D"] > 0:
        # Assign the beam indexes
        _   = readAndConvert.apply_sorter(element_beam_part_indexes, beam_ids_tracker).astype(int) + shell_part_num            
        self._d3plot.arrays[ArrayType.element_beam_part_indexes]    = inverted_part_ids_tracker[_]
        self._d3plot.arrays[ArrayType.element_beam_node_indexes]    = inverted_node_ids_tracker[readAndConvert.apply_sorter(element_beam_node_indexes, beam_ids_tracker).astype(int)]
    
    if rr.raw_header["nbElts3D"] > 0:            
        # Assign the solid part indexes
        _   = readAndConvert.apply_sorter(rr.arrays["element_solid_part_indexes"], solid_ids_tracker) + shell_part_num + beam_part_num              
        self._d3plot.arrays[ArrayType.element_solid_part_indexes]   = inverted_part_ids_tracker[_]   
        self._d3plot.arrays[ArrayType.element_solid_ids]            = element_solid_ids_out.astype(int)  
        self._d3plot.arrays[ArrayType.element_solid_node_indexes]   = inverted_node_ids_tracker[readAndConvert.apply_sorter(element_solid_node_indexes, solid_ids_tracker)]
        
    self.LOGGER("Processing states", silent)
    
    for ifile, file in enumerate(tqdm(file_list, disable = silent)):            
        
        if ifile:
            rr = RadiossReader(file) 
            #rr.raw_header["nbElts1D"] = 0
            
        
        self._d3plot.arrays[ArrayType.node_coordinates]               = original_node_coordinates          
        
        "Node Updates"
                                                        
        self._d3plot.arrays[ArrayType.node_displacement]              = np.array([readAndConvert.apply_sorter(rr.arrays["node_coordinates"], node_ids_tracker)]).astype("<f")
           
        "Timestep Updates"
        timesteps                       = []              
        timesteps.append(rr.arrays["timesteps"])            
        
        "Shells"    
        if rr.raw_header["nbFacets"] > 0:
            element_shell_is_alive                                        = []
            element_shell_is_alive.append(readAndConvert.apply_sorter(rr.arrays["element_shell_is_alive"], shell_ids_tracker).astype("<f"))
            self._d3plot.arrays[ArrayType.element_shell_is_alive]         = np.array(element_shell_is_alive).astype("<f") 
                        
        "Beams"
        
        if rr.raw_header["nbElts1D"] > 0: 
            element_beam_is_alive           = []
            element_beam_is_alive.append(readAndConvert.apply_sorter(rr.arrays["element_beam_is_alive"], beam_ids_tracker).astype("<f"))
            self._d3plot.arrays[ArrayType.element_beam_is_alive]        = np.array(element_beam_is_alive).astype("<f") 

        "Solids"
        
        if rr.raw_header["nbElts3D"] > 0: 
            element_solid_is_alive                                      = []
            element_solid_is_alive.append(readAndConvert.apply_sorter(rr.arrays["element_solid_is_alive"], solid_ids_tracker))
            self._d3plot.arrays[ArrayType.element_solid_is_alive]       = np.array(element_solid_is_alive).astype("<f")                         
        
        "Global"
        self._d3plot.arrays[ArrayType.global_timesteps]             = np.array(timesteps)
                                                       
        if True:
            
            database_extent_binary ={}
            array_requirements = {}

            if rr.raw_header["nbNodes"] > 0:   
                
                flag = "NODES"
                
                database_extent_binary[flag] = {}      
                _ = database_extent_binary[flag]
                
                database_extent_binary[flag][0] = []
                database_extent_binary[flag][1] = _[0] + [ArrayType.node_velocity]  
                database_extent_binary[flag][2] = _[1] + [ArrayType.node_acceleration]  
                
                # Dyna output
                array_requirements[ArrayType.node_velocity] = {}
                _ = array_requirements[ArrayType.node_velocity]
                # Radioss outputs needed to compute Dyna output
                _["dependents"]     = ["node_velocity"]
                _["shape"]          = (1,n_nodes,3)
                _["convert"]        = None
                _["tracker"]        = node_ids_tracker
                _["additional"]     = []
                
                # Dyna output
                array_requirements[ArrayType.node_acceleration] = {}
                _ = array_requirements[ArrayType.node_acceleration]
                # Radioss outputs needed to compute Dyna output
                _["dependents"]     = ["node_acceleration"]
                _["shape"]          = (1,n_nodes,3)
                _["convert"]        = None
                _["tracker"]        = node_ids_tracker
                _["additional"]     = []
            
            if rr.raw_header["nbEFunc"] > 0:   
                
                flag = "SHELLS"
                
                database_extent_binary[flag] = {}      
                _ = database_extent_binary[flag]
                
                # [0] are essential arrays and need creating even if no data available
                
                database_extent_binary[flag][0] = []
                database_extent_binary[flag][0] = _[0] + [ArrayType.element_shell_is_alive]  
                database_extent_binary[flag][0] = _[0] + [ArrayType.element_shell_stress]    
                database_extent_binary[flag][0] = _[0] + [ArrayType.element_shell_effective_plastic_strain]
                
                database_extent_binary[flag][1] = _[0] + [ArrayType.element_shell_thickness]        
                database_extent_binary[flag][1] = _[1] + [ArrayType.element_shell_internal_energy]                        
                
                # Dyna output
                array_requirements[ArrayType.element_shell_thickness] = {}
                _ = array_requirements[ArrayType.element_shell_thickness]
                # Radioss outputs needed to compute Dyna output
                _["dependents"]     = ["element_shell_thickness"]
                _["shape"]          = (1,n_shell)
                _["convert"]        = None
                _["tracker"]        = shell_ids_tracker
                _["additional"]     = []
                
                # Dyna output
                array_requirements[ArrayType.element_shell_is_alive] = {}
                _ = array_requirements[ArrayType.element_shell_is_alive]
                # Radioss outputs needed to compute Dyna output
                _["dependents"]     = ["element_shell_is_alive"]
                _["shape"]          = (1,n_shell)
                _["convert"]        = None
                _["tracker"]        = shell_ids_tracker
                _["additional"]     = []
                
                # Dyna output
                array_requirements[ArrayType.element_shell_internal_energy] = {}
                _ = array_requirements[ArrayType.element_shell_internal_energy]
                # Radioss outputs needed to compute Dyna output
                _["dependents"]     = ["element_shell_specific_energy", "element_shell_density"]
                _["shape"]          = (1,n_shell)
                _["convert"]        = convert.element_shell_internal_energy
                _["tracker"]        = shell_ids_tracker
                _["additional"]     = []
                
               # Dyna output
                array_requirements[ArrayType.element_shell_stress] = {}
                _ = array_requirements[ArrayType.element_shell_stress]
                # Radioss outputs needed to comptute Dyna output
                _["dependents"]     = ["Stress (upper)","Stress (lower)"]
                _["shape"]          = (1,n_shell, nip_shell, 6)
                _["convert"]        = convert.element_shell_stress
                _["tracker"]        = shell_ids_tracker
                _["additional"]     = [nip_shell]
                
               # Dyna output
                array_requirements[ArrayType.element_shell_effective_plastic_strain] = {}
                _ = array_requirements[ArrayType.element_shell_effective_plastic_strain]
                # Radioss outputs needed to comptute Dyna output
                _["dependents"]     = ["element_shell_plastic_strain_upper", 'element_shell_plastic_strain_lower']
                _["shape"]          = (1, n_shell, nip_shell)
                _["convert"]        = convert.element_shell_effective_plastic_strain
                _["tracker"]        = shell_ids_tracker  
                _["additional"]     = [nip_shell]
               
            flag = "PARTS"
            
            database_extent_binary[flag] = {}      
            _ = database_extent_binary[flag]
            
            # Part masses for shells      
            if rr.raw_header["nbEFunc"] > 0: 
                
                database_extent_binary[flag][0] = []
                database_extent_binary[flag][0] = _[0] + [ArrayType.part_mass]   
                
                array_requirements[ArrayType.part_mass] = {}
                _ = array_requirements[ArrayType.part_mass]
                
                _["dependents"]     = ["node_coordinates","element_shell_node_indexes","element_shell_thickness",\
                                       "element_shell_density","element_shell_part_indexes", "element_shell_is_alive"]
                _["shape"]          = (1, n_parts)
                _["convert"]        = convert.part_shell_mass
                _["tracker"]        = part_ids_tracker     
                _["additional"]     = [n_parts]
                
        "Assign the arrays to the D3PLOT class for writing"
                    
        "Generate the availability check"
        
        dependency_check = {}
        flag_max        =  {}

        for flag in database_extent_binary:
            flag_max[flag] = -float('inf')
            _ = database_extent_binary[flag]
            for array_group in _:
                __ = _[array_group]
                for array_output in __:
                    # Check all dependencies exist
                    all_dependents_exist = True
                    ___ = array_requirements[array_output]["dependents"]
                    for check_dependent in ___:
                        if check_dependent not in rr.arrays:
                            all_dependents_exist = False
                            break
                
                    dependency_check[array_output] = all_dependents_exist
                    if all_dependents_exist:
                        flag_max[flag] = max(flag_max[flag],array_group) 
        
        "Generate the output arrays"

        for flag in database_extent_binary:
            _ = database_extent_binary[flag]
            for array_group in _:
                __ = _[array_group]
                
                if array_group <= flag_max[flag]:
                    for array_output in __:
                        if dependency_check[array_output]:
                            conversion_function = array_requirements[array_output]["convert"]
                            tracker             = array_requirements[array_output]["tracker"]
                            if conversion_function:
                                conversion_inputs   = [rr.arrays[i] for i in array_requirements[array_output]["dependents"]]
                                additional_inputs   = [i for i in array_requirements[array_output]["additional"]]
                                ___                   = conversion_function(*conversion_inputs, additional_inputs)
                                if tracker is not None:
                                    self._d3plot.arrays[array_output] = np.array(readAndConvert.apply_sorter(___, tracker)[np.newaxis, :]).astype("<f")
                                else:
                                    self._d3plot.arrays[array_output] = np.array(___[np.newaxis, :]).astype("<f")
                            else:
                                ___ = rr.arrays[array_requirements[array_output]["dependents"][0]]
                                if tracker is not None:
                                    self._d3plot.arrays[array_output] = np.array(readAndConvert.apply_sorter(___, tracker)[np.newaxis, :]).astype("<f")
                                else:
                                    self._d3plot.arrays[array_output] = np.array(___[np.newaxis, :]).astype("<f")
                        else:
                            self._d3plot.arrays[array_output] = np.zeros(shape=(array_requirements[array_output]["shape"])).astype("<f")
                                                                          
        "Write out the d3plot state"
                                    
        random_name = readAndConvert.generate_random_name(10, ifile)
        temp_d3plot_name = os.path.dirname(file_stem) + "/" + random_name
        
        d3plot_index = ifile+1
        if d3plot_index <100: 
            padding = 2
        else:
            padding = 3            
        
        "Remove old files"
        if ifile == 0:
            _ = file_stem + ".d3plot"
            if os.path.isfile(_):
                os.remove(_)
        _ = file_stem + ".d3plot" + str(d3plot_index).zfill(padding)
        if os.path.isfile(_):
            os.remove(_)           
        
        self._d3plot.header.itype = np.int64
        self._d3plot.header.ftype = np.float64
        self._d3plot.header.wordsize = 8      

        self._d3plot.write_d3plot(temp_d3plot_name, single_file = False)
        
        "Rename new files and remove temp files"
        if ifile == 0:
            _ = file_stem + ".d3plot"
            os.rename(temp_d3plot_name, _)
        else:
            os.remove(temp_d3plot_name)
            
        _ = file_stem + ".d3plot" + str(d3plot_index).zfill(padding)
        os.rename(temp_d3plot_name + "01", _)        
                                             
    return True

if name == 'main':

file_stem = "C:/Users/PC/Downloads/roofc/DynaOpt"

a2d = readAndConvert(file_stem, use_shell_mask=False, silent=False)

Thanks.

Kind Regards,
Guido

[gservetti]

Hallo,

I have run the script after removing the d3plot file and I have this output:

===================================================== RESTART: D:\SW\Python\testscript\test_readingfile2.py ====================================================
['D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A001', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A002', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A003', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A004', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A005', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A006', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A007', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A008', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A009', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A010', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A011', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A012', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A013', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A014', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A015', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A016', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A017', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A018', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A019', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A020', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A021', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A022', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A023', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A024', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A025', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A026', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A027', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A028', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A029', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A030', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A031', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A032', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A033', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A034', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A035', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A036', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A037', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A038', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A039', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A040', 'D:\SW\RADIOSS\OpenRadiossExamples\Test_exe_springback\DBEND_44A041']
Traceback (most recent call last):
File "D:\SW\Python\testscript\test_readingfile2.py", line 14, in
a2d = readAndConvert(file_stem, use_shell_mask=True, silent=False, I4R4=True)
TypeError: readAndConvert.init() got an unexpected keyword argument 'I4R4'

Looks something is wrong with the last line keyword I4R4

[Vortex-CAE]

Ah your version is slightly older than mine, the I4R4 option was added in recently. If you could please try it without the I4R4 option.

a2d = readAndConvert(file_stem, use_shell_mask=True, silent=False)

[gservetti]

Hallo,

I have tried without option I4R4 and looks is working converting in d3plot. However when I have tried in another folder for another job there is the following error:

The files that I want to convert are launchA001, launchA002, launchA002, up to launchA101

[gservetti]

Hallo

I have tried to run the last script that you suggested me and it is now working. My last reply with the error was about another script: 3dpconverter.py.

From now on I can use the one that you suggested me which this one:

from vortex_radioss.animtod3plot.Anim_to_D3plot import readAndConvert
import re
import glob

def natural_sort_key(s):
# Function to sort strings in human order (so file_stemA101 comes before file_stemA1000)
return [int(text) if text.isdigit() else text.lower() for text in re.split('(\d+)', s)]

file_stem = "D:\path\launchfile"
file_list = glob.glob(file_stem + "A*[0-9]")
file_list.sort(key=natural_sort_key)
print(file_list)

a2d = readAndConvert(file_stem, use_shell_mask=True, silent=False)

I have tried it for few examples and it is working.

Thank you very much for your support, much appreciated.

[Vortex-CAE]

Not a problem @gservetti, hope that you enjoy the library!

Kind regards,
David

[gservetti]

I have tried to manually insert the path at the end of the script so I put:

#file_stem = "C:/Users/PC/Downloads/roofc/DynaOpt"
file_stem = "D:/SW/RADIOSS/OpenRadiossExamples/Test_exe_springback"

but when I try to run the script the following error appear:

Traceback (most recent call last):
File "D:\SW\RADIOSS\OpenRadioss\exec\d3convert.py", line 735, in
a2d = readAndConvert(file_stem, use_shell_mask=False, silent=False)
File "D:\SW\RADIOSS\OpenRadioss\exec\d3convert.py", line 163, in init
self.A_2_D(filepath, use_shell_mask, use_solid_mask, use_beam_mask, silent)
File "D:\SW\RADIOSS\OpenRadioss\exec\d3convert.py", line 253, in A_2_D
rr = RadiossReader(file_list[0])
File "D:\SW\RADIOSS\OpenRadioss\exec\vortex_radioss\animtod3plot\RadiossReader.py", line 203, in init
self.load_file(filepath)
File "D:\SW\RADIOSS\OpenRadioss\exec\vortex_radioss\animtod3plot\RadiossReader.py", line 313, in load_file
bb = self._read_file_buffer(file)
File "D:\SW\RADIOSS\OpenRadioss\exec\vortex_radioss\animtod3plot\RadiossReader.py", line 227, in _read_file_buffer
bb = BinaryBuffer(filepath)
File "C:\Users\CAE1\AppData\Local\Programs\Python\Python311\Lib\site-packages\lasso\io\binary_buffer.py", line 27, in init
self.load(filepath, n_bytes)
File "C:\Users\CAE1\AppData\Local\Programs\Python\Python311\Lib\site-packages\lasso\io\binary_buffer.py", line 266, in load
with open(path, "br") as fp:
PermissionError: [Errno 13] Permission denied: 'D:/SW/RADIOSS/OpenRadiossExamples\Test_exe_springback'

I am not sure if there is something else that need to be change?

Thanks

[Vortex-CAE]

Hi @gservetti,

Can you please try?

file_stem = "C:\Users\PC\Downloads\roofc\DynaOpt"

[gservetti]

Hallo,

I have tried as suggested but I have the problem as before:

Mapping database
No files found..
Please check file stem:
e.g
C:/Folder/ModelA00*
Would be:
C:/Folder/Model*

Thanks

[gservetti]

Hallo,

I have tried as suggested but I have the problem as before:

Mapping database
No files found..
Please check file stem:
e.g
C:/Folder/ModelA00*
Would be:
C:/Folder/Model*

Thanks

[JaswanthGangolu]

Hi,

I would like to have an access to d3plot convertor. Could you let me know the procedure?

[sebastienVilleneuve]

Hi @JaswanthGangolu

Tool is now public , available here : https://github.com/Vortex-CAE/Vortex-Radioss

Regards,
Sébastien

[JaswanthGangolu]

Hi,

I need your help in installing lasso-python and vortex radioss in converting VTK files to Ls Prepost d3plot. I am using Windows 64 OS. Is it possible to install?

[SyazwanSamad]

Vortex-Radioss converts Anim file to d3plot (not vtk to d3plot). Since it is based on Python, it should work in most platform.
Anyway, the step will be:

1. Install Python (make sure that you add python to PATH environment variable)
2. Install lasso-python. Use 'pip install lasso-python' in cmd prompt.
3. Download the Vortex-Radioss library. You can use it directly or put it into the library (site-packages). There's instructions on how to use Vortex-radioss in the GitHub page.

Regards