├── .gitignore ├── Benchmark ├── core.py ├── fullatommodel.py ├── lstm.py ├── main.py ├── reducedmodel.py └── rmsd.py ├── LICENSE ├── Layers ├── FullAtomModel │ ├── Angles2Coords │ │ ├── angles2coords_interface.cpp │ │ └── angles2coords_interface.h │ ├── Coords2TypedCoords │ │ ├── coords2typedcoords_interface.cpp │ │ └── coords2typedcoords_interface.h │ ├── CoordsTransform │ │ ├── coordsTransformGPU_interface.cpp │ │ ├── coordsTransformGPU_interface.h │ │ ├── coordsTransform_interface.cpp │ │ └── coordsTransform_interface.h │ ├── PDB2Coords │ │ ├── pdb2coords_interface.cpp │ │ └── pdb2coords_interface.h │ ├── TransformCUDAKernels.cu │ ├── TransformCUDAKernels.h │ ├── cConformation.cpp │ ├── cConformation.h │ ├── cConformationAA.cpp │ ├── cGeometry.cpp │ ├── cGeometry.h │ ├── cPDBLoader.cpp │ ├── cPDBLoader.h │ ├── cRigidGroup.cpp │ ├── cRigidGroup.h │ └── main.cpp ├── RMSD │ ├── Coords2RMSD │ │ ├── coords2rmsd_interface.cpp │ │ └── coords2rmsd_interface.h │ ├── RMSDKernels.cu │ ├── RMSDKernels.h │ └── main.cpp ├── ReducedModel │ ├── Angles2Backbone │ │ ├── angles2backbone_interface.cpp │ │ └── angles2backbone_interface.h │ ├── cBackboneProteinCPUKernels.cpp │ ├── cBackboneProteinCPUKernels.hpp │ ├── cBackboneProteinCUDAKernels.cu │ ├── cBackboneProteinCUDAKernels.h │ └── main.cpp └── Volume │ ├── Kernels.cu │ ├── Kernels.h │ ├── RotateGrid.cu │ ├── RotateGrid.h │ ├── Select │ ├── select_interface.cpp │ └── select_interface.h │ ├── TypedCoords2Volume │ ├── typedcoords2volume_interface.cpp │ └── typedcoords2volume_interface.h │ ├── Volume2Xplor │ ├── volume2xplor_interface.cpp │ └── volume2xplor_interface.h │ ├── VolumeConv.cu │ ├── VolumeConv.h │ ├── VolumeConvolution │ ├── volumeConvolution_interface.cpp │ └── volumeConvolution_interface.h │ ├── VolumeRMSD.cu │ ├── VolumeRMSD.h │ ├── VolumeRMSD │ ├── volumeRMSD_interface.cpp │ └── volumeRMSD_interface.h │ ├── VolumeRotation │ ├── volumeRotation_interface.cpp │ └── volumeRotation_interface.h │ └── main.cpp ├── Math ├── CMakeLists.txt ├── cMathCUDAKernels.cu ├── cMathCUDAKernels.h ├── cMatrix33.cpp ├── cMatrix33.h ├── cMatrix44.cpp ├── cMatrix44.h ├── cVector3.cpp ├── cVector3.h ├── nUtil.cpp └── nUtil.h ├── README.md ├── TorchProteinLibrary ├── FullAtomModel │ ├── Angles2Coords │ │ ├── Angles2Coords.py │ │ └── __init__.py │ ├── Coords2TypedCoords │ │ ├── Coords2TypedCoords.py │ │ └── __init__.py │ ├── CoordsTransform │ │ ├── CoordsTransform.py │ │ └── __init__.py │ ├── PDB2Coords │ │ ├── PDB2Coords.py │ │ └── __init__.py │ └── __init__.py ├── RMSD │ ├── Coords2RMSD │ │ ├── Coords2RMSD.py │ │ └── __init__.py │ └── __init__.py ├── ReducedModel │ ├── Angles2Backbone │ │ ├── Angles2Backbone.py │ │ └── __init__.py │ └── __init__.py ├── Volume │ ├── Select │ │ ├── SelectVolume.py │ │ └── __init__.py │ ├── TypedCoords2Volume │ │ ├── TypedCoords2Volume.py │ │ └── __init__.py │ ├── VolumeConvolution │ │ ├── VolumeConvolution.py │ │ └── __init__.py │ ├── VolumeRMSD │ │ ├── VolumeRMSD.py │ │ └── __init__.py │ ├── VolumeRotation │ │ ├── VolumeRotation.py │ │ └── __init__.py │ └── __init__.py └── __init__.py ├── UnitTests ├── FullAtomModel │ ├── Angles2Coords │ │ ├── __init__.py │ │ ├── rotamers.py │ │ ├── simple_test.py │ │ ├── test.py │ │ └── utils.py │ ├── Coords2TypedCoords │ │ ├── __init__.py │ │ └── test.py │ ├── CoordsTransform │ │ ├── __init__.py │ │ ├── test.py │ │ ├── test_backward.py │ │ └── test_forward.py │ ├── PDB2Coords │ │ ├── __init__.py │ │ └── test.py │ └── __init__.py ├── RMSD │ ├── Coords2RMSD │ │ ├── __init__.py │ │ ├── test.py │ │ └── test_backward.py │ └── __init__.py ├── ReducedModel │ ├── Angles2Backbone │ │ ├── __init__.py │ │ ├── test.py │ │ ├── test_backward.py │ │ ├── test_forward.py │ │ └── test_forward_simple.py │ └── __init__.py ├── Volume │ ├── Select │ │ └── test.py │ ├── TypedCoords2Volume │ │ ├── __init__.py │ │ ├── test.py │ │ ├── test_backward.py │ │ └── test_forward.py │ ├── VolumeConvolution │ │ ├── __init__.py │ │ ├── grad_example.py │ │ ├── test.py │ │ ├── test_backward.py │ │ └── test_forward.py │ ├── VolumeRMSD │ │ └── test_forward.py │ ├── VolumeRotation │ │ └── test_forward.py │ └── __init__.py └── main.py ├── docs ├── Examples │ ├── ExampleFitBackboneTrace.png │ ├── FullAtomModel │ │ ├── ExampleAngles2Coords.png │ │ ├── ExampleAngles2Coords.py │ │ ├── ExamplePDB2CoordsUnordered.png │ │ └── ExamplePDB2CoordsUnordered.py │ ├── ReducedModel │ │ └── ExampleAngles2Backbone.py │ ├── Volume │ │ └── ExampleTypedCoords2Volume.py │ └── fitBackbone.py ├── Fig │ ├── Amino-acid.png │ ├── MolecularGraph.png │ ├── Tensors.png │ ├── VolumeSelect.png │ ├── example_graph.png │ └── examples │ │ ├── ExampleAngles2Backbone.png │ │ ├── ExampleAngles2Coords.png │ │ ├── ExampleFitBackbone.mp4 │ │ ├── ExampleFitBackboneTrace.png │ │ ├── ExamplePDB2CoordsUnordered.png │ │ └── ExampleTypedCoords2Volume.png ├── css │ └── default.css ├── examples.html ├── fullatommodel.html ├── index.html ├── js │ ├── highlight.pack.js │ └── scripts.js ├── reducedmodel.html ├── rmsd.html └── volume.html └── setup.py /.gitignore: -------------------------------------------------------------------------------- 1 | #Temp files 2 | *~ 3 | *.png 4 | *.pdb 5 | *.xplor 6 | *.tex 7 | *.svg 8 | *.code-workspace 9 | *.egg-info 10 | *.pkl 11 | *.js 12 | *.bib 13 | *.pdf 14 | *.sty 15 | *.gif 16 | *.txt 17 | 18 | #Python 19 | *.pyc 20 | 21 | # Prerequisites 22 | *.d 23 | 24 | # Compiled Object files 25 | *.slo 26 | *.lo 27 | *.o 28 | *.obj 29 | 30 | # Precompiled Headers 31 | *.gch 32 | *.pch 33 | 34 | # Compiled Dynamic libraries 35 | *.so 36 | *.dylib 37 | *.dll 38 | 39 | # Fortran module files 40 | *.mod 41 | *.smod 42 | 43 | # Compiled Static libraries 44 | *.lai 45 | *.la 46 | *.a 47 | *.lib 48 | 49 | # Executables 50 | *.exe 51 | *.out 52 | *.app 53 | -------------------------------------------------------------------------------- /Benchmark/core.py: -------------------------------------------------------------------------------- 1 | import torch 2 | from torch.autograd import profiler 3 | from TorchProteinLibrary import ReducedModel, FullAtomModel, RMSD 4 | import numpy as np 5 | 6 | class ModuleBenchmark: 7 | def __init__(self, device='cpu'): 8 | self.module = None 9 | if device=='cpu': 10 | self.use_cuda=False 11 | else: 12 | self.use_cuda=True 13 | 14 | def prepare(self): 15 | pass 16 | 17 | def run_forward(self): 18 | pass 19 | 20 | def run_backward(self): 21 | pass 22 | 23 | def measure_forward(self): 24 | self.prepare() 25 | with profiler.profile(use_cuda=self.use_cuda) as prof: 26 | self.run_forward() 27 | dur = 0.0 28 | threads = set([]) 29 | if self.use_cuda: 30 | for evt in prof.function_events: 31 | threads.add(evt.thread) 32 | for k in evt.kernels: 33 | dur += k.interval.elapsed_us() 34 | else: 35 | for evt in prof.function_events: 36 | threads.add(evt.thread) 37 | dur += evt.cpu_interval.elapsed_us() 38 | # print(len(threads)) 39 | return dur 40 | 41 | 42 | def measure_backward(self): 43 | self.prepare() 44 | with profiler.profile(use_cuda=self.use_cuda) as prof: 45 | self.run_backward() 46 | dur = 0.0 47 | threads = set([]) 48 | if self.use_cuda: 49 | for evt in prof.function_events: 50 | threads.add(evt.thread) 51 | for k in evt.kernels: 52 | dur += k.interval.elapsed_us() 53 | else: 54 | for evt in prof.function_events: 55 | threads.add(evt.thread) 56 | dur += evt.cpu_interval.elapsed_us() 57 | # print(len(threads)) 58 | return dur 59 | 60 | -------------------------------------------------------------------------------- /Benchmark/fullatommodel.py: -------------------------------------------------------------------------------- 1 | from core import ModuleBenchmark 2 | import torch 3 | from torch.autograd import profiler 4 | from TorchProteinLibrary import ReducedModel, FullAtomModel, RMSD 5 | import numpy as np 6 | from Bio.PDB.Polypeptide import aa1 7 | import random 8 | import seaborn as sea 9 | from matplotlib import pylab as plt 10 | import pandas as pd 11 | from tqdm import tqdm 12 | import pickle as pkl 13 | 14 | def gen_rand_seq(seq_len=150): 15 | return ''.join([random.choice(aa1) for i in range(seq_len)]) 16 | 17 | class Angles2CoordsBenchmark(ModuleBenchmark): 18 | def __init__(self, device='cpu', num_sequences=32, seq_length=350): 19 | self.module = FullAtomModel.Angles2Coords() 20 | self.sequences = [gen_rand_seq(seq_length) for i in range(num_sequences)] 21 | # print(self.sequences) 22 | self.angles = torch.randn(len(self.sequences), 7, len(self.sequences[-1]), dtype=torch.double, device='cpu', requires_grad=True) 23 | 24 | def prepare(self): 25 | self.angles.requires_grad_() 26 | self.coords, res_names, atom_names, num_atoms = self.module(self.angles, self.sequences) 27 | self.grad_coords = torch.ones(self.coords.size(), dtype=torch.double, device='cpu') 28 | 29 | def run_forward(self): 30 | self.angles.detach() 31 | self.coords, res_names, atom_names, num_atoms = self.module(self.angles, self.sequences) 32 | 33 | def run_backward(self): 34 | self.coords.backward(self.grad_coords) 35 | 36 | 37 | def test_length( interval=(60, 20, 300), num_measurements=1, output_filename='length.dat'): 38 | time = [] 39 | direction = [] 40 | length = [] 41 | for n in range(num_measurements): 42 | for i in tqdm(range(interval[0], interval[2], interval[1])): 43 | mb = Angles2CoordsBenchmark(seq_length=i) 44 | dur_fwd = mb.measure_forward() 45 | time.append(dur_fwd/1000.0) 46 | direction.append('Forward') 47 | length.append(i) 48 | dur_bwd = mb.measure_backward() 49 | time.append(dur_bwd/1000.0) 50 | direction.append('Backward') 51 | length.append(i) 52 | 53 | data = pd.DataFrame({ 'Time': time, 54 | 'Direction': direction, 55 | 'Length': length 56 | }) 57 | data.to_pickle(output_filename) 58 | 59 | 60 | 61 | if __name__=='__main__': 62 | 63 | # test_length(interval=(60, 20, 700), output_filename='Data/FullAtomModelTime.pkl', num_measurements=10) 64 | 65 | data = pd.read_pickle('Data/FullAtomModelTime.pkl') 66 | sea.set_style("whitegrid") 67 | sea.set_context("paper", font_scale=1.5, rc={"lines.linewidth": 1.5}) 68 | g1 = sea.relplot(x="Length", y="Time", hue='Direction', kind="line", style="Direction", height=6, aspect=1.3, markers=True, data=data) 69 | plt.ylabel("Time, ms") 70 | plt.xlabel("Sequence length, amino-acids") 71 | sea.despine() 72 | # plt.show() 73 | plt.savefig("Fig/FullAtomModelTime.png") 74 | -------------------------------------------------------------------------------- /Benchmark/lstm.py: -------------------------------------------------------------------------------- 1 | from core import ModuleBenchmark 2 | import torch 3 | from torch.autograd import profiler 4 | from TorchProteinLibrary import ReducedModel, FullAtomModel, RMSD 5 | 6 | import numpy as np 7 | import seaborn as sea 8 | from matplotlib import pylab as plt 9 | import pandas as pd 10 | from tqdm import tqdm 11 | import pickle as pkl 12 | 13 | class LSTMBenchmark(ModuleBenchmark): 14 | def __init__(self, device='gpu', num_sequences=32, input_length=128, input_size=128, hidden_size=256, num_layers=1): 15 | super().__init__(device) 16 | self.input = torch.randn(num_sequences, input_length, input_size, dtype=torch.float, device='cuda', requires_grad=True) 17 | self.module = torch.nn.LSTM(input_size=input_size, hidden_size=hidden_size, num_layers=num_layers, batch_first=True).cuda() 18 | 19 | def prepare(self): 20 | self.input.requires_grad_() 21 | self.output, _ = self.module(self.input) 22 | self.grad_output = torch.ones(self.output.size(), dtype=torch.float, device='cuda') 23 | 24 | def run_forward(self): 25 | self.input.detach() 26 | self.output, _ = self.module(self.input) 27 | 28 | def run_backward(self): 29 | self.output.backward(self.grad_output) 30 | 31 | def test_length( interval=(60, 20, 300), num_measurements=1, output_filename='length.dat'): 32 | time = [] 33 | direction = [] 34 | length = [] 35 | for n in range(num_measurements): 36 | for i in tqdm(range(interval[0], interval[2], interval[1])): 37 | mb = LSTMBenchmark(input_length=i) 38 | dur_fwd = mb.measure_forward() 39 | time.append(dur_fwd/1000.0) 40 | direction.append('Forward') 41 | length.append(i) 42 | dur_bwd = mb.measure_backward() 43 | time.append(dur_bwd/1000.0) 44 | direction.append('Backward') 45 | length.append(i) 46 | 47 | data = pd.DataFrame({ 'Time': time, 48 | 'Direction': direction, 49 | 'Length': length 50 | }) 51 | data.to_pickle(output_filename) 52 | 53 | if __name__=='__main__': 54 | 55 | test_length(interval=(60, 20, 700), output_filename='Data/LSTMTime.pkl', num_measurements=10) 56 | 57 | data = pd.read_pickle('Data/LSTMTime.pkl') 58 | sea.set_style("whitegrid") 59 | sea.set_context("paper", font_scale=1.5, rc={"lines.linewidth": 1.5}) 60 | g1 = sea.relplot(x="Length", y="Time", hue='Direction', kind="line", style="Direction", height=6, aspect=1.3, markers=True, data=data) 61 | plt.ylabel("Time, ms") 62 | plt.xlabel("Sequence length, amino-acids") 63 | sea.despine() 64 | # plt.show() 65 | plt.savefig("Fig/LSTMTime.png") -------------------------------------------------------------------------------- /Benchmark/main.py: -------------------------------------------------------------------------------- 1 | import torch 2 | from torch.autograd import profiler 3 | from TorchProteinLibrary import ReducedModel, FullAtomModel, RMSD 4 | import numpy as np 5 | 6 | if __name__=='__main__': 7 | a2c = FullAtomModel.Angles2Coords() 8 | sequences = ['GGMLGWAHFGY'] 9 | 10 | #Setting conformation to alpha-helix 11 | angles = torch.zeros(len(sequences), 7, len(sequences[-1]), dtype=torch.double, device='cpu') 12 | angles.data[:,0,:] = -1.047 13 | angles.data[:,1,:] = -0.698 14 | angles.data[:,2:,:] = 110.4*np.pi/180.0 15 | 16 | #Converting angles to coordinates 17 | with profiler.profile() as prof: 18 | coords, res_names, atom_names, num_atoms = a2c(angles, sequences) 19 | # coords.backward() 20 | dur = 0.0 21 | for evt in prof.function_events: 22 | dur += evt.cpu_interval.elapsed_us() 23 | print(dur/1000.0, 'ms') 24 | 25 | # print(prof) 26 | # print(prof.total_average()) 27 | -------------------------------------------------------------------------------- /Benchmark/reducedmodel.py: -------------------------------------------------------------------------------- 1 | from core import ModuleBenchmark 2 | import torch 3 | from torch.autograd import profiler 4 | from TorchProteinLibrary import ReducedModel, FullAtomModel, RMSD 5 | import matplotlib as mpl 6 | mpl.use('Agg') 7 | import numpy as np 8 | import seaborn as sea 9 | from matplotlib import pylab as plt 10 | import pandas as pd 11 | from tqdm import tqdm 12 | import pickle as pkl 13 | 14 | class Angles2BackboneBenchmark(ModuleBenchmark): 15 | def __init__(self, device='cuda', num_sequences=32, seq_length=350): 16 | super().__init__(device) 17 | self.device=device 18 | if device == 'cpu': 19 | self.dtype = torch.double 20 | else: 21 | self.dtype = torch.float 22 | self.angles = torch.randn(num_sequences, 3, seq_length, dtype=self.dtype, device=device, requires_grad=True) 23 | self.length = torch.zeros(num_sequences, dtype=torch.int, device=device).fill_(seq_length) 24 | self.module = ReducedModel.Angles2Backbone() 25 | 26 | def prepare(self): 27 | self.angles.requires_grad_() 28 | self.coords = self.module(self.angles, self.length) 29 | self.grad_coords = torch.ones(self.coords.size(), dtype=self.dtype, device=self.device) 30 | 31 | def run_forward(self): 32 | self.angles.detach() 33 | self.coords = self.module(self.angles, self.length) 34 | 35 | def run_backward(self): 36 | self.coords.backward(self.grad_coords) 37 | 38 | def test_length(device='cuda', interval=(60, 20, 300), num_measurements=1, output_filename='length.dat'): 39 | time = [] 40 | direction = [] 41 | length = [] 42 | for n in range(num_measurements): 43 | for i in tqdm(range(interval[0], interval[2], interval[1])): 44 | mb = Angles2BackboneBenchmark(device=device, seq_length=i) 45 | dur_fwd = mb.measure_forward() 46 | time.append(dur_fwd/1000.0) 47 | direction.append('Forward') 48 | length.append(i) 49 | dur_bwd = mb.measure_backward() 50 | time.append(dur_bwd/1000.0) 51 | direction.append('Backward') 52 | length.append(i) 53 | 54 | data = pd.DataFrame({ 'Time': time, 55 | 'Direction': direction, 56 | 'Length': length 57 | }) 58 | data.to_pickle(output_filename) 59 | 60 | if __name__=='__main__': 61 | 62 | test_length(device='cpu', interval=(300, 50, 700), output_filename='Data/ReducedModelTime.pkl', num_measurements=3) 63 | 64 | data = pd.read_pickle('Data/ReducedModelTime.pkl') 65 | sea.set_style("whitegrid") 66 | sea.set_context("paper", font_scale=1.5, rc={"lines.linewidth": 1.5}) 67 | g1 = sea.relplot(x="Length", y="Time", hue='Direction', kind="line", style="Direction", height=6, aspect=1.3, markers=True, data=data) 68 | plt.ylabel("Time, ms") 69 | plt.xlabel("Sequence length, amino-acids") 70 | sea.despine() 71 | # plt.show() 72 | plt.savefig("Fig/ReducedModelTimeCPU.png") -------------------------------------------------------------------------------- /Benchmark/rmsd.py: -------------------------------------------------------------------------------- 1 | from core import ModuleBenchmark 2 | import torch 3 | from torch.autograd import profiler 4 | from TorchProteinLibrary import ReducedModel, FullAtomModel, RMSD 5 | 6 | import numpy as np 7 | import seaborn as sea 8 | from matplotlib import pylab as plt 9 | import pandas as pd 10 | from tqdm import tqdm 11 | import pickle as pkl 12 | 13 | class Coords2RMSDBenchmark(ModuleBenchmark): 14 | def __init__(self, device='gpu', num_sequences=32, num_atoms=350): 15 | super().__init__(device) 16 | self.coords = torch.randn(num_sequences, 3*num_atoms, dtype=torch.double, device='cuda', requires_grad=True) 17 | self.ref = torch.randn(num_sequences, 3*num_atoms, dtype=torch.double, device='cuda', requires_grad=False) 18 | self.length = torch.zeros(num_sequences, dtype=torch.int, device='cuda').fill_(num_atoms) 19 | self.module = RMSD.Coords2RMSD().cuda() 20 | 21 | def prepare(self): 22 | self.coords.requires_grad_() 23 | self.ref.detach() 24 | self.rmsd = self.module(self.coords, self.ref, self.length) 25 | self.grad_rmsd = torch.ones(self.rmsd.size(), dtype=torch.double, device='cuda') 26 | 27 | def run_forward(self): 28 | self.coords.detach() 29 | # self.ref.detach() 30 | self.rmsd = self.module(self.coords, self.ref, self.length) 31 | # self.rmsd.detach() 32 | 33 | def run_backward(self): 34 | self.rmsd.backward(self.grad_rmsd) 35 | # self.rmsd.detach() 36 | 37 | def test_length( interval=(60, 20, 300), num_measurements=1, output_filename='length.dat'): 38 | time = [] 39 | direction = [] 40 | length = [] 41 | for n in range(num_measurements): 42 | for i in tqdm(range(interval[0], interval[2], interval[1])): 43 | mb = Coords2RMSDBenchmark(num_atoms=i) 44 | dur_fwd = mb.measure_forward() 45 | time.append(dur_fwd/1000.0) 46 | direction.append('Forward') 47 | length.append(i) 48 | dur_bwd = mb.measure_backward() 49 | time.append(dur_bwd/1000.0) 50 | direction.append('Backward') 51 | length.append(i) 52 | 53 | data = pd.DataFrame({ 'Time': time, 54 | 'Direction': direction, 55 | 'NumAtoms': length 56 | }) 57 | data.to_pickle(output_filename) 58 | 59 | if __name__=='__main__': 60 | 61 | test_length(interval=(100, 100, 3000), output_filename='Data/RMSDTime.pkl', num_measurements=10) 62 | 63 | data = pd.read_pickle('Data/RMSDTime.pkl') 64 | sea.set_style("whitegrid") 65 | sea.set_context("paper", font_scale=1.5, rc={"lines.linewidth": 1.5}) 66 | g1 = sea.relplot(x="NumAtoms", y="Time", hue='Direction', kind="line", style="Direction", height=6, aspect=1.3, markers=True, data=data) 67 | plt.ylabel("Time, ms") 68 | plt.xlabel("Number of atoms") 69 | sea.despine() 70 | # plt.show() 71 | plt.savefig("Fig/RMSDTime.png") -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2017 George 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /Layers/FullAtomModel/Angles2Coords/angles2coords_interface.h: -------------------------------------------------------------------------------- 1 | #include 2 | void Angles2Coords_forward( at::Tensor sequences, 3 | at::Tensor input_angles, 4 | at::Tensor output_coords, 5 | at::Tensor res_names, 6 | at::Tensor atom_names 7 | ); 8 | 9 | void Angles2Coords_backward( at::Tensor grad_atoms, 10 | at::Tensor grad_angles, 11 | at::Tensor sequences, 12 | at::Tensor input_angles 13 | ); 14 | void Angles2Coords_save( const char* sequence, 15 | at::Tensor input_angles, 16 | const char* output_filename, 17 | const char mode 18 | ); 19 | int getSeqNumAtoms( const char *sequence); -------------------------------------------------------------------------------- /Layers/FullAtomModel/Coords2TypedCoords/coords2typedcoords_interface.h: -------------------------------------------------------------------------------- 1 | #include 2 | void Coords2TypedCoords_forward( torch::Tensor input_coords, 3 | torch::Tensor res_names, 4 | torch::Tensor atom_names, 5 | torch::Tensor input_num_atoms, 6 | torch::Tensor output_coords, 7 | torch::Tensor output_num_atoms_of_type, 8 | torch::Tensor output_offsets, 9 | torch::Tensor output_atom_indexes 10 | ); 11 | void Coords2TypedCoords_backward( torch::Tensor grad_typed_coords, 12 | torch::Tensor grad_flat_coords, 13 | torch::Tensor num_atoms_of_type, 14 | torch::Tensor offsets, 15 | torch::Tensor atom_indexes 16 | ); -------------------------------------------------------------------------------- /Layers/FullAtomModel/CoordsTransform/coordsTransformGPU_interface.h: -------------------------------------------------------------------------------- 1 | #include 2 | void CoordsTranslateGPU_forward( torch::Tensor input_coords, 3 | torch::Tensor output_coords, 4 | torch::Tensor T, 5 | torch::Tensor num_atoms); 6 | 7 | void CoordsTranslateGPU_backward( torch::Tensor grad_output_coords, 8 | torch::Tensor grad_input_coords, 9 | torch::Tensor T, 10 | torch::Tensor num_atoms); 11 | 12 | void CoordsRotateGPU_forward( torch::Tensor input_coords, 13 | torch::Tensor output_coords, 14 | torch::Tensor R, 15 | torch::Tensor num_atoms); 16 | 17 | void CoordsRotateGPU_backward( torch::Tensor grad_output_coords, 18 | torch::Tensor grad_input_coords, 19 | torch::Tensor R, 20 | torch::Tensor num_atoms); 21 | 22 | void Coords2CenterGPU_forward( torch::Tensor input_coords, 23 | torch::Tensor output_T, 24 | torch::Tensor num_atoms); 25 | 26 | void Coords2CenterGPU_backward( torch::Tensor grad_output_T, 27 | torch::Tensor grad_input_coords, 28 | torch::Tensor num_atoms); -------------------------------------------------------------------------------- /Layers/FullAtomModel/CoordsTransform/coordsTransform_interface.h: -------------------------------------------------------------------------------- 1 | #include 2 | void CoordsTranslate_forward( torch::Tensor input_coords, 3 | torch::Tensor output_coords, 4 | torch::Tensor T, 5 | torch::Tensor num_atoms 6 | ); 7 | 8 | void CoordsTranslate_backward( torch::Tensor grad_output_coords, 9 | torch::Tensor grad_input_coords, 10 | torch::Tensor T, 11 | torch::Tensor num_atoms 12 | ); 13 | 14 | void CoordsRotate_forward( torch::Tensor input_coords, 15 | torch::Tensor output_coords, 16 | torch::Tensor R, 17 | torch::Tensor num_atoms 18 | ); 19 | 20 | void CoordsRotate_backward( torch::Tensor grad_output_coords, 21 | torch::Tensor grad_input_coords, 22 | torch::Tensor R, 23 | torch::Tensor num_atoms); 24 | 25 | 26 | void Coords2Center_forward( torch::Tensor input_coords, 27 | torch::Tensor output_T, 28 | torch::Tensor num_atoms); 29 | 30 | void Coords2Center_backward( torch::Tensor grad_output_T, 31 | torch::Tensor grad_input_coords, 32 | torch::Tensor num_atoms); 33 | 34 | void getBBox( torch::Tensor input_coords, 35 | torch::Tensor a, torch::Tensor b, 36 | torch::Tensor num_atoms); 37 | 38 | void getRandomRotation( torch::Tensor R); 39 | void getRotation( torch::Tensor R, torch::Tensor u ); 40 | void getRandomTranslation( torch::Tensor T, torch::Tensor a, torch::Tensor b, float volume_size); 41 | -------------------------------------------------------------------------------- /Layers/FullAtomModel/PDB2Coords/pdb2coords_interface.h: -------------------------------------------------------------------------------- 1 | #include 2 | // void PDB2CoordsOrdered(torch::Tensor filenames, torch::Tensor coords, torch::Tensor res_names, torch::Tensor atom_names, torch::Tensor mask); 3 | void PDB2CoordsUnordered(torch::Tensor filenames, torch::Tensor coords, torch::Tensor chain_names, torch::Tensor res_names, torch::Tensor res_nums, torch::Tensor atom_names, torch::Tensor num_atoms); 4 | -------------------------------------------------------------------------------- /Layers/FullAtomModel/TransformCUDAKernels.h: -------------------------------------------------------------------------------- 1 | template void gpu_CoordsTranslateForward(T *coords_src, T *coords_dst, T *translation, int *num_atoms, int batch_size, int atoms_stride); 2 | template void gpu_CoordsTranslateBackward(T *grad_coords_output, T *grad_coords_input, T *translation, int *num_atoms, int batch_size, int atoms_stride); 3 | 4 | template void gpu_CoordsRotateForward(T *coords_src, T *coords_dst, T *rotation, int *num_atoms, int batch_size, int atoms_stride); 5 | template void gpu_CoordsRotateBackward(T *grad_coords_output, T *grad_coords_input, T *rotation, int *num_atoms, int batch_size, int atoms_stride); 6 | 7 | template void gpu_Coords2CenterForward(T *coords_src, T *center, int *num_atoms, int batch_size, int atoms_stride); 8 | template void gpu_Coords2CenterBackward(T *grad_T, T *grad_coords, int *num_atoms, int batch_size, int atoms_stride); 9 | 10 | 11 | -------------------------------------------------------------------------------- /Layers/FullAtomModel/cConformation.h: -------------------------------------------------------------------------------- 1 | #ifndef CCONFORMATION_H_ 2 | #define CCONFORMATION_H_ 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | template 11 | class cTransform{ 12 | public: 13 | T *alpha, *beta; 14 | T *grad_alpha; 15 | T d; 16 | 17 | public: 18 | cMatrix44 mat, dmat; 19 | cTransform(T *param_alpha, T *param_beta, T d, T *grad_alpha){ 20 | this->alpha = param_alpha; 21 | this->beta = param_beta; 22 | this->d = d; 23 | this->grad_alpha = grad_alpha; 24 | }; 25 | ~cTransform(){}; 26 | void updateMatrix(); 27 | void updateDMatrix(); 28 | void print(); 29 | }; 30 | 31 | template 32 | class cNode{ 33 | public: 34 | cRigidGroup *group; 35 | cTransform *Tr; //transform from parent to this node 36 | cMatrix44 M; //aggregate transform from root 37 | cMatrix44 F; //matrix for computing gradient 38 | cNode *left; 39 | cNode *right; 40 | cNode *parent; 41 | 42 | cNode(){parent = NULL;left=NULL;right=NULL;}; 43 | ~cNode(){}; 44 | }; 45 | 46 | // template std::ostream& operator<<(std::ostream& os, const cNode& node); 47 | 48 | template 49 | class cConformation{ 50 | // private: 51 | public: 52 | std::vector*> nodes; 53 | std::vector*> groups; 54 | std::vector*> transforms; 55 | 56 | T zero_const; 57 | T *atoms_global; //pointer to computed coordinates 58 | cGeometry geo; 59 | uint num_atoms; 60 | 61 | public: 62 | cNode *root; 63 | 64 | // Construct protein graph and bind grad to the angles 65 | cConformation(std::string aa, T *angles, T *angles_grad, uint angles_length, T *atoms_global, bool add_terminal=false); 66 | ~cConformation(); 67 | 68 | void print(cNode *node); 69 | 70 | // Backward propagation with external gradients 71 | T backward(cNode *root_node, cNode *node, T *atoms_grad); 72 | void backward(cNode *node, T *atoms_grad); 73 | 74 | //Computes coordinates of the atoms 75 | void update(cNode *node); 76 | 77 | //Saving to pdb 78 | void save(std::string filename, const char mode); 79 | 80 | private: 81 | cNode *addNode(cNode *parent, cRigidGroup *group, cTransform *t); 82 | 83 | cNode *addGly(cNode *parentC, std::vector params, std::vector params_grad, bool terminal=false); 84 | cNode *addAla(cNode *parentC, std::vector params, std::vector params_grad, bool terminal=false); 85 | cNode *addSer(cNode *parentC, std::vector params, std::vector params_grad, bool terminal=false); 86 | cNode *addCys(cNode *parentC, std::vector params, std::vector params_grad, bool terminal=false); 87 | cNode *addVal(cNode *parentC, std::vector params, std::vector params_grad, bool terminal=false); 88 | cNode *addIle(cNode *parentC, std::vector params, std::vector params_grad, bool terminal=false); 89 | cNode *addLeu(cNode *parentC, std::vector params, std::vector params_grad, bool terminal=false); 90 | cNode *addThr(cNode *parentC, std::vector params, std::vector params_grad, bool terminal=false); 91 | cNode *addArg(cNode *parentC, std::vector params, std::vector params_grad, bool terminal=false); 92 | cNode *addLys(cNode *parentC, std::vector params, std::vector params_grad, bool terminal=false); 93 | cNode *addAsp(cNode *parentC, std::vector params, std::vector params_grad, bool terminal=false); 94 | cNode *addAsn(cNode *parentC, std::vector params, std::vector params_grad, bool terminal=false); 95 | cNode *addGlu(cNode *parentC, std::vector params, std::vector params_grad, bool terminal=false); 96 | cNode *addGln(cNode *parentC, std::vector params, std::vector params_grad, bool terminal=false); 97 | cNode *addMet(cNode *parentC, std::vector params, std::vector params_grad, bool terminal=false); 98 | cNode *addHis(cNode *parentC, std::vector params, std::vector params_grad, bool terminal=false); 99 | cNode *addPro(cNode *parentC, std::vector params, std::vector params_grad, bool terminal=false); 100 | cNode *addPhe(cNode *parentC, std::vector params, std::vector params_grad, bool terminal=false); 101 | cNode *addTyr(cNode *parentC, std::vector params, std::vector params_grad, bool terminal=false); 102 | cNode *addTrp(cNode *parentC, std::vector params, std::vector params_grad, bool terminal=false); 103 | }; 104 | 105 | #endif -------------------------------------------------------------------------------- /Layers/FullAtomModel/cGeometry.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define KAPPA1 (3.14159 - 1.9391) 5 | #define KAPPA2 (3.14159 - 2.061) 6 | #define KAPPA3 (3.14159 -2.1186) 7 | #define OMEGACIS -3.1318 8 | 9 | template cGeometry::cGeometry(){ 10 | //backbone angles 11 | C_N_CA_angle = (M_PI - 1.9391); 12 | N_CA_C_angle = (M_PI - 2.061); 13 | CA_C_N_angle = (M_PI - 2.1186); 14 | CA_C_O_angle = (M_PI - 2.1033); 15 | omega_const = -3.1318; 16 | //backbone distatnces 17 | R_CA_C = 1.525; 18 | R_C_N = 1.330; 19 | R_N_CA = 1.460; 20 | 21 | //C-beta 22 | R_CA_CB = 1.52; 23 | // C_CA_CB_angle = -(M_PI - 1.9111); 24 | C_CA_CB_angle = -(M_PI -M_PI*109.5/180.0); 25 | N_C_CA_CB_diangle = 0.5*M_PI*122.6860/180.0; 26 | correction_angle = 0.0;//-C_CA_CB_angle/2.0; 27 | 28 | //OG serine 29 | R_CB_OG = 1.417; 30 | CA_CB_OG_angle = M_PI*110.773/180.0; 31 | //SG cysteine 32 | R_CB_SG = 1.808; 33 | CA_CB_SG_angle = M_PI*113.8169/180.0; 34 | //Valine CG1 and CG2 35 | R_CB_CG = 1.527; 36 | CA_CB_CG1_angle = M_PI*110.7/180.0; 37 | CG1_CB_CG2_angle = 1.88444687881; 38 | //Isoleucine 39 | R_CG1_CD1 = 1.52; 40 | CB_CG1_CD1_angle = M_PI*113.97/180.0; 41 | //Threonine 42 | R_CB_OG1 = 1.43; 43 | CA_CB_OG1_angle = M_PI*109.18/180.0; 44 | OG1_CB_CG2_angle = 1.90291866134; 45 | //Arginine 46 | R_C_C = R_CA_CB; 47 | C_C_C_angle = C_CA_CB_angle; 48 | R_CD_NE = 1.46; 49 | R_NE_CZ = 1.33; 50 | R_CZ_NH = 1.33; 51 | CA_CB_CG_angle = -(M_PI - M_PI*113.83/180.0); 52 | CB_CG_CD_angle = -(M_PI - M_PI*111.79/180.0); 53 | CG_CD_NE_angle = -(M_PI - M_PI*111.68/180.0); 54 | CD_NE_CZ_angle = -(M_PI - M_PI*124.79/180.0); 55 | NE_CZ_NH_angle = M_PI*124.79/180.0; 56 | //Lysine 57 | R_CD_CE = 1.46; 58 | R_CE_NZ = 1.33; 59 | CD_CE_NZ_angle = -(M_PI - M_PI*124.79/180.0); 60 | //Aspartic acid 61 | R_CG_OD = 1.25; 62 | CB_CG_OD_angle = M_PI*119.22/180.0; 63 | OD1_CG_OD2_angle = 2.13911043783; 64 | //Asparagine 65 | R_CG_OD1 = 1.23; 66 | R_CG_ND2 = 1.33; 67 | CB_CG_OD1_angle = M_PI*120.85/180.0; 68 | CB_CG_ND2_angle = M_PI*116.48/180.0; 69 | //Methionine 70 | R_CG_SD = 1.81; 71 | R_SD_CE = 1.79; 72 | CB_CG_SD_angle = -(M_PI - M_PI*112.69/180.0); 73 | CG_SD_CE_angle = -(M_PI - M_PI*100.61/180.0); 74 | //Histidine 75 | R_CG_CD2 = 1.35; 76 | R_CG_ND1 = 1.38; 77 | R_CG_NE2 = 2.1912; 78 | R_CG_CE1 = 2.1915; 79 | CB_CG_CD2_angle = -(M_PI - 2.27957453603); 80 | CB_CG_ND1_angle = (M_PI - 2.14413698608); 81 | CB_CG_NE2_angle = -(M_PI - 2.90352974362); 82 | CB_CG_CE1_angle = (M_PI - 2.75209584734); 83 | 84 | 85 | 86 | } 87 | 88 | template cGeometry::~cGeometry(){ 89 | 90 | } 91 | 92 | template void cGeometry::gly(){ 93 | //backbone angles 94 | C_N_CA_angle = (3.14159 - 1.9391); 95 | N_CA_C_angle = (3.14159 - 2.061); 96 | CA_C_N_angle = (3.14159 - 2.1186); 97 | CA_C_O_angle = (3.14159 - 2.1033); 98 | omega_const = -3.1318; 99 | //backbone distatnces 100 | R_CA_C = 1.525; 101 | R_C_N = 1.330; 102 | R_N_CA = 1.460; 103 | } 104 | 105 | template void cGeometry::ala(){ 106 | //backbone angles 107 | C_N_CA_angle = (3.14159 - 1.9391); 108 | N_CA_C_angle = (3.14159 - 2.061); 109 | CA_C_N_angle = (3.14159 - 2.1186); 110 | CA_C_O_angle = (3.14159 - 2.1033); 111 | omega_const = -3.1318; 112 | //backbone distatnces 113 | R_CA_C = 1.525; 114 | R_C_N = 1.330; 115 | R_N_CA = 1.460; 116 | 117 | //C-beta 118 | R_CA_CB = 1.52; 119 | C_CA_CB_angle = -(3.14159 - 1.9111);//(3.14159 - 1.9111); 120 | N_C_CA_CB_diangle = M_PI*111.0/180.0;; 121 | } 122 | 123 | template class cGeometry; 124 | template class cGeometry; -------------------------------------------------------------------------------- /Layers/FullAtomModel/cGeometry.h: -------------------------------------------------------------------------------- 1 | #ifndef CGEOMETRY_H_ 2 | #define CGEOMETRY_H_ 3 | 4 | template 5 | class cGeometry{ 6 | public: 7 | T zero_const; 8 | //backbone angles 9 | T omega_const, C_N_CA_angle, N_CA_C_angle, CA_C_N_angle, CA_C_O_angle; 10 | 11 | //backbone distances 12 | T R_CA_C, R_C_N, R_N_CA, R_C_O; 13 | T C_CA_CB_angle, N_C_CA_CB_diangle, correction_angle; 14 | 15 | //C-beta atom 16 | T R_CA_CB; 17 | 18 | //Serine 19 | T CA_CB_OG_angle; 20 | T R_CB_OG; 21 | //Cysteine 22 | T CA_CB_SG_angle; 23 | T R_CB_SG; 24 | //Valine 25 | T R_CB_CG; 26 | T CG1_CB_CG2_angle, CA_CB_CG1_angle; 27 | //Isoleucine 28 | T R_CG1_CD1; 29 | T CB_CG1_CD1_angle; 30 | //Threonine 31 | T R_CB_OG1; 32 | T CA_CB_OG1_angle, OG1_CB_CG2_angle; 33 | //Arginine 34 | T R_C_C; 35 | T C_C_C_angle; 36 | T R_CD_NE, R_NE_CZ, R_CZ_NH; 37 | T CA_CB_CG_angle, CB_CG_CD_angle, CG_CD_NE_angle; 38 | T CD_NE_CZ_angle, NE_CZ_NH_angle; 39 | //Lysine 40 | T R_CD_CE, R_CE_NZ; 41 | T CD_CE_NZ_angle; 42 | //Aspartic acid 43 | T R_CG_OD; 44 | T CB_CG_OD_angle, OD1_CG_OD2_angle; 45 | //Asparagine 46 | T R_CG_OD1, R_CG_ND2; 47 | T CB_CG_OD1_angle, CB_CG_ND2_angle; 48 | //Methionine 49 | T R_CG_SD, R_SD_CE; 50 | T CB_CG_SD_angle, CG_SD_CE_angle; 51 | //Histidine 52 | T R_CG_CD2, R_CG_ND1, R_CG_NE2, R_CG_CE1; 53 | T CB_CG_CD2_angle, CB_CG_ND1_angle, CB_CG_NE2_angle, CB_CG_CE1_angle; 54 | 55 | cGeometry(); 56 | ~cGeometry(); 57 | 58 | void gly(); 59 | void ala(); 60 | }; 61 | 62 | #endif -------------------------------------------------------------------------------- /Layers/FullAtomModel/cPDBLoader.h: -------------------------------------------------------------------------------- 1 | #ifndef CPDBLOADER_H_ 2 | #define CPDBLOADER_H_ 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | class cPDBLoader { 10 | public: 11 | 12 | //ordering accoring to PDB lines 13 | std::vector> r; 14 | std::vector atom_names; 15 | std::vector res_names; 16 | std::vector chain_names; 17 | std::vector res_nums; 18 | 19 | //ordering accoring to residues 20 | std::vector res_res_names; 21 | std::vector> > res_r; 22 | std::vector > res_atom_names; 23 | 24 | cVector3 b0, b1; 25 | public: 26 | cPDBLoader(); 27 | cPDBLoader(std::string filename); 28 | virtual ~cPDBLoader(); 29 | 30 | //order according to cConformation 31 | void reorder(); 32 | 33 | //order according to atom types 34 | // void reorder(double *coords, int *num_atoms_of_type, int *offsets); 35 | 36 | cVector3 getCenterMass(); 37 | void translate(cVector3 dr); 38 | // void randRot(THGenerator *gen); 39 | // void randTrans(THGenerator *gen, int spatial_dim); 40 | 41 | inline uint getNumAtoms(){return r.size();}; 42 | void computeBoundingBox(); 43 | 44 | 45 | 46 | }; 47 | 48 | #endif /* CPROTEINLOADER_H_ */ 49 | -------------------------------------------------------------------------------- /Layers/FullAtomModel/cRigidGroup.h: -------------------------------------------------------------------------------- 1 | #ifndef CRIGIDGROUP_H_ 2 | #define CRIGIDGROUP_H_ 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | template 10 | class cRigidGroup{ 11 | public: 12 | std::vector> atoms_local; 13 | std::vector> atoms_global; 14 | std::vector atomNames; 15 | std::vector atomIndexes; 16 | uint residueIndex; 17 | char residueName; 18 | cRigidGroup(); 19 | ~cRigidGroup(); 20 | void addAtom(cVector3 pos, std::string atomName, uint atomIndex, char residueName, uint residueIndex, T *atoms_global_ptr); 21 | void applyTransform(cMatrix44 mat); 22 | }; 23 | template cRigidGroup *makeAtom(std::string atomName, uint atomIndex, char residueName, uint residueIndex, T *atoms_global_ptr); 24 | template cRigidGroup *makeCarbonyl(cGeometry &geo, uint atomIndex, char residueName, uint residueIndex, T *atoms_global_ptr, bool terminal=false); 25 | template cRigidGroup *makeSerGroup(cGeometry &geo, uint atomIndex, char residueName, uint residueIndex, T *atoms_global_ptr); 26 | template cRigidGroup *makeCysGroup(cGeometry &geo, uint atomIndex, char residueName, uint residueIndex, T *atoms_global_ptr); 27 | template cRigidGroup *makeValGroup(cGeometry &geo, uint atomIndex, char residueName, uint residueIndex, T *atoms_global_ptr); 28 | template cRigidGroup *makeIleGroup1(cGeometry &geo, uint atomIndex, char residueName, uint residueIndex, T *atoms_global_ptr); 29 | template cRigidGroup *makeIleGroup2(cGeometry &geo, uint atomIndex, char residueName, uint residueIndex, T *atoms_global_ptr); 30 | template cRigidGroup *makeLeuGroup(cGeometry &geo, uint atomIndex, char residueName, uint residueIndex, T *atoms_global_ptr); 31 | template cRigidGroup *makeThrGroup(cGeometry &geo, uint atomIndex, char residueName, uint residueIndex, T *atoms_global_ptr); 32 | template cRigidGroup *makeArgGroup(cGeometry &geo, uint atomIndex, char residueName, uint residueIndex, T *atoms_global_ptr); 33 | template cRigidGroup *makeAspGroup(cGeometry &geo, std::string C, std::string O1, std::string O2, uint atomIndex, char residueName, uint residueIndex, T *atoms_global_ptr); 34 | template cRigidGroup *makeAsnGroup(cGeometry &geo, std::string C, std::string O1, std::string N2, uint atomIndex, char residueName, uint residueIndex, T *atoms_global_ptr); 35 | template cRigidGroup *makeHisGroup(cGeometry &geo, uint atomIndex, char residueName, uint residueIndex, T *atoms_global_ptr); 36 | template cRigidGroup *makeProGroup(cGeometry &geo, uint atomIndex, char residueName, uint residueIndex, T *atoms_global_ptr); 37 | template cRigidGroup *makePheGroup(cGeometry &geo, uint atomIndex, char residueName, uint residueIndex, T *atoms_global_ptr); 38 | template cRigidGroup *makeTyrGroup(cGeometry &geo, uint atomIndex, char residueName, uint residueIndex, T *atoms_global_ptr); 39 | template cRigidGroup *makeTrpGroup(cGeometry &geo, uint atomIndex, char residueName, uint residueIndex, T *atoms_global_ptr); 40 | template std::ostream& operator<<(std::ostream& os, const cRigidGroup& rg); 41 | 42 | 43 | #endif -------------------------------------------------------------------------------- /Layers/FullAtomModel/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | // #include 9 | // #include 10 | 11 | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { 12 | 13 | m.def("Angles2Coords_forward", &Angles2Coords_forward, "Angles2Coords forward"); 14 | m.def("Angles2Coords_backward", &Angles2Coords_backward, "Angles2Coords backward"); 15 | m.def("Angles2Coords_save", &Angles2Coords_save, "Angles2Coords save"); 16 | m.def("getSeqNumAtoms", &getSeqNumAtoms, "Get number of atoms in a sequence"); 17 | 18 | m.def("PDB2CoordsUnordered", &PDB2CoordsUnordered, "Convert PDB to coordinates in the PDB order"); 19 | 20 | m.def("Coords2TypedCoords_forward", &Coords2TypedCoords_forward, "Convert coordinates to atom types"); 21 | m.def("Coords2TypedCoords_backward", &Coords2TypedCoords_backward, "Backward of Coords2TypedCoords"); 22 | 23 | m.def("CoordsTranslate_forward", &CoordsTranslate_forward, "Translate coordinates"); 24 | m.def("CoordsTranslateGPU_forward", &CoordsTranslateGPU_forward, "Translate coordinates on GPU"); 25 | m.def("CoordsTranslate_backward", &CoordsTranslate_backward, "Backward of translate coordinates"); 26 | m.def("CoordsTranslateGPU_backward", &CoordsTranslateGPU_backward, "Backward of translate coordinates"); 27 | 28 | 29 | m.def("CoordsRotate_forward", &CoordsRotate_forward, "Rotate coordinates"); 30 | m.def("CoordsRotateGPU_forward", &CoordsRotateGPU_forward, "Rotate coordinates on GPU"); 31 | m.def("CoordsRotate_backward", &CoordsRotate_backward, "Backward of rotate coordinates"); 32 | m.def("CoordsRotateGPU_backward", &CoordsRotateGPU_backward, "Backward of rotate coordinates on GPU"); 33 | 34 | m.def("Coords2Center_forward", &Coords2Center_forward, "Get coordinates center"); 35 | m.def("Coords2CenterGPU_forward", &Coords2CenterGPU_forward, "Get coordinates center on GPU"); 36 | m.def("Coords2Center_backward", &Coords2Center_backward, "Backward of get coordinates center"); 37 | m.def("Coords2CenterGPU_backward", &Coords2CenterGPU_backward, "Backward of get coordinates center on GPU"); 38 | 39 | m.def("getBBox", &getBBox, "Get bounding box of coordinates"); 40 | m.def("getRandomRotation", &getRandomRotation, "Get random rotation"); 41 | m.def("getRotation", &getRotation, "Get rotation from parameters"); 42 | m.def("getRandomTranslation", &getRandomTranslation, "Get random translation"); 43 | } -------------------------------------------------------------------------------- /Layers/RMSD/Coords2RMSD/coords2rmsd_interface.h: -------------------------------------------------------------------------------- 1 | #include 2 | void Coords2RMSDGPU_forward( torch::Tensor centered_coords_src, 3 | torch::Tensor centered_coords_dst, 4 | torch::Tensor output, 5 | torch::Tensor num_atoms, 6 | torch::Tensor UT 7 | ); 8 | void Coords2RMSD_forward( torch::Tensor centered_coords_src, 9 | torch::Tensor centered_coords_dst, 10 | torch::Tensor output, 11 | torch::Tensor num_atoms, 12 | torch::Tensor UT 13 | ); -------------------------------------------------------------------------------- /Layers/RMSD/RMSDKernels.cu: -------------------------------------------------------------------------------- 1 | #include "RMSDKernels.h" 2 | #include 3 | 4 | template 5 | __global__ void cuda_correlationMatrix( T *d_coords1, T *d_coords2, double *RMat, int *num_atoms, int atoms_stride){ 6 | uint batch_idx = blockIdx.x; 7 | uint i = threadIdx.x; 8 | uint j = threadIdx.y; 9 | int r_index = 9*batch_idx + 3*i+j; 10 | int n_atoms = num_atoms[batch_idx]; 11 | T *coords1 = d_coords1 + batch_idx*atoms_stride*3; 12 | T *coords2 = d_coords2 + batch_idx*atoms_stride*3; 13 | 14 | RMat[r_index] = 0.0; 15 | for(int k=0; k 33 | __global__ void cuda_computeR2( T *d_coordinates, int num_atoms, double *R2){ 34 | int dim_index = threadIdx.x; 35 | R2[dim_index] = 0.0; 36 | for(int i=0; i 42 | void gpu_correlationMatrix(T *d_coords1, T *d_coords2, double *TMat, int *num_atoms, int batch_size, int atoms_stride){ 43 | double *RMat; 44 | cudaMalloc( &RMat, batch_size*9*sizeof(double)); 45 | dim3 coords_dim(3, 3, 1); 46 | cuda_correlationMatrix<<>>(d_coords1, d_coords2, RMat, num_atoms, atoms_stride); 47 | cuda_TMatrix<<>>(RMat, TMat); 48 | cudaFree(RMat); 49 | } 50 | 51 | template 52 | void gpu_computeR2( T *d_coordinates, int num_atoms, double *R2){ 53 | cuda_computeR2<<<1,3>>>( d_coordinates, num_atoms, R2); 54 | } 55 | 56 | 57 | template void gpu_correlationMatrix(float*, float*, double*, int*, int, int); 58 | template void gpu_correlationMatrix(double*, double*, double*, int*, int, int); 59 | 60 | template void gpu_computeR2(float*, int, double*); 61 | template void gpu_computeR2(double*, int, double*); -------------------------------------------------------------------------------- /Layers/RMSD/RMSDKernels.h: -------------------------------------------------------------------------------- 1 | template 2 | void gpu_correlationMatrix( T *d_coords1, //input: coordinates 1 3 | T *d_coords2, //input: coordinates 2 4 | double *TMat, //output: correlation matrix 5 | int *num_atoms, 6 | int batch_size, 7 | int atoms_stride); 8 | template 9 | void gpu_computeR2( T *d_coords, int num_atoms, double *R2); 10 | -------------------------------------------------------------------------------- /Layers/RMSD/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { 5 | m.def("Coords2RMSDGPU_forward", &Coords2RMSDGPU_forward, "Coords2RMSD forward on GPU"); 6 | m.def("Coords2RMSD_forward", &Coords2RMSD_forward, "Coords2RMSD forward on CPU"); 7 | } -------------------------------------------------------------------------------- /Layers/ReducedModel/Angles2Backbone/angles2backbone_interface.cpp: -------------------------------------------------------------------------------- 1 | #include "angles2backbone_interface.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | int Angles2BackboneGPU_forward(torch::Tensor input_angles, 8 | torch::Tensor output_coords, 9 | torch::Tensor angles_length, 10 | torch::Tensor A 11 | ){ 12 | CHECK_GPU_INPUT(input_angles); 13 | CHECK_GPU_INPUT(output_coords); 14 | CHECK_GPU_INPUT(A); 15 | CHECK_GPU_INPUT_TYPE(angles_length, torch::kInt); 16 | if(input_angles.ndimension() != 3){ 17 | ERROR("Incorrect input ndim"); 18 | } 19 | 20 | gpu_computeCoordinatesBackbone( input_angles.data(), 21 | output_coords.data(), 22 | A.data(), 23 | angles_length.data(), 24 | input_angles.size(0), 25 | input_angles.size(2)); 26 | } 27 | int Angles2BackboneGPU_backward( torch::Tensor gradInput, 28 | torch::Tensor gradOutput, 29 | torch::Tensor input_angles, 30 | torch::Tensor angles_length, 31 | torch::Tensor A, 32 | torch::Tensor dr_dangle 33 | ){ 34 | CHECK_GPU_INPUT(gradInput); 35 | CHECK_GPU_INPUT(gradOutput); 36 | CHECK_GPU_INPUT(input_angles); 37 | CHECK_GPU_INPUT(dr_dangle); 38 | CHECK_GPU_INPUT(A); 39 | CHECK_GPU_INPUT_TYPE(angles_length, torch::kInt); 40 | if(gradOutput.ndimension() != 2){ 41 | ERROR("Incorrect input ndim"); 42 | } 43 | gpu_computeDerivativesBackbone( input_angles.data(), 44 | dr_dangle.data(), 45 | A.data(), 46 | angles_length.data(), 47 | input_angles.size(0), 48 | input_angles.size(2)); 49 | 50 | gpu_backwardFromCoordsBackbone( gradInput.data(), 51 | gradOutput.data(), 52 | dr_dangle.data(), 53 | angles_length.data(), 54 | input_angles.size(0), 55 | input_angles.size(2)); 56 | } 57 | 58 | 59 | 60 | int Angles2BackboneCPU_forward(torch::Tensor input_angles, 61 | torch::Tensor output_coords, 62 | torch::Tensor angles_length, 63 | torch::Tensor A 64 | ){ 65 | CHECK_CPU_INPUT(input_angles); 66 | CHECK_CPU_INPUT(output_coords); 67 | CHECK_CPU_INPUT(A); 68 | CHECK_CPU_INPUT_TYPE(angles_length, torch::kInt); 69 | if(input_angles.ndimension() != 3){ 70 | ERROR("Incorrect input ndim"); 71 | } 72 | 73 | cpu_computeCoordinatesBackbone( input_angles.data(), 74 | output_coords.data(), 75 | A.data(), 76 | angles_length.data(), 77 | input_angles.size(0), 78 | input_angles.size(2)); 79 | } 80 | 81 | 82 | int Angles2BackboneCPU_backward(torch::Tensor gradInput, 83 | torch::Tensor gradOutput, 84 | torch::Tensor input_angles, 85 | torch::Tensor angles_length, 86 | torch::Tensor A, 87 | torch::Tensor dr_dangle 88 | ){ 89 | CHECK_CPU_INPUT(gradInput); 90 | CHECK_CPU_INPUT(gradOutput); 91 | CHECK_CPU_INPUT(input_angles); 92 | CHECK_CPU_INPUT(dr_dangle); 93 | CHECK_CPU_INPUT(A); 94 | CHECK_CPU_INPUT_TYPE(angles_length, torch::kInt); 95 | if(gradOutput.ndimension() != 2){ 96 | ERROR("Incorrect input ndim"); 97 | } 98 | 99 | cpu_computeDerivativesBackbone( input_angles.data(), 100 | dr_dangle.data(), 101 | A.data(), 102 | angles_length.data(), 103 | input_angles.size(0), 104 | input_angles.size(2)); 105 | 106 | cpu_backwardFromCoordsBackbone( gradInput.data(), 107 | gradOutput.data(), 108 | dr_dangle.data(), 109 | angles_length.data(), 110 | input_angles.size(0), 111 | input_angles.size(2)); 112 | } -------------------------------------------------------------------------------- /Layers/ReducedModel/Angles2Backbone/angles2backbone_interface.h: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int Angles2BackboneGPU_forward(torch::Tensor input_angles, 4 | torch::Tensor output_coords, 5 | torch::Tensor angles_length, 6 | torch::Tensor A 7 | ); 8 | 9 | int Angles2BackboneGPU_backward( torch::Tensor gradInput, 10 | torch::Tensor gradOutput, 11 | torch::Tensor input_angles, 12 | torch::Tensor angles_length, 13 | torch::Tensor A, 14 | torch::Tensor dr_dangle 15 | ); 16 | 17 | int Angles2BackboneCPU_forward(torch::Tensor input_angles, 18 | torch::Tensor output_coords, 19 | torch::Tensor angles_length, 20 | torch::Tensor A 21 | ); 22 | 23 | int Angles2BackboneCPU_backward( torch::Tensor gradInput, 24 | torch::Tensor gradOutput, 25 | torch::Tensor input_angles, 26 | torch::Tensor angles_length, 27 | torch::Tensor A, 28 | torch::Tensor dr_dangle 29 | ); -------------------------------------------------------------------------------- /Layers/ReducedModel/cBackboneProteinCPUKernels.hpp: -------------------------------------------------------------------------------- 1 | template 2 | void cpu_computeCoordinatesBackbone( T *angles, 3 | T *dr, 4 | T *dR_dangle, 5 | int *length, 6 | int batch_size, 7 | int angles_stride); 8 | template 9 | void cpu_computeDerivativesBackbone( T *angles, 10 | T *dR_dangle, 11 | T *A, 12 | int *length, 13 | int batch_size, 14 | int angles_stride); 15 | template 16 | void cpu_backwardFromCoordsBackbone( T *gradInput, 17 | T *gradOutput, 18 | T *dR_dangle, 19 | int *length, 20 | int batch_size, 21 | int angles_stride); -------------------------------------------------------------------------------- /Layers/ReducedModel/cBackboneProteinCUDAKernels.h: -------------------------------------------------------------------------------- 1 | 2 | #define REAL float 3 | template 4 | void gpu_computeCoordinatesBackbone(T *angles, 5 | T *dr, 6 | T *dR_dangle, 7 | int *length, 8 | int batch_size, 9 | int angles_stride); 10 | template 11 | void gpu_computeDerivativesBackbone(T *angles, 12 | T *atoms, 13 | T *A, 14 | int *length, 15 | int batch_size, 16 | int angles_stride); 17 | template 18 | void gpu_backwardFromCoordsBackbone(T *angles, 19 | T *dR_dangle, 20 | T *A, 21 | int *length, 22 | int batch_size, 23 | int angles_stride); -------------------------------------------------------------------------------- /Layers/ReducedModel/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { 5 | m.def("Angles2BackboneCPU_forward", &Angles2BackboneCPU_forward, "Angles2Backbone cpu forward"); 6 | m.def("Angles2BackboneCPU_backward", &Angles2BackboneCPU_backward, "Angles2Backbone cpu backward"); 7 | m.def("Angles2BackboneGPU_forward", &Angles2BackboneGPU_forward, "Angles2Backbone gpu forward"); 8 | m.def("Angles2BackboneGPU_backward", &Angles2BackboneGPU_backward, "Angles2Backbone gpu backward"); 9 | } -------------------------------------------------------------------------------- /Layers/Volume/Kernels.h: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | template 4 | void gpu_computeCoords2Volume( T *coords, 5 | int *num_atoms_of_type, 6 | int *offsets, 7 | T *volume, 8 | int spatial_dim, 9 | int num_atom_types, 10 | float res); 11 | 12 | template 13 | void gpu_computeVolume2Coords( T *coords, 14 | T* grad, 15 | int *num_atoms_of_type, 16 | int *offsets, 17 | T *volume, 18 | int spatial_dim, 19 | int num_atom_types, 20 | float res); 21 | 22 | void gpu_selectFromTensor( float *features, int num_features, 23 | float* volume, int spatial_dim, 24 | float *coords, int num_atoms, int max_num_atoms, 25 | float res); -------------------------------------------------------------------------------- /Layers/Volume/RotateGrid.cu: -------------------------------------------------------------------------------- 1 | #include "RotateGrid.h" 2 | 3 | __global__ void gpuRotatePoint(REAL *d_rotations, REAL *d_grid, int batch_size, int volume_size){ 4 | int batch_id = blockIdx.x; 5 | float *d_m = d_rotations + batch_id * 9; 6 | 7 | int volume = (volume_size*volume_size*volume_size); 8 | int volume_slice = (volume_size*volume_size); 9 | 10 | int x = blockIdx.y; 11 | int y = blockIdx.z; 12 | int z = threadIdx.x; 13 | 14 | float d_v[3] = { 2.0*float(x + 0.5 - volume_size/2.0)/ float(volume_size), 15 | 2.0*float(y + 0.5 - volume_size/2.0)/ float(volume_size), 16 | 2.0*float(z + 0.5 - volume_size/2.0)/ float(volume_size) }; 17 | 18 | float *dst = d_grid + batch_id*volume*3 + x*volume_slice*3 + y*volume_size*3 + z*3; 19 | 20 | // x, y, z 21 | // dst[0] = d_m[0]*d_v[0]+d_m[1]*d_v[1]+d_m[2]*d_v[2]; 22 | // dst[1] = d_m[3]*d_v[0]+d_m[4]*d_v[1]+d_m[5]*d_v[2]; 23 | // dst[2] = d_m[6]*d_v[0]+d_m[7]*d_v[1]+d_m[8]*d_v[2]; 24 | 25 | // z, y, x 26 | dst[2] = d_m[0]*d_v[0]+d_m[1]*d_v[1]+d_m[2]*d_v[2]; 27 | dst[1] = d_m[3]*d_v[0]+d_m[4]*d_v[1]+d_m[5]*d_v[2]; 28 | dst[0] = d_m[6]*d_v[0]+d_m[7]*d_v[1]+d_m[8]*d_v[2]; 29 | 30 | } 31 | 32 | void cpu_RotateGrid(REAL *d_rotations, REAL *d_grid, int batch_size, int volume_size){ 33 | 34 | dim3 dim_special(batch_size, volume_size, volume_size); 35 | gpuRotatePoint<<>>(d_rotations, d_grid, batch_size, volume_size); 36 | 37 | } -------------------------------------------------------------------------------- /Layers/Volume/RotateGrid.h: -------------------------------------------------------------------------------- 1 | #define REAL float 2 | // #define REAL double 3 | 4 | void cpu_RotateGrid(REAL *d_rotations, REAL *d_grid, int batch_size, int volume_size); -------------------------------------------------------------------------------- /Layers/Volume/Select/select_interface.cpp: -------------------------------------------------------------------------------- 1 | #include "select_interface.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | void SelectVolume_forward( torch::Tensor volume, 8 | torch::Tensor coords, 9 | torch::Tensor num_atoms, 10 | torch::Tensor features, 11 | float res 12 | ){ 13 | CHECK_GPU_INPUT(volume); 14 | CHECK_GPU_INPUT(coords); 15 | CHECK_GPU_INPUT(features); 16 | CHECK_GPU_INPUT_TYPE(num_atoms, torch::kInt); 17 | if(coords.ndimension() != 2){ 18 | ERROR("Incorrect input ndim"); 19 | } 20 | 21 | 22 | int batch_size = coords.size(0); 23 | int num_features = features.size(1); 24 | int spatial_dim = volume.size(2); 25 | int max_num_atoms = coords.size(1)/3; 26 | 27 | #pragma omp parallel for 28 | for(int i=0; i(), num_features, 35 | single_volume.data(), spatial_dim, 36 | single_coords.data(), single_num_atoms, max_num_atoms, res); 37 | } 38 | } 39 | 40 | -------------------------------------------------------------------------------- /Layers/Volume/Select/select_interface.h: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void SelectVolume_forward( torch::Tensor volume, 4 | torch::Tensor coords, 5 | torch::Tensor num_atoms, 6 | torch::Tensor features, 7 | float res 8 | ); -------------------------------------------------------------------------------- /Layers/Volume/TypedCoords2Volume/typedcoords2volume_interface.cpp: -------------------------------------------------------------------------------- 1 | #include "typedcoords2volume_interface.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | void TypedCoords2Volume_forward( torch::Tensor input_coords, 8 | torch::Tensor volume, 9 | torch::Tensor num_atoms_of_type, 10 | torch::Tensor offsets, 11 | float resolution){ 12 | int num_atom_types=11; 13 | CHECK_GPU_INPUT(volume); 14 | CHECK_GPU_INPUT(input_coords); 15 | CHECK_GPU_INPUT_TYPE(num_atoms_of_type, torch::kInt); 16 | CHECK_GPU_INPUT_TYPE(offsets, torch::kInt); 17 | if(input_coords.ndimension() != 2){ 18 | ERROR("Incorrect input ndim"); 19 | } 20 | int batch_size = input_coords.size(0); 21 | 22 | #pragma omp parallel for 23 | for(int i=0; i( single_input_coords.data(), 30 | single_num_atoms_of_type.data(), 31 | single_offsets.data(), 32 | single_volume.data(), single_volume.size(1), num_atom_types, resolution); 33 | })); 34 | } 35 | 36 | } 37 | void TypedCoords2Volume_backward( torch::Tensor grad_volume, 38 | torch::Tensor grad_coords, 39 | torch::Tensor coords, 40 | torch::Tensor num_atoms_of_type, 41 | torch::Tensor offsets, 42 | float resolution){ 43 | int num_atom_types=11; 44 | CHECK_GPU_INPUT(grad_volume); 45 | CHECK_GPU_INPUT(grad_coords); 46 | CHECK_GPU_INPUT(coords); 47 | CHECK_GPU_INPUT_TYPE(num_atoms_of_type, torch::kInt); 48 | CHECK_GPU_INPUT_TYPE(offsets, torch::kInt); 49 | if(grad_coords.ndimension() != 2){ 50 | ERROR("Incorrect input ndim"); 51 | } 52 | int batch_size = grad_coords.size(0); 53 | #pragma omp parallel for 54 | for(int i=0; i(single_coords.data(), 63 | single_grad_coords.data(), 64 | single_num_atoms_of_type.data(), 65 | single_offsets.data(), 66 | single_grad_volume.data(), 67 | single_grad_volume.size(1), num_atom_types, resolution); 68 | })); 69 | } 70 | 71 | } 72 | -------------------------------------------------------------------------------- /Layers/Volume/TypedCoords2Volume/typedcoords2volume_interface.h: -------------------------------------------------------------------------------- 1 | #include 2 | void TypedCoords2Volume_forward( torch::Tensor input_coords, 3 | torch::Tensor volume, 4 | torch::Tensor num_atoms_of_type, 5 | torch::Tensor offsets, 6 | float resolution); 7 | void TypedCoords2Volume_backward( torch::Tensor grad_volume, 8 | torch::Tensor grad_coords, 9 | torch::Tensor coords, 10 | torch::Tensor num_atoms_of_type, 11 | torch::Tensor offsets, 12 | float resolution); -------------------------------------------------------------------------------- /Layers/Volume/Volume2Xplor/volume2xplor_interface.cpp: -------------------------------------------------------------------------------- 1 | #include "volume2xplor_interface.h" 2 | #include 3 | #include 4 | #include 5 | 6 | void Volume2Xplor( at::Tensor volume, const char *filename, float resolution){ 7 | CHECK_CPU_INPUT(volume); 8 | if(volume.ndimension() != 3){ 9 | ERROR("Incorrect input ndim"); 10 | } 11 | auto V = volume.accessor(); 12 | int size = volume.size(0); 13 | float mean=0.5, std=0.5; 14 | 15 | FILE *fout = fopen(filename, "w"); 16 | fprintf(fout, "\n"); 17 | fprintf(fout, " Density map\n"); 18 | fprintf(fout, " 1\n"); 19 | fprintf(fout, " 0\n"); 20 | fprintf(fout, "%8d%8d%8d%8d%8d%8d%8d%8d%8d\n",size-1,0,size-1,size-1,0,size-1,size-1,0,size-1); 21 | fprintf(fout, "%12.5E%12.5E%12.5E%12.5E%12.5E%12.5E\n",float(size)*resolution,float(size)*resolution,float(size)*resolution,90.,90.,90.); 22 | fprintf(fout, "ZYX\n"); 23 | 24 | for(int z=0; z(); 57 | int size = volume.size(0); 58 | float mean=0.5, std=0.5; 59 | 60 | FILE *fout = fopen(filename, "wb"); 61 | // fprintf(fout, "\n"); 62 | fprintf(fout, "%80s", "Density map"); 63 | fprintf(fout, "%80s", "3"); 64 | fprintf(fout, "%80s", "4"); 65 | fprintf(fout, "%80s", "5"); 66 | fprintf(fout, "%8d%8d%8d%8d%8d%8d%8d%8d%8d",size-1,0,size-1,size-1,0,size-1,size-1,0,size-1); 67 | fprintf(fout, "%12.5E%12.5E%12.5E%12.5E%12.5E%12.5E",float(size),float(size),float(size),90.,90.,90.); 68 | fprintf(fout, "ZYX"); 69 | unsigned long int ind=1; 70 | for(int z=0; z 2 | void Volume2Xplor( torch::Tensor volume, const char *filename, float resolution); -------------------------------------------------------------------------------- /Layers/Volume/VolumeConv.h: -------------------------------------------------------------------------------- 1 | 2 | #define REAL float 3 | // #define REAL double 4 | 5 | 6 | void cpu_VolumeConv(REAL *d_volume1, REAL *d_volume2, REAL *d_output, int batch_size, int volume_size, bool conjugate); 7 | // Computes F(tau) = \int vol1(r)vol2(tau-r) dr 8 | -------------------------------------------------------------------------------- /Layers/Volume/VolumeConvolution/volumeConvolution_interface.cpp: -------------------------------------------------------------------------------- 1 | #include "volumeConvolution_interface.h" 2 | #include 3 | #include 4 | #include 5 | 6 | 7 | void VolumeConvolution_forward( torch::Tensor volume1, 8 | torch::Tensor volume2, 9 | torch::Tensor output){ 10 | CHECK_GPU_INPUT_TYPE(volume1, torch::kFloat); 11 | CHECK_GPU_INPUT_TYPE(volume2, torch::kFloat); 12 | CHECK_GPU_INPUT_TYPE(output, torch::kFloat); 13 | if(volume1.ndimension()!=4){ 14 | ERROR("incorrect input dimension"); 15 | } 16 | cpu_VolumeConv( volume1.data(), 17 | volume2.data(), 18 | output.data(), 19 | volume1.size(0), 20 | volume1.size(1), 21 | true); 22 | } 23 | void VolumeConvolution_backward( torch::Tensor gradOutput, 24 | torch::Tensor gradVolume1, 25 | torch::Tensor gradVolume2, 26 | torch::Tensor volume1, 27 | torch::Tensor volume2){ 28 | CHECK_GPU_INPUT_TYPE(gradVolume1, torch::kFloat); 29 | CHECK_GPU_INPUT_TYPE(gradVolume2, torch::kFloat); 30 | CHECK_GPU_INPUT_TYPE(gradOutput, torch::kFloat); 31 | CHECK_GPU_INPUT_TYPE(volume1, torch::kFloat); 32 | CHECK_GPU_INPUT_TYPE(volume2, torch::kFloat); 33 | if(gradOutput.ndimension()!=4){ 34 | ERROR("incorrect input dimension"); 35 | } 36 | 37 | cpu_VolumeConv( gradOutput.data(), 38 | volume2.data(), 39 | gradVolume1.data(), 40 | volume1.size(0), 41 | volume1.size(1), 42 | false); 43 | 44 | cpu_VolumeConv( volume1.data(), 45 | gradOutput.data(), 46 | gradVolume2.data(), 47 | volume1.size(0), 48 | volume1.size(1), 49 | true); 50 | } 51 | 52 | 53 | -------------------------------------------------------------------------------- /Layers/Volume/VolumeConvolution/volumeConvolution_interface.h: -------------------------------------------------------------------------------- 1 | #include 2 | void VolumeConvolution_forward( torch::Tensor volume1, 3 | torch::Tensor volume2, 4 | torch::Tensor output); 5 | void VolumeConvolution_backward( torch::Tensor gradOutput, 6 | torch::Tensor gradVolume1, 7 | torch::Tensor gradVolume2, 8 | torch::Tensor volume1, 9 | torch::Tensor volume2); -------------------------------------------------------------------------------- /Layers/Volume/VolumeRMSD.cu: -------------------------------------------------------------------------------- 1 | #include "VolumeRMSD.h" 2 | 3 | __global__ void fillVolume( REAL *d_volume, 4 | REAL add, 5 | REAL T0_x, REAL T0_y, REAL T0_z, 6 | REAL D_x, REAL D_y, REAL D_z, 7 | float resolution){ 8 | uint x = blockIdx.y; 9 | uint y = blockIdx.z; 10 | uint z = threadIdx.x; 11 | uint volume_size = gridDim.y; 12 | 13 | uint half_size = volume_size/2; 14 | uint vol2_bytes = volume_size*volume_size; 15 | 16 | REAL *vol = d_volume + x*vol2_bytes + y*volume_size; 17 | 18 | REAL T1_x = x*resolution, T1_y = y*resolution, T1_z = z*resolution; 19 | if (x >= half_size) 20 | T1_x = -(float(volume_size) - float(x)) * resolution; 21 | if (y >= half_size) 22 | T1_y = -(float(volume_size) - float(y)) * resolution; 23 | if (z >= half_size) 24 | T1_z = -(float(volume_size) - float(z)) * resolution; 25 | 26 | vol[z] = sqrt((T0_x - T1_x)*(T0_x - T1_x) + (T0_y - T1_y)*(T0_y - T1_y) + (T0_z - T1_z)*(T0_z - T1_z) + \ 27 | (T0_x - T1_x)*D_x + (T0_y - T1_y)*D_y + (T0_z - T1_z)*D_z + add); 28 | 29 | } 30 | 31 | void gpu_VolumeRMSD(REAL *d_volume, 32 | REAL add, 33 | REAL T0_x, REAL T0_y, REAL T0_z, 34 | REAL D_x, REAL D_y, REAL D_z, 35 | int volume_size, float resolution){ 36 | 37 | dim3 dim_special(1, volume_size, volume_size); 38 | fillVolume<<>>(d_volume, add, T0_x, T0_y, T0_z, D_x, D_y, D_z, resolution); 39 | } 40 | 41 | 42 | -------------------------------------------------------------------------------- /Layers/Volume/VolumeRMSD.h: -------------------------------------------------------------------------------- 1 | #define REAL float 2 | 3 | void gpu_VolumeRMSD(REAL *d_volume, 4 | REAL add, 5 | REAL T0_x, REAL T0_y, REAL T0_z, 6 | REAL D_x, REAL D_y, REAL D_z, 7 | int volume_size, float resolution); -------------------------------------------------------------------------------- /Layers/Volume/VolumeRMSD/volumeRMSD_interface.cpp: -------------------------------------------------------------------------------- 1 | #include "volumeRMSD_interface.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | void VolumeGenRMSD( torch::Tensor coords, 9 | torch::Tensor num_atoms, 10 | torch::Tensor R0, 11 | torch::Tensor R1, 12 | torch::Tensor T0, 13 | torch::Tensor translation_volume, 14 | float resolution){ 15 | CHECK_CPU_INPUT_TYPE(coords, torch::kDouble); 16 | CHECK_CPU_INPUT_TYPE(num_atoms, torch::kInt); 17 | CHECK_CPU_INPUT_TYPE(R0, torch::kDouble); 18 | CHECK_CPU_INPUT_TYPE(R1, torch::kDouble); 19 | CHECK_CPU_INPUT_TYPE(T0, torch::kDouble); 20 | CHECK_GPU_INPUT_TYPE(translation_volume, torch::kFloat); 21 | if(translation_volume.ndimension()!=4){ 22 | ERROR("incorrect input dimension"); 23 | } 24 | 25 | int batch_size = coords.size(0); 26 | auto num_atoms_acc = num_atoms.accessor(); 27 | #pragma omp parallel for 28 | for(int i=0; i(); 35 | auto R1_acc = single_R1.accessor(); 36 | auto T0_acc = single_T0.accessor(); 37 | 38 | //Computing additive term: 2/N (delta - R0*R1)X 39 | cMatrix33 X; X.setZero(); 40 | double rmsd2R = 0.0; 41 | for(int j=0; j r(single_coords.data()+3*j); 43 | X(0,0) += r.v[0]*r.v[0]; 44 | X(0,1) += r.v[0]*r.v[1]; 45 | X(0,2) += r.v[0]*r.v[2]; 46 | X(1,0) += r.v[1]*r.v[0]; 47 | X(1,1) += r.v[1]*r.v[1]; 48 | X(1,2) += r.v[1]*r.v[2]; 49 | X(2,0) += r.v[2]*r.v[0]; 50 | X(2,1) += r.v[2]*r.v[1]; 51 | X(2,2) += r.v[2]*r.v[2]; 52 | } 53 | for(int k=0; k<3; k++){ 54 | for(int l=0; l<3; l++){ 55 | double Rsum = 0.0; 56 | double deltakl = 0.0; 57 | for(int m=0; m<3; m++){ 58 | Rsum += R0_acc[m][k] * R1_acc[m][l]; 59 | } 60 | if(k==l) 61 | deltakl = 1.0; 62 | 63 | rmsd2R += (deltakl - Rsum)*X(k,l); 64 | }} 65 | rmsd2R *= 2.0/double(num_atoms_acc[i]); 66 | 67 | 68 | //Computing multiplicative term delta: 2.0*(R1 - R2)C 69 | cVector3 centroid; centroid.setZero(); 70 | cVector3 delta; delta.setZero(); 71 | 72 | for(int j=0; j(single_coords.data()+3*j); 74 | } 75 | centroid /= double(num_atoms_acc[i]); 76 | 77 | for(int k=0; k<3; k++){ 78 | for(int m=0; m<3; m++){ 79 | delta.v[k] += 2.0*(R0_acc[k][m] - R1_acc[k][m])*centroid.v[m]; 80 | } 81 | } 82 | 83 | //Filling volume with RMSD values 84 | gpu_VolumeRMSD( single_volume.data(), 85 | rmsd2R, 86 | T0_acc[0], T0_acc[1], T0_acc[2], 87 | delta.v[0], delta.v[1], delta.v[2], 88 | single_volume.size(0), resolution); 89 | 90 | } 91 | } 92 | 93 | 94 | -------------------------------------------------------------------------------- /Layers/Volume/VolumeRMSD/volumeRMSD_interface.h: -------------------------------------------------------------------------------- 1 | #include 2 | void VolumeGenRMSD( torch::Tensor coords, 3 | torch::Tensor num_atoms, 4 | torch::Tensor R0, 5 | torch::Tensor R1, 6 | torch::Tensor T0, 7 | torch::Tensor translation_volume, 8 | float resolution); -------------------------------------------------------------------------------- /Layers/Volume/VolumeRotation/volumeRotation_interface.cpp: -------------------------------------------------------------------------------- 1 | #include "volumeRotation_interface.h" 2 | #include 3 | #include 4 | #include 5 | 6 | 7 | void VolumeGenGrid( torch::Tensor rotations, torch::Tensor grid){ 8 | CHECK_GPU_INPUT_TYPE(rotations, torch::kFloat32); 9 | CHECK_GPU_INPUT_TYPE(grid, torch::kFloat32); 10 | if(rotations.ndimension()!=3 || grid.ndimension()!=5){ 11 | ERROR("incorrect input dimension"); 12 | } 13 | int batch_size = rotations.size(0); 14 | int size = grid.size(1); 15 | cpu_RotateGrid(rotations.data(), grid.data(), batch_size, size); 16 | } 17 | 18 | -------------------------------------------------------------------------------- /Layers/Volume/VolumeRotation/volumeRotation_interface.h: -------------------------------------------------------------------------------- 1 | #include 2 | void VolumeGenGrid( torch::Tensor rotations, torch::Tensor grid); -------------------------------------------------------------------------------- /Layers/Volume/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include