from mcstasscript.helper.formatting import bcolors from mcstasscript.helper.formatting import is_legal_parameter from mcstasscript.helper.exceptions import McStasError from mcstasscript.helper.name_inspector import find_python_variable_name from mcstasscript.helper.search_statement import SearchStatement, SearchStatementList from libpyvinyl.Parameters.Parameter import Parameter def provide_parameter(*args, **kwargs): """Makes a libpyvinyl parameter object Examples -------- Creates a parameter with name wavelength and associated comment A = provide_parameter("wavelength", comment="wavelength in [AA]") Creates a parameter with name A3 and default value A = provide_parameter("A3", value=30, comment="A3 angle in [deg]") Creates a parameter with type string and name sample_name A = provide_parameter("string", "sample_name") Parameters ---------- If giving a type: Positional argument 1: type: str Type of the parameter, double, int or string Positional argument 2: name: str Name of input parameter If not giving type Positional argument 1: name : str Name of input parameter Keyword arguments value : float, int or str sets default value of parameter unit : str string that describes the unit comment : str sets comment displayed next to declaration options : list or value list or value of allowed values for this parameter """ if len(args) == 0: # Check all required keyword arguments present if "name" not in kwargs: try: name = find_python_variable_name(error_text="", n_levels=3) kwargs["name"] = name except: raise RuntimeError("Need to provide name, either as first argument" + ", keyword argument or python variable.") provided_name = kwargs["name"] provided_type = "" if "type" in kwargs: provided_type = kwargs["type"] elif len(args) == 1: if "name" in kwargs: raise RuntimeError("Only specify name with argument or keyword argument") provided_name = args[0] # Assume default type if not given provided_type = "" if "type" in kwargs: provided_type = kwargs["type"] elif len(args) == 2: if "type" in kwargs: raise RuntimeError("Only specify type with argument or keyword argument") provided_type = args[0] if "name" in kwargs: raise RuntimeError("Only specify name with argument or keyword argument") provided_name = args[1] else: raise RuntimeError("Too many arguments given to parameter") if not is_legal_parameter(provided_name): raise NameError("The given parameter name: \"" + provided_name + "\" is not a legal c variable name, " + " and cannot be used in McStas.") allowed_types = {"", "double", "int", "string"} if provided_type not in allowed_types: raise RuntimeError("Tried to create parameter of type \"" + str(provided_type) + "\" which is not among the allowed types " + str(allowed_types) + ".") comment = "" if "comment" in kwargs: if not isinstance(comment, str): raise RuntimeError("Tried to create a parameter with a " + "comment that was not a string.") comment = kwargs["comment"] unit = "" if "unit" in kwargs: if not isinstance(unit, str): raise RuntimeError("Unit has to be a string") unit = kwargs["unit"] parameter = Parameter(name=provided_name, unit=unit, comment=comment) parameter.type = provided_type if "options" in kwargs: parameter.add_option(kwargs["options"], True) if "value" in kwargs: parameter.value = kwargs["value"] return parameter def write_parameter(fo, parameter, stop_character): """ Writes a parameter object to McStas define section Parameters ---------- fo : file object Open file object to write parameter string to parameter : Parameter Parameter object to be written stop_character : str Character inserted after parameter, usually comma and space """ if not isinstance(stop_character, str): raise RuntimeError("stop_character in write_parameter should be " + "a string.") if parameter.type is None: # This can happen if parameter given by libpyvinyl directly, infer type if parameter.value is None: raise RuntimeError("Need to set parameter '" + parameter.name + "' before writing instrument.") if isinstance(parameter.value, (float, int)): parameter.type = "double" elif isinstance(parameter.value, str): parameter.type = "string" else: raise RuntimeError("Parameter '" + parameter.name + "' has value " + "of type not recognized by McStasScript.") if not parameter.type == "": fo.write("%s %s" % (parameter.type, parameter.name)) else: fo.write(parameter.name) if parameter.value is not None: if isinstance(parameter.value, int): fo.write(" = %d" % parameter.value) elif isinstance(parameter.value, float): fo.write(" = %G" % parameter.value) else: fo.write(" = %s" % str(parameter.value)) fo.write(stop_character) if parameter.comment is None or parameter.comment == "": c_comment = "" else: c_comment = "// " + parameter.comment fo.write(c_comment) fo.write("\n") class DeclareVariable: """ Class describing a declared variable in McStas instrument McStas parameters are declared in declare section with c syntax. This class is initialized with type, name. Using keyword arguments, the variable can become an array and have its initial value set. Can also be used as a user variable in uservars (McStas 3.0) Attributes ---------- type : str McStas type to declare: Double, Int, String name : str Name of variable value : any Initial value of variable, converted to string comment : str Comment displayed next to the declaration, could contain units vector : int 0 if a single value is given, otherwise contains the length Methods ------- write_line(fo) Writes a line to text file fo declaring the parameter in c """ def __init__(self, type, name=None, **kwargs): """ Initializing mcstas declare variable or user variable object Examples -------- Creates a variable with name A3 and default value A = DeclareVariable("double", "A3", value=30) Creates a variable with type integer and name A A = DeclareVariable("int") Creates a variable with type integer and name sample_number A = DeclareVariable("int", "sample_number") Creates an array variable called m_values A = DeclareVariable("double", "m_values", array=3, value=[2, 2.5, 2]) Parameters ---------- type : str Type of the parameter, double, int or string name : str Name of input parameter Keyword arguments array : int length of array to be allocated, 0 if single value value : any sets initial value of parameter, can be a list with length matching array comment : str sets comment displayed next to declaration """ self.type = type if not isinstance(self.type, str): raise RuntimeError("Given type of DeclareVariable should be a " + "string.") if name is None: error_text = ("When using automatic assignment of name, the call" " need to assign it to a variable name") name = find_python_variable_name(error_text=error_text, n_levels=3) self.name = str(name) par_name = self.name if "*" in par_name[0]: # Remove any number of prefixed *, indicating variable is a pointer par_name = par_name.split("*")[-1] elif "&" in par_name[0]: # Remove the first & indicating the variable is an address par_name = par_name[1:] if not is_legal_parameter(par_name): raise NameError("The given parameter name: \"" + self.name + "\" is not a legal c variable name, " + " and cannot be used in McStas.") self.value = "" if "value" in kwargs: self.value = kwargs["value"] self.vector = 0 if "array" in kwargs: self.vector = kwargs["array"] self.comment = "" if "comment" in kwargs: self.comment = " // " + kwargs["comment"] def write_line(self, fo): """ Writes line declaring variable to file fo Parameters ---------- fo : file object File the line will be written to """ if self.value == "" and self.vector == 0: fo.write("%s %s;%s" % (self.type, self.name, self.comment)) if self.value != "" and self.vector == 0: if self.type == "int": fo.write("%s %s = %d;%s" % (self.type, self.name, self.value, self.comment)) else: try: fo.write("%s %s = %G;%s" % (self.type, self.name, self.value, self.comment)) except TypeError: # Value could not be converted to float, write as string fo.write("%s %s = %s;%s" % (self.type, self.name, self.value, self.comment)) if self.value == "" and self.vector != 0: fo.write("%s %s[%d];%s" % (self.type, self.name, self.vector, self.comment)) if self.value != "" and self.vector != 0: if isinstance(self.value, str): # value is a string string = self.value fo.write("%s %s[%d] = %s;" % (self.type, self.name, self.vector, string)) else: # list of values fo.write("%s %s[%d] = {" % (self.type, self.name, self.vector)) for i in range(0, len(self.value) - 1): fo.write("%G," % self.value[i]) fo.write("%G};%s" % (self.value[-1], self.comment)) def __repr__(self): string = "Declare variable: '" string += str(self.name) string += "' of type " string += str(self.type) if self.value != "": string += " with value: " string += str(self.value) if self.vector != 0: string += ". Array with length " string += str(self.vector) return string class Component: """ A class describing a McStas component to be written to an instrument This class is used by the instrument class when setting up components as dynamic subclasses to this class. Most information can be given on initialize using keyword arguments, but there are methods for setting the attributes describing the component. The class contains both methods to write the component to an instrument file and methods for printing to the python terminal for checking the information. The McStas_Instr class creates subclasses from this class that have attributes for all parameters for the given component. The component information is read directly from the component files in the McStas installation. This class is frozen after __init__ so that no new attributes can be created, which allows direct feedback to the user if a parameter name is misspelled. Attributes ---------- name : str Name of the component instance in McStas (must be unique) component_name : str Name of the component code to use, e.g. Arm, Guide_gravity, ... AT_data : list of 3 floats, default [0, 0, 0] Position data of the component AT_relative : str, default "ABSOLUTE" Name of former component to use as reference for position ROTATED_data : list of 3 floats, default [0, 0, 0] Rotation data of the component ROTATED_relative : str, default "ABSOLUTE" Name of former component to use as reference for position WHEN : str, default "" String with logical c expression x for when component is active EXTEND : str, default "" c code for McStas EXTEND section GROUP : str, default "" Name of group the component should belong to JUMP : str, default "" String describing use of JUMP, need to contain all after "JUMP" SPLIT : int, default 0 (disabled) Integer setting SPLIT, splitting the neutron before this component c_code_before : str, default "" C code inserted before the component c_code_after : str, default "" C code inserted after the component component_parameters : dict Parameters to be used with component in dictionary comment : str, default "" Comment inserted before the component as an explanation __isfrozen : bool If true no new attributes can be created, when false they can Methods ------- set_AT(at_list, RELATIVE) Sets AT_data, can set AT_relative using keyword set_AT_RELATIVE(relative) Can set RELATIVE for position set_ROTATED(rotated_list, RELATIVE) Sets ROTATED_data, can set ROTATED_relative using keyword set_ROTATED_RELATIVE(relative) Can set RELATIVE for rotation set_RELATIVE(relative_name) Set both AT_relative and ROTATED_relative to relative_name set_parameters(dict_input) Adds dictionary entries to parameter dictionary set_WHEN(string) Sets WHEN string set_SPLIT(value) Sets SPLIT value, a value of 0 disables SPLIT set_GROUP(string) Sets GROUP name set_JUMP(string) Sets JUMP string append_EXTEND(string) Append string to EXTEND string set_c_code_before(string) Sets c code to be inserted before component set_c_code_before(string) Sets c code to be inserted after component set_comment(string) Sets comment for component write_component(fo) Writes component code to instrument file show_parameters() Prints current component state with all parameters print_long() Prints basic view of component code (not correct syntax) print_long_deprecated() Prints basic view of component code (obsolete) print_short(**kwargs) Prints short description, used in print_components set_keyword_input(**kwargs) Handle keyword arguments during initialize __setattr__(key, value) Overwriting __setattr__ to implement ability to freeze _freeze() Freeze the class so no new attributes can be defined _unfreeze() Unfreeze the class so new attributes can be defined again """ __isfrozen = False # When frozen, no new attributes allowed def __init__(self, instance_name, component_name, AT=None, AT_RELATIVE=None, ROTATED=None, ROTATED_RELATIVE=None, RELATIVE=None, WHEN=None, EXTEND=None, GROUP=None, JUMP=None, SPLIT=None, comment=None, c_code_before=None, c_code_after=None, save_parameters=False): """ Initializes McStas component with specified name and component Parameters ---------- instance_name : str name of the instance of the component component_name : str name of the component type e.g. Arm, Guide_gravity, ... keyword arguments: AT : list of 3 floats, default [0, 0, 0] Sets AT_data describing position of component AT_RELATIVE : str, default "ABSOLUTE" sets AT_relative, describing position reference ROTATED : list of 3 floats, default [0, 0, 0] Sets ROTATED_data, describing rotation of component ROTATED_RELATIVE : str, default "ABSOLUTE" Sets ROTATED_relative, sets reference for rotation RELATIVE : str Sets both AT_relative and ROTATED_relative WHEN : str, default "" Sets WHEN string, should contain logical c expression EXTEND : str, default "" Sets initial EXTEND string, should contain c code GROUP : str, default "" Sets name of group the component should belong to JUMP : str, default "" Sets JUMP str SPLIT : int, default 0 (disabled) Sets SPLIT value comment: str, default "" Sets comment string c_code_before: str, default "" Sets c code before component c_code_after: str, default "" Sets c code after component """ # Allow addition of attributes in init self._unfreeze() self.name = instance_name self.component_name = component_name # initialize McStas information self.AT_data = [0, 0, 0] self.AT_relative = "ABSOLUTE" self.ROTATED_specified = False self.ROTATED_data = [0, 0, 0] self.ROTATED_relative = "ABSOLUTE" self.WHEN = "" self.EXTEND = "" self.GROUP = "" self.JUMP = "" self.SPLIT = 0 self.comment = "" self.c_code_before = "" self.c_code_after = "" self.search_statement_list = SearchStatementList() self.save_parameters = save_parameters # references to component names self.AT_reference = None self.ROTATED_reference = None # If any keywords are set in kwargs, update these self.set_keyword_input(AT=AT, AT_RELATIVE=AT_RELATIVE, ROTATED=ROTATED, ROTATED_RELATIVE=ROTATED_RELATIVE, RELATIVE=RELATIVE, WHEN=WHEN, EXTEND=EXTEND, GROUP=GROUP, JUMP=JUMP, SPLIT=SPLIT, comment=comment, c_code_before=c_code_before, c_code_after=c_code_after) """ Could store an option for whether this component should be printed in instrument file or in a separate file which would then be included. """ # Do not allow addition of attributes after init self._freeze() def set_keyword_input(self, AT=None, AT_RELATIVE=None, ROTATED=None, ROTATED_RELATIVE=None, RELATIVE=None, WHEN=None, EXTEND=None, GROUP=None, JUMP=None, SPLIT=None, comment=None, c_code_before=None, c_code_after=None, save_parameters=None): # Allow addition of attributes in init self._unfreeze() if AT is not None: self.set_AT(AT) if AT_RELATIVE is not None: self.set_AT_RELATIVE(AT_RELATIVE) self.ROTATED_specified = False if ROTATED is not None: self.set_ROTATED(ROTATED) if ROTATED_RELATIVE is not None: self.set_ROTATED_RELATIVE(ROTATED_RELATIVE) if RELATIVE is not None: self.set_RELATIVE(RELATIVE) if WHEN is not None: self.set_WHEN(WHEN) if EXTEND is not None: self.append_EXTEND(EXTEND) if GROUP is not None: self.set_GROUP(GROUP) if JUMP is not None: self.set_JUMP(JUMP) if SPLIT is not None: self.set_SPLIT(SPLIT) if comment is not None: self.set_comment(comment) if c_code_before is not None: self.set_c_code_before(c_code_before) if c_code_after is not None: self.set_c_code_after(c_code_after) def __setattr__(self, key, value): if self.__isfrozen and not hasattr(self, key): raise AttributeError("No parameter called '" + key + "' in component named " + self.name + " of component type " + self.component_name + ".") object.__setattr__(self, key, value) def _freeze(self): self.__isfrozen = True def _unfreeze(self): self.__isfrozen = False def set_AT(self, at_list, RELATIVE=None): """ Method for setting position of component Sets the position of the component using provided length 3 list as a vector. If only a float is given, it is considered along the beam direction, [0, 0, z]. The RELATIVE keyword is used to specify in relation to what the position is given, and can take either a string with a component name or a Component object. Parameters ---------- at_list : List of 3 floats or float Position of component relative to reference component keyword arguments: RELATIVE : str Sets reference component for position """ if isinstance(at_list, (int, float, str)): at_list = [0, 0, at_list] if not isinstance(at_list, list): raise RuntimeError("set_AT should be given either a list or " + "float, but received " + str(type(at_list))) if len(at_list) != 3: raise RuntimeError("Position data given to set_AT should " + "either be of length 3 or just a float.") # If parameter objects given, take their name instead for index, element in enumerate(at_list): if isinstance(element, (Parameter, DeclareVariable)): at_list[index] = element.name self.AT_data = at_list if RELATIVE is not None: self.set_AT_RELATIVE(RELATIVE) def set_AT_RELATIVE(self, relative): """ Sets AT RELATIVE with string or Component instance Set relative which becomes the reference for this components position, it is possible to use a string that match another component name or use a Component object where the name is used as the reference. Parameters ---------- relative : str or Component object Used as reference for component position """ # Extract name if Component instance is given if isinstance(relative, Component): relative = relative.name elif not isinstance(relative, str): raise ValueError("Relative must be either string or " + "Component object.") # Set AT relative if relative == "ABSOLUTE": self.AT_relative = "ABSOLUTE" self.AT_reference = None else: self.AT_relative = "RELATIVE " + relative self.AT_reference = relative def set_ROTATED(self, rotated_list, RELATIVE=None): """ Method for setting rotation of component Parameters ---------- rotated_list : List of 3 floats Rotation of component relative to reference component keyword arguments: RELATIVE : str Sets reference component for rotation """ if not isinstance(rotated_list, list): raise RuntimeError("set_ROTATED should be given a list " + " but received " + str(type(rotated_list))) if len(rotated_list) != 3: raise RuntimeError("Rotation data given to set_ROTATED should " + "be of length 3.") # If parameter objects given, take their name instead for index, element in enumerate(rotated_list): if isinstance(element, (Parameter, DeclareVariable)): rotated_list[index] = element.name self.ROTATED_data = rotated_list self.ROTATED_specified = True if RELATIVE is not None: self.set_ROTATED_RELATIVE(RELATIVE) def set_ROTATED_RELATIVE(self, relative): """ Sets ROTATED RELATIVE with string or Component instance Set relative which becomes the reference for this components rotation, it is possible to use a string that match another component name or use a Component object where the name is used as the reference. Parameters ---------- relative : str or Component object Used as reference for component rotation """ self.ROTATED_specified = True # Extract name if a Component instance is given if isinstance(relative, Component): relative = relative.name elif not isinstance(relative, str): raise ValueError("Relative must be either string or " + "Component object.") # Set ROTATED relative if relative == "ABSOLUTE": self.ROTATED_relative = "ABSOLUTE" self.ROTATED_reference = None else: self.ROTATED_relative = "RELATIVE " + relative self.ROTATED_reference = relative def set_RELATIVE(self, relative): """ Method for setting reference of component position and rotation Input can be either a string matching an earlier component or a Component object. Parameters ---------- relative : str Reference component for position and rotation """ # Extract name if a Component instance is given if isinstance(relative, Component): relative = relative.name elif not isinstance(relative, str): raise ValueError("Relative must be either string or " + "Component object.") if relative == "ABSOLUTE": self.AT_relative = "ABSOLUTE" self.AT_reference = None self.ROTATED_relative = "ABSOLUTE" self.ROTATED_reference = None else: self.AT_relative = "RELATIVE " + relative self.AT_reference = relative self.ROTATED_relative = "RELATIVE " + relative self.ROTATED_reference = relative def set_parameters(self, args_as_dict=None, **kwargs): """ Set Component parameters from dictionary input or keyword arguments Relies on attributes added when McCode_Instr creates a subclass from the Component class where each component parameter is added as an attribute. An error is raised if trying to set a parameter that does not exist Parameters ---------- args_as_dict : dict Parameters names and their values as dictionary """ if args_as_dict is not None: parameter_dict = args_as_dict else: parameter_dict = kwargs for key, val in parameter_dict.items(): if not hasattr(self, key): raise NameError("No parameter called " + key + " in component named " + self.name + " of component type " + self.component_name + ".") else: setattr(self, key, val) def set_WHEN(self, string): """ Method for setting WHEN c expression of this component Parameters ---------- WHEN : str Sets WHEN c expression for named McStas component """ if not isinstance(string, str): raise RuntimeError("set_WHEN expect a string, but was " + "given " + str(type(string))) self.WHEN = "WHEN (" + string + ")" def set_GROUP(self, string): """ Method for setting GROUP keyword of this component Parameters ---------- GROUP : str Sets GROUP name for named McStas component """ if not isinstance(string, str): raise RuntimeError("set_GROUP expect a string, but was " + "given " + str(type(string))) self.GROUP = string def set_JUMP(self, string): """ Method for setting JUMP expression of this component Should contain all code needed after JUMP Parameters ---------- JUMP : str Sets JUMP expression for named McStas component """ if not isinstance(string, str): raise RuntimeError("set_JUMP expect a string, but was " + "given " + str(type(string))) self.JUMP = string def set_SPLIT(self, value): """ Method for setting SPLIT value of this component Parameters ---------- SPLIT : int or str Sets SPLIT value for named McStas component """ if not isinstance(value, (int, str)): raise RuntimeError("set_SPLIT expect a integer or string, but " + "was given " + str(type(value))) if isinstance(value, int): if value < 0: raise RuntimeError("set_SPLIT got a negative value, this is " + "meaningless, has to be a " + "positive value.") self.SPLIT = value def append_EXTEND(self, string): """ Method for adding line of c to EXTEND section of this component Parameters ---------- EXTEND : str Line of c code added to EXTEND section of named component """ if not isinstance(string, str): raise RuntimeError("append_EXTEND expect a string, but was " + "given " + str(type(string))) self.EXTEND = self.EXTEND + string + "\n" def set_comment(self, string): """ Sets a comment displayed before the component in written files Parameters ---------- string : str Comment string """ if not isinstance(string, str): raise RuntimeError("set_comment expect a string, but was " + "given " + str(type(string))) self.comment = string def set_c_code_before(self, string): """ Method for setting c code before this component Parameters ---------- code : str Code to be pasted before component """ if not isinstance(string, str): raise RuntimeError("set_c_code_before expect a string, but was " + "given " + str(type(string))) self.c_code_before = string def set_c_code_after(self, string): """ Method for setting c code after this component Parameters ---------- code : str Code to be pasted after component """ if not isinstance(string, str): raise RuntimeError("set_c_code_after expect a string, but was " + "given " + str(type(string))) self.c_code_after = string def set_save_parameters(self, value): if value: self.save_parameters = True else: self.save_parameters = False def add_search(self, statement, SHELL=False): """ Adds a search statement to the component The search line can be used to tell McStas to search for files in additional locations. Double quotes are added. Parameters ---------- statement : str The search statement SHELL : bool (default False) if True, shell keyword is added """ self.search_statement_list.add_statement(SearchStatement(statement, SHELL=SHELL)) def clear_search(self): """ Clears the component of all search statements """ self.search_statement_list.clear() def show_search(self): """ Shows all search statements of component """ print(self.search_statement_list) def write_component(self, fo, instrument_search=None): """ Method that writes component to file Relies on attributes added when McStas_Instr creates a subclass based on the component class. """ parameters_per_line = 2 # Could use character limit on lines instead parameters_written = 0 # internal parameter save_parameter_string = "" if len(self.c_code_before) > 0: explanation = "From component named " + self.name fo.write("%s // %s\n" % (str(self.c_code_before), explanation)) fo.write("\n") # Write comment if present if len(self.comment) > 1: fo.write("// %s\n" % (str(self.comment))) # Write search statements self.search_statement_list.write(fo) # Add search statement for instrument if supplied if instrument_search is not None: instrument_search.write(fo) if self.SPLIT != 0: fo.write("SPLIT " + str(self.SPLIT) + " ") # Write component name and component type fo.write("COMPONENT %s = %s(" % (self.name, self.component_name)) component_parameters = {} for key in self.parameter_names: val = getattr(self, key) if val is None: if self.parameter_defaults[key] is None: raise NameError("Required parameter named " + key + " in component named " + self.name + " not set.") else: continue elif isinstance(val, (Parameter, DeclareVariable)): # Extract the parameter name val = val.name component_parameters[key] = val number_of_parameters = len(component_parameters) if number_of_parameters == 0: fo.write(")\n") # If there are no parameters, close immediately else: fo.write("\n") # If there are parameters, start a new line for key, val in component_parameters.items(): if isinstance(val, float): # CHeck if value is a number # Small or large numbers written in scientific format fo.write(" %s = %G" % (str(key), val)) else: fo.write(" %s = %s" % (str(key), str(val))) parameters_written = parameters_written + 1 if parameters_written < number_of_parameters: fo.write(",") # Comma between parameters if parameters_written % parameters_per_line == 0: fo.write("\n") else: fo.write(")\n") # End paranthesis after last parameter # Optional WHEN section if not self.WHEN == "": fo.write("%s\n" % self.WHEN) # Write AT and ROTATED section fo.write("AT (%s,%s,%s)" % (str(self.AT_data[0]), str(self.AT_data[1]), str(self.AT_data[2]))) fo.write(" %s\n" % self.AT_relative) if self.save_parameters: save_parameter_string += " %s\n" % self.AT_relative if self.ROTATED_specified: fo.write("ROTATED (%s,%s,%s)" % (str(self.ROTATED_data[0]), str(self.ROTATED_data[1]), str(self.ROTATED_data[2]))) fo.write(" %s\n" % self.ROTATED_relative) if not self.GROUP == "": fo.write("GROUP %s\n" % self.GROUP) # Optional EXTEND section if not self.EXTEND == "": fo.write("EXTEND %{\n") fo.write("%s" % self.EXTEND) fo.write("%}\n") if not self.JUMP == "": fo.write("JUMP %s\n" % self.JUMP) if len(self.c_code_after) > 0: fo.write("\n") explanation = "From component named " + self.name fo.write("%s // %s\n" % (str(self.c_code_after), explanation)) # Leave a new line between components for readability fo.write("\n") def make_write_string(self): string = "" string += f'fprintf(file, "COMPONENT {self.name} = {self.component_name}\\n");\n' component_parameters = {} for key in self.parameter_names: val = getattr(self, key) if val is None: if self.parameter_defaults[key] is None: raise NameError("Required parameter named " + key + " in component named " + self.name + " not set.") else: continue elif isinstance(val, (Parameter, DeclareVariable)): # Extract the parameter name val = val.name component_parameters[key] = val for key, val in component_parameters.items(): par_type = self.parameter_types[key] # from component reader cast = "" if par_type == "" or par_type == "double": type_string = "%lf" cast = "(double)" elif par_type == "int": type_string = "%d" cast = "(int)" elif par_type == "string": type_string = "%s" else: raise ValueError("Unknown parameter type: " + par_type) string += f'fprintf(file, "{key}={type_string}\\n", {cast} {val});\n' string += f'fprintf(file, "AT (%lf,%lf,%lf) {self.AT_relative}\\n",' string += "(double) " + str(self.AT_data[0]) + "," string += "(double) " + str(self.AT_data[1]) + "," string += "(double) " + str(self.AT_data[2]) + ");\n" if self.ROTATED_specified: string += f'fprintf(file, "ROTATED (%lf,%lf,%lf) {self.ROTATED_relative}\\n",' string += "(double) " + str(self.ROTATED_data[0]) + "," string += "(double) " + str(self.ROTATED_data[1]) + "," string += "(double) " + str(self.ROTATED_data[2]) + ");\n" return string def __str__(self): """ Returns string of information about the component Includes information on required parameters if they are not yet specified. Information on the components are added when the class is used as a superclass for classes describing each McStas component. """ string = "" if len(self.c_code_before) > 1: string += self.c_code_before + "\n" string += self.search_statement_list.make_string() if len(self.comment) > 1: string += "// " + self.comment + "\n" if self.SPLIT != 0: string += "SPLIT " + str(self.SPLIT) + " " string += "COMPONENT " + str(self.name) string += " = " + str(self.component_name) + "(" last_par_name = "" for key in self.parameter_names: if getattr(self, key) is not None: last_par_name = key for key in self.parameter_names: val = getattr(self, key) parameter_name = bcolors.BOLD + key + bcolors.ENDC if val is not None: unit = "" if key in self.parameter_units: unit += " // [" + self.parameter_units[key] + "]" if isinstance(val, Parameter): #val_string = val.print_line() # too long val_string = val.name elif isinstance(val, DeclareVariable): val_string = val.name else: val_string = str(val) value = (bcolors.BOLD + bcolors.OKGREEN + val_string + bcolors.ENDC + bcolors.ENDC) string += "\n" string += " " + parameter_name string += " = " + value if key != last_par_name: string += "," string += unit else: if self.parameter_defaults[key] is None: string += "\n" string += " " + parameter_name string += bcolors.FAIL string += " : Required parameter not yet specified" string += bcolors.ENDC string += "\n)" if not self.WHEN == "": string += " " + self.WHEN string += "\n" string += f"AT {tuple(self.AT_data)} " #"AT (" + str(self.AT_data[0]) + ", " + str(self.AT_data[1]) + ", " + str(self.AT_data[2]) + ") " string += str(self.AT_relative) + "\n" if self.ROTATED_specified: string += f"ROTATED {tuple(self.ROTATED_data)}" string += " " + self.ROTATED_relative + "\n" if not self.GROUP == "": string += "GROUP " + self.GROUP + "\n" if not self.EXTEND == "": string += "EXTEND %{" + "\n" string += self.EXTEND + "%}" + "\n" if not self.JUMP == "": string += "JUMP " + self.JUMP + "\n" if len(self.c_code_after) > 1: string += self.c_code_after + "\n" return string.strip() def print_long(self): """ Prints information about the component Includes information on required parameters if they are not yet specified. Information on the components are added when the class is used as a superclass for classes describing each McStas component. """ print(self.__str__()) def __repr__(self): return self.__str__() def print_short(self, longest_name=None): """Prints short description of component to list print""" if self.ROTATED_specified: print_rotate_rel = self.ROTATED_relative else: print_rotate_rel = self.AT_relative if longest_name is not None: number_of_spaces = 3+longest_name-len(self.name) print(str(self.name) + " "*number_of_spaces, end='') print(str(self.component_name), "\tAT", self.AT_data, self.AT_relative, "ROTATED", self.ROTATED_data, print_rotate_rel) else: print(str(self.name), "=", str(self.component_name), "\tAT", self.AT_data, self.AT_relative, "ROTATED", self.ROTATED_data, print_rotate_rel) def show_parameters(self, line_length=None): """ Shows available parameters and their defaults for the component Any value specified is not reflected in this view. The additional attributes defined when McStas_Instr creates subclasses for the individual components are required to run this method. """ # line_limit created in _create_component_instance on instr if line_length is None: line_length = self.line_limit # Minimum reasonable line length if line_length < 74: line_length = 74 print(" ___ Help " + self.component_name + " " + (line_length - 11 - len(self.component_name))*"_") print("|" + bcolors.BOLD + "optional parameter" + bcolors.ENDC + "|" + bcolors.BOLD + bcolors.UNDERLINE + "required parameter" + bcolors.ENDC + bcolors.ENDC + "|" + bcolors.BOLD + bcolors.OKBLUE + "default value" + bcolors.ENDC + bcolors.ENDC + "|" + bcolors.BOLD + bcolors.OKGREEN + "user specified value" + bcolors.ENDC + bcolors.ENDC + "|") for parameter in self.parameter_names: characters_before_comment = 4 unit = "" if parameter in self.parameter_units: unit = " [" + self.parameter_units[parameter] + "]" characters_before_comment += len(unit) comment = "" if parameter in self.parameter_comments: if not self.parameter_comments[parameter] == "": comment = " // " + self.parameter_comments[parameter] parameter_name = bcolors.BOLD + parameter + bcolors.ENDC characters_before_comment += len(parameter) value = "" characters_from_value = 0 if self.parameter_defaults[parameter] is None: parameter_name = (bcolors.UNDERLINE + parameter_name + bcolors.ENDC) else: this_default = str(self.parameter_defaults[parameter]) value = (" = " + bcolors.BOLD + bcolors.OKBLUE + this_default + bcolors.ENDC + bcolors.ENDC) characters_from_value = 3 + len(this_default) if getattr(self, parameter) is not None: parameter_input = getattr(self, parameter) # Use name when an par/var object is found if isinstance(parameter_input, (Parameter, DeclareVariable)): parameter_input = parameter_input.name this_set_value = str(parameter_input) value = (" = " + bcolors.BOLD + bcolors.OKGREEN + this_set_value + bcolors.ENDC + bcolors.ENDC) characters_from_value = 3 + len(this_set_value) characters_before_comment += characters_from_value print(parameter_name + value + unit, end="") if characters_before_comment + len(comment) < line_length: print(comment) else: length_for_comment = line_length - characters_before_comment # Split comment into several lines original_comment = comment words = comment.split(" ") words_left = len(words) last_index = 0 current_index = 0 comment = "" iterations = 0 max_iterations = 50 while(words_left > 0): iterations += 1 if iterations > max_iterations: # Something went long, print on one line break line_left = length_for_comment while(line_left > 0): if current_index >= len(words): current_index = len(words) + 1 break line_left -= len(str(words[current_index])) + 1 current_index += 1 current_index -= 1 for word in words[last_index:current_index]: comment += word + " " words_left = len(words) - current_index if words_left > 0: comment += "\n" + " "*characters_before_comment last_index = current_index if not iterations == max_iterations + 1: print(comment) else: print(str(original_comment)) print(line_length*"-") def show_parameters_simple(self): """ Shows available parameters and their defaults for the component Any value specified is not reflected in this view. The additional attributes defined when McStas_Instr creates subclasses for the individual components are required to run this method. """ print("---- Help " + self.component_name + " -----") for parameter in self.parameter_names: value = "" if self.parameter_defaults[parameter] is not None: value = " = " + str(self.parameter_defaults[parameter]) if getattr(self, parameter) is not None: value = " = " + str(getattr(self, parameter)) unit = "" if parameter in self.parameter_units: unit = " [" + self.parameter_units[parameter] + "]" comment = "" if parameter in self.parameter_comments: if self.parameter_comments[parameter] != "": comment = " // " + self.parameter_comments[parameter] print(parameter + value + unit + comment) print("----------" + "-"*len(self.component_name) + "------") def check_parameters(self, instrument_variables): """ Checks the current component parameters are in given name list The name list will typically be a list of instrument parameters and declared variables. Parameters ---------- instrument_variables : list of str List of instrument variable names """ McStas_constants = ["DEG2RAD", "RAD2DEG", "MIN2RAD", "RAD2MIN", "V2K", "K2V", "VS2E", "SE2V", "FWHM2RMS", "RMS2FWHM", "MNEUTRON" "HBAR", "PI", "FLT_MAX"] # parameter_names attribute added in _create_component_instance for par_name in self.parameter_names: par = getattr(self, par_name) if isinstance(par, str): if not par.isalpha(): # Allow numbers and strings with math symbols # They may have errors, but can't be easily checked continue if par in McStas_constants: # Allow McStas defined constants continue if par in instrument_variables: # Allow variables on given whitelist continue # If none of the above approves the variable, raise error raise McStasError("Variable not recognized.\n" f"Unrecognized variable '{par}' " "assigned to component parameter " f"'{par_name}' in component " f"'{self.name}' of type " f"'{self.component_name}'.\n" "This check can be skipped with " "settings(checks=False)")