Exemple #1
0
 def run_loop_input(self, lines, score=None):
     lines_iterator = iter(lines)
     while True:
         try:
             line = next(lines_iterator)
         except StopIteration:
             return self.ff
         cols = line.split()
         if cols[0] == 'DIR':
             self.direc = cols[1]
         if cols[0] == 'FFLD':
             # Import FF data.
             if cols[1] == 'read':
                 if cols[2] == 'mm3.fld':
                     self.ff = datatypes.MM3(os.path.join(self.direc, 
                                                          cols[2]))
                 if '.prm' in cols[2]:
                     self.ff = datatypes.TinkerFF(os.path.join(self.direc,
                                                               cols[2]))
                 self.ff.import_ff()
                 self.ff.method = 'READ'
                 with open(os.path.join(self.direc, cols[2]), 'r') as f:
                     self.ff.lines = f.readlines()
             # Export FF data.
             if cols[1] == 'write':
                 self.ff.export_ff(os.path.join(self.direc, cols[2]))
         # Trim parameters.
         if cols[0] == 'PARM':
             logger.log(20, '~~ SELECTING PARAMETERS ~~'.rjust(79, '~'))
             self.ff.params = parameters.trim_params_by_file(
                 self.ff.params, os.path.join(self.direc, cols[1]))
         if cols[0] == 'LOOP':
             # Read lines that will be looped over.
             inner_loop_lines = []
             line = next(lines_iterator)
             while line.split()[0] != 'END':
                 inner_loop_lines.append(line)
                 line = next(lines_iterator)
             # Make loop object and populate attributes.
             loop = Loop()
             loop.convergence = float(cols[1])
             loop.direc = self.direc
             loop.ff = self.ff
             loop.args_ff = self.args_ff
             loop.args_ref = self.args_ref
             loop.ref_data = self.ref_data
             loop.loop_lines = inner_loop_lines
             # Log commands.
             pretty_loop_input(
                 inner_loop_lines, name='OPTIMIZATION LOOP',
                 score=self.ff.score)
             # Run inner loop.
             self.ff = loop.opt_loop()
         # Note: Probably want to update this to append the directory given
         #       by the new DIR command.
         if cols[0] == 'RDAT':
             logger.log(
                 20, '~~ CALCULATING REFERENCE DATA ~~'.rjust(79, '~'))
             if len(cols) > 1:
                 self.args_ref = ' '.join(cols[1:]).split()
             self.ref_data = opt.return_ref_data(self.args_ref)
         if cols[0] == 'CDAT':
             logger.log(
                 20, '~~ CALCULATING FF DATA ~~'.rjust(79, '~'))
             if len(cols) > 1:
                 self.args_ff = ' '.join(cols[1:]).split()
             self.ff.data = calculate.main(self.args_ff)
         if cols[0] == 'COMP':
         # Deprecated
         #    self.ff.score = compare.compare_data(
         #        self.ref_data, self.ff.data)
         #    if '-o' in cols:
         #        compare.pretty_data_comp(
         #            self.ref_data,
         #            self.ff.data,
         #            os.path.join(self.direc, cols[cols.index('-o') + 1]))
         #    if '-p' in cols:
         #        compare.pretty_data_comp(
         #            self.ref_data,
         #            self.ff.data,
         #            doprint=True)
             output = False
             doprint = False
             r_dict = compare.data_by_type(self.ref_data)
             c_dict = compare.data_by_type(self.ff.data)
             r_dict, c_dict = compare.trim_data(r_dict,c_dict)
             if '-o' in cols:
                 output = os.path.join(self.direc, cols[cols.index('-o') +1])
             if '-p' in cols:
                 doprint = True
             self.ff.score = compare.compare_data(
                 r_dict, c_dict, output=output, doprint=doprint)
         if cols[0] == 'GRAD':
             grad = gradient.Gradient(
                 direc=self.direc,
                 ff=self.ff,
                 ff_lines=self.ff.lines,
                 args_ff=self.args_ff)
             #### Should probably just write a function instead of looping
             #### this for every gradient method. This includes everything
             #### between the two lines of #. TR 20180112
             ##############################################################        
             for col in cols[1:]:
                 if "lstsq" in col:
                     g_args = col.split('=')[1].split(',')
                     for arg in g_args:
                         if arg == "True":
                             grad.do_lstsq=True
                         elif arg == False:
                             grad.do_lstsq=False
                         if 'radii' in arg:
                             grad.lstsq_radii = []
                             radii_vals = re.search(
                                 r"\[(.+)\]",arg).group(1).split('/')
                             if radii_vals == "None":
                                 grad.lstsq_radii = None
                             else:
                                 for val in radii_vals:
                                     grad.lstsq_radii.append(float(val)) 
                         if 'cutoff' in arg:
                             grad.lstsq_cutoff = []
                             cutoff_vals = re.search(
                                 r"\[(.+)\]",arg).group(1).split('/')
                             if cutoff_vals == "None":
                                 grad.lstsq_cutoff = None
                             else:
                                 if len(cutoff_vals) > 2 or \
                                     len(cutoff_vals) < 2:
                                     raise Exception("Cutoff values must " \
                                         "be between two numbers.")
                                 for val in cutoff_vals:
                                     grad.lstsq_cutoff.append(float(val))
                 elif "newton" in col:
                     g_args = col.split('=')[1].split(',')
                     for arg in g_args:
                         if arg == "True":
                             grad.do_newton=True
                         elif arg == False:
                             grad.do_newton=False
                         if 'radii' in arg:
                             grad.newton_radii = []
                             radii_vals = re.search(
                                 r"\[(.+)\]",arg).group(1).split('/')
                             if radii_vals=='None':
                                 grad.newton_radii = None
                             else:
                                 for val in radii_vals:
                                     grad.newton_radii.append(float(val)) 
                         if 'cutoff' in arg:
                             grad.newton_cutoff = []
                             cutoff_vals = re.search(
                                 r"\[(.+)\]",arg).group(1).split('/')
                             if cutoff_vals=='None':
                                 grad.newton_cutoff = None
                             else:
                                 if len(cutoff_vals) > 2 or \
                                     len(cutoff_vals) < 2:
                                     raise Exception("Cutoff values must " \
                                         "be between two numbers.")
                                 for val in cutoff_vals:
                                     grad.newton_cutoff.append(float(val))
                 elif "levenberg" in col:
                     g_args = col.split('=')[1].split(',')
                     for arg in g_args:
                         if arg == "True":
                             grad.do_levenberg=True
                         elif arg == False:
                             grad.do_levenberg=False
                         if 'radii' in arg:
                             grad.levenberg_radii = []
                             radii_vals = re.search(
                                 r"\[(.+)\]",arg).group(1).split('/')
                             if radii_vals=='None':
                                 grad.levenberg_radii = None
                             else:
                                 for val in radii_vals:
                                     grad.levenberg_radii.append(float(val)) 
                         if 'cutoff' in arg:
                             grad.levenberg_cutoff = []
                             cutoff_vals = re.search(
                                 r"\[(.+)\]",arg).group(1).split('/')
                             if cutoff_vals=='None':
                                 grad.levenberg_cutoff = None
                             else:
                                 if len(cutoff_vals) > 2 or \
                                     len(cutoff_vals) < 2:
                                     raise Exception("Cutoff values must " \
                                         "be between two numbers.")
                                 for val in cutoff_vals:
                                     grad.levenberg_cutoff.append(float(val))
                         if 'factor' in arg:
                             grad.levenberg_cutoff = []
                             factor_vals = re.search(
                                 r"\[(.+)\]",arg).group(1).split('/')
                             if factor_vals=='None':
                                 grad.levenberg_factor = None
                             else:
                                 for val in factor_vals:
                                     grad.levenberg_factor.append(float(val))
                 elif "lagrange" in col:
                     g_args = col.split('=')[1].split(',')
                     for arg in g_args:
                         if arg == "True":
                             grad.do_lagrange=True
                         elif arg == False:
                             grad.do_lagrange=False
                         if 'radii' in arg:
                             grad.lagrange_radii = []
                             radii_vals = re.search(
                                 r"\[(.+)\]",arg).group(1).split('/')
                             if radii_vals=='None':
                                 grad.lagrange_radii = None
                             else:
                                 for val in radii_vals:
                                     grad.lagrange_radii.append(float(val)) 
                         if 'cutoff' in arg:
                             grad.lagrange_cutoff = []
                             cutoff_vals = re.search(
                                 r"\[(.+)\]",arg).group(1).split('/')
                             if cutoff_vals=='None':
                                 grad.lagrange_cutoff = None
                             else:
                                 if len(cutoff_vals) > 2 or \
                                     len(cutoff_vals) < 2:
                                     raise Exception("Cutoff values must " \
                                         "be between two numbers.")
                                 for val in cutoff_vals:
                                     grad.lagrange_cutoff.append(float(val))
                         if 'factor' in arg:
                             grad.lagrange_factors = []
                             factor_vals = re.search(
                                 r"\[(.+)\]",arg).group(1).split('/')
                             if factor_vals=='None':
                                 grad.lagrange_factors = None
                             else:
                                 for val in factor_vals:
                                     grad.lagrange_factors.append(float(val))
                 elif "svd" in col:
                     g_args = col.split('=')[1].split(',')
                     for arg in g_args:
                         if arg == "True":
                             grad.do_svd=True
                         elif arg == False:
                             grad.do_svd=False
                         if 'radii' in arg:
                             grad.svd_radii = []
                             radii_vals = re.search(
                                 r"\[(.+)\]",arg).group(1).split('/')
                             if radii_vals=='None':
                                 grad.svd_radii = None
                             else:
                                 for val in radii_vals:
                                     grad.svd_radii.append(float(val)) 
                         if 'cutoff' in arg:
                             grad.svd_cutoff = []
                             cutoff_vals = re.search(
                                 r"\[(.+)\]",arg).group(1).split('/')
                             if cutoff_vals=='None':
                                 grad.svd_cutoff = None
                             else:
                                 if len(cutoff_vals) > 2 or \
                                     len(cutoff_vals) < 2:
                                     raise Exception("Cutoff values must " \
                                         "be between two numbers.")
                                 for val in cutoff_vals:
                                     grad.svd_cutoff.append(float(val))
                         if 'factor' in arg:
                             grad.svd_cutoff = []
                             factor_vals = re.search(
                                 r"\[(.+)\]",arg).group(1).split('/')
                             if factor_vals=='None':
                                 grad.svd_factor = None
                             else:
                                 for val in factor_vals:
                                     grad.svd_factor.append(float(val))
                 else:
                     raise Exception("'{}' : Not Recognized".format(col))
             ##############################################################
             self.ff = grad.run(ref_data=self.ref_data)
         if cols[0] == 'SIMP':
             simp = simplex.Simplex(
                 direc=self.direc,
                 ff=self.ff,
                 ff_lines=self.ff.lines,
                 args_ff=self.args_ff)
             for col in cols[1:]:
                 if "max_params" in col:
                     simp.max_params = col.split('=')[1]
                 else:
                     raise Exception("'{}' : Not Recognized".format(col))
             self.ff = simp.run(r_data=self.ref_data)
         if cols[0] == 'WGHT':
             data_type = cols[1]
             co.WEIGHTS[data_type] = float(cols[2])
         if cols[0] == 'STEP':
             param_type = cols[1]
             co.STEPS[param_type] = float(cols[2])
Exemple #2
0
    FF.
    """
    old_ff.copy_attributes(new_ff)
    if len(old_ff.params) > len(new_ff.params):
        logger.log(15, '  -- Restoring {} parameters to new FF.'.format(
                len(old_ff.params) - len(new_ff.params)))
        # Backup new parameters.
        new_params = copy.deepcopy(new_ff.params)
        # Copy over all old parameters.
        new_ff.params = copy.deepcopy(old_ff.params)
        # Replace the old with the new.
        for i, param_o in enumerate(old_ff.params):
            for param_n in new_params:
                # Should replace this with a general index scheme.
                if param_o.mm3_row == param_n.mm3_row and \
                        param_o.mm3_col == param_n.mm3_col:
                    new_ff.params[i] = copy.deepcopy(param_n)
    return new_ff

if __name__ == '__main__':
    logging.config.dictConfig(co.LOG_SETTINGS)
    # Just for testing.
    ff = datatypes.MM3('b071/mm3.fld')
    ff.import_ff()
    ff.params = parameters.trim_params_by_file(ff.params, 'b071/params.txt')
    a = Simplex(
        direc='b071', ff=ff,
        args_ff=' -d b071 -me X002a.mae X002b.mae -mb X002a.mae',
        args_ref=' -d b071 -je X002a.mae X002b.mae -jb X002a.mae')
    a.run()
Exemple #3
0
 def run_loop_input(self, lines, score=None):
     lines_iterator = iter(lines)
     while True:
         try:
             line = lines_iterator.next()
         except StopIteration:
             return self.ff
         cols = line.split()
         if cols[0] == 'DIR':
             self.direc = cols[1]
         if cols[0] == 'FFLD':
             # Import FF data.
             if cols[1] == 'read':
                 self.ff = datatypes.MM3(os.path.join(self.direc, cols[2]))
                 self.ff.import_ff()
                 self.ff.method = 'READ'
                 with open(os.path.join(self.direc, cols[2]), 'r') as f:
                     self.ff.lines = f.readlines()
             # Export FF data.
             if cols[1] == 'write':
                 self.ff.export_ff(os.path.join(self.direc, cols[2]))
         # Trim parameters.
         if cols[0] == 'PARM':
             logger.log(20, '~~ SELECTING PARAMETERS ~~'.rjust(79, '~'))
             self.ff.params = parameters.trim_params_by_file(
                 self.ff.params, os.path.join(self.direc, cols[1]))
         if cols[0] == 'LOOP':
             # Read lines that will be looped over.
             inner_loop_lines = []
             line = lines_iterator.next()
             while line.split()[0] != 'END':
                 inner_loop_lines.append(line)
                 line = lines_iterator.next()
             # Make loop object and populate attributes.
             loop = Loop()
             loop.convergence = float(cols[1])
             loop.direc = self.direc
             loop.ff = self.ff
             loop.args_ff = self.args_ff
             loop.args_ref = self.args_ref
             loop.ref_data = self.ref_data
             loop.loop_lines = inner_loop_lines
             # Log commands.
             pretty_loop_input(
                 inner_loop_lines, name='OPTIMIZATION LOOP',
                 score=self.ff.score)
             # Run inner loop.
             self.ff = loop.opt_loop()
         # Note: Probably want to update this to append the directory given
         #       by the new DIR command.
         if cols[0] == 'RDAT':
             logger.log(
                 20, '~~ CALCULATING REFERENCE DATA ~~'.rjust(79, '~'))
             if len(cols) > 1:
                 self.args_ref = ' '.join(cols[1:]).split()
             self.ref_data = opt.return_ref_data(self.args_ref)
         if cols[0] == 'CDAT':
             logger.log(
                 20, '~~ CALCULATING FF DATA ~~'.rjust(79, '~'))
             if len(cols) > 1:
                 self.args_ff = ' '.join(cols[1:]).split()
             self.ff.data = calculate.main(self.args_ff)
         if cols[0] == 'COMP':
             self.ff.score = compare.compare_data(
                 self.ref_data, self.ff.data)
             if '-o' in cols:
                 compare.pretty_data_comp(
                     self.ref_data,
                     self.ff.data,
                     os.path.join(self.direc, cols[cols.index('-o') + 1]))
             if '-p' in cols:
                 compare.pretty_data_comp(
                     self.ref_data,
                     self.ff.data)
         if cols[0] == 'GRAD':
             grad = gradient.Gradient(
                 direc=self.direc,
                 ff=self.ff,
                 ff_lines=self.ff.lines,
                 args_ff=self.args_ff)
             self.ff = grad.run(ref_data=self.ref_data)
         if cols[0] == 'SIMP':
             simp = simplex.Simplex(
                 direc=self.direc,
                 ff=self.ff,
                 ff_lines=self.ff.lines,
                 args_ff=self.args_ff)
             self.ff = simp.run(r_data=self.ref_data)
         if cols[0] == 'WGHT':
             data_type = cols[1]
             co.WEIGHTS[data_type] = float(cols[2])