Coverage for biobb_analysis/ambertools/cpptraj_rmsf.py: 96%

69 statements  

« prev     ^ index     » next       coverage.py v7.10.6, created at 2025-09-08 10:47 +0000

1#!/usr/bin/env python3 

2 

3"""Module containing the Cpptraj Rmsf class and the command line interface.""" 

4 

5from typing import Optional 

6from pathlib import PurePath 

7from biobb_common.generic.biobb_object import BiobbObject 

8from biobb_common.tools.file_utils import launchlogger 

9from biobb_analysis.ambertools.common import get_default_value, check_top_path, check_traj_path, check_out_path, get_binary_path, get_in_parameters, get_negative_mask, setup_structure, get_mask, get_reference 

10 

11 

12class CpptrajRmsf(BiobbObject): 

13 """ 

14 | biobb_analysis CpptrajRmsf 

15 | Wrapper of the Ambertools Cpptraj module for calculating the Root Mean Square fluctuations (RMSf) of a given cpptraj compatible trajectory. 

16 | Cpptraj (the successor to ptraj) is the main program in Ambertools for processing coordinate trajectories and data files. The parameter names and defaults are the same as the ones in the official `Cpptraj manual <https://raw.githubusercontent.com/Amber-MD/cpptraj/master/doc/CpptrajManual.pdf>`_. 

17 

18 Args: 

19 input_top_path (str): Path to the input structure or topology file. File type: input. `Sample file <https://github.com/bioexcel/biobb_analysis/raw/master/biobb_analysis/test/data/ambertools/cpptraj.parm.top>`_. Accepted formats: top (edam:format_3881), pdb (edam:format_1476), prmtop (edam:format_3881), parmtop (edam:format_3881), zip (edam:format_3987). 

20 input_traj_path (str): Path to the input trajectory to be processed. File type: input. `Sample file <https://github.com/bioexcel/biobb_analysis/raw/master/biobb_analysis/test/data/ambertools/cpptraj.traj.dcd>`_. Accepted formats: mdcrd (edam:format_3878), crd (edam:format_3878), cdf (edam:format_3650), netcdf (edam:format_3650), nc (edam:format_3650), restart (edam:format_3886), ncrestart (edam:format_3886), restartnc (edam:format_3886), dcd (edam:format_3878), charmm (edam:format_3887), cor (edam:format_2033), pdb (edam:format_1476), mol2 (edam:format_3816), trr (edam:format_3910), gro (edam:format_2033), binpos (edam:format_3885), xtc (edam:format_3875), cif (edam:format_1477), arc (edam:format_2333), sqm (edam:format_2033), sdf (edam:format_3814), conflib (edam:format_2033). 

21 input_exp_path (str) (Optional): Path to the experimental reference file (required if reference = experimental). File type: input. `Sample file <https://github.com/bioexcel/biobb_analysis/raw/master/biobb_analysis/test/data/ambertools/experimental.1e5t.pdb>`_. Accepted formats: pdb (edam:format_1476). 

22 output_cpptraj_path (str): Path to the output processed analysis. File type: output. `Sample file <https://github.com/bioexcel/biobb_analysis/raw/master/biobb_analysis/test/reference/ambertools/ref_cpptraj.rmsf.first.dat>`_. Accepted formats: dat (edam:format_1637), agr (edam:format_2033), xmgr (edam:format_2033), gnu (edam:format_2033). 

23 properties (dic - Python dictionary object containing the tool parameters, not input/output files): 

24 * **start** (*int*) - (1) [1~100000|1] Starting frame for slicing 

25 * **end** (*int*) - (-1) [-1~100000|1] Ending frame for slicing 

26 * **steps** (*int*) - (1) [1~100000|1] Step for slicing 

27 * **mask** (*str*) - ("all-atoms") Mask definition. Values: c-alpha (All c-alpha atoms; protein only), backbone (Backbone atoms), all-atoms (All system atoms), heavy-atoms (System heavy atoms; not hydrogen), side-chain (All not backbone atoms), solute (All system atoms except solvent atoms), ions (All ion molecules), solvent (All solvent atoms), AnyAmberFromatMask (Amber atom selection syntax like `@*`). 

28 * **reference** (*str*) - ("first") Reference definition. Values: first (Use the first trajectory frame as reference), average (Use the average of all trajectory frames as reference), experimental (Use the experimental structure as reference). 

29 * **binary_path** (*str*) - ("cpptraj") Path to the cpptraj executable binary. 

30 * **remove_tmp** (*bool*) - (True) [WF property] Remove temporal files. 

31 * **restart** (*bool*) - (False) [WF property] Do not execute if output files exist. 

32 * **sandbox_path** (*str*) - ("./") [WF property] Parent path to the sandbox directory. 

33 * **container_path** (*str*) - (None) Container path definition. 

34 * **container_image** (*str*) - ('afandiadib/ambertools:serial') Container image definition. 

35 * **container_volume_path** (*str*) - ('/tmp') Container volume path definition. 

36 * **container_working_dir** (*str*) - (None) Container working directory definition. 

37 * **container_user_id** (*str*) - (None) Container user_id definition. 

38 * **container_shell_path** (*str*) - ('/bin/bash') Path to default shell inside the container. 

39 

40 Examples: 

41 This is a use example of how to use the building block from Python:: 

42 

43 from biobb_analysis.ambertools.cpptraj_rmsf import cpptraj_rmsf 

44 prop = { 

45 'start': 1, 

46 'end': -1, 

47 'steps': 1, 

48 'mask': 'c-alpha', 

49 'reference': 'first' 

50 } 

51 cpptraj_rmsf(input_top_path='/path/to/myTopology.top', 

52 input_traj_path='/path/to/myTrajectory.dcd', 

53 output_cpptraj_path='/path/to/newAnalysis.dat', 

54 input_exp_path= '/path/to/myExpStructure.pdb', 

55 properties=prop) 

56 

57 Info: 

58 * wrapped_software: 

59 * name: Ambertools Cpptraj 

60 * version: >=22.5 

61 * license: GNU 

62 * ontology: 

63 * name: EDAM 

64 * schema: http://edamontology.org/EDAM.owl 

65 

66 """ 

67 

68 def __init__(self, input_top_path, input_traj_path, output_cpptraj_path, 

69 input_exp_path=None, properties=None, **kwargs) -> None: 

70 properties = properties or {} 

71 

72 # Call parent class constructor 

73 super().__init__(properties) 

74 self.locals_var_dict = locals().copy() 

75 

76 # Input/Output files 

77 self.io_dict = { 

78 "in": {"input_top_path": input_top_path, "input_traj_path": input_traj_path, "input_exp_path": input_exp_path}, 

79 "out": {"output_cpptraj_path": output_cpptraj_path} 

80 } 

81 

82 # Properties specific for BB 

83 self.instructions_file = get_default_value('instructions_file') 

84 self.start = properties.get('start', 1) 

85 self.end = properties.get('end', -1) 

86 self.steps = properties.get('steps', 1) 

87 self.mask = properties.get('mask', 'all-atoms') 

88 self.reference = properties.get('reference', 'first') 

89 self.properties = properties 

90 self.binary_path = get_binary_path(properties, 'binary_path') 

91 

92 # Check the properties 

93 self.check_init(properties) 

94 

95 def check_data_params(self, out_log, err_log): 

96 """ Checks all the input/output paths and parameters """ 

97 self.io_dict["in"]["input_top_path"], self.input_top_path_orig = check_top_path(self.io_dict["in"]["input_top_path"], out_log, self.__class__.__name__) 

98 self.io_dict["in"]["input_traj_path"] = check_traj_path(self.io_dict["in"]["input_traj_path"], out_log, self.__class__.__name__) 

99 self.io_dict["out"]["output_cpptraj_path"] = check_out_path(self.io_dict["out"]["output_cpptraj_path"], out_log, self.__class__.__name__) 

100 self.in_parameters = {'start': self.start, 'end': self.end, 'step': self.steps, 'mask': self.mask, 'reference': self.reference} 

101 

102 def create_instructions_file(self, container_io_dict, out_log, err_log): 

103 """Creates an input file using the properties file settings""" 

104 instructions_list = [] 

105 # different path if container execution or not 

106 if self.container_path: 

107 self.instructions_file = str(PurePath(self.container_volume_path).joinpath(self.instructions_file)) 

108 else: 

109 self.instructions_file = self.create_tmp_file(self.instructions_file) 

110 

111 # parm 

112 instructions_list.append('parm ' + container_io_dict["in"]["input_top_path"]) 

113 

114 # trajin 

115 in_params = get_in_parameters(self.in_parameters, out_log) 

116 instructions_list.append('trajin ' + container_io_dict["in"]["input_traj_path"] + ' ' + in_params) 

117 

118 # Set up 

119 instructions_list += setup_structure(self) 

120 

121 # mask 

122 mask = self.in_parameters.get('mask', '') 

123 ref_mask = '' 

124 if mask: 

125 strip_mask = get_negative_mask(mask, out_log) 

126 ref_mask = get_mask(mask, out_log) 

127 instructions_list.append('strip ' + strip_mask) 

128 

129 # reference 

130 reference = self.in_parameters.get('reference', '') 

131 inp_exp_pth = None 

132 if "input_exp_path" in container_io_dict["in"]: 

133 inp_exp_pth = container_io_dict["in"]["input_exp_path"] 

134 instructions_list += get_reference(reference, container_io_dict["out"]["output_cpptraj_path"], inp_exp_pth, ref_mask, False, self.__class__.__name__, out_log) 

135 instructions_list.append('atomicfluct out ' + container_io_dict["out"]["output_cpptraj_path"] + ' byres') 

136 

137 # create .in file 

138 with open(self.instructions_file, 'w') as mdp: 

139 for line in instructions_list: 

140 mdp.write(line.strip() + '\n') 

141 

142 return self.instructions_file 

143 

144 @launchlogger 

145 def launch(self) -> int: 

146 """Execute the :class:`CpptrajRmsf <ambertools.cpptraj_rmsf.CpptrajRmsf>` object.""" 

147 

148 # check input/output paths and parameters 

149 self.check_data_params(self.out_log, self.err_log) 

150 

151 # Setup Biobb 

152 if self.check_restart(): 

153 return 0 

154 self.stage_files() 

155 

156 # create instructions file 

157 self.create_instructions_file(self.stage_io_dict, self.out_log, self.err_log) 

158 

159 # create cmd and launch execution 

160 self.cmd = [self.binary_path, '-i', self.instructions_file] 

161 

162 # Run Biobb block 

163 self.run_biobb() 

164 

165 # Copy files to host 

166 self.copy_to_host() 

167 

168 # remove temporary folder(s) 

169 self.remove_tmp_files() 

170 self.check_arguments(output_files_created=True, raise_exception=False) 

171 

172 return self.return_code 

173 

174 

175def cpptraj_rmsf(input_top_path: str, input_traj_path: str, output_cpptraj_path: str, input_exp_path: Optional[str] = None, properties: Optional[dict] = None, **kwargs) -> int: 

176 """Execute the :class:`CpptrajRmsf <ambertools.cpptraj_rmsf.CpptrajRmsf>` class and 

177 execute the :meth:`launch() <ambertools.cpptraj_rmsf.CpptrajRmsf.launch>` method.""" 

178 return CpptrajRmsf(**dict(locals())).launch() 

179 

180 

181cpptraj_rmsf.__doc__ = CpptrajRmsf.__doc__ 

182main = CpptrajRmsf.get_main(cpptraj_rmsf, "Calculates the Root Mean Square fluctuations (RMSf) of a given cpptraj compatible trajectory.") 

183 

184if __name__ == '__main__': 

185 main()