def Mods(Fracs, Beads, Denss): pre = 'results/snapshots/coordination_analysis/f_' for Frac in Fracs: f = int((1 - Frac) * 10 % 10) for Bead in Beads: # os.makedirs('./'+str(pre)+str(f)+'/b_'+str(Bead)) for Dens in Denss: data = import_file('./frac_' + str(Frac) + '/m_' + str(Bead) + '/d_' + str(Dens) + '/final_snapshot.xyz') co = ((Bead * 1000) / Dens)**(1 / 3) modifier = CoordinationAnalysisModifier(cutoff=co / 2, partial=True, number_of_bins=180) data.modifiers.append(modifier) export_file( data, str(pre) + str(f) + "/b_" + str(Bead) + "/d_" + str(Dens) + ".txt", "txt/table") exit()
def vacancylabel_io(file_path, filename): orig_dir = os.getcwd() try: os.chdir(file_path) except: print('Couldn' 't find that directory, check syntax (/mnt/d/UserName/...)') sys.exit(1) try: pipeline = import_file(filename) except: print('File not found (check the name and that you' 're in the right directory)') sys.exit(1) wigmod = WignerSeitzAnalysisModifier( per_type_occupancies=True, affine_mapping=ReferenceConfigurationModifier.AffineMapping.ToReference ) wigmod.reference = FileSource() try: wigmod.reference.load('FCCreference.lmp') except: print('FCCreference.lmp was not found!') sys.exit(1) pipeline.modifiers.append(wigmod) pipeline.modifiers.append( ComputePropertyModifier(output_property='Particle Type', expressions='3')) # see custom modifier above pipeline.modifiers.append(modify) pipeline.modifiers.append(InvertSelectionModifier()) pipeline.modifiers.append(DeleteSelectedModifier()) # export a file with the vacancies only (type = 3) export_file(pipeline, filename.split('.')[0] + "vacancies.xyz", "xyz", columns=[ 'Particle Identifier', 'Particle Type', 'Position.X', 'Position.Y', 'Position.Z' ], multiple_frames=True) # new pipeline to combine the vacancies with the original data (this will append the vacancies at the end of the Particle IDs and reassign new IDs accordingly) newpipeline = import_file(filename) mod = CombineDatasetsModifier() mod.source.load(filename.split('.')[0] + 'vacancies.xyz') newpipeline.modifiers.append(mod) # make a new file with the vacancies and all atoms included for visualization export_file(newpipeline, "new" + filename.split('.')[0] + ".xyz", "xyz", columns=[ 'Particle Identifier', 'Particle Type', 'Position.X', 'Position.Y', 'Position.Z' ], multiple_frames=True) os.chdir(orig_dir)
def write_lammps_data(ftxt, atoms, **kwargs): # FAIL: use ase.io.write(ftxt, atoms, format='lammps-data', atom_style='charge') from ovito.io import export_file from ovito.pipeline import StaticSource, Pipeline from ovito.io.ase import ase_to_ovito atoms.set_initial_charges(atoms.get_initial_charges()) dc = ase_to_ovito(atoms) #dc.particles.masses = np.ones(len(atoms)) #dc.particles_.create_property('masses', data=atoms.get_masses()) pl = Pipeline(source=StaticSource(data=dc)) export_file(pl, ftxt, 'lammps/data', atom_style='charge')#**kwargs)
def Mods(Fracs, Beads, Denss, Inters): for Frac in Fracs: frac = int((1-Frac)*10%10) print(frac) print('') for Bead in Beads: print(Bead) print('') for Dens in Denss: print(Dens) print('') for Inter in Inters: print(Inter) print('') File = f'centros_de_massas/{Inter}/f_{frac}-b_{Bead}-d_{Dens}.xyz' path = f'centros_de_massas/{Inter}/rdfs/f-' data = import_file(File) co = ((Bead*1000)/Dens)**(1/3) modifier = CoordinationAnalysisModifier(cutoff = co/2, number_of_bins = 60) data.modifiers.append(modifier) export_file(data, path+str(frac)+"_b-"+str(Bead)+"_d-"+str(Dens)+".txt", "txt/table") print('Done. Next Inter') print('Done. Next Dens') print('Done. Next Bead') print('Done. Next Frac') print('') print('that\'s all, folks!') exit()
def write_lammps_dump(fout, fxyz, charge=False, columns=None): import os if os.path.isfile(fout): raise RuntimeError('%s exists' % fout) from ovito.io import import_file, export_file pl = import_file(fxyz) if columns is None: columns = ["Particle Identifier", "Particle Type", "Position.X", "Position.Y", "Position.Z"] if charge: cname = 'Charge' columns += [cname] def add_charge(frame, data): data.particles_.create_property(cname, data=data.particles['initial_charges']) pl.modifiers.append(add_charge) export_file(pl, fout, 'lammps/dump', columns=columns, multiple_frames=True)
def Mods(Fracs, Beads, Denss): pre = 'results/snapshots/coordination_analysis/f_' for Frac in Fracs: f = int((1-Frac)*10%10) for Bead in Beads: os.makedirs('./'+str(pre)+str(f)+'/b_'+str(Bead)) for Dens in Denss: data = import_file('./frac_'+str(Frac)+'/m_'+str(Bead)+'/d_'+str(Dens)+'/final_snapshot.xyz') data.modifiers.append(modifier) export_file(data, str(pre)+str(f)+"/b_"+str(Bead)+"/d_"+str(Dens)+".txt", "txt/table") exit()
def to_lammps(trjfile: str, indices_per_atom: npt.NDArray[np.float64]) -> str: pipeline = import_file(trjfile, sort_particles=True) for frame, linde in enumerate(indices_per_atom): data = pipeline.compute(frame) data.particles_.create_property("lindemann", data=linde) export_file( data, f"lindemann_outputfile_X{frame}.dump", "lammps/dump", columns=[ "Particle Identifier", "Particle Type", "Position.X", "Position.Y", "Position.Z", "lindemann", ], multiple_frames=True, ) """ This is section is weird and very hacky, I dont like it. Does someone have a idea how to do this in a better way? First I save the files with the ovito export_file, then I save them in a file, finally I remove the files... I know... """ filenames = [f"lindemann_outputfile_X{frame}.dump" for frame in range(len(indices_per_atom))] file_name = "lindemann_per_atom.lammpstrj" with open(file_name, "w") as outfile: for fname in filenames: with open(fname) as infile: outfile.write(infile.read()) for frame in range(len(indices_per_atom)): os.remove(f"lindemann_outputfile_X{frame}.dump") return "saved trajectory as lindemann_per_atom.lammpstrj"
import sys if "ovito.modifiers.crystalanalysis" not in sys.modules: sys.exit() from ovito.io import import_file, export_file from ovito.data import SurfaceMesh from ovito.modifiers import ConstructSurfaceModifier # Load a particle set and construct the surface mesh: pipeline = import_file("simulation.dump") pipeline.modifiers.append(ConstructSurfaceModifier(radius=2.8)) mesh = pipeline.compute().expect(SurfaceMesh) # Export the mesh to a VTK file for visualization with ParaView. export_file(mesh, 'surface_mesh.vtk', 'vtk/trimesh')
import argparse from ovito.io import export_file, import_file from ovito.modifiers import CommonNeighborAnalysisModifier parser = argparse.ArgumentParser() parser.add_argument('--input_file', '-i', help='Input grain boundary struct file to produce cumulative energy.') args = parser.parse_args() #initialize node and import file node = import_file(args.input_file) cna = CommonNeighborAnalysisModifier() node.modifiers.append(cna) node.compute() export_file(node, "output.xyz", "xyz", columns = ["Particle Identifier", "Particle Type", "Position.X", "Position.Y", "Position.Z", "Potential Energy", "Structure Type"])
from ovito.io import import_file, export_file from ovito.modifiers import DislocationAnalysisModifier from ovito.data import DislocationNetwork pipeline = import_file("input/simulation.dump") # Extract dislocation lines from a crystal with diamond structure: modifier = DislocationAnalysisModifier() modifier.input_crystal_structure = DislocationAnalysisModifier.Lattice.CubicDiamond pipeline.modifiers.append(modifier) data = pipeline.compute() total_line_length = data.attributes['DislocationAnalysis.total_line_length'] cell_volume = data.attributes['DislocationAnalysis.cell_volume'] print("Dislocation density: %f" % (total_line_length / cell_volume)) # Print list of dislocation lines: print("Found %i dislocation segments" % len(data.dislocations.segments)) for segment in data.dislocations.segments: print("Segment %i: length=%f, Burgers vector=%s" % (segment.id, segment.length, segment.true_burgers_vector)) print(segment.points) # Export dislocation lines to a CA file: export_file(pipeline, "output/dislocations.ca", "ca") # Or export dislocations to a ParaView VTK file: export_file(pipeline, "output/dislocations.vtk", "vtk/disloc”)
from ovito.pipeline import StaticSource, Pipeline from ovito.data import SimulationCell from ovito.modifiers import CreateBondsModifier from ovito.io import export_file # Create a new Pipeline with a StaticSource as data source: pipeline = Pipeline(source=StaticSource()) # Insert a new SimulationCell object into the StaticSource: cell = SimulationCell(pbc=(False, False, False)) with cell.modify() as matrix: matrix[:, 0] = (4, 0, 0) matrix[:, 1] = (0, 2, 0) matrix[:, 2] = (0, 0, 2) pipeline.source.objects.append(cell) # Insert two particles into the StaticSource: xyz = [[0, 0, 0], [2, 0, 0]] pipeline.source.particle_properties.create('Position', data=xyz) # Apply a modifier: pipeline.modifiers.append(CreateBondsModifier(cutoff=3.0)) # Write pipeline results to an output file: export_file(pipeline, 'output.data', 'lammps/data', atom_style='bond')
# Compute the structure factor and find the height of the first peak sf = np.zeros(k_len) i = 0 for k in k_list: sin_sum = np.sum(np.sin(k * x)) cos_sum = np.sum(np.cos(k * x)) sf[i] = (np.power(sin_sum, 2) + np.power(cos_sum, 2)) / N i = i + 1 av_sf = av_sf + sf / k_len peak_h = av_sf[np.argmax(av_sf[60:120]) + 60] np.savetxt(output_file_av_sf, [av_sf]) output_file_shear.write(shear_rate + " ") np.savetxt(output_file_peak, [peak_h]) export_file(node, output_filepath + '/config_check_' + str(shear_rate) + '.dump', 'lammps/dump', columns=["Position.X", "Position.Y", "Position.Z"], multiple_frames=False) else: print("File: " + input_file_dir + str(shear_rate) + input_file + " not found") output_file_shear.close() output_file_av_sf.close() output_file_peak.close()
# Calculate per-particle displacements with respect to initial simulation frame: dmod = CalculateDisplacementsModifier() dmod.reference.load("C:/work/test") node.modifiers.append(dmod) # Define the custom modifier function: def modify(frame, input, output): # Access the per-particle displacement magnitudes computed by an existing # Displacement Vectors modifier that precedes this custom modifier in the # data pipeline: displacement_magnitudes = input.particle_properties.displacement_magnitude.array # Compute MSD: msd = numpy.sum(displacement_magnitudes**2) / len(displacement_magnitudes) # Output MSD value as a global attribute: output.attributes["MSD"] = msd # Insert custom modifier into the data pipeline. node.modifiers.append(PythonScriptModifier(function=modify)) # Export calculated MSD value to a text file and let OVITO's data pipeline do the rest: export_file(node, "C:\work\msd_test.txt", format="txt", columns=["Timestep", "MSD"], multiple_frames=True)
# Create bonds. pipeline.modifiers.append(CreateBondsModifier(cutoff=3.2)) # Identifying the Structure type and dislocations pipeline.modifiers.append(DislocationAnalysisModifier()) # Used for detecting the shell of the simulation box pipeline.modifiers.append(CentroSymmetryModifier()) # Get the type of stacking fault. pipeline.modifiers.append(pair_analysis) data = pipeline.compute() output_name = 'pair.' + input_name # Save the sanpshot with the Fault Type. export_file(data, output_name, "lammps/dump", columns=["Particle Identifier", "Particle Type", "Structure Type", "Position.X", "Position.Y", "Position.Z", 'Pair', 'Fault Type']) # Delete all of the bulk particles but leave the outer surface. pipeline.modifiers.append(ExpressionSelectionModifier(expression='FaultType == 0 && Centrosymmetry < 9')) pipeline.modifiers.append(DeleteSelectedModifier()) # increase the transparency of the outer surface particles. pipeline.modifiers.append(ExpressionSelectionModifier(expression='Centrosymmetry > 9 && Position.X >15')) transparency = 0.9 pipeline.modifiers.append(ComputePropertyModifier( output_property='Transparency', expressions=[str(transparency)], only_selected=True)) dark = [0.6, 0.3]
from ovito.io import import_file, export_file from ovito.modifiers import CombineParticleSetsModifier # Load a first set of particles. pipeline = import_file('first_file.dump') # Insert the particles from a second file into the dataset. modifier = CombineParticleSetsModifier() modifier.source.load('second_file.dump') pipeline.modifiers.append(modifier) # Export combined dataset to a new file. export_file(pipeline, 'output.dump', 'lammps/dump', columns=['Position.X', 'Position.Y', 'Position.Z'])
import sys if "ovito.modifiers.crystalanalysis" not in sys.modules: sys.exit() from ovito.io import import_file, export_file from ovito.modifiers import DislocationAnalysisModifier pipeline = import_file("simulation.dump") # Extract dislocation lines from a crystal with diamond structure: modifier = DislocationAnalysisModifier() modifier.input_crystal_structure = DislocationAnalysisModifier.Lattice.CubicDiamond pipeline.modifiers.append(modifier) data = pipeline.compute() total_line_length = data.attributes['DislocationAnalysis.total_line_length'] cell_volume = data.attributes['DislocationAnalysis.cell_volume'] print("Dislocation density: %f" % (total_line_length / cell_volume)) # Print list of dislocation lines: network = data.dislocations print("Found %i dislocation segments" % len(network.segments)) for segment in network.segments: print("Segment %i: length=%f, Burgers vector=%s" % (segment.id, segment.length, segment.true_burgers_vector)) print(segment.points) # Export dislocation lines to a CA file: export_file(pipeline, "dislocations.ca", "ca") # Or export dislocations to a ParaView file: export_file(pipeline, "dislocations.vtk", "vtk/disloc")
disp_awin = uf.calc_win_disps(num_atoms, ndump_avgw, A_window, input_dump_wc, pipeline) disp_bwin = uf.calc_win_disps(num_atoms, ndump_avgw, B_window, input_dump_wc, pipeline) avg_pos = 0 * pos_pbd tot_ndw = 2 * ndump_avgw + 1 for ct1 in range(3): avg_disp = ( (np.sum(disp_awin[ct1], axis=1) + np.sum(disp_bwin[ct1], axis=1)) / (tot_ndw)) avg_pos[:, ct1] = (pos_pbd[:, ct1] - avg_disp) data.particles.create_property('Position', data=avg_pos) ########################## # dumping the adjusted files ########################### dname = avg_xcoor_dir + avg_fwc + str(tstep) + '.out' oio.export_file(data, dname, format="lammps_dump", columns=[ "Particle Identifier", "Particle Type", "Position.X", "Position.Y", "Position.Z", "c_csym" ], frame=tstep) pipeline = [] sys.path.remove(dir_path)
output_property="Radius", only_selected=True)) node.modifiers.append( mods.AssignColorModifier(color=(204 / 255, 255 / 255, 229 / 255))) #node.modifiers.append(mods.ComputePropertyModifier(expressions=[monomer_bead_radius],output_property="Transparency",only_selected=False)) monomer_expression = " || ".join([ "MoleculeIdentifier == {}".format(mol) for mol in args.mon_list.split(",") ]) print(monomer_expression) node.modifiers.append( mods.SelectExpressionModifier(expression=monomer_expression)) #node.modifiers.append(mods.ComputePropertyModifier(expressions=[transparency],output_property="Transparency",only_selected=True)) #node.modifiers.append(mods.InvertSelectionModifier()) node.modifiers.append(mods.DeleteSelectedParticlesModifier()) io.export_file(node, 'output.data', format="lammps_data", atom_style="angle") vp = vis.Viewport() vp.type = vis.Viewport.Type.PERSPECTIVE vp.camera_pos = (-20, 20, -20) vp.camera_dir = (3, -2, 3) vp.fov = math.radians(60.0) settings = vis.RenderSettings() settings.renderer = vis.TachyonRenderer() settings.renderer.shadows = True settings.filename = args.dest_folder + '/' + args.imagename settings.size = (800, 600) node.add_to_scene() vp.render(settings)
#!/usr/bin/env python3 import sys from ovito.io import import_file, export_file if len(sys.argv) not in [2, 3] or sys.argv[1] == "-h": print("Syntax: lammps_last_frame.py lammps_dump [output]") sys.exit(1) try: output = sys.argv[2] except IndexError: output = "last_frame.xyz" data = import_file(sys.argv[1]) last = data.compute(data.source.num_frames) export_file( last, output, "xyz", columns=["Particle Type", "Position.X", "Position.Y", "Position.Z"], )
def write(atoms, filename, bond_specs=None, atom_style="molecular", size=(640, 480), camera_dir=(2, 1, -1), viewport_type="perspective", atom_radii=None): """Write atoms to lammps data file :param atoms: The atoms object to write to file :type atoms: ase.Atoms :param filename: filename to write to. Can either have suffix `.data` or `.png`, in which case a Lammps data file or a png picture will be produced, respectively. :type filename: str :param bonds_spec: List of (element1, element2, cutoff) :type bonds_spec: List of tuples """ import os suffix = os.path.splitext(filename)[1] if not suffix in [".data", ".png"]: raise ValueError(f"Invalid file format {suffix}") import tempfile import os from ase.formula import Formula # Using tempfile and write + read rather than ovito's ase_to_ovito and back because the # ordering of particle types for some (bug) reason becomes unpredictable with tempfile.TemporaryDirectory() as tmp_dir: symbols = list(Formula(atoms.get_chemical_formula()).count().keys()) symbols_dict = {} for i, symbol in enumerate(symbols): symbols_dict[symbol] = i + 1 atoms.write(os.path.join(tmp_dir, "tmp.data"), format="lammps-data", specorder=symbols) from ovito.io import import_file, export_file from ovito.modifiers import CreateBondsModifier pipeline = import_file(os.path.join(tmp_dir, "tmp.data")) types = pipeline.source.data.particles_.particle_types for symbol, i in symbols_dict.items(): types.type_by_id(i).name = symbol types.type_by_id(i).load_defaults() if not atom_radii is None: types = pipeline.source.data.particles.particle_types for pair in atom_radii: types.type_by_id(symbols_dict[pair[0]]).radius = pair[1] # Accept a single tuple not contained in a list if there is only one bond type. if not bond_specs is None: bondsmodifier = CreateBondsModifier( mode=CreateBondsModifier.Mode.Pairwise) if not isinstance(bond_specs, list) and isinstance( bond_specs, tuple): bond_specs = [bond_specs] for element in bond_specs: bondsmodifier.set_pairwise_cutoff(symbols_dict[element[0]], symbols_dict[element[1]], element[2]) pipeline.modifiers.append(bondsmodifier) pipeline.compute() if suffix == ".data": export_file(pipeline, filename, "lammps/data", atom_style=atom_style) elif suffix == ".png": from ovito.vis import Viewport, TachyonRenderer, OpenGLRenderer pipeline.add_to_scene() if viewport_type == "perspective": vp = Viewport(type=Viewport.Type.Perspective, camera_dir=camera_dir) elif viewport_type == "orthogonal": vp = Viewport(type=Viewport.Type.Ortho, camera_dir=camera_dir) else: raise ValueError( "viewport type has to be perspective or orthogonal") vp.zoom_all(size=size) vp.render_image(filename=filename, size=size, renderer=TachyonRenderer()) pipeline.remove_from_scene()
# Calculate per-particle displacements with respect to initial simulation frame: dmod = CalculateDisplacementsModifier() dmod.reference.load("simulation.dump") node.modifiers.append(dmod) # Define the custom modifier function: def modify(frame, input, output): # Access the per-particle displacement magnitudes computed by an existing # Displacement Vectors modifier that precedes this custom modifier in the # data pipeline: displacement_magnitudes = input.particle_properties.displacement_magnitude.array # Compute MSD: msd = numpy.sum(displacement_magnitudes**2) / len(displacement_magnitudes) # Output MSD value as a global attribute: output.attributes["MSD"] = msd # Insert custom modifier into the data pipeline. node.modifiers.append(PythonScriptModifier(function=modify)) # Export calculated MSD value to a text file and let OVITO's data pipeline do the rest: export_file(node, "msd_data.txt", format="txt", columns=["Timestep", "MSD"], multiple_frames=True)
import sys #from ovito.vis import Viewport, TachyonRenderer strFilename = str( sys.argv[1] ) #assumes "ovitos PMStructure.py strFilename fltRMSD "command line fltRMSD = float(sys.argv[2]) pipeline = io.import_file(strFilename, multiple_frames=True) n = pipeline.source.num_frames pipeline.add_to_scene() pipeline.modifiers.append( om.ElasticStrainModifier(calculate_strain_tensors=False, lattice_constant=4.05)) pipeline.modifiers.append( om.PolyhedralTemplateMatchingModifier(rmsd_cutoff=fltRMSD, output_orientation=False) ) #this needs to be last otherwise the structure types are not updated pipeline.compute() #vp = Viewport(type = Viewport.Type.Top) #vp.zoom_all() #vp.render_image(filename=strFilename + '.png', size=(320, 240),frame=n-1, renderer=TachyonRenderer()) #print(pipeline.output) #debug information io.export_file(pipeline, strFilename + 'PM', "lammps_dump", frame=n, columns=[ 'Particle Identifier', 'Position.X', 'Position.Y', 'Position.Z', 'Velocity.X', 'Velocity.Y', 'Velocity.Z', 'c_pe1', 'c_v[1]', 'Structure Type', 'Volumetric Strain' ])
from ovito.io import import_file, export_file from ovito.modifiers import DislocationAnalysisModifier node = import_file("simulation.dump") # Extract dislocation lines from a crystal with diamond structure: modifier = DislocationAnalysisModifier() modifier.input_crystal_structure = DislocationAnalysisModifier.Lattice.CubicDiamond node.modifiers.append(modifier) node.compute() total_line_length = node.output.attributes[ 'DislocationAnalysis.total_line_length'] print("Dislocation density: %f" % (total_line_length / node.output.cell.volume)) # Print list of dislocation lines: network = node.output.dislocations print("Found %i dislocation segments" % len(network.segments)) for segment in network.segments: print("Segment %i: length=%f, Burgers vector=%s" % (segment.id, segment.length, segment.true_burgers_vector)) print(segment.points) # Export dislocation lines to a CA file: export_file(node, "dislocations.ca", "ca")
newtyp, newq, newpos = create_tms_molecule_planar(rp, rho / rhoNorm) s = 13 * iTMS + identif_array.size for j in range(newtyp.size): new_pos_prop.marray[s,:] = newpos[j,:] new_type_prop.marray[s] = newtyp[j] new_identifier_prop.marray[s] = s + 1 new_charge_prop.marray[s] = newq[j] s = s + 1 new_data = DataCollection() new_data.add(new_pos_prop) new_data.add(new_identifier_prop) new_data.add(new_type_prop) new_data.add(new_charge_prop) new_data.add(node.source.cell) if "Timestep" in node.source.attributes: new_data.attributes['Timestep'] = node.source.attributes["Timestep"] new_node = ovito.ObjectNode() new_node.source = new_data new_node.compute() #new_node.add_to_scene() print("... new number of particles %d"%(new_node.output.particle_properties['Particle Type'].size)) print(new_node.output.particle_properties["Particle Type"].array) export_file(new_node, sys.argv[3], "lammps_dump", columns=["Particle Identifier", "Particle Type", "Charge" ,"Position.X", "Position.Y", "Position.Z"]) print("... done writing LAMMPS data file %s"%(args.outfname))
#!/usr/bin/env python3 import sys if not 2 <= len(sys.argv) <= 3: sys.exit("Uses Ovito to read in a datafile and write an xyz.\n" "Atom type labels must be present in the Masses section\n" "i.e. 7 12.011 # C3\n" "Syntax: datafile_to_wrapped_xyz.py input [output (optional)]") from ovito.io import import_file, export_file from ovito.modifiers import UnwrapTrajectoriesModifier traj = sys.argv[1] if len(sys.argv) == 2: output = traj.rsplit('.')[0] + '.wrapped.xyz' else: output = sys.argv[2] pipeline = import_file(traj, atom_style='full') export_file( pipeline, output, 'xyz', columns=["Particle Type", "Position.X", "Position.Y", "Position.Z"])
from ovito.io import import_file, export_file from ovito.modifiers import (CoordinationNumberModifier, FreezePropertyModifier, ExpressionSelectionModifier) # Load a input simulation sequence. pl = import_file("simulation.*.dump") # Add modifier for computing the coordination numbers of particles. pl.modifiers.append(CoordinationNumberModifier(cutoff=2.9)) # Save the initial coordination numbers from frame 0 under a new name. modifier = FreezePropertyModifier(source_property='Coordination', destination_property='Coord0', freeze_at=0) pl.modifiers.append(modifier) # Select all particles whose coordination number has changed since frame 0 # by comapring the dynamically computed coordination numbers with the frozen ones. pl.modifiers.append( ExpressionSelectionModifier(expression='Coordination != Coord0')) # Write out number of particles exhibiting a change in coordination number. export_file(pl, 'output.txt', 'txt', columns=['Timestep', 'SelectExpression.num_selected'], multiple_frames=True)
def extractFrames( topology_file='datafile.lammps', # lammps data file trajectory_file='trajectory.nc', # netcdf trajectory frames=None, # list of frame numbers outfile_name=None, # list of outfiles, same length as frames outfile_pattern='frame_{:08d}.lammps', atom_style='full'): """Extracts selected or all frames from a NetCDF trajectory. Parameters ---------- topology_file : str, optional LAMMPS data file, per default atom style 'full' trajectory_file: str, optional Trajectory file (atom positions) in NetCDF format frames: :obj:`list` of :obj:`int`, optional Arbitrary selection of frames. Per default, all frames extracted. outfile_name :obj:`dict` of :obj:`int` : :obj:`str`, optional Dictionary assigning output file name for every selected frame. outfile_pattern: str, optional If `outfile_name` not given, output file names are constructed from this pattern and frame number. Must conatin some {:d} integer placeholder, i.e. 'frame_{:08d}.lammps' atom_style: str, optional LAMMPS atom sytle as understood by ovitos """ from ovito.io import import_file, export_file from ovito.modifiers import LoadTrajectoryModifier logger = logging.getLogger('netcdf2data.extractFrames') logger.info("Reading topology from '{:s}'".format(topology_file)) # Load static topology data from a LAMMPS data file. node = import_file(topology_file, atom_style=atom_style) logger.info("Reading trajectory from '{:s}'".format(trajectory_file)) # Load atom trajectories from separate LAMMPS dump file. traj_mod = LoadTrajectoryModifier() traj_mod.source.load(trajectory_file, multiple_frames=True) # Insert modifier into modification pipeline. node.modifiers.append(traj_mod) if frames is None: frames = range(traj_mod.source.num_frames) if outfile_name is None: outfile_name = { frame: outfile_pattern.format(frame) for frame in frames } for frame in frames: try: logger.info("Storing frame {:08d} to '{:s}'".format( frame, outfile_name[frame])) except IndexError: logger.error( "No outfile name specified for frame {:d}!".format(frame)) pass # out of range export_file(node, outfile_name[frame], 'lammps_data', atom_style=atom_style, frame=frame) return