def create_engine():
# create engine
ENGINE = Engine(path=None)
ENGINE.set_pdb(pdbPath)
# initialize constraints
B_CONSTRAINT = BondConstraint()
BA_CONSTRAINT = BondsAngleConstraint()
IA_CONSTRAINT = ImproperAngleConstraint()
# add constraints
ENGINE.add_constraints([B_CONSTRAINT])
B_CONSTRAINT.create_bonds_by_definition( bondsDefinition={"THF": [('O' ,'C1' , 1.20, 1.70),
('O' ,'C4' , 1.20, 1.70),
('C1','C2' , 1.25, 1.90),
('C2','C3' , 1.25, 1.90),
('C3','C4' , 1.25, 1.90),
('C1','H11', 0.88, 1.16),('C1','H12', 0.88, 1.16),
('C2','H21', 0.88, 1.16),('C2','H22', 0.88, 1.16),
('C3','H31', 0.88, 1.16),('C3','H32', 0.88, 1.16),
('C4','H41', 0.88, 1.16),('C4','H42', 0.88, 1.16)] })
ENGINE.add_constraints([BA_CONSTRAINT])
BA_CONSTRAINT.create_angles_by_definition( anglesDefinition={"THF": [ ('O' ,'C1' ,'C4' , 105, 125),
('C1' ,'O' ,'C2' , 100, 120),
('C4' ,'O' ,'C3' , 100, 120),
('C2' ,'C1' ,'C3' , 95 , 115),
('C3' ,'C2' ,'C4' , 95 , 115),
# H-C-H angle
('C1' ,'H11','H12', 98 , 118),
('C2' ,'H21','H22', 98 , 118),
('C3' ,'H31','H32', 98 , 118),
('C4' ,'H41','H42', 98 , 118),
# H-C-O angle
('C1' ,'H11','O' , 100, 120),
('C1' ,'H12','O' , 100, 120),
('C4' ,'H41','O' , 100, 120),
('C4' ,'H42','O' , 100, 120),
# H-C-C
('C1' ,'H11','C2' , 103, 123),
('C1' ,'H12','C2' , 103, 123),
('C2' ,'H21','C1' , 103, 123),
('C2' ,'H21','C3' , 103, 123),
('C2' ,'H22','C1' , 103, 123),
('C2' ,'H22','C3' , 103, 123),
('C3' ,'H31','C2' , 103, 123),
('C3' ,'H31','C4' , 103, 123),
('C3' ,'H32','C2' , 103, 123),
('C3' ,'H32','C4' , 103, 123),
('C4' ,'H41','C3' , 103, 123),
('C4' ,'H42','C3' , 103, 123) ] })
ENGINE.add_constraints([IA_CONSTRAINT])
IA_CONSTRAINT.create_angles_by_definition( anglesDefinition={"THF": [ ('C2','O','C1','C4', -15, 15),
('C3','O','C1','C4', -15, 15) ] })
# initialize constraints data
ENGINE.initialize_used_constraints()
# set moves generators
# set all move generators to Translation with a maximum amplutide of 0.3 A
[g.set_move_generator(TranslationGenerator(amplitude=0.3)) for g in ENGINE.groups]
# set randomly 25% of the translation amplitude to 10A
[g.set_move_generator(TranslationGenerator(amplitude=10.)) for g in ENGINE.groups if np.random.random()>0.25]
# return engine
return ENGINE
from fullrmc.Constraints.BondConstraints import BondConstraint
from fullrmc.Constraints.AngleConstraints import BondsAngleConstraint
##########################################################################################
################################## SHUT DOWN LOGGING ###################################
LOGGER.set_minimum_level(sys.maxint, stdoutFlag=True, fileFlag=True)
##########################################################################################
##################################### CREATE ENGINE ####################################
pdbPath = "system.pdb"
ENGINE = Engine(path=None)
ENGINE.set_pdb(pdbPath)
# add constraints
B_CONSTRAINT = BondConstraint()
BA_CONSTRAINT = BondsAngleConstraint()
ENGINE.add_constraints([B_CONSTRAINT, BA_CONSTRAINT])
B_CONSTRAINT.create_bonds_by_definition(bondsDefinition={
"TIP": [('OH2', 'H1', 0.8, 1.1), ('OH2', 'H2', 0.8, 1.1)]
})
BA_CONSTRAINT.create_angles_by_definition(
anglesDefinition={"TIP": [('OH2', 'H1', 'H2', 80, 120)]})
# set TranslationGenerator move generators amplitude
[g.moveGenerator.set_amplitude(0.025) for g in ENGINE.groups]
##########################################################################################
#################################### DIFFERENT RUNS ####################################
def run_normal(nsteps, xyzPath):
B_CONSTRAINT.create_bonds_by_definition(bondsDefinition={
##########################################################################################
##################################### CREATE ENGINE ####################################
# parameters
NSTEPS = 10000
pdbPath = 'system.pdb'
expData = 'experimental.gr'
# initialize engine
ENGINE = Engine(path=None)
ENGINE.set_pdb(pdbPath)
# create constraints
PDF_CONSTRAINT = PairDistributionConstraint(experimentalData=expData,
weighting="atomicNumber")
EMD_CONSTRAINT = InterMolecularDistanceConstraint()
B_CONSTRAINT = BondConstraint()
BA_CONSTRAINT = BondsAngleConstraint()
IA_CONSTRAINT = ImproperAngleConstraint()
# add constraints to engine
ENGINE.add_constraints([
PDF_CONSTRAINT, EMD_CONSTRAINT, B_CONSTRAINT, BA_CONSTRAINT, IA_CONSTRAINT
])
# initialize constraints definitions
B_CONSTRAINT.create_bonds_by_definition(
bondsDefinition={
"THF": [('O', 'C1', 1.22,
1.70), ('O', 'C4', 1.22, 1.70), (
'C1', 'C2', 1.25,
1.90), ('C2', 'C3', 1.25, 1.90), (
'C3', 'C4', 1.25,
1.90), ('C1', 'H11', 0.58,
1.22), ('C1', 'H12', 0.58,
from fullrmc.Constraints.AngleConstraints import BondsAngleConstraint
from fullrmc.Constraints.ImproperAngleConstraints import ImproperAngleConstraint
##########################################################################################
################################## SHUT DOWN LOGGING ###################################
LOGGER.set_minimum_level(maxint, stdoutFlag=True, fileFlag=True)
##########################################################################################
##################################### CREATE ENGINE ####################################
pdbPath = "system.pdb"
ENGINE = Engine(path=None)
ENGINE.set_pdb(pdbPath)
# add constraints
B_CONSTRAINT = BondConstraint()
BA_CONSTRAINT = BondsAngleConstraint()
IA_CONSTRAINT = ImproperAngleConstraint()
ENGINE.add_constraints([B_CONSTRAINT, BA_CONSTRAINT, IA_CONSTRAINT])
B_CONSTRAINT.create_bonds_by_definition(
bondsDefinition={
"PFT": [
('Xe', 'F1', 1.9, 2.1),
('Xe', 'F2', 1.9, 2.1),
('Xe', 'F3', 1.9, 2.1),
('Xe', 'F4', 1.9, 2.1),
('Xe', 'F5', 1.9, 2.1),
]
})
BA_CONSTRAINT.create_angles_by_definition(
anglesDefinition={
"PFT": [
# file names
expDataPath = "Xrays.gr"
pdbPath = "CO2.pdb"
enginePath = "CO2.rmc"
FRESH_START = False
ENGINE = Engine(path=None)
if not ENGINE.is_engine(enginePath) or FRESH_START:
# initialize engine
ENGINE = Engine(path=enginePath, freshStart=True)
ENGINE.set_pdb(pdbPath)
PDF_CONSTRAINT = PairDistributionConstraint(experimentalData=expDataPath,
weighting="atomicNumber")
IMD_CONSTRAINT = InterMolecularDistanceConstraint(defaultDistance=1.4)
B_CONSTRAINT = BondConstraint()
BA_CONSTRAINT = BondsAngleConstraint()
# add constraints
ENGINE.add_constraints(
[PDF_CONSTRAINT, IMD_CONSTRAINT, B_CONSTRAINT, BA_CONSTRAINT])
B_CONSTRAINT.create_bonds_by_definition(bondsDefinition={
"CO2": [('C', 'O1', 0.52, 1.4), ('C', 'O2', 0.52, 1.4)]
})
BA_CONSTRAINT.create_angles_by_definition(
anglesDefinition={"CO2": [('C', 'O1', 'O2', 170, 180)]})
# initialize constraints data
ENGINE.initialize_used_constraints()
# save engine
ENGINE.save()
else:
ENGINE = ENGINE.load(enginePath)
# unpack constraints before fitting in case tweaking is needed
def run_engine(PDF=True,
IMD=True,
B=True,
BA=True,
IA=True,
molecular=True,
nsteps=10000,
ncores=1):
ENGINE = Engine(path=None)
ENGINE.set_pdb(pdbPath)
# create experimental constraints
if PDF:
C = PairDistributionConstraint(experimentalData=expPath,
weighting="atomicNumber")
ENGINE.add_constraints(C)
# create and define molecular constraints
if IMD:
C = InterMolecularDistanceConstraint(defaultDistance=1.5)
ENGINE.add_constraints(C)
if B:
C = BondConstraint()
ENGINE.add_constraints(C)
C.create_bonds_by_definition(
bondsDefinition={
"THF": [('O', 'C1', 1.29,
1.70), ('O', 'C4', 1.29,
1.70), ('C1', 'C2', 1.29,
1.70), ('C2', 'C3', 1.29,
1.70), ('C3', 'C4', 1.29,
1.70),
('C1', 'H11', 0.58,
1.15), ('C1', 'H12', 0.58,
1.15), ('C2', 'H21', 0.58,
1.15), ('C2', 'H22', 0.58, 1.15),
('C3', 'H31', 0.58,
1.15), ('C3', 'H32', 0.58,
1.15), ('C4', 'H41', 0.58,
1.15), ('C4', 'H42', 0.58, 1.15)]
})
if BA:
C = BondsAngleConstraint()
ENGINE.add_constraints(C)
C.create_angles_by_definition(
anglesDefinition={
"THF": [
('O', 'C1', 'C4', 95, 135),
('C1', 'O', 'C2', 95, 135),
('C4', 'O', 'C3', 95, 135),
('C2', 'C1', 'C3', 90, 120),
('C3', 'C2', 'C4', 90, 120),
# H-C-H angle
('C1', 'H11', 'H12', 95, 125),
('C2', 'H21', 'H22', 95, 125),
('C3', 'H31', 'H32', 95, 125),
('C4', 'H41', 'H42', 95, 125),
# H-C-O angle
('C1', 'H11', 'O', 100, 120),
('C1', 'H12', 'O', 100, 120),
('C4', 'H41', 'O', 100, 120),
('C4', 'H42', 'O', 100, 120),
# H-C-C
('C1', 'H11', 'C2', 80, 123),
('C1', 'H12', 'C2', 80, 123),
('C2', 'H21', 'C1', 80, 123),
('C2', 'H21', 'C3', 80, 123),
('C2', 'H22', 'C1', 80, 123),
('C2', 'H22', 'C3', 80, 123),
('C3', 'H31', 'C2', 80, 123),
('C3', 'H31', 'C4', 80, 123),
('C3', 'H32', 'C2', 80, 123),
('C3', 'H32', 'C4', 80, 123),
('C4', 'H41', 'C3', 80, 123),
('C4', 'H42', 'C3', 80, 123)
]
})
if IA:
C = ImproperAngleConstraint()
ENGINE.add_constraints(C)
C.create_angles_by_definition(
anglesDefinition={
"THF": [('C2', 'O', 'C1', 'C4', -15,
15), ('C3', 'O', 'C1', 'C4', -15, 15)]
})
# initialize constraints data
ENGINE.initialize_used_constraints()
# run engine
if molecular:
ENGINE.set_groups_as_molecules()
print 'molecular, %s atoms, %s steps, %2s cores' % (
ENGINE.numberOfAtoms, nsteps, ncores),
tic = time.time()
ENGINE.run(numberOfSteps=nsteps,
saveFrequency=2 * nsteps,
restartPdb=None,
ncores=ncores)
elapsed = float(time.time() - tic) / float(nsteps)
print ' -- > %s seconds per step' % (elapsed, )
else:
ENGINE.set_groups_as_atoms()
print 'atomic , %s atoms, %s steps, %2s cores' % (
ENGINE.numberOfAtoms, nsteps, ncores),
tic = time.time()
ENGINE.run(numberOfSteps=nsteps,
saveFrequency=2 * nsteps,
restartPdb=None,
ncores=ncores)
elapsed = float(time.time() - tic) / float(nsteps)
print ' -- > %s seconds per step' % (elapsed, )
# return elapsed time
return elapsed
##########################################################################################
################################## SHUT DOWN LOGGING ###################################
LOGGER.set_minimum_level(maxint, stdoutFlag=True, fileFlag=True)
##########################################################################################
##################################### CREATE ENGINE ####################################
pdbPath = "system.pdb"
ENGINE = Engine(path=None)
ENGINE.set_pdb(pdbPath)
# add constraints
B_CONSTRAINT = BondConstraint()
BA_CONSTRAINT = BondsAngleConstraint()
DA_CONSTRAINT = DihedralAngleConstraint()
ENGINE.add_constraints([B_CONSTRAINT, BA_CONSTRAINT, DA_CONSTRAINT])
B_CONSTRAINT.create_bonds_by_definition( bondsDefinition={"BUT": [# C-C bonds
('C1' ,'C2' , 1.33, 1.73),
('C2' ,'C3' , 1.33, 1.73),
('C3' ,'C4' , 1.33, 1.73),
# C-H3 bonds
('C1' ,'H11', 1.01, 1.21),
('C1' ,'H12', 1.01, 1.21),
('C1' ,'H13', 1.01, 1.21),
('C4' ,'H41', 1.01, 1.21),
('C4' ,'H42', 1.01, 1.21),
('C4' ,'H43', 1.01, 1.21),
# C-H2 bonds
('C2' ,'H21', 0.99, 1.19),
# create engine
ENGINE = Engine(path=engineFilePath, freshStart=True)
ENGINE.set_pdb(pdbFileName)
## create experimental constraints
#PDF_CONSTRAINT = PairDistributionConstraint(experimentalData=expPath, weighting="atomicNumber")
_, _, _, gr = convert_Gr_to_gr(np.loadtxt(expPath), minIndex=[4, 5, 6])
dataWeights = np.ones(gr.shape[0])
dataWeights[:np.nonzero(gr[:, 1] > 0)[0][0]] = 0
PDF_CONSTRAINT = PairCorrelationConstraint(
experimentalData=gr.astype(FLOAT_TYPE),
weighting="atomicNumber",
dataWeights=dataWeights)
# create and define molecular constraints
EMD_CONSTRAINT = InterMolecularDistanceConstraint(defaultDistance=1.5)
B_CONSTRAINT = BondConstraint()
BA_CONSTRAINT = BondsAngleConstraint()
IA_CONSTRAINT = ImproperAngleConstraint()
# add constraints to engine
ENGINE.add_constraints([
PDF_CONSTRAINT, EMD_CONSTRAINT, B_CONSTRAINT, BA_CONSTRAINT,
IA_CONSTRAINT
])
# initialize constraints definitions
B_CONSTRAINT.create_bonds_by_definition(
bondsDefinition={
"THF": [('O', 'C1', 1.29, 1.70), (
'O', 'C4', 1.29,
1.70), ('C1', 'C2', 1.29, 1.70), (
'C2', 'C3', 1.29,
1.70), ('C3', 'C4', 1.29,
1.70), ('C1', 'H11', 0.58,
