class ModelBuilder(object): """A class for model construction interface. Parameters --------- name : str Name for the model. parfile : str optional The .par file input for select components. If the parfile is provided the self.model_instance will be put model instance with .par file read in. If it is not provided, self.model_instance will return as None. Returns ------- A class contains the result model instance if parfile is provided and method to build the model. """ def __init__(self, parfile=None, name=""): self.timing_model = None self.name = name self.param_inparF = None self.param_unrecognized = {} self.param_inModel = [] self.param_prefix = {} self.select_comp = {} self.control_params = ["EPHEM", "CLK"] if parfile is not None: self.parfile = parfile self.build_model(self.parfile, self.name) def __str__(self): result = "Model name : " + self.name + "\n" result += "Components in the model : \n" for c in self.select_comp: result += " " + str(c) + "\n" if self.model_instance is not None: result += "Read parameters from : " + self.parfile + "\n" result += "The model instance is :\n" + str(self.model_instance) return result def preprocess_parfile(self, parfile): """Preprocess the par file. Return ------ A dictionary with all the parfile parameters with values in string """ param = {} repeat_par = {} pfile = open(parfile, "r") for l in [pl.strip() for pl in pfile.readlines()]: # Skip blank lines if not l: continue # Skip commented lines if l.startswith("#") or l[:2] == "C ": continue k = l.split() if (k[0] in param.keys() ): # repeat parameter TODO: add JUMP1 even there is only one if k[0] in repeat_par.keys(): repeat_par[k[0]] += 1 else: repeat_par[k[0]] = 2 param[k[0] + str(repeat_par[k[0]])] = k[1:] else: param[k[0]] = k[1:] self.param_inparF = param for key in repeat_par.keys(): self.param_inparF[key + str(1)] = self.param_inparF.pop(key) pfile.close() return self.param_inparF def get_all_categories(self, ): """Obtain a dictionary from category to a list of instances.""" comp_category = defaultdict(list) for k, cp in Component.component_types.items(): comp_category[cp.category].append(cp()) return dict(comp_category) def get_comp_from_parfile(self, parfile): """Right now we only have one component on each category.""" params_inpar = self.preprocess_parfile(parfile) for cat, cmps in self.get_all_categories().items(): selected_c = None for cpi in cmps: if cpi.component_special_params: if any(par in params_inpar for par in cpi.component_special_params): selected_c = cpi # Once have match, stop searching break else: continue else: if cpi.is_in_parfile(params_inpar): selected_c = cpi if selected_c is not None: self.select_comp[cat] = selected_c def sort_components(self, category_order=DEFAULT_ORDER): """Sort the components into order. Parameters ---------- category_order: list, optional The order for the order sensitive component categories. Note ---- If a category is not listed in the category_order, it will be treated as order non-sensitive category and put in the end of sorted order list. """ sorted_components = [] for cat in self.get_all_categories(): if cat not in category_order: category_order.append(cat) for co in category_order: if co not in self.select_comp: continue cp = self.select_comp[co] sorted_components.append(cp) return sorted_components def search_prefix_param(self, paramList, model, prefix_type): """ Check if the Unrecognized parameter has prefix parameter """ prefixs = {} prefix_inModel = model.get_params_of_type(prefix_type) for pn in prefix_inModel: par = getattr(model, pn) prefixs[par.prefix] = [] for p in paramList: try: pre, idxstr, idxV = split_prefixed_name(p) if pre in [par.prefix] + par.prefix_aliases: prefixs[par.prefix].append(p) except: # FIXME: is this meant to catch KeyErrors? continue return prefixs def build_model(self, parfile=None, name=""): """Read parfile using the model_instance attribute. Parameters --------- name: str, optional The name for the timing model parfile : str optional The parfile name """ if parfile is not None: self.get_comp_from_parfile(parfile) sorted_comps = self.sort_components() self.timing_model = TimingModel(name, sorted_comps) param_inModel = self.timing_model.get_params_mapping() # Find unrecognised parameters in par file. if self.param_inparF is not None: parName = [] # add aliases for p in list(param_inModel.keys()): parName += getattr(self.timing_model, p).aliases parName += param_inModel.keys() for pp in self.param_inparF.keys(): if pp not in parName: self.param_unrecognized[pp] = self.param_inparF[pp] for ptype in ["prefixParameter", "maskParameter"]: prefix_param = self.search_prefix_param( self.param_unrecognized, self.timing_model, ptype) prefix_in_model = self.timing_model.get_params_of_type(ptype) for key in prefix_param: ppnames = [x for x in prefix_in_model if x.startswith(key)] for ppn in ppnames: pfx, idxs, idxv = split_prefixed_name(ppn) if pfx == key: exm_par = getattr(self.timing_model, ppn) else: continue exm_par_comp = param_inModel[exm_par.name] for parname in prefix_param[key]: pre, idstr, idx = split_prefixed_name(parname) if idx == exm_par.index: continue if hasattr(exm_par, "new_param"): new_par = exm_par.new_param(idx) self.timing_model.add_param_from_top( new_par, exm_par_comp) if "BINARY" in self.param_inparF: vals = self.param_inparF["BINARY"] if len(vals) != 1: raise ValueError( "Mal-formed binary model selection: {}".format( repr(" ".join(["BINARY"] + vals)))) (bm, ) = vals cats = self.timing_model.get_component_of_category() if "pulsar_system" not in cats: raise UnknownBinaryModel( "Unknown binary model requested in par file: {}". format(bm)) # FIXME: consistency check - the componens actually chosen should know the name bm if parfile is not None: self.timing_model.read_parfile(parfile) def get_control_info(self): info = {} if not self.param_unrecognized == {}: for ctrlp in self.control_params: if ctrlp in self.param_unrecognized: info[ctrlp] = self.param_unrecognized[ctrlp] else: # Check if the prefix match for p in self.control_params.keys(): if p.startswith(ctrlp): info[ctrlp] = self.param_unrecognized[ctrlp] return info
def choose_model(parfile, category_order=None, name=None, check_for_missing_parameters=False): """Determine which model components are appropriate for parfile.""" if name is None: if isinstance(parfile, str): name = os.path.basename(parfile) else: name = "" if category_order is None: category_order = DEFAULT_ORDER models_by_category = defaultdict(list) for k, c_type in Component.component_types.items(): models_by_category[c_type.category].append(c_type) par_dict = {} par_lines = [] multi_tags = set(["JUMP", "ECORR", "T2EFAC", "T2EQUAD", "EQUAD", "EFAC"]) multi_line = Counter() for l in interesting_lines(lines_of(parfile), comments=("#", "C ")): ll = l.split() k = ll[0] if k in multi_tags: multi_line[k] += 1 k = k + str(multi_line[k]) if k in par_dict: # FIXME: what happens with JUMPs? log.info("Lines with duplicate keys in par file: {} and {}".format( [k] + par_dict[k], ll)) par_dict[k] = ll[1:] par_lines.append(l) models_to_use = {} for category, models in models_by_category.items(): acceptable = [] for m_type in models: m = m_type() if m.is_in_parfile(par_dict): acceptable.append(m) if len(acceptable) > 1: raise ValueError( "Multiple models are compatible with this par file: {}".format( acceptable)) if acceptable: models_to_use[category] = acceptable[0] if "BINARY" in par_dict: vals = par_dict["BINARY"] if len(vals) != 1: raise ValueError("Mal-formed binary model selection: {}".format( repr(" ".join(["BINARY"] + vals)))) (bm, ) = vals if "pulsar_system" not in models_to_use: # Either we're missing parameters or the model is bogus # FIXME: distinguish raise UnknownBinaryModel( "Unknown binary model requested in par file: {}".format(bm)) # FIXME: consistency check - the componens actually chosen should know the name bm models_in_order = [] for category in category_order: try: models_in_order.append(models_to_use.pop(category)) except KeyError: pass models_in_order.extend(v for k, v in sorted(models_to_use.items())) tm = TimingModel(name, models_in_order) # FIXME: this should go in TimingModel for when you try to # add conflicting components alias_map = {} for prefix_type in ["prefixParameter", "maskParameter"]: for pn in tm.get_params_of_type(prefix_type): par = getattr(tm, pn) for a in [par.prefix] + par.prefix_aliases: if a in alias_map: raise ValueError( "Two prefix/mask parameters have the same " "alias {}: {} and {}".format(a, alias_map[a], par)) alias_map[a] = par leftover_params = par_dict.copy() for k in tm.get_params_mapping(): leftover_params.pop(k, None) for a in getattr(tm, k).aliases: leftover_params.pop(a, None) for p in leftover_params: try: pre, idxstr, idxV = split_prefixed_name(p) try: par = alias_map[pre] except KeyError: if pre in ignore_prefix: log.warning("Ignoring unhandled prefix {}".format(pre)) continue else: raise ValueError( "Mystery parameter {}, prefix {} with number {}". format(p, pre, idxV)) component = tm.get_params_mapping()[par.name] new_parameter = par.new_param(idxV) if hasattr(tm, new_parameter.name): raise ValueError("Received duplicate parameter {}".format( new_parameter.name)) tm.add_param_from_top(new_parameter, component) except PrefixError: pass return tm