def make_pfunc_factory(conf_space, ffparams, numcores, eps, algo_index, emat_cache_pattern, data): """make_pfunc_factory Return a PartitionFunctionFactory object for the input confspace, which we can use to make partition functions for various sequences. """ parallelism = osprey.Parallelism(cpuCores=numcores) data['numCpus'] = numcores # how should we compute energies of molecules? minimizingEcalc = osprey.EnergyCalculator(conf_space, ffparams, parallelism=parallelism, isMinimizing=True) # Compute reference energies eref = osprey.ReferenceEnergies(conf_space, minimizingEcalc) #Create a minimizing energy calculator confEcalcMinimized = osprey.ConfEnergyCalculator(conf_space, minimizingEcalc, referenceEnergies=eref) # we need rigid energies too for many algorithms rigidEcalc = osprey.SharedEnergyCalculator(minimizingEcalc, isMinimizing=False) rigidConfEcalc = osprey.ConfEnergyCalculatorCopy(confEcalcMinimized, rigidEcalc) confEcalcRigid = rigidConfEcalc # Specify the type of partitionFunction if ALGO_LIST[algo_index] == 'SHARK': # using SHARK* impt_ecalc = rigidConfEcalc choose_markstar = False elif ALGO_LIST[algo_index] == 'MARK': # using MARK* impt_ecalc = rigidConfEcalc choose_markstar = True else: # using Gradient descent pfunc impt_ecalc = None choose_markstar = False pfuncFactory = osprey.PartitionFunctionFactory( conf_space, confEcalcMinimized, emat_cache_pattern, confUpperBoundcalc=impt_ecalc, useMARK=choose_markstar) # Set cache pattern pfuncFactory.setCachePattern( '%s/emat.%s.%s' % (XTMP_DIR, emat_cache_pattern, data["design name"])) print('Cache pattern: %s/emat.%s.%s' % (XTMP_DIR, emat_cache_pattern, data["design name"])) return pfuncFactory
def configure_bbk(instance, minimizingEcalc, type_string, id_obj, algo_index): """Configure the energy calculators and info for BBK* instance""" for info in instance.confSpaceInfos(): # Compute reference energies eref = osprey.ReferenceEnergies(info.confSpace, minimizingEcalc) #Create a minimizing energy calculator info.confEcalcMinimized = osprey.ConfEnergyCalculator( info.confSpace, minimizingEcalc, referenceEnergies=eref) # BBK* needs rigid energies too rigidEcalc = osprey.SharedEnergyCalculator(minimizingEcalc, isMinimizing=False) rigidConfEcalc = osprey.ConfEnergyCalculatorCopy( info.confEcalcMinimized, rigidEcalc) info.confEcalcRigid = rigidConfEcalc # Specify the input for the partition functions. Providing the confUpperBoundcalc turns on SHARK* if ALGO_LIST[algo_index] == 'SHARK': impt_ecalc = rigidConfEcalc choose_markstar = False elif ALGO_LIST[algo_index] == 'MARK': impt_ecalc = rigidConfEcalc choose_markstar = True else: impt_ecalc = None choose_markstar = False info.pfuncFactory = osprey.PartitionFunctionFactory( info.confSpace, info.confEcalcMinimized, info.id, confUpperBoundcalc=impt_ecalc, useMARK=choose_markstar) # Set cache pattern info.pfuncFactory.setCachePattern('%s/emat.%s.%s' % (XTMP_DIR, info.id, id_obj)) print('Cache pattern: %s/emat.%s.%s' % (XTMP_DIR, info.id, id_obj)) # compute the energy matrices info.ematMinimized = info.pfuncFactory.getOrMakeEmat( info.confEcalcMinimized, 'minimized') info.ematRigid = info.pfuncFactory.getOrMakeEmat( info.confEcalcRigid, 'rigid') # Updating energy matrix? #info.ematCorrected =\ #osprey.c.ematrix.UpdatingEnergyMatrix( #info.confSpace, #info.ematMinimized, #info.confEcalcMinimized #) # how should confs be ordered and searched? (don't forget to capture emat by using a defaulted argument) def makeAStar_min(rcs, emat=info.ematMinimized): return osprey.AStarTraditional(emat, rcs, showProgress=True) info.confSearchFactoryMinimized =\ osprey.KStar.ConfSearchFactory(makeAStar_min) def makeRigidAStar(rcs, emat=info.ematRigid): return osprey.AStarTraditional(emat, rcs, showProgress=True) info.confSearchFactoryRigid =\ osprey.KStar.ConfSearchFactory(makeRigidAStar)
# configure K* inputs for each conf space for info in kstar.confSpaceInfos(): # how should we define energies of conformations? eref = osprey.ReferenceEnergies(info.confSpace, ecalc) info.confEcalc = osprey.ConfEnergyCalculator(info.confSpace, ecalc, referenceEnergies=eref) # compute the minimized energy matrix ematMinimized = osprey.EnergyMatrix(info.confEcalc, cacheFile='emat.%s.dat' % info.id) # if you want to use MARK*, pass in a rigid energy calculator and energy matrix as well confEcalcRigid = osprey.ConfEnergyCalculatorCopy(info.confEcalc, ecalcRigid) ematRigid = osprey.EnergyMatrix(confEcalcRigid, cacheFile='emat.%s.rigid.dat' % info.id) # how should we score each sequence? # (since we're in a loop, need capture variables above by using defaulted arguments) def makePfunc(rcs, confEcalcMinimized=info.confEcalc, ematMinimized=ematMinimized, confEcalcRigid=confEcalcRigid, ematRigid=ematRigid): return osprey.MARKStarPfunc(confEcalcMinimized.confSpace, ematMinimized, confEcalcMinimized, ematRigid, confEcalcRigid, rcs) info.pfuncFactory = osprey.KStar.PfuncFactory(makePfunc)
info.confSpace, minimizingEcalc, referenceEnergies=eref) # compute the energy matrix ematMinimized = osprey.EnergyMatrix(info.confEcalcMinimized, cacheFile='emat.%s.dat' % info.id) # how should confs be ordered and searched? # (since we're in a loop, need capture variables above by using defaulted arguments) def makeAStarMinimized(rcs, emat=ematMinimized): return osprey.AStarTraditional(emat, rcs, showProgress=False) info.confSearchFactoryMinimized = osprey.BBKStar.ConfSearchFactory( makeAStarMinimized) # BBK* needs rigid energies too confEcalcRigid = osprey.ConfEnergyCalculatorCopy(info.confEcalcMinimized, rigidEcalc) ematRigid = osprey.EnergyMatrix(confEcalcRigid, cacheFile='emat.%s.rigid.dat' % info.id) def makeAStarRigid(rcs, emat=ematRigid): return osprey.AStarTraditional(emat, rcs, showProgress=False) info.confSearchFactoryRigid = osprey.BBKStar.ConfSearchFactory( makeAStarRigid) # how should we score each sequence? # (since we're in a loop, need capture variables above by using defaulted arguments) def makePfunc(rcs, confEcalc=info.confEcalcMinimized, emat=ematMinimized): return osprey.PartitionFunction( confEcalc, osprey.AStarTraditional(emat, rcs, showProgress=False), osprey.AStarTraditional(emat, rcs, showProgress=False), rcs)
# how should we compute energies of molecules? # (give all the conf spaces to the ecalc) confSpaces = [state.confSpace for state in mskstar.states] parallelism = osprey.Parallelism(cpuCores=4) ecalc = osprey.EnergyCalculator(confSpaces, ffparams, parallelism=parallelism) rigidEcalc = osprey.SharedEnergyCalculator(ecalc, isMinimizing=False) # configure MSK* states for state in mskstar.states: # how should we define energies of conformations? eref = osprey.ReferenceEnergies(state.confSpace, ecalc) state.confEcalc = osprey.ConfEnergyCalculator(state.confSpace, ecalc, referenceEnergies=eref) rigidConfEcalc = osprey.ConfEnergyCalculatorCopy(state.confEcalc, rigidEcalc) # compute the energy matrix emat = osprey.EnergyMatrix(state.confEcalc, cacheFile='emat.%s.dat' % state.name) state.fragmentEnergies = emat # how should we compute partition functions? state.pfuncFactory = osprey.PartitionFunctionFactory( state.confSpace, state.confEcalc, state.name, confUpperBoundcalc=rigidConfEcalc) # how should confs be ordered and searched? (don't forget to capture emat by using a defaulted argument) def makeAStar(rcs, emat=emat):