Example #1
0
    def _read_1_2_results(self, file_data, verbosity=1):
        """Read the relax 1.2 model-free results file.

        @param file_data:   The processed results file data.
        @type file_data:    list of lists of str
        @keyword verbosity: A variable specifying the amount of information to print.  The higher
                            the value, the greater the verbosity.
        @type verbosity:    int
        """

        # Extract and remove the header.
        header = file_data[0]
        file_data = file_data[1:]

        # Sort the column numbers.
        col = self._read_1_2_col_numbers(header)

        # Test the file.
        if len(col) < 2:
            raise RelaxInvalidDataError

        # Initialise some data structures and flags.
        sim_num = None
        sims = []
        all_select_sim = []
        diff_data_set = False
        diff_error_set = False
        diff_sim_set = None
        model_type = None
        pdb = False
        pdb_model = None
        pdb_heteronuc = None
        pdb_proton = None
        ri_labels = None

        # Generate the sequence.
        if verbosity:
            print("\nGenerating the sequence.")
        for file_line in file_data:
            # The data set.
            data_set = file_line[col['data_set']]

            # Stop creating the sequence once the data_set is no longer 'value'.
            if data_set != 'value':
                break

            # Sequence.
            self._generate_sequence(file_line, col, verbosity)

        # Count the number of simulations.
        for file_line in file_data:
            # The data set.
            data_set = file_line[col['data_set']]

            # Simulation number.
            if data_set != 'value' and data_set != 'error':
                # Extract the number from the data_set string.
                sim_num = data_set.split('_')
                try:
                    sim_num = int(sim_num[1])
                except:
                    raise RelaxError("The simulation number '%s' is invalid." % sim_num)
        if sim_num != None:
            cdp.sim_number = sim_num + 1

        # Loop over the lines of the file data.
        for file_line in file_data:
            # The data set.
            data_set = file_line[col['data_set']]

            # The spin info (for relax 1.2).
            if 'num' in col:
                mol_name = None
                res_num = int(file_line[col['num']])
                res_name = file_line[col['name']]
                spin_num = None
                spin_name = None
                if col['nucleus'] < len(file_line) and search('N', file_line[col['nucleus']]):
                    spin_name = 'N'
                if col['nucleus'] < len(file_line) and search('C', file_line[col['nucleus']]):
                    spin_name = 'C'

            # The spin info.
            else:
                mol_name = file_line[col['mol_name']]
                res_num = int(file_line[col['res_num']])
                res_name = file_line[col['res_name']]
                spin_num = int(file_line[col['spin_num']])
                spin_name = file_line[col['spin_name']]

            # Create the spin ID.
            spin_id = generate_spin_id_unique(mol_name=mol_name, res_num=res_num, res_name=res_name, spin_num=spin_num, spin_name=spin_name)

            # Get the spin container.
            spin = return_spin(spin_id)

            # Create a new spin container for the proton, then set up a dipole interaction between the two spins.
            if data_set == 'value' and spin_name:
                h_spin = create_spin(mol_name=mol_name, res_num=res_num, res_name=res_name, spin_name='H')
                h_spin.select = False
                h_spin.element = 'H'
                h_spin.isotope = '1H'
                spin_id2 = generate_spin_id_unique(mol_name=mol_name, res_num=res_num, res_name=res_name, spin_name='H')
                define(spin_id, spin_id2, verbose=False)

            # Backwards compatibility for the reading of the results file from versions 1.2.0 to 1.2.9.
            if len(file_line) == 4:
                continue

            # Set the nuclear isotope types and spin names (absent from the 1.2 results file).
            if data_set == 'value':
                if file_line[col['nucleus']] != 'None':
                    if search('N', file_line[col['nucleus']]):
                        spin.isotope = '15N'
                        if spin.name == None:
                            spin.name = 'N'
                    elif search('C', file_line[col['nucleus']]):
                        spin.isotope = '13C'
                        if spin.name == None:
                            spin.name = 'C'

            # Simulation number.
            if data_set != 'value' and data_set != 'error':
                # Extract the number from the data_set string.
                sim_num = data_set.split('_')
                try:
                    sim_num = int(sim_num[1])
                except:
                    raise RelaxError("The simulation number '%s' is invalid." % sim_num)

                # A new simulation number.
                if sim_num not in sims:
                    # Update the sims array and append an empty array to the selected sims array.
                    sims.append(sim_num)
                    all_select_sim.append([])

                # Selected simulations.
                all_select_sim[-1].append(bool(file_line[col['select']]))

                # Initial printout for the simulation.
                if verbosity:
                    if diff_sim_set == None:
                        print("\nLoading simulations.")
                    if sim_num != diff_sim_set:
                        print(data_set)

            # Diffusion tensor data.
            if data_set == 'value' and not diff_data_set:
                self._read_1_2_set_diff_tensor(file_line, col, data_set, verbosity, sim_num=sim_num)
                diff_data_set = True

            # Diffusion tensor errors.
            elif data_set == 'error' and not diff_error_set:
                self._read_1_2_set_diff_tensor(file_line, col, data_set, verbosity, sim_num=sim_num)
                diff_error_set = True

            # Diffusion tensor simulation data.
            elif data_set != 'value' and data_set != 'error' and sim_num != diff_sim_set:
                # Set up the diffusion tensor.
                if not hasattr(cdp.diff_tensor, '_sim_num') or cdp.diff_tensor._sim_num == None:
                    cdp.diff_tensor.set_sim_num(cdp.sim_number)

                self._read_1_2_set_diff_tensor(file_line, col, data_set, verbosity, sim_num=sim_num)
                diff_sim_set = sim_num

            # Model type.
            if model_type == None:
                self._fix_params(file_line, col, verbosity)

            # PDB.
            if not pdb:
                if self._load_structure(file_line, col, verbosity):
                    pdb = True

            # XH vector, heteronucleus, and proton.
            if data_set == 'value':
                self._set_xh_vect(file_line, col, spin, spin_id1=spin_id, spin_id2=spin_id2, verbosity=verbosity)

            # Relaxation data.
            self._load_relax_data(file_line, col, data_set, spin, verbosity)

            # Model-free data.
            self._load_model_free_data(file_line, col, data_set, spin, spin_id, verbosity)

        # Set up the simulations.
        if len(sims):
            # Convert the selected simulation array of arrays into a Numeric matrix, transpose it, then convert back to a Python list.
            all_select_sim = transpose(array(all_select_sim))
            all_select_sim = all_select_sim.tolist()

            # Set up the Monte Carlo simulations.
            pipe_control.monte_carlo.setup(number=len(sims), all_select_sim=all_select_sim)

            # Turn the simulation state to off!
            cdp.sim_state = False
Example #2
0
def bmrb_read(star, sample_conditions=None):
    """Read the relaxation data from the NMR-STAR dictionary object.

    @param star:                The NMR-STAR dictionary object.
    @type star:                 NMR_STAR instance
    @keyword sample_conditions: The sample condition label to read.  Only one sample condition can be read per data pipe.
    @type sample_conditions:    None or str
    """

    # Get the relaxation data.
    for data in star.relaxation.loop():
        # Store the keys.
        keys = list(data.keys())

        # Sample conditions do not match (remove the $ sign).
        if 'sample_cond_list_label' in keys and sample_conditions and data['sample_cond_list_label'].replace('$', '') != sample_conditions:
            continue

        # Create the labels.
        ri_type = data['data_type']
        frq = float(data['frq']) * 1e6

        # Round the label to the nearest factor of 10.
        frq_label = create_frq_label(float(data['frq']) * 1e6)

        # The ID string.
        ri_id = "%s_%s" % (ri_type, frq_label)

        # The number of spins.
        N = bmrb.num_spins(data)

        # No data in the saveframe.
        if N == 0:
            continue

        # The molecule names.
        mol_names = bmrb.molecule_names(data, N)

        # Generate the sequence if needed.
        bmrb.generate_sequence(N, spin_names=data['atom_names'], res_nums=data['res_nums'], res_names=data['res_names'], mol_names=mol_names, isotopes=data['isotope'], elements=data['atom_types'])

        # The attached protons.
        if 'atom_names_2' in data:
            # Generate the proton spins.
            bmrb.generate_sequence(N, spin_names=data['atom_names_2'], res_nums=data['res_nums'], res_names=data['res_names'], mol_names=mol_names, isotopes=data['isotope_2'], elements=data['atom_types_2'])

            # Define the dipolar interaction.
            for i in range(len(data['atom_names'])):
                # The spin IDs.
                spin_id1 = generate_spin_id_unique(spin_name=data['atom_names'][i], res_num=data['res_nums'][i], res_name=data['res_names'][i], mol_name=mol_names[i])
                spin_id2 = generate_spin_id_unique(spin_name=data['atom_names_2'][i], res_num=data['res_nums'][i], res_name=data['res_names'][i], mol_name=mol_names[i])

                # Check if the container exists.
                if return_interatom(spin_id1=spin_id1, spin_id2=spin_id2):
                    continue

                # Define.
                define(spin_id1=spin_id1, spin_id2=spin_id2, verbose=False)

        # The data and error.
        vals = data['data']
        errors = data['errors']
        if vals == None:
            vals = [None] * N
        if errors == None:
            errors = [None] * N

        # Data transformation.
        if vals != None and 'units' in keys:
            # Scaling.
            if data['units'] == 'ms':
                # Loop over the data.
                for i in range(N):
                    # The value.
                    if vals[i] != None:
                        vals[i] = vals[i] / 1000

                    # The error.
                    if errors[i] != None:
                        errors[i] = errors[i] / 1000

            # Invert.
            if data['units'] in ['s', 'ms']:
                # Loop over the data.
                for i in range(len(vals)):
                    # The value.
                    if vals[i] != None:
                        vals[i] = 1.0 / vals[i]

                    # The error.
                    if vals[i] != None and errors[i] != None:
                        errors[i] = errors[i] * vals[i]**2

        # Pack the data.
        pack_data(ri_id, ri_type, frq, vals, errors, mol_names=mol_names, res_nums=data['res_nums'], res_names=data['res_names'], spin_nums=None, spin_names=data['atom_names'], gen_seq=True, verbose=False)

        # Store the temperature calibration and control.
        if data['temp_calibration']:
            temp_calibration(ri_id=ri_id, method=data['temp_calibration'])
        if data['temp_control']:
            temp_control(ri_id=ri_id, method=data['temp_control'])

        # Peak intensity type.
        if data['peak_intensity_type']:
            peak_intensity_type(ri_id=ri_id, type=data['peak_intensity_type'])