def read_from_file_test():
print('Reading structure from test file')
#Condicions del test
number_of_dimensions = 2
f_coordinates = open('Data Files/test.out', 'r')
f_velocity = open('Data Files/test2.out', 'r')
f_trajectory = open('Data Files/test3.out', 'r')
#Coordinates reading
positions = []
while True:
row = f_coordinates.readline().split()
if not row: break
for i in range(len(row)): row[i] = float(row[i])
positions.append(row)
atom_type = np.array(positions,dtype=int)[:, 2]
positions = np.array(positions)[:,:number_of_dimensions]
print('Coordinates reading complete')
structure = atomtest.Structure(positions=positions,
atomic_numbers=atom_type,
cell=[[2,0],[0,1]],
masses=[1 for i in range(positions.shape[0])]) #all 1
number_of_atoms = structure.get_number_of_atoms()
structure.set_number_of_primitive_atoms(2)
print('number of atoms in primitive cell')
print((structure.get_number_of_primitive_atoms()))
print('number of total atoms in structure (super cell)')
print(number_of_atoms)
#Velocity reading section
velocity = []
while True:
row = f_velocity.readline().replace('I','j').replace('*','').replace('^','E').split()
if not row: break
for i in range(len(row)): row[i] = complex('('+row[i]+')')
velocity.append(row)
# velocity = velocity[:4000][:] #Limitate the number of points (just for testing)
time = np.array([velocity[i][0] for i in range(len(velocity))]).real
velocity = np.array([[[velocity[i][j*number_of_dimensions+k+1]
for k in range(number_of_dimensions)]
for j in range(number_of_atoms)]
for i in range (len(velocity))])
print('Velocity reading complete')
#Trajectory reading
trajectory = []
while True:
row = f_trajectory.readline().replace('I','j').replace('*','').replace('^','E').split()
if not row: break
for i in range(len(row)): row[i] = complex('('+row[i]+')')
trajectory.append(row)
trajectory = np.array([[[trajectory[i][j*number_of_dimensions+k+1]
for k in range(number_of_dimensions)]
for j in range(number_of_atoms)]
for i in range (len(trajectory))])
print('Trajectory reading complete')
return dyn.Dynamics(trajectory=trajectory,
#velocity=velocity,
time=time,
structure=structure)
def read_from_file_structure_outcar(file_name):
#Check file exists
if not os.path.isfile(file_name):
print('Structure file does not exist!')
exit()
#Read from VASP OUTCAR file
print('Reading VASP structure')
with open(file_name, "r+") as f:
# memory-map the file
file_map = mmap.mmap(f.fileno(), 0)
#Setting number of dimensions
number_of_dimensions = 3
#trash reading for guessing primitive cell (Not stable)
if False:
#Reading primitive cell (not sure about this, by default disabled)
position_number = file_map.find('PRICEL')
file_map.seek(position_number)
position_number = file_map.find('A1')
file_map.seek(position_number)
primitive_cell = [] #Primitive Cell
for i in range (number_of_dimensions):
primitive_cell.append(file_map.readline()
.replace(",", "")
.replace(")", "")
.replace(")","")
.split()[3:number_of_dimensions+3])
primitive_cell = np.array(primitive_cell,dtype="double").T
#Reading number of atoms
position_number = file_map.find('NIONS =')
file_map.seek(position_number+7)
number_of_atoms = int(file_map.readline())
#Reading atoms per type
position_number = file_map.find('ions per type')
file_map.seek(position_number+15)
atoms_per_type = np.array(file_map.readline().split(),dtype=int)
#Reading atoms mass
position_number = file_map.find('POMASS =')
atomic_mass_per_type = []
for i in range(atoms_per_type.shape[0]):
file_map.seek(position_number+9+6*i)
atomic_mass_per_type.append(file_map.read(6))
atomic_mass = sum([[atomic_mass_per_type[j]
for i in range(atoms_per_type[j])]
for j in range(atoms_per_type.shape[0])],[])
atomic_mass = np.array(atomic_mass,dtype='double')
#Reading cell
position_number = file_map.find('direct lattice vectors')
file_map.seek(position_number)
file_map.readline()
direct_cell = [] #Direct Cell
for i in range (number_of_dimensions):
direct_cell.append(file_map.readline().split()[0:number_of_dimensions])
direct_cell = np.array(direct_cell,dtype='double').T
file_map.seek(position_number)
file_map.readline()
reciprocal_cell = [] #Reciprocal cell
for i in range (number_of_dimensions):
reciprocal_cell.append(file_map.readline().split()[number_of_dimensions:number_of_dimensions*2])
reciprocal_cell = np.array(reciprocal_cell,dtype='double').T
#Reading positions fractional cartesian
position_number=file_map.find('position of ions in fractional coordinates')
file_map.seek(position_number)
file_map.readline()
positions_fractional = []
for i in range (number_of_atoms):
positions_fractional.append(file_map.readline().split()[0:number_of_dimensions])
positions_fractional = np.array(positions_fractional,dtype='double')
#Reading positions cartesian
position_number=file_map.find('position of ions in cartesian coordinates')
file_map.seek(position_number)
file_map.readline()
positions = []
for i in range (number_of_atoms):
positions.append(file_map.readline().split()[0:3])
positions = np.array(positions,dtype='double')
file_map.close()
return atomtest.Structure(cell= direct_cell,
positions=positions,
masses=atomic_mass,
)
def read_from_file_structure_poscar(file_name, number_of_dimensions=3):
#Check file exists
if not os.path.isfile(file_name):
print('Structure file does not exist!')
exit()
#Read from VASP OUTCAR file
print("Reading VASP POSCAR structure")
poscar_file = open(file_name, 'r')
data_lines = poscar_file.read().split('\n')
poscar_file.close()
multiply = float(data_lines[1])
direct_cell = np.array([data_lines[i].split()
for i in range(2, 2+number_of_dimensions)],dtype=float).T
direct_cell *= multiply
scaled_positions = None
positions = None
try:
number_of_types = np.array(data_lines[3+number_of_dimensions].split(),dtype=int)
coordinates_type = data_lines[4+number_of_dimensions][0]
if coordinates_type == 'D' or coordinates_type == 'd' :
scaled_positions = np.array([data_lines[8+k].split()[0:3]
for k in range(np.sum(number_of_types))],dtype=float)
else:
positions = np.array([data_lines[8+k].split()[0:3]
for k in range(np.sum(number_of_types))],dtype=float)
atomic_types = []
for i,j in enumerate(data_lines[5].split()):
atomic_types.append([j]*number_of_types[i])
atomic_types = [item for sublist in atomic_types for item in sublist]
# atomic_types = np.array(atomic_types).flatten().tolist()
#Old style POSCAR format
except ValueError:
print("Reading old style POSCAR")
number_of_types = np.array(data_lines[5].split(), dtype=int)
coordinates_type = data_lines[6][0]
if coordinates_type == 'D' or coordinates_type == 'd':
scaled_positions = np.array([data_lines[7+k].split()[0:3]
for k in range(np.sum(number_of_types))], dtype=float)
else:
positions = np.array([data_lines[7+k].split()[0:3]
for k in range(np.sum(number_of_types))], dtype=float)
atomic_types = []
for i,j in enumerate(data_lines[0].split()):
atomic_types.append([j]*number_of_types[i])
atomic_types = [item for sublist in atomic_types for item in sublist]
# atomic_types = np.array(atomic_types).flatten().tolist()
return atomtest.Structure(cell= direct_cell,
scaled_positions=scaled_positions,
positions=positions,
atomic_elements=atomic_types,
# primitive_cell=primitive_cell
)