Returns the continuous symmetry measures of the current local geometry in a dictionary.
        :return: the continuous symmetry measures of the current local geometry in a dictionary.

def get_coordination_symmetry_measures(self, only_minimum=True,
                                           all_csms=True, optimization=None):
        """
        Returns the continuous symmetry measures of the current local geometry in a dictionary.
        :return: the continuous symmetry measures of the current local geometry in a dictionary.
        """
        test_geometries = self.allcg.get_implemented_geometries(
            len(self.local_geometry.coords))
        if len(self.local_geometry.coords) == 1:
            if len(test_geometries) == 0:
                return {}
            result_dict = {'S:1': {'csm': 0.0, 'indices': [0], 'algo': 'EXPLICIT',
                                   'local2perfect_map': {0: 0}, 'perfect2local_map': {0: 0},
                                   'scaling_factor': None, 'rotation_matrix': None, 'translation_vector': None}}
            if all_csms:
                for csmtype in ['wocs_ctwocc', 'wocs_ctwcc', 'wocs_csc', 'wcs_ctwocc', 'wcs_ctwcc', 'wcs_csc']:
                    result_dict['S:1']['csm_{}'.format(csmtype)] = 0.0
                    result_dict['S:1']['scaling_factor_{}'.format(csmtype)] = None
                    result_dict['S:1']['rotation_matrix_{}'.format(csmtype)] = None
                    result_dict['S:1']['translation_vector_{}'.format(csmtype)] = None
            return result_dict
        result_dict = {}
        for geometry in test_geometries:
            self.perfect_geometry = AbstractGeometry.from_cg(cg=geometry,
                                                             centering_type=self.centering_type,
                                                             include_central_site_in_centroid=
                                                             self.include_central_site_in_centroid)
            points_perfect = self.perfect_geometry.points_wcs_ctwcc()
            cgsm = self.coordination_geometry_symmetry_measures(geometry,
                                                                points_perfect=points_perfect,
                                                                optimization=optimization)
            result, permutations, algos, local2perfect_maps, perfect2local_maps = cgsm
            if only_minimum:
                if len(result) > 0:
                    imin = np.argmin([rr['symmetry_measure'] for rr in result])
                    if geometry.algorithms is not None:
                        algo = algos[imin]
                    else:
                        algo = algos
                    result_dict[geometry.mp_symbol] = {'csm': result[imin]['symmetry_measure'],
                                                       'indices': permutations[
                                                           imin],
                                                       'algo': algo,
                                                       'local2perfect_map':
                                                           local2perfect_maps[
                                                               imin],
                                                       'perfect2local_map':
                                                           perfect2local_maps[
                                                               imin],
                                                       'scaling_factor': 1.0 / result[imin]['scaling_factor'],
                                                       'rotation_matrix':
                                                           np.linalg.inv(result[imin]['rotation_matrix']),
                                                       'translation_vector': result[imin]['translation_vector']}
                    if all_csms:
                        self._update_results_all_csms(result_dict, permutations, imin, geometry)
            else:
                result_dict[geometry.mp_symbol] = {'csm': result,
                                                   'indices': permutations,
                                                   'algo': algos,
                                                   'local2perfect_map': local2perfect_maps,
                                                   'perfect2local_map': perfect2local_maps}
        return result_dict