def test_implicit_hydrogen(self):
     with warnings.catch_warnings():
         warnings.simplefilter("ignore")
         parser = CifParser(os.path.join(test_dir, 'Senegalite_implicit_hydrogen.cif'))
         for s in parser.get_structures():
             self.assertEqual(s.formula, "Al8 P4 O32")
             self.assertEqual(sum(s.site_properties['implicit_hydrogens']), 20)

 def test_one_line_symm(self):
     with warnings.catch_warnings():
         warnings.simplefilter("ignore")
         f = os.path.join(test_dir, "OneLineSymmP1.cif")
         p = CifParser(f)
         s = p.get_structures()[0]
         self.assertEqual(s.formula, "Ga4 Pb2 O8")

 def test_bad_cif(self):
     f = os.path.join(test_dir, "bad_occu.cif")
     p = CifParser(f)
     self.assertRaises(ValueError, p.get_structures)
     p = CifParser(f, occupancy_tolerance=2)
     s = p.get_structures()[0]
     self.assertAlmostEqual(s[0].species_and_occu["Al3+"], 0.5)

 def test_no_symmops(self):
     with warnings.catch_warnings():
         warnings.simplefilter("ignore")
         f = self.TEST_FILES_DIR / "nosymm.cif"
         p = CifParser(f)
         s = p.get_structures()[0]
         self.assertEqual(s.formula, "H96 C60 O8")

 def test_one_line_symm(self):
     with warnings.catch_warnings():
         warnings.simplefilter("ignore")
         f = self.TEST_FILES_DIR / "OneLineSymmP1.cif"
         p = CifParser(f)
         s = p.get_structures()[0]
         self.assertEqual(s.formula, "Ga4 Pb2 O8")

 def setUp(self):
     warnings.filterwarnings("ignore")
     self.mcif = CifParser(self.TEST_FILES_DIR / "magnetic.example.NiO.mcif")
     self.mcif_ncl = CifParser(self.TEST_FILES_DIR / "magnetic.ncl.example.GdB4.mcif")
     self.mcif_incom = CifParser(self.TEST_FILES_DIR / "magnetic.incommensurate.example.Cr.mcif")
     self.mcif_disord = CifParser(self.TEST_FILES_DIR / "magnetic.disordered.example.CuMnO2.mcif")
     self.mcif_ncl2 = CifParser(self.TEST_FILES_DIR / "Mn3Ge_IR2.mcif")

    def test_jahn_teller_structure_analysis(self):
        parser = CifParser(os.path.join(test_dir, 'LiFePO4.cif'))
        LiFePO4 = parser.get_structures()[0]

        parser = CifParser(os.path.join(test_dir, 'Fe3O4.cif'))
        Fe3O4 = parser.get_structures()[0]

        self.assertTrue(self.jt.is_jahn_teller_active(LiFePO4))
        self.assertTrue(self.jt.is_jahn_teller_active(Fe3O4))

        LiFePO4_analysis = {
            'active': True,
            'strength': 'weak',
            'sites': [
                {
                    'ligand': 'O2-',
                    'ligand_bond_length_spread': 0.2111,
                    'ligand_bond_lengths': [2.1382,
                                            2.0840,
                                            2.0863,
                                            2.2383,
                                            2.2951,
                                            2.2215],
                    'strength': 'weak',
                    'motif': 'oct',
                    'motif_order_parameter': 0.1441,
                    'site_indices': [4, 5, 6, 7],
                    'species': 'Fe2+',
                    'spin_state': 'unknown'
                }
            ]
        }

        self.assertDictEqual(LiFePO4_analysis, self.jt.get_analysis(LiFePO4))

 def test_no_symmops(self):
     with warnings.catch_warnings():
         warnings.simplefilter("ignore")
         f = os.path.join(test_dir, "nosymm.cif")
         p = CifParser(f)
         s = p.get_structures()[0]
         self.assertEqual(s.formula, "H96 C60 O8")

 def setUp(self):
     """
     Setup Fe3O4  structure for testing multiple oxidation states
     """
     cif_ob = CifParser(os.path.join(test_dir, "Fe3O4.cif"))
     self._struct = cif_ob.get_structures()[0]
     self._valrad_evaluator = ValenceIonicRadiusEvaluator(self._struct)
     self._length = len(self._struct.sites)

 def test_missing_atom_site_type_with_oxistates(self):
     with warnings.catch_warnings():
         warnings.simplefilter("ignore")
         parser = CifParser(self.TEST_FILES_DIR / 'P24Ru4H252C296S24N16.cif')
         c = Composition({'S0+': 24, 'Ru0+': 4, 'H0+': 252, 'C0+': 296,
                          'N0+': 16, 'P0+': 24})
         for s in parser.get_structures(False):
             self.assertEqual(s.composition, c)

 def test_replacing_finite_precision_frac_coords(self):
     f = self.TEST_FILES_DIR / "cif_finite_precision_frac_coord_error.cif"
     with warnings.catch_warnings():
         p = CifParser(f)
         s = p.get_structures()[0]
         self.assertEqual(str(s.composition), "N5+24")
         self.assertIn("Some fractional co-ordinates rounded to ideal values to "
                       "avoid finite precision errors.", p.errors)

 def test_bad_cif(self):
     with warnings.catch_warnings():
         warnings.simplefilter("ignore")
         f = self.TEST_FILES_DIR / "bad_occu.cif"
         p = CifParser(f)
         self.assertRaises(ValueError, p.get_structures)
         p = CifParser(f, occupancy_tolerance=2)
         s = p.get_structures()[0]
         self.assertAlmostEqual(s[0].species["Al3+"], 0.5)

 def test_bad_cif(self):
     with warnings.catch_warnings():
         warnings.simplefilter("ignore")
         f = os.path.join(test_dir, "bad_occu.cif")
         p = CifParser(f)
         self.assertRaises(ValueError, p.get_structures)
         p = CifParser(f, occupancy_tolerance=2)
         s = p.get_structures()[0]
         self.assertAlmostEqual(s[0].species_and_occu["Al3+"], 0.5)

 def test_cluster_from_file(self):
     r = CifParser(os.path.join(test_dir, "CoO19128.cif"))
     structure = r.get_structures()[0]
     atoms = Atoms(structure, "O", 10.0)
     atoms.write_file("ATOMS_test")
     mol_1 = Atoms.cluster_from_file("ATOMS_test")
     mol_2 = Atoms.cluster_from_file(os.path.join(test_dir, "ATOMS"))
     self.assertEqual(mol_1.formula, mol_2.formula)
     self.assertEqual(len(mol_1), len(mol_2))
     os.remove("ATOMS_test")

 def setUp(self):
     self.mcif = CifParser(os.path.join(test_dir,
                                        "magnetic.example.NiO.mcif"))
     self.mcif_ncl = CifParser(os.path.join(test_dir,
                                            "magnetic.ncl.example.GdB4.mcif"))
     self.mcif_incom = CifParser(os.path.join(test_dir,
                                              "magnetic.incommensurate.example.Cr.mcif"))
     self.mcif_disord = CifParser(os.path.join(test_dir,
                                               "magnetic.disordered.example.CuMnO2.mcif"))
     self.mcif_ncl2 = CifParser(os.path.join(test_dir,
                                               "Mn3Ge_IR2.mcif"))

def handle_insufficientpowderdata(cif_string):
    """
    Handles CIF parsing errors arising from too few or too many values in data loop for diffraction data.

    :param cif_string: (str) cif file
    :return: corrected cif string
    """
    smlineno = 0
    looplineno = 0
    cif_lines = json.loads(json.dumps(cif_string)).splitlines()
    powderdataline = False
    loopdataline = False
    cif_string_new = ''
    for lineno, line in enumerate(cif_lines):
        if '_sm_powderpattern_remark' in line:
            powderdataline = True
            smlineno = lineno + 1
            break
        else:
            cif_string_new += line + '\n'
    if powderdataline:
        for line in cif_lines[smlineno:]:
            line_list = line.split()
            if len(line_list) > 10:
                cif_string_new += line + '\n'
            elif 1 < len(line_list) < 11:
                cif_string_new += '#' + line + '\n'
    try:
        print CifParser.from_string(cif_string_new).get_structures()[0].as_dict()
        return cif_string_new
    except:
        print 'UNSUCCESSFUL 1st attempt (uncommenting lines with insufficient or too many values for powder pattern)'
        cif_string_new = ''
        for lineno, line in enumerate(cif_lines):
            if 'loop_' in line:
                if '_sm_powderpattern' in cif_lines[lineno + 1]:
                    cif_string_new += '#' + line + '\n'
                    loopdataline = True
                    looplineno = lineno + 1
                    break
                else:
                    cif_string_new += line + '\n'
            else:
                cif_string_new += line + '\n'
        if loopdataline:
            for line in cif_lines[looplineno:]:
                cif_string_new += '#' + line + '\n'
        try:
            print CifParser.from_string(cif_string_new).get_structures()[0].as_dict()
            return cif_string_new
        except:
            print 'UNSUCCESSFUL 2nd attempt (uncommenting all powder diffraction lines)'
            return cif_string_new

 def setUp(self):
     filepath1 = os.path.join(test_dir, 'Li2O.cif')
     p = CifParser(filepath1).get_structures(False)[0]
     bv = BVAnalyzer()
     valences = bv.get_valences(p)
     el = [site.species_string for site in p.sites]
     val_dict = dict(zip(el, valences))
     self._radii = {}
     for k, v in val_dict.items():
         k1 = re.sub('[1-9,+,\-]', '', k)
         self._radii[k1] = float(Specie(k1, v).ionic_radius)
     p.remove(0)
     self._vac_struct = p

 def test_find_primitive(self):
     """
     F m -3 m Li2O testing of converting to primitive cell
     """
     parser = CifParser(os.path.join(test_dir, 'Li2O.cif'))
     structure = parser.get_structures(False)[0]
     s = SpacegroupAnalyzer(structure)
     primitive_structure = s.find_primitive()
     self.assertEqual(primitive_structure.formula, "Li2 O1")
     # This isn't what is expected. All the angles should be 60
     self.assertAlmostEqual(primitive_structure.lattice.alpha, 60)
     self.assertAlmostEqual(primitive_structure.lattice.beta, 60)
     self.assertAlmostEqual(primitive_structure.lattice.gamma, 60)
     self.assertAlmostEqual(primitive_structure.lattice.volume,
                            structure.lattice.volume / 4.0)

 def test_implicit_hydrogen(self):
     with warnings.catch_warnings():
         warnings.simplefilter("ignore")
         parser = CifParser(self.TEST_FILES_DIR / 'Senegalite_implicit_hydrogen.cif')
         for s in parser.get_structures():
             self.assertEqual(s.formula, "Al8 P4 O32")
             self.assertEqual(sum(s.site_properties['implicit_hydrogens']), 20)
         self.assertIn("Structure has implicit hydrogens defined, "
                       "parsed structure unlikely to be suitable for use "
                       "in calculations unless hydrogens added.", parser.errors)
         parser = CifParser(self.TEST_FILES_DIR / 'cif_implicit_hydrogens_cod_1011130.cif')
         s = parser.get_structures()[0]
         self.assertIn("Structure has implicit hydrogens defined, "
                       "parsed structure unlikely to be suitable for use "
                       "in calculations unless hydrogens added.", parser.errors)

    def from_cif_file(cif_file, source='', comment=''):
        """
        Static method to create Header object from cif_file

        Args:
            cif_file: cif_file path and name
            source: User supplied identifier, i.e. for Materials Project this
                would be the material ID number
            comment: User comment that goes in header

        Returns:
            Header Object
        """
        r = CifParser(cif_file)
        structure = r.get_structures()[0]
        return Header(structure, source, comment)