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):