import pymatgen as pm

import numpy as np

import csv

import copy

import warnings

import ewald

from itertools import combinations, combinations_with_replacement, permutations

from rotation_matrix import *

from scipy.optimize import minimize

from sys import maxint

"""

The tetpack module works like this:

1. Start with a solid-state structure, preferably something "tetrahedral close-packed (tcp)," e.g. gamma brass(Cu5Zn8)

2. Scan up to n nearest neighbors for each site (see function n_nearest_neighbors)

3. Pick out "most regular" tetrahedra formed by each site and any three neighbors (get_tets)

4. Remove duplicates (remove_duplicate_tets)

5. Build regular tetrahedra. They are aligned to best match the tetrahedral cell they are drawn from, which of course is not regular (see the tetrahedron class)

6. Add the perfect tetrahedra to a new periodic structure as methane -- C is the center, each H is a vertex (tetrahedron.add_to_structure)

7. compression, annealing...see compression.py

There is a convenience method tetrahedron_from_structure that combines steps 1-6. It takes a pymatgen structure object and returns a new structure with tetrahedra (methanes) and a list of tetrahedra objects:

Example:

import pymatgen as pm #import pymatgen

import tetpack #import this module

gamma = pm.read_structure('mp-1368.mson') #load the gamma brass structure

tet_str, tet_reg = tetpack.tetrahedra_from_structure(gamma) #generate a new pymatgen structure (periodic) and a list of tetrahedra objects

pm.write_structure(tet_str, 'tet_str.cif') #export our methane tetrahedra to a CIF so we can view it in the crystallohraphic structure program of our choice!

"""

def random_configuration(structure, n_tets):

return return_structure, tets

def ewald_relaxation(structure, max_steps=3, motion_factor = 1.):

return return_str

def n_nearest_neighbors(structure, n, max_dist = 5.0):

return [map(lambda d: d[0], neighbors[:n]) for neighbors in t]

def simplex_volume(sites):#triple product evaluation of tetrahedral volume

return abs(np.dot((sites[0] - sites[3]), np.cross(sites[1]-sites[3], sites[2]-sites[3]) ))/6.0

def get_tets(structure, site, neighbors, stdcutoff = 0.10, volcutoff = 2.0):#relax stdcutoff to 0.50 for more initial tetrahedra

return tets

def site_in_cell(site):

return not any(map(lambda x: round(x,4) < 0. or round(x,4) >= 1., site.frac_coords))

def tets_in_cell(structure, tets):

return in_tets

def tet_supercell(structure, tets, cutoff=2.0):

return supercell

def get_nearby_tets(tets, supercell_tets, radius=2.0):

return neighbor_indices

def tet_center(tet_sites):

return reduce(np.add, [site for site in tet_sites])/4.

def remove_duplicate_tets(tet_list):#remove duplicate tets from a list by center of gravity only

return unique_tets

def tetrahedra_from_structure(structure, n=12, maxdist=5.0, stdcutoff=0.10, volcutoff=2.0):

return empty_structure, tets_in_cell(empty_structure, regular_tetrahedra)

def nearest(tet, neighbors):

return nearest_tet

def adjust_axes(structure, a_per, b_per=False, c_per=False, alpha_per=False, beta_per=False, gamma_per=False):

return new_structure

def to_challenge_output(structure, output_path):

writer.writerow(row)

def packing_density(structure):

#assumes tetrahedra are properly formed, and unit volume etc. Simply divide the number of carbons by the unit cell volume

return [site.specie.symbol for site in structure.sites].count('C')/structure.volume

def tetrahedron_collision(tet, neighbors):

return False

class tetrahedron:

self.regularize()

class dimer:

def __init__(self, center, axial_direction, first_vertex_direction):

pass

class barrelan:

def __init__(self, center, axial_direction, first_vertex_direction):

pass