original_docstring: 
          Apply MagOrderTransformation to an input structure.
          :param structure: Any ordered structure.
          :param return_ranked_list: As in other Transformations.
          :return:
          
docstring: Apply MagOrderTransformation to an input structure.
docstring_tokens: Apply MagOrderTransformation to an input structure .
code: def apply_transformation(self, structure, return_ranked_list=False):
          """
          Apply MagOrderTransformation to an input structure.
          :param structure: Any ordered structure.
          :param return_ranked_list: As in other Transformations.
          :return:
          """
  
          if not structure.is_ordered:
              raise ValueError("Create an ordered approximation of "
                               "your  input structure first.")
  
          # retrieve order parameters
          order_parameters = [MagOrderParameterConstraint.from_dict(op_dict)
                              for op_dict in self.order_parameter]
          # add dummy species on which to perform enumeration
          structure = self._add_dummy_species(structure, order_parameters)
  
          # trivial case
          if structure.is_ordered:
              structure = self._remove_dummy_species(structure)
              return [structure] if return_ranked_list > 1 else structure
  
          enum_kwargs = self.enum_kwargs.copy()
  
          enum_kwargs["min_cell_size"] = max(
              int(self.determine_min_cell(structure)),
              enum_kwargs.get("min_cell_size", 1)
          )
  
          if enum_kwargs.get("max_cell_size", None):
              if enum_kwargs["min_cell_size"] > enum_kwargs["max_cell_size"]:
                  warnings.warn("Specified max cell size ({}) is smaller "
                                "than the minimum enumerable cell size ({}), "
                                "changing max cell size to {}".format(enum_kwargs["max_cell_size"],
                                                                      enum_kwargs["min_cell_size"],
                                                                      enum_kwargs["min_cell_size"]))
                  enum_kwargs["max_cell_size"] = enum_kwargs["min_cell_size"]
          else:
              enum_kwargs["max_cell_size"] = enum_kwargs["min_cell_size"]
  
          t = EnumerateStructureTransformation(**enum_kwargs)
  
          alls = t.apply_transformation(structure,
                                        return_ranked_list=return_ranked_list)
  
          # handle the fact that EnumerateStructureTransformation can either
          # return a single Structure or a list
          if isinstance(alls, Structure):
              # remove dummy species and replace Spin.up or Spin.down
              # with spin magnitudes given in mag_species_spin arg
              alls = self._remove_dummy_species(alls)
              alls = self._add_spin_magnitudes(alls)
          else:
              for idx, _ in enumerate(alls):
                  alls[idx]["structure"] = self._remove_dummy_species(alls[idx]["structure"])
                  alls[idx]["structure"] = self._add_spin_magnitudes(alls[idx]["structure"])
  
          try:
              num_to_return = int(return_ranked_list)
          except ValueError:
              num_to_return = 1
  
          if num_to_return == 1 or not return_ranked_list:
              return alls[0]["structure"] if num_to_return else alls
  
          # remove duplicate structures and group according to energy model
          m = StructureMatcher(comparator=SpinComparator())
          key = lambda x: SpacegroupAnalyzer(x, 0.1).get_space_group_number()
          out = []
          for _, g in groupby(sorted([d["structure"] for d in alls],
                                     key=key), key):
              g = list(g)
              grouped = m.group_structures(g)
              out.extend([{"structure": g[0],
                           "energy": self.energy_model.get_energy(g[0])}
                          for g in grouped])
  
          self._all_structures = sorted(out, key=lambda d: d["energy"])
  
          return self._all_structures[0:num_to_return]
code_tokens: def apply_transformation ( self , structure , return_ranked_list = False ) : if not structure . is_ordered : raise ValueError ( "Create an ordered approximation of " "your  input structure first." ) order_parameters = [ MagOrderParameterConstraint . from_dict ( op_dict ) for op_dict in self . order_parameter ] structure = self . _add_dummy_species ( structure , order_parameters ) if structure . is_ordered : structure = self . _remove_dummy_species ( structure ) return [ structure ] if return_ranked_list > 1 else structure enum_kwargs = self . enum_kwargs . copy ( ) enum_kwargs [ "min_cell_size" ] = max ( int ( self . determine_min_cell ( structure ) ) , enum_kwargs . get ( "min_cell_size" , 1 ) ) if enum_kwargs . get ( "max_cell_size" , None ) : if enum_kwargs [ "min_cell_size" ] > enum_kwargs [ "max_cell_size" ] : warnings . warn ( "Specified max cell size ({}) is smaller " "than the minimum enumerable cell size ({}), " "changing max cell size to {}" . format ( enum_kwargs [ "max_cell_size" ] , enum_kwargs [ "min_cell_size" ] , enum_kwargs [ "min_cell_size" ] ) ) enum_kwargs [ "max_cell_size" ] = enum_kwargs [ "min_cell_size" ] else : enum_kwargs [ "max_cell_size" ] = enum_kwargs [ "min_cell_size" ] t = EnumerateStructureTransformation ( ** enum_kwargs ) alls = t . apply_transformation ( structure , return_ranked_list = return_ranked_list ) if isinstance ( alls , Structure ) : alls = self . _remove_dummy_species ( alls ) alls = self . _add_spin_magnitudes ( alls ) else : for idx , _ in enumerate ( alls ) : alls [ idx ] [ "structure" ] = self . _remove_dummy_species ( alls [ idx ] [ "structure" ] ) alls [ idx ] [ "structure" ] = self . _add_spin_magnitudes ( alls [ idx ] [ "structure" ] ) try : num_to_return = int ( return_ranked_list ) except ValueError : num_to_return = 1 if num_to_return == 1 or not return_ranked_list : return alls [ 0 ] [ "structure" ] if num_to_return else alls m = StructureMatcher ( comparator = SpinComparator ( ) ) key = lambda x : SpacegroupAnalyzer ( x , 0.1 ) . get_space_group_number ( ) out = [ ] for _ , g in groupby ( sorted ( [ d [ "structure" ] for d in alls ] , key = key ) , key ) : g = list ( g ) grouped = m . group_structures ( g ) out . extend ( [ { "structure" : g [ 0 ] , "energy" : self . energy_model . get_energy ( g [ 0 ] ) } for g in grouped ] ) self . _all_structures = sorted ( out , key = lambda d : d [ "energy" ] ) return self . _all_structures [ 0 : num_to_return ]
short_docstring: Apply MagOrderTransformation to an input structure.
short_docstring_tokens: Apply MagOrderTransformation to an input structure .
comment: """
          Apply MagOrderTransformation to an input structure.
          :param structure: Any ordered structure.
          :param return_ranked_list: As in other Transformations.
          :return:
          """$SEP$# retrieve order parameters$SEP$# add dummy species on which to perform enumeration$SEP$# trivial case$SEP$# handle the fact that EnumerateStructureTransformation can either$SEP$# return a single Structure or a list$SEP$# remove dummy species and replace Spin.up or Spin.down$SEP$# with spin magnitudes given in mag_species_spin arg$SEP$# remove duplicate structures and group according to energy model