Package org.rcsb.cif.model.generated

Class Refine

  • All Implemented Interfaces:
    Category
    @Generated("org.rcsb.cif.generator.SchemaGenerator")
public class Refine
extends BaseCategory
    Data items in the REFINE category record details about the structure-refinement parameters.

    • Method Detail

      • getAnisoB11

        public FloatColumn getAnisoB11()
        The elements of the matrix that defines the overall anisotropic displacement model if one was refined for this structure.
        Returns:
        FloatColumn

      • getAnisoB12

        public FloatColumn getAnisoB12()
        The elements of the matrix that defines the overall anisotropic displacement model if one was refined for this structure.
        Returns:
        FloatColumn

      • getAnisoB13

        public FloatColumn getAnisoB13()
        The elements of the matrix that defines the overall anisotropic displacement model if one was refined for this structure.
        Returns:
        FloatColumn

      • getAnisoB22

        public FloatColumn getAnisoB22()
        The elements of the matrix that defines the overall anisotropic displacement model if one was refined for this structure.
        Returns:
        FloatColumn

      • getAnisoB23

        public FloatColumn getAnisoB23()
        The elements of the matrix that defines the overall anisotropic displacement model if one was refined for this structure.
        Returns:
        FloatColumn

      • getAnisoB33

        public FloatColumn getAnisoB33()
        The elements of the matrix that defines the overall anisotropic displacement model if one was refined for this structure.
        Returns:
        FloatColumn

      • getBIsoMax

        public FloatColumn getBIsoMax()
        The maximum isotropic displacement parameter (B value) found in the coordinate set.
        Returns:
        FloatColumn

      • getBIsoMean

        public FloatColumn getBIsoMean()
        The mean isotropic displacement parameter (B value) for the coordinate set.
        Returns:
        FloatColumn

      • getBIsoMin

        public FloatColumn getBIsoMin()
        The minimum isotropic displacement parameter (B value) found in the coordinate set.
        Returns:
        FloatColumn

      • getCorrelationCoeffFoToFc

        public FloatColumn getCorrelationCoeffFoToFc()
        The correlation coefficient between the observed and calculated structure factors for reflections included in the refinement. The correlation coefficient is scale-independent and gives an idea of the quality of the refined model. sum~i~(Fo~i~ Fc~i~ - <Fo><Fc>) R~corr~ = ------------------------------------------------------------ SQRT{sum~i~(Fo~i~)^2^-<Fo>^2^} SQRT{sum~i~(Fc~i~)^2^-<Fc>^2^} Fo = observed structure factors Fc = calculated structure factors <> denotes average value summation is over reflections included in the refinement
        Returns:
        FloatColumn

      • getCorrelationCoeffFoToFcFree

        public FloatColumn getCorrelationCoeffFoToFcFree()
        The correlation coefficient between the observed and calculated structure factors for reflections not included in the refinement (free reflections). The correlation coefficient is scale-independent and gives an idea of the quality of the refined model. sum~i~(Fo~i~ Fc~i~ - <Fo><Fc>) R~corr~ = ------------------------------------------------------------ SQRT{sum~i~(Fo~i~)^2^-<Fo>^2^} SQRT{sum~i~(Fc~i~)^2^-<Fc>^2^} Fo = observed structure factors Fc = calculated structure factors <> denotes average value summation is over reflections not included in the refinement (free reflections)
        Returns:
        FloatColumn

      • getDetails

        public StrColumn getDetails()
        Description of special aspects of the refinement process.
        Returns:
        StrColumn

      • getDiffDensityMax

        public FloatColumn getDiffDensityMax()
        The maximum value of the electron density in the final difference Fourier map.
        Returns:
        FloatColumn

      • getDiffDensityMaxEsd

        public FloatColumn getDiffDensityMaxEsd()
        The standard uncertainty (estimated standard deviation) of _refine.diff_density_max.
        Returns:
        FloatColumn

      • getDiffDensityMin

        public FloatColumn getDiffDensityMin()
        The minimum value of the electron density in the final difference Fourier map.
        Returns:
        FloatColumn

      • getDiffDensityMinEsd

        public FloatColumn getDiffDensityMinEsd()
        The standard uncertainty (estimated standard deviation) of _refine.diff_density_min.
        Returns:
        FloatColumn

      • getDiffDensityRms

        public FloatColumn getDiffDensityRms()
        The root-mean-square-deviation of the electron density in the final difference Fourier map. This value is measured with respect to the arithmetic mean density and is derived from summations over each grid point in the asymmetric unit of the cell. This quantity is useful for assessing the significance of the values of _refine.diff_density_min and _refine.diff_density_max, and also for defining suitable contour levels.
        Returns:
        FloatColumn

      • getDiffDensityRmsEsd

        public FloatColumn getDiffDensityRmsEsd()
        The standard uncertainty (estimated standard deviation) of _refine.diff_density_rms.
        Returns:
        FloatColumn

      • getEntryId

        public StrColumn getEntryId()
        This data item is a pointer to _entry.id in the ENTRY category.
        Returns:
        StrColumn

      • getPdbxRefineId

        public StrColumn getPdbxRefineId()
        This data item uniquely identifies a refinement within an entry. _refine.pdbx_refine_id can be used to distinguish the results of joint refinements.
        Returns:
        StrColumn

      • getLsAbsStructureDetails

        public StrColumn getLsAbsStructureDetails()
        The nature of the absolute structure and how it was determined. For example, this may describe the Friedel pairs used.
        Returns:
        StrColumn

      • getLsAbsStructureFlack

        public FloatColumn getLsAbsStructureFlack()
        The measure of absolute structure (enantiomorph or polarity) as defined by Flack (1983). For centrosymmetric structures, the only permitted value, if the data name is present, is 'inapplicable', represented by '.' . For noncentrosymmetric structures the value must lie in the 99.97% Gaussian confidence interval -3u =< x =< 1 + 3u and a standard uncertainty (estimated standard deviation) u must be supplied. The item range of [0.0:1.0] is correctly interpreted as meaning (0.0 - 3u) =< x =< (1.0 + 3u). Ref: Flack, H. D. (1983). Acta Cryst. A39, 876-881.
        Returns:
        FloatColumn

      • getLsAbsStructureFlackEsd

        public FloatColumn getLsAbsStructureFlackEsd()
        The standard uncertainty (estimated standard deviation) of _refine.ls_abs_structure_Flack.
        Returns:
        FloatColumn

      • getLsAbsStructureRogers

        public FloatColumn getLsAbsStructureRogers()
        The measure of absolute structure (enantiomorph or polarity) as defined by Rogers. The value must lie in the 99.97% Gaussian confidence interval -1 -3u =< \h =< 1 + 3u and a standard uncertainty (estimated standard deviation) u must be supplied. The item range of [-1.0, 1.0] is correctly interpreted as meaning (-1.0 - 3u) =< \h =< (1.0 + 3u). Ref: Rogers, D. (1981). Acta Cryst. A37, 734-741.
        Returns:
        FloatColumn

      • getLsAbsStructureRogersEsd

        public FloatColumn getLsAbsStructureRogersEsd()
        The standard uncertainty (estimated standard deviation) of _refine.ls_abs_structure_Rogers.
        Returns:
        FloatColumn

      • getLsDResHigh

        public FloatColumn getLsDResHigh()
        The smallest value for the interplanar spacings for the reflection data used in the refinement in angstroms. This is called the highest resolution.
        Returns:
        FloatColumn

      • getLsDResLow

        public FloatColumn getLsDResLow()
        The largest value for the interplanar spacings for the reflection data used in the refinement in angstroms. This is called the lowest resolution.
        Returns:
        FloatColumn

      • getLsExtinctionCoef

        public FloatColumn getLsExtinctionCoef()
        The extinction coefficient used to calculate the correction factor applied to the structure-factor data. The nature of the extinction coefficient is given in the definitions of _refine.ls_extinction_expression and _refine.ls_extinction_method. For the 'Zachariasen' method it is the r* value; for the 'Becker-Coppens type 1 isotropic' method it is the 'g' value, and for 'Becker-Coppens type 2 isotropic' corrections it is the 'rho' value. Note that the magnitude of these values is usually of the order of 10000. Ref: Becker, P. J. & Coppens, P. (1974). Acta Cryst. A30, 129-47, 148-153. Zachariasen, W. H. (1967). Acta Cryst. 23, 558-564. Larson, A. C. (1967). Acta Cryst. 23, 664-665.
        Returns:
        FloatColumn

      • getLsExtinctionCoefEsd

        public FloatColumn getLsExtinctionCoefEsd()
        The standard uncertainty (estimated standard deviation) of _refine.ls_extinction_coef.
        Returns:
        FloatColumn

      • getLsExtinctionExpression

        public StrColumn getLsExtinctionExpression()
        A description of or reference to the extinction-correction equation used to apply the data item _refine.ls_extinction_coef. This information must be sufficient to reproduce the extinction-correction factors applied to the structure factors.
        Returns:
        StrColumn

      • getLsExtinctionMethod

        public StrColumn getLsExtinctionMethod()
        A description of the extinction-correction method applied. This description should include information about the correction method, either 'Becker-Coppens' or 'Zachariasen'. The latter is sometimes referred to as the 'Larson' method even though it employs Zachariasen's formula. The Becker-Coppens procedure is referred to as 'type 1' when correcting secondary extinction dominated by the mosaic spread; as 'type 2' when secondary extinction is dominated by particle size and includes a primary extinction component; and as 'mixed' when there is a mixture of types 1 and 2. For the Becker-Coppens method, it is also necessary to set the mosaic distribution as either 'Gaussian' or 'Lorentzian' and the nature of the extinction as 'isotropic' or 'anisotropic'. Note that if either the 'mixed' or 'anisotropic' corrections are applied, the multiple coefficients cannot be contained in *_extinction_coef and must be listed in _refine.details. Ref: Becker, P. J. & Coppens, P. (1974). Acta Cryst. A30, 129-147, 148-153. Zachariasen, W. H. (1967). Acta Cryst. 23, 558- 564. Larson, A. C. (1967). Acta Cryst. 23, 664-665.
        Returns:
        StrColumn

      • getLsGoodnessOfFitAll

        public FloatColumn getLsGoodnessOfFitAll()
        The least-squares goodness-of-fit parameter S for all data after the final cycle of refinement. Ideally, account should be taken of parameters restrained in the least-squares refinement. See also the definition of _refine.ls_restrained_S_all. ( sum|w |Y~obs~ - Y~calc~|^2^| )^1/2^ S = ( ---------------------------- ) ( N~ref~ - N~param~ ) Y~obs~ = the observed coefficients (see _refine.ls_structure_factor_coef) Y~calc~ = the calculated coefficients (see _refine.ls_structure_factor_coef) w = the least-squares reflection weight [1/(e.s.d. squared)] N~ref~ = the number of reflections used in the refinement N~param~ = the number of refined parameters sum is taken over the specified reflections
        Returns:
        FloatColumn

      • getLsGoodnessOfFitAllEsd

        public FloatColumn getLsGoodnessOfFitAllEsd()
        The standard uncertainty (estimated standard deviation) of _refine.ls_goodness_of_fit_all.
        Returns:
        FloatColumn

      • getLsGoodnessOfFitObs

        public FloatColumn getLsGoodnessOfFitObs()
        The least-squares goodness-of-fit parameter S for reflection data classified as 'observed' (see _reflns.observed_criterion) after the final cycle of refinement. Ideally, account should be taken of parameters restrained in the least-squares refinement. See also the definition of _refine.ls_restrained_S_obs. ( sum|w |Y~obs~ - Y~calc~|^2^| )^1/2^ S = ( ---------------------------- ) ( N~ref~ - N~param~ ) Y~obs~ = the observed coefficients (see _refine.ls_structure_factor_coef) Y~calc~ = the calculated coefficients (see _refine.ls_structure_factor_coef) w = the least-squares reflection weight [1/(e.s.d. squared)] N~ref~ = the number of reflections used in the refinement N~param~ = the number of refined parameters sum is taken over the specified reflections
        Returns:
        FloatColumn

      • getLsGoodnessOfFitObsEsd

        public FloatColumn getLsGoodnessOfFitObsEsd()
        The standard uncertainty (estimated standard deviation) of _refine.ls_goodness_of_fit_obs.
        Returns:
        FloatColumn

      • getLsHydrogenTreatment

        public StrColumn getLsHydrogenTreatment()
        Treatment of hydrogen atoms in the least-squares refinement.
        Returns:
        StrColumn

      • getLsMatrixType

        public StrColumn getLsMatrixType()
        Type of matrix used to accumulate the least-squares derivatives.
        Returns:
        StrColumn

      • getLsNumberConstraints

        public IntColumn getLsNumberConstraints()
        The number of constrained (non-refined or dependent) parameters in the least-squares process. These may be due to symmetry or any other constraint process (e.g. rigid-body refinement). See also _atom_site.constraints and _atom_site.refinement_flags. A general description of constraints may appear in _refine.details.
        Returns:
        IntColumn

      • getLsNumberParameters

        public IntColumn getLsNumberParameters()
        The number of parameters refined in the least-squares process. If possible, this number should include some contribution from the restrained parameters. The restrained parameters are distinct from the constrained parameters (where one or more parameters are linearly dependent on the refined value of another). Least-squares restraints often depend on geometry or energy considerations and this makes their direct contribution to this number, and to the goodness-of-fit calculation, difficult to assess.
        Returns:
        IntColumn

      • getLsNumberReflnsAll

        public IntColumn getLsNumberReflnsAll()
        The number of reflections that satisfy the resolution limits established by _refine.ls_d_res_high and _refine.ls_d_res_low.
        Returns:
        IntColumn

      • getLsNumberReflnsObs

        public IntColumn getLsNumberReflnsObs()
        The number of reflections that satisfy the resolution limits established by _refine.ls_d_res_high and _refine.ls_d_res_low and the observation limit established by _reflns.observed_criterion.
        Returns:
        IntColumn

      • getLsNumberReflnsRFree

        public IntColumn getLsNumberReflnsRFree()
        The number of reflections that satisfy the resolution limits established by _refine.ls_d_res_high and _refine.ls_d_res_low and the observation limit established by _reflns.observed_criterion, and that were used as the test reflections (i.e. were excluded from the refinement) when the refinement included the calculation of a 'free' R factor. Details of how reflections were assigned to the working and test sets are given in _reflns.R_free_details.
        Returns:
        IntColumn

      • getLsNumberReflnsRWork

        public IntColumn getLsNumberReflnsRWork()
        The number of reflections that satisfy the resolution limits established by _refine.ls_d_res_high and _refine.ls_d_res_low and the observation limit established by _reflns.observed_criterion, and that were used as the working reflections (i.e. were included in the refinement) when the refinement included the calculation of a 'free' R factor. Details of how reflections were assigned to the working and test sets are given in _reflns.R_free_details.
        Returns:
        IntColumn

      • getLsNumberRestraints

        public IntColumn getLsNumberRestraints()
        The number of restrained parameters. These are parameters which are not directly dependent on another refined parameter. Restrained parameters often involve geometry or energy dependencies. See also _atom_site.constraints and _atom_site.refinement_flags. A general description of refinement constraints may appear in _refine.details.
        Returns:
        IntColumn

      • getLsPercentReflnsObs

        public FloatColumn getLsPercentReflnsObs()
        The number of reflections that satisfy the resolution limits established by _refine.ls_d_res_high and _refine.ls_d_res_low and the observation limit established by _reflns.observed_criterion, expressed as a percentage of the number of geometrically observable reflections that satisfy the resolution limits.
        Returns:
        FloatColumn

      • getLsPercentReflnsRFree

        public FloatColumn getLsPercentReflnsRFree()
        The number of reflections that satisfy the resolution limits established by _refine.ls_d_res_high and _refine.ls_d_res_low and the observation limit established by _reflns.observed_criterion, and that were used as the test reflections (i.e. were excluded from the refinement) when the refinement included the calculation of a 'free' R factor, expressed as a percentage of the number of geometrically observable reflections that satisfy the resolution limits.
        Returns:
        FloatColumn

      • getLsRFactorAll

        public FloatColumn getLsRFactorAll()
        Residual factor R for all reflections that satisfy the resolution limits established by _refine.ls_d_res_high and _refine.ls_d_res_low. sum|F~obs~ - F~calc~| R = --------------------- sum|F~obs~| F~obs~ = the observed structure-factor amplitudes F~calc~ = the calculated structure-factor amplitudes sum is taken over the specified reflections
        Returns:
        FloatColumn

      • getLsRFactorObs

        public FloatColumn getLsRFactorObs()
        Residual factor R for reflections that satisfy the resolution limits established by _refine.ls_d_res_high and _refine.ls_d_res_low and the observation limit established by _reflns.observed_criterion. _refine.ls_R_factor_obs should not be confused with _refine.ls_R_factor_R_work; the former reports the results of a refinement in which all observed reflections were used, the latter a refinement in which a subset of the observed reflections were excluded from refinement for the calculation of a 'free' R factor. However, it would be meaningful to quote both values if a 'free' R factor were calculated for most of the refinement, but all of the observed reflections were used in the final rounds of refinement; such a protocol should be explained in _refine.details. sum|F~obs~ - F~calc~| R = --------------------- sum|F~obs~| F~obs~ = the observed structure-factor amplitudes F~calc~ = the calculated structure-factor amplitudes sum is taken over the specified reflections
        Returns:
        FloatColumn

      • getLsRFactorRFree

        public FloatColumn getLsRFactorRFree()
        Residual factor R for reflections that satisfy the resolution limits established by _refine.ls_d_res_high and _refine.ls_d_res_low and the observation limit established by _reflns.observed_criterion, and that were used as the test reflections (i.e. were excluded from the refinement) when the refinement included the calculation of a 'free' R factor. Details of how reflections were assigned to the working and test sets are given in _reflns.R_free_details. sum|F~obs~ - F~calc~| R = --------------------- sum|F~obs~| F~obs~ = the observed structure-factor amplitudes F~calc~ = the calculated structure-factor amplitudes sum is taken over the specified reflections
        Returns:
        FloatColumn

      • getLsRFactorRFreeError

        public FloatColumn getLsRFactorRFreeError()
        The estimated error in _refine.ls_R_factor_R_free. The method used to estimate the error is described in the item _refine.ls_R_factor_R_free_error_details.
        Returns:
        FloatColumn

      • getLsRFactorRFreeErrorDetails

        public StrColumn getLsRFactorRFreeErrorDetails()
        Special aspects of the method used to estimated the error in _refine.ls_R_factor_R_free.
        Returns:
        StrColumn

      • getLsRFactorRWork

        public FloatColumn getLsRFactorRWork()
        Residual factor R for reflections that satisfy the resolution limits established by _refine.ls_d_res_high and _refine.ls_d_res_low and the observation limit established by _reflns.observed_criterion, and that were used as the working reflections (i.e. were included in the refinement) when the refinement included the calculation of a 'free' R factor. Details of how reflections were assigned to the working and test sets are given in _reflns.R_free_details. _refine.ls_R_factor_obs should not be confused with _refine.ls_R_factor_R_work; the former reports the results of a refinement in which all observed reflections were used, the latter a refinement in which a subset of the observed reflections were excluded from refinement for the calculation of a 'free' R factor. However, it would be meaningful to quote both values if a 'free' R factor were calculated for most of the refinement, but all of the observed reflections were used in the final rounds of refinement; such a protocol should be explained in _refine.details. sum|F~obs~ - F~calc~| R = --------------------- sum|F~obs~| F~obs~ = the observed structure-factor amplitudes F~calc~ = the calculated structure-factor amplitudes sum is taken over the specified reflections
        Returns:
        FloatColumn

      • getLsRFsqdFactorObs

        public FloatColumn getLsRFsqdFactorObs()
        Residual factor R(Fsqd) for reflections that satisfy the resolution limits established by _refine.ls_d_res_high and _refine.ls_d_res_low and the observation limit established by _reflns.observed_criterion, calculated on the squares of the observed and calculated structure-factor amplitudes. sum|F~obs~^2^ - F~calc~^2^| R(Fsqd) = --------------------------- sum|F~obs~^2^| F~obs~^2^ = squares of the observed structure-factor amplitudes F~calc~^2^ = squares of the calculated structure-factor amplitudes sum is taken over the specified reflections
        Returns:
        FloatColumn

      • getLsRIFactorObs

        public FloatColumn getLsRIFactorObs()
        Residual factor R(I) for reflections that satisfy the resolution limits established by _refine.ls_d_res_high and _refine.ls_d_res_low and the observation limit established by _reflns.observed_criterion, calculated on the estimated reflection intensities. This is most often calculated in Rietveld refinements against powder data, where it is referred to as R~B~ or R~Bragg~. sum|I~obs~ - I~calc~| R(I) = --------------------- sum|I~obs~| I~obs~ = the net observed intensities I~calc~ = the net calculated intensities sum is taken over the specified reflections
        Returns:
        FloatColumn

      • getLsRedundancyReflnsAll

        public FloatColumn getLsRedundancyReflnsAll()
        The ratio of the total number of observations of the reflections that satisfy the resolution limits established by _refine.ls_d_res_high and _refine.ls_d_res_low to the number of crystallographically unique reflections that satisfy the same limits.
        Returns:
        FloatColumn

      • getLsRedundancyReflnsObs

        public FloatColumn getLsRedundancyReflnsObs()
        The ratio of the total number of observations of the reflections that satisfy the resolution limits established by _refine.ls_d_res_high and _refine.ls_d_res_low and the observation limit established by _reflns.observed_criterion to the number of crystallographically unique reflections that satisfy the same limits.
        Returns:
        FloatColumn

      • getLsRestrainedSAll

        public FloatColumn getLsRestrainedSAll()
        The least-squares goodness-of-fit parameter S' for all reflections after the final cycle of least-squares refinement. This parameter explicitly includes the restraints applied in the least-squares process. See also the definition of _refine.ls_goodness_of_fit_all. ( sum |w |Y~obs~ - Y~calc~|^2^| )^1/2^ ( + sum~r~|w~r~ |P~calc~ - P~targ~|^2^| ) S' = ( ------------------------------------- ) ( N~ref~ + N~restr~ - N~param~ ) Y~obs~ = the observed coefficients (see _refine.ls_structure_factor_coef) Y~calc~ = the calculated coefficients (see _refine.ls_structure_factor_coef) w = the least-squares reflection weight [1/(e.s.d. squared)] P~calc~ = the calculated restraint values P~targ~ = the target restraint values w~r~ = the restraint weight N~ref~ = the number of reflections used in the refinement (see _refine.ls_number_reflns_obs) N~restr~ = the number of restraints (see _refine.ls_number_restraints) N~param~ = the number of refined parameters (see _refine.ls_number_parameters) sum is taken over the specified reflections sumr is taken over the restraints
        Returns:
        FloatColumn

      • getLsRestrainedSObs

        public FloatColumn getLsRestrainedSObs()
        The least-squares goodness-of-fit parameter S' for reflection data classified as observed (see _reflns.observed_criterion) after the final cycle of least-squares refinement. This parameter explicitly includes the restraints applied in the least-squares process. See also the definition of _refine.ls_goodness_of_fit_obs. ( sum |w |Y~obs~ - Y~calc~|^2^| )^1/2^ ( + sum~r~|w~r~ |P~calc~ - P~targ~|^2^| ) S' = ( ------------------------------------- ) ( N~ref~ + N~restr~ - N~param~ ) Y~obs~ = the observed coefficients (see _refine.ls_structure_factor_coef) Y~calc~ = the calculated coefficients (see _refine.ls_structure_factor_coef) w = the least-squares reflection weight [1/(e.s.d. squared)] P~calc~ = the calculated restraint values P~targ~ = the target restraint values w~r~ = the restraint weight N~ref~ = the number of reflections used in the refinement (see _refine.ls_number_reflns_obs) N~restr~ = the number of restraints (see _refine.ls_number_restraints) N~param~ = the number of refined parameters (see _refine.ls_number_parameters) sum is taken over the specified reflections sumr is taken over the restraints
        Returns:
        FloatColumn

      • getLsShiftOverEsdMax

        public FloatColumn getLsShiftOverEsdMax()
        The largest ratio of the final least-squares parameter shift to the final standard uncertainty (estimated standard deviation).
        Returns:
        FloatColumn

      • getLsShiftOverEsdMean

        public FloatColumn getLsShiftOverEsdMean()
        The average ratio of the final least-squares parameter shift to the final standard uncertainty (estimated standard deviation).
        Returns:
        FloatColumn

      • getLsStructureFactorCoef

        public StrColumn getLsStructureFactorCoef()
        Structure-factor coefficient |F|, F^2^ or I used in the least- squares refinement process.
        Returns:
        StrColumn

      • getLsWeightingDetails

        public StrColumn getLsWeightingDetails()
        A description of special aspects of the weighting scheme used in least-squares refinement. Used to describe the weighting when the value of _refine.ls_weighting_scheme is specified as 'calc'.
        Returns:
        StrColumn

      • getLsWeightingScheme

        public StrColumn getLsWeightingScheme()
        The weighting scheme applied in the least-squares process. The standard code may be followed by a description of the weight (but see _refine.ls_weighting_details for a preferred approach).
        Returns:
        StrColumn

      • getLsWRFactorAll

        public FloatColumn getLsWRFactorAll()
        Weighted residual factor wR for all reflections that satisfy the resolution limits established by _refine.ls_d_res_high and _refine.ls_d_res_low. ( sum|w |Y~obs~ - Y~calc~|^2^| )^1/2^ wR = ( ---------------------------- ) ( sum|w Y~obs~^2^| ) Y~obs~ = the observed amplitude specified by _refine.ls_structure_factor_coef Y~calc~ = the calculated amplitude specified by _refine.ls_structure_factor_coef w = the least-squares weight sum is taken over the specified reflections
        Returns:
        FloatColumn

      • getLsWRFactorObs

        public FloatColumn getLsWRFactorObs()
        Weighted residual factor wR for reflections that satisfy the resolution limits established by _refine.ls_d_res_high and _refine.ls_d_res_low and the observation limit established by _reflns.observed_criterion. ( sum|w |Y~obs~ - Y~calc~|^2^| )^1/2^ wR = ( ---------------------------- ) ( sum|w Y~obs~^2^| ) Y~obs~ = the observed amplitude specified by _refine.ls_structure_factor_coef Y~calc~ = the calculated amplitude specified by _refine.ls_structure_factor_coef w = the least-squares weight sum is taken over the specified reflections
        Returns:
        FloatColumn

      • getLsWRFactorRFree

        public FloatColumn getLsWRFactorRFree()
        Weighted residual factor wR for reflections that satisfy the resolution limits established by _refine.ls_d_res_high and _refine.ls_d_res_low and the observation limit established by _reflns.observed_criterion, and that were used as the test reflections (i.e. were excluded from the refinement) when the refinement included the calculation of a 'free' R factor. Details of how reflections were assigned to the working and test sets are given in _reflns.R_free_details. ( sum|w |Y~obs~ - Y~calc~|^2^| )^1/2^ wR = ( ---------------------------- ) ( sum|w Y~obs~^2^| ) Y~obs~ = the observed amplitude specified by _refine.ls_structure_factor_coef Y~calc~ = the calculated amplitude specified by _refine.ls_structure_factor_coef w = the least-squares weight sum is taken over the specified reflections
        Returns:
        FloatColumn

      • getLsWRFactorRWork

        public FloatColumn getLsWRFactorRWork()
        Weighted residual factor wR for reflections that satisfy the resolution limits established by _refine.ls_d_res_high and _refine.ls_d_res_low and the observation limit established by _reflns.observed_criterion, and that were used as the working reflections (i.e. were included in the refinement) when the refinement included the calculation of a 'free' R factor. Details of how reflections were assigned to the working and test sets are given in _reflns.R_free_details. ( sum|w |Y~obs~ - Y~calc~|^2^| )^1/2^ wR = ( ---------------------------- ) ( sum|w Y~obs~^2^| ) Y~obs~ = the observed amplitude specified by _refine.ls_structure_factor_coef Y~calc~ = the calculated amplitude specified by _refine.ls_structure_factor_coef w = the least-squares weight sum is taken over the specified reflections
        Returns:
        FloatColumn

      • getOccupancyMax

        public FloatColumn getOccupancyMax()
        The maximum value for occupancy found in the coordinate set.
        Returns:
        FloatColumn

      • getOccupancyMin

        public FloatColumn getOccupancyMin()
        The minimum value for occupancy found in the coordinate set.
        Returns:
        FloatColumn

      • getSolventModelDetails

        public StrColumn getSolventModelDetails()
        Special aspects of the solvent model used during refinement.
        Returns:
        StrColumn

      • getSolventModelParamBsol

        public FloatColumn getSolventModelParamBsol()
        The value of the BSOL solvent-model parameter describing the average isotropic displacement parameter of disordered solvent atoms. This is one of the two parameters (the other is _refine.solvent_model_param_ksol) in Tronrud's method of modelling the contribution of bulk solvent to the scattering. The standard scale factor is modified according to the expression k0 exp(-B0 * s^2^)[1-KSOL * exp(-BSOL * s^2^)] where k0 and B0 are the scale factors for the protein. Ref: Tronrud, D. E. (1997). Methods Enzymol. 277, 243-268.
        Returns:
        FloatColumn

      • getSolventModelParamKsol

        public FloatColumn getSolventModelParamKsol()
        The value of the KSOL solvent-model parameter describing the ratio of the electron density in the bulk solvent to the electron density in the molecular solute. This is one of the two parameters (the other is _refine.solvent_model_param_bsol) in Tronrud's method of modelling the contribution of bulk solvent to the scattering. The standard scale factor is modified according to the expression k0 exp(-B0 * s^2^)[1-KSOL * exp(-BSOL * s^2^)] where k0 and B0 are the scale factors for the protein. Ref: Tronrud, D. E. (1997). Methods Enzymol. 277, 243-268.
        Returns:
        FloatColumn

      • getLsRFactorGt

        public FloatColumn getLsRFactorGt()
        Residual factor for the reflections (with number given by _reflns.number_gt) judged significantly intense (i.e. satisfying the threshold specified by _reflns.threshold_expression) and included in the refinement. The reflections also satisfy the resolution limits established by _refine.ls_d_res_high and _refine.ls_d_res_low. This is the conventional R factor. See also _refine.ls_wR_factor_ definitions. sum | F(obs) - F(calc) | R = ------------------------ sum | F(obs) | F(obs) = the observed structure-factor amplitudes F(calc) = the calculated structure-factor amplitudes and the sum is taken over the specified reflections
        Returns:
        FloatColumn

      • getLsGoodnessOfFitGt

        public FloatColumn getLsGoodnessOfFitGt()
        The least-squares goodness-of-fit parameter S for significantly intense reflections (see _reflns.threshold_expression) after the final cycle of refinement. Ideally, account should be taken of parameters restrained in the least-squares refinement. See also _refine.ls_restrained_S_ definitions. { sum { w [ Y(obs) - Y(calc) ]^2^ } }^1/2^ S = { ----------------------------------- } { Nref - Nparam } Y(obs) = the observed coefficients (see _refine_ls_structure_factor_coef) Y(calc) = the calculated coefficients (see _refine_ls_structure_factor_coef) w = the least-squares reflection weight [1/(u^2^)] u = standard uncertainty Nref = the number of reflections used in the refinement Nparam = the number of refined parameters and the sum is taken over the specified reflections
        Returns:
        FloatColumn

      • getLsGoodnessOfFitRef

        public FloatColumn getLsGoodnessOfFitRef()
        The least-squares goodness-of-fit parameter S for all reflections included in the refinement after the final cycle of refinement. Ideally, account should be taken of parameters restrained in the least-squares refinement. See also _refine_ls_restrained_S_ definitions. { sum | w | Y(obs) - Y(calc) |^2^ | }^1/2^ S = { ----------------------------------- } { Nref - Nparam } Y(obs) = the observed coefficients (see _refine_ls_structure_factor_coef) Y(calc) = the calculated coefficients (see _refine_ls_structure_factor_coef) w = the least-squares reflection weight [1/(u^2^)] u = standard uncertainty Nref = the number of reflections used in the refinement Nparam = the number of refined parameters and the sum is taken over the specified reflections
        Returns:
        FloatColumn

      • getLsShiftOverSuMax

        public FloatColumn getLsShiftOverSuMax()
        The largest ratio of the final least-squares parameter shift to the final standard uncertainty.
        Returns:
        FloatColumn

      • getLsShiftOverSuMaxLt

        public FloatColumn getLsShiftOverSuMaxLt()
        An upper limit for the largest ratio of the final least-squares parameter shift to the final standard uncertainty. This item is used when the largest value of the shift divided by the final standard uncertainty is too small to measure.
        Returns:
        FloatColumn

      • getLsShiftOverSuMean

        public FloatColumn getLsShiftOverSuMean()
        The average ratio of the final least-squares parameter shift to the final standard uncertainty.
        Returns:
        FloatColumn

      • getLsShiftOverSuMeanLt

        public FloatColumn getLsShiftOverSuMeanLt()
        An upper limit for the average ratio of the final least-squares parameter shift to the final standard uncertainty. This item is used when the average value of the shift divided by the final standard uncertainty is too small to measure.
        Returns:
        FloatColumn

      • getPdbxLsSigmaI

        public FloatColumn getPdbxLsSigmaI()
        Data cutoff (SIGMA(I))
        Returns:
        FloatColumn

      • getPdbxLsSigmaF

        public FloatColumn getPdbxLsSigmaF()
        Data cutoff (SIGMA(F))
        Returns:
        FloatColumn

      • getPdbxLsSigmaFsqd

        public FloatColumn getPdbxLsSigmaFsqd()
        Data cutoff (SIGMA(F^2))
        Returns:
        FloatColumn

      • getPdbxDataCutoffHighAbsF

        public FloatColumn getPdbxDataCutoffHighAbsF()
        Value of F at "high end" of data cutoff.
        Returns:
        FloatColumn

      • getPdbxDataCutoffHighRmsAbsF

        public FloatColumn getPdbxDataCutoffHighRmsAbsF()
        Value of RMS |F| used as high data cutoff.
        Returns:
        FloatColumn

      • getPdbxDataCutoffLowAbsF

        public FloatColumn getPdbxDataCutoffLowAbsF()
        Value of F at "low end" of data cutoff.
        Returns:
        FloatColumn

      • getPdbxIsotropicThermalModel

        public StrColumn getPdbxIsotropicThermalModel()
        Whether the structure was refined with indvidual isotropic, anisotropic or overall temperature factor.
        Returns:
        StrColumn

      • getPdbxLsCrossValidMethod

        public StrColumn getPdbxLsCrossValidMethod()
        Whether the cross validataion method was used through out or only at the end.
        Returns:
        StrColumn

      • getPdbxMethodToDetermineStruct

        public StrColumn getPdbxMethodToDetermineStruct()
        Method(s) used to determine the structure.
        Returns:
        StrColumn

      • getPdbxStartingModel

        public StrColumn getPdbxStartingModel()
        Starting model for refinement. Starting model for molecular replacement should refer to a previous structure or experiment.
        Returns:
        StrColumn

      • getPdbxStereochemistryTargetValues

        public StrColumn getPdbxStereochemistryTargetValues()
        Stereochemistry target values used in refinement.
        Returns:
        StrColumn

      • getPdbxRFreeSelectionDetails

        public StrColumn getPdbxRFreeSelectionDetails()
        Details of the manner in which the cross validation reflections were selected.
        Returns:
        StrColumn

      • getPdbxStereochemTargetValSpecCase

        public StrColumn getPdbxStereochemTargetValSpecCase()
        Special case of stereochemistry target values used in SHELXL refinement.
        Returns:
        StrColumn

      • getPdbxOverallESUR

        public FloatColumn getPdbxOverallESUR()
        Overall estimated standard uncertainties of positional parameters based on R value.
        Returns:
        FloatColumn

      • getPdbxOverallESURFree

        public FloatColumn getPdbxOverallESURFree()
        Overall estimated standard uncertainties of positional parameters based on R free value.
        Returns:
        FloatColumn

      • getPdbxSolventVdwProbeRadii

        public FloatColumn getPdbxSolventVdwProbeRadii()
        For bulk solvent mask calculation, the value by which the vdw radii of non-ion atoms (like carbon) are increased and used.
        Returns:
        FloatColumn

      • getPdbxSolventIonProbeRadii

        public FloatColumn getPdbxSolventIonProbeRadii()
        For bulk solvent mask calculation, the amount that the ionic radii of atoms, which can be ions, are increased used.
        Returns:
        FloatColumn

      • getPdbxSolventShrinkageRadii

        public FloatColumn getPdbxSolventShrinkageRadii()
        For bulk solvent mask calculation, amount mask is shrunk after taking away atoms with new radii and a constant value assigned to this new region.
        Returns:
        FloatColumn

      • getPdbxRealSpaceR

        public FloatColumn getPdbxRealSpaceR()
        Real space R factor of electron density for all atoms. The real space R factor is calculated by the equation R_real = [Sum~i (|Dobs - Dcal|)]/[Sum~i (|Dobs + Dcal|)] Where: Dobs is the observed electron density, Dcal is the calculated electron density, summation is for all the grid points Ref: Branden, C.I. & Jones, T.A. (1990). Nature, 343, 687-689
        Returns:
        FloatColumn

      • getPdbxDensityCorrelation

        public FloatColumn getPdbxDensityCorrelation()
        The density correlation coefficient is calculated from atomic densities of (2Fobs-Fcalc) map - "Robs" and the model map (Fcalc) - "Rcalc" : D_corr = <Robs><Rcalc>/sqrt(<Robs**2><Rcalc**2>) where <Robs> is the mean of "observed" densities of all atoms <Rcalc> is the mean of "calculated" densities of all atoms. The value of density for some atom from map R(x) is: sum_i ( R(xi) * Ratom(xi - xa) ) Dens = ---------------------------------- sum_i ( Ratom(xi - xa) ) where Ratom(x) is atomic electron density for the x-th grid point. xa - vector of the centre of atom. xi - vector of the i-th point of grid. Sum is taken over all grid points which have distance from the center of the atom less than the Radius_limit. For all atoms Radius_limit = 2.5 A. Ref: Vaguine, A.A., Richelle, J. & Wodak, S.J. (1999). Acta Cryst. D55,199-205
        Returns:
        FloatColumn

      • getPdbxPdNumberOfPowderPatterns

        public IntColumn getPdbxPdNumberOfPowderPatterns()
        The total number of powder patterns used.
        Returns:
        IntColumn

      • getPdbxPdNumberOfPoints

        public IntColumn getPdbxPdNumberOfPoints()
        The total number of data points in the processed diffractogram.
        Returns:
        IntColumn

      • getPdbxPdMeasNumberOfPoints

        public IntColumn getPdbxPdMeasNumberOfPoints()
        The total number of points in the measured diffractogram.
        Returns:
        IntColumn

      • getPdbxPdProcLsProfRFactor

        public FloatColumn getPdbxPdProcLsProfRFactor()
        Rietveld/Profile fit R factors. Note that the R factor computed for Rietveld refinements using the extracted reflection intensity values (often called the Rietveld or Bragg R factor, R~B~) is not properly a profile R factor. pdbx_pd_proc_ls_prof_R_factor, often called R~p~, is an unweighted fitness metric for the agreement between the observed and computed diffraction patterns R~p~ = sum~i~ | I~obs~(i) - I~calc~(i) | / sum~i~ ( I~obs~(i) ) Note that in the above equations, w(i) is the weight for the ith data point I~obs~(i) is the observed intensity for the ith data point, sometimes referred to as y~i~(obs) or y~oi~. I~calc~(i) is the computed intensity for the ith data point with background and other corrections applied to match the scale of the observed dataset, sometimes referred to as y~i~(calc) or y~ci~. n is the total number of data points (see _refine.pdbx_pd_number_of_points) less the number of data points excluded from the refinement. p is the total number of refined parameters.
        Returns:
        FloatColumn

      • getPdbxPdProcLsProfWRFactor

        public FloatColumn getPdbxPdProcLsProfWRFactor()
        Rietveld/Profile fit R factors. Note that the R factor computed for Rietveld refinements using the extracted reflection intensity values (often called the Rietveld or Bragg R factor, R~B~) is not properly a profile R factor. pdbx_pd_proc_ls_prof_wR_factor often called R~wp~, is a weighted fitness metric for the agreement between the observed and computed diffraction patterns R~wp~ = SQRT { sum~i~ ( w(i) [ I~obs~(i) - I~calc~(i) ]^2^ ) / sum~i~ ( w(i) [I~obs~(i)]^2^ ) } Note that in the above equations, w(i) is the weight for the ith data point I~obs~(i) is the observed intensity for the ith data point, sometimes referred to as y~i~(obs) or y~oi~. I~calc~(i) is the computed intensity for the ith data point with background and other corrections applied to match the scale of the observed dataset, sometimes referred to as y~i~(calc) or y~ci~. n is the total number of data points (see _refine.pdbx_pd_number_of_points) less the number of data points excluded from the refinement. p is the total number of refined parameters.
        Returns:
        FloatColumn

      • getPdbxPdMarquardtCorrelationCoeff

        public FloatColumn getPdbxPdMarquardtCorrelationCoeff()
        The correlation coefficient between the observed and calculated structure factors for reflections included in the refinement. This correlation factor is found in the fitting using the Levenberg-Marquardt algorithm to search for the minimum value of chisquare. Almost all computer codes for Rietveld refinement employ the Gauss-Newton algorithm to find parameters which minimize the weighted sum of squares of the residuals. A description of the equations is given on http://www.water.hut.fi/~tkarvone/fr_org_s.htm
        Returns:
        FloatColumn

      • getPdbxPdFsqrdRFactor

        public FloatColumn getPdbxPdFsqrdRFactor()
        Residual factor R for reflections that satisfy the resolution limits established by _refine.ls_d_res_high and _refine.ls_d_res_low and the observation limit established by _reflns.observed_criterion. sum|F~obs~**2 - F~calc~**2| R = --------------------- sum|F~obs~**2| F~obs~ = the observed structure-factor amplitudes F~calc~ = the calculated structure-factor amplitudes sum is taken over the specified reflections
        Returns:
        FloatColumn

      • getPdbxPdLsMatrixBandWidth

        public IntColumn getPdbxPdLsMatrixBandWidth()
        The least squares refinement "band matrix" approximation to the full matrix.
        Returns:
        IntColumn

      • getPdbxOverallPhaseError

        public FloatColumn getPdbxOverallPhaseError()
        The overall phase error for all reflections after refinement using the current refinement target.
        Returns:
        FloatColumn

      • getPdbxOverallSURFreeCruickshankDPI

        public FloatColumn getPdbxOverallSURFreeCruickshankDPI()
        The overall standard uncertainty (estimated standard deviation) of the displacement parameters based on the crystallographic R-free value, expressed in a formalism known as the dispersion precision indicator (DPI). Ref: Cruickshank, D. W. J. (1999). Acta Cryst. D55, 583-601.
        Returns:
        FloatColumn

      • getPdbxOverallSURFreeBlowDPI

        public FloatColumn getPdbxOverallSURFreeBlowDPI()
        The overall standard uncertainty (estimated standard deviation) of the displacement parameters based on the crystallographic R-free value, expressed in a formalism known as the dispersion precision indicator (DPI). Ref: Blow, D (2002) Acta Cryst. D58, 792-797
        Returns:
        FloatColumn

      • getPdbxOverallSURBlowDPI

        public FloatColumn getPdbxOverallSURBlowDPI()
        The overall standard uncertainty (estimated standard deviation) of the displacement parameters based on the crystallographic R value, expressed in a formalism known as the dispersion precision indicator (DPI). Ref: Blow, D (2002) Acta Cryst. D58, 792-797
        Returns:
        FloatColumn

      • getPdbxTLSResidualADPFlag

        public StrColumn getPdbxTLSResidualADPFlag()
        A flag for TLS refinements identifying the type of atomic displacement parameters stored in _atom_site.B_iso_or_equiv.
        Returns:
        StrColumn

      • getPdbxDiffrnId

        public StrColumn getPdbxDiffrnId()
        An identifier for the diffraction data set used in this refinement. Multiple diffraction data sets specified as a comma separated list.
        Returns:
        StrColumn

      • getOverallSUB

        public FloatColumn getOverallSUB()
        The overall standard uncertainty (estimated standard deviation) of the displacement parameters based on a maximum-likelihood residual. The overall standard uncertainty (sigma~B~)^2^ gives an idea of the uncertainty in the B values of averagely defined atoms (atoms with B values equal to the average B value). N~a~ (sigma~B~)^2^ = 8 ---------------------------------------------- sum~i~ {[1/Sigma - (E~o~)^2^ (1-m^2^)](SUM_AS)s^4^} N~a~ = number of atoms E~o~ = normalized structure factors m = figure of merit of phases of reflections included in the summation s = reciprocal-space vector SUM_AS = (sigma~A~)^2^/Sigma^2^ Sigma = (sigma~{E;exp}~)^2^ + epsilon [1-(sigma~A~)^2^] sigma~{E;exp}~ = experimental uncertainties of normalized structure factors sigma~A~ = <cos 2 pi s delta~x~> SQRT(Sigma~P~/Sigma~N~) estimated using maximum likelihood Sigma~P~ = sum~{atoms in model}~ f^2^ Sigma~N~ = sum~{atoms in crystal}~ f^2^ f = atom form factor delta~x~ = expected error epsilon = multiplicity of diffracting plane summation is over all reflections included in refinement Ref: (sigma~A~ estimation) "Refinement of macromolecular structures by the maximum-likelihood method", Murshudov, G. N., Vagin, A. A. & Dodson, E. J. (1997). Acta Cryst. D53, 240-255. (SU B estimation) Murshudov, G. N. & Dodson, E. J. (1997). Simplified error estimation a la Cruickshank in macromolecular crystallography. CCP4 Newsletter on Protein Crystallography, No. 33, January 1997, pp. 31-39. http://www.ccp4.ac.uk/newsletters/newsletter33/murshudov.html
        Returns:
        FloatColumn

      • getOverallSUML

        public FloatColumn getOverallSUML()
        The overall standard uncertainty (estimated standard deviation) of the positional parameters based on a maximum likelihood residual. The overall standard uncertainty (sigma~X~)^2^ gives an idea of the uncertainty in the position of averagely defined atoms (atoms with B values equal to average B value) 3 N~a~ (sigma~X~)^2^ = --------------------------------------------------------- 8 pi^2^ sum~i~ {[1/Sigma - (E~o~)^2^ (1-m^2^)](SUM_AS)s^2^} N~a~ = number of atoms E~o~ = normalized structure factors m = figure of merit of phases of reflections included in the summation s = reciprocal-space vector SUM_AS = (sigma~A~)^2^/Sigma^2^ Sigma = (sigma~{E;exp}~)^2^ + epsilon [1-(sigma~A~)^2^] sigma~{E;exp}~ = experimental uncertainties of normalized structure factors sigma~A~ = <cos 2 pi s delta~x~> SQRT(Sigma~P~/Sigma~N~) estimated using maximum likelihood Sigma~P~ = sum~{atoms in model}~ f^2^ Sigma~N~ = sum~{atoms in crystal}~ f^2^ f = atom form factor delta~x~ = expected error epsilon = multiplicity of diffracting plane summation is over all reflections included in refinement Ref: (sigma_A estimation) "Refinement of macromolecular structures by the maximum-likelihood method", Murshudov, G. N., Vagin, A. A. & Dodson, E. J. (1997). Acta Cryst. D53, 240-255. (SU ML estimation) Murshudov, G. N. & Dodson, E. J. (1997). Simplified error estimation a la Cruickshank in macromolecular crystallography. CCP4 Newsletter on Protein Crystallography, No. 33, January 1997, pp. 31-39. http://www.ccp4.ac.uk/newsletters/newsletter33/murshudov.html
        Returns:
        FloatColumn

      • getOverallSURCruickshankDPI

        public FloatColumn getOverallSURCruickshankDPI()
        The overall standard uncertainty (estimated standard deviation) of the displacement parameters based on the crystallographic R value, expressed in a formalism known as the dispersion precision indicator (DPI). The overall standard uncertainty (sigma~B~) gives an idea of the uncertainty in the B values of averagely defined atoms (atoms with B values equal to the average B value). N~a~ (sigma~B~)^2^ = 0.65 ---------- (R~value~)^2^ (D~min~)^2^ C^-2/3^ (N~o~-N~p~) N~a~ = number of atoms included in refinement N~o~ = number of observations N~p~ = number of parameters refined R~value~ = conventional crystallographic R value D~min~ = maximum resolution C = completeness of data Ref: Cruickshank, D. W. J. (1999). Acta Cryst. D55, 583-601. Murshudov, G. N. & Dodson, E. J. (1997). Simplified error estimation a la Cruickshank in macromolecular crystallography. CCP4 Newsletter on Protein Crystallography, No. 33, January 1997, pp. 31-39. http://www.ccp4.ac.uk/newsletters/newsletter33/murshudov.html
        Returns:
        FloatColumn

      • getOverallSURFree

        public FloatColumn getOverallSURFree()
        The overall standard uncertainty (estimated standard deviation) of the displacement parameters based on the free R value. The overall standard uncertainty (sigma~B~) gives an idea of the uncertainty in the B values of averagely defined atoms (atoms with B values equal to the average B value). N~a~ (sigma~B~)^2^ = 0.65 ---------- (R~free~)^2^ (D~min~)^2^ C^-2/3^ (N~o~-N~p~) N~a~ = number of atoms included in refinement N~o~ = number of observations N~p~ = number of parameters refined R~free~ = conventional free crystallographic R value calculated using reflections not included in refinement D~min~ = maximum resolution C = completeness of data Ref: Cruickshank, D. W. J. (1999). Acta Cryst. D55, 583-601. Murshudov, G. N. & Dodson, E. J. (1997). Simplified error estimation a la Cruickshank in macromolecular crystallography. CCP4 Newsletter on Protein Crystallography, No. 33, January 1997, pp. 31-39. http://www.ccp4.ac.uk/newsletters/newsletter33/murshudov.html
        Returns:
        FloatColumn

      • getOverallFOMFreeRSet

        public FloatColumn getOverallFOMFreeRSet()
        Average figure of merit of phases of reflections not included in the refinement. This value is derived from the likelihood function. FOM = I~1~(X)/I~0~(X) I~0~, I~1~ = zero- and first-order modified Bessel functions of the first kind X = sigma~A~ |E~o~| |E~c~|/SIGMA E~o~, E~c~ = normalized observed and calculated structure factors sigma~A~ = <cos 2 pi s delta~x~> SQRT(Sigma~P~/Sigma~N~) estimated using maximum likelihood Sigma~P~ = sum~{atoms in model}~ f^2^ Sigma~N~ = sum~{atoms in crystal}~ f^2^ f = form factor of atoms delta~x~ = expected error SIGMA = (sigma~{E;exp}~)^2^ + epsilon [1-(sigma~A~)^2^] sigma~{E;exp}~ = uncertainties of normalized observed structure factors epsilon = multiplicity of the diffracting plane Ref: Murshudov, G. N., Vagin, A. A. & Dodson, E. J. (1997). Acta Cryst. D53, 240-255.
        Returns:
        FloatColumn

      • getOverallFOMWorkRSet

        public FloatColumn getOverallFOMWorkRSet()
        Average figure of merit of phases of reflections included in the refinement. This value is derived from the likelihood function. FOM = I~1~(X)/I~0~(X) I~0~, I~1~ = zero- and first-order modified Bessel functions of the first kind X = sigma~A~ |E~o~| |E~c~|/SIGMA E~o~, E~c~ = normalized observed and calculated structure factors sigma~A~ = <cos 2 pi s delta~x~> SQRT(Sigma~P~/Sigma~N~) estimated using maximum likelihood Sigma~P~ = sum~{atoms in model}~ f^2^ Sigma~N~ = sum~{atoms in crystal}~ f^2^ f = form factor of atoms delta~x~ = expected error SIGMA = (sigma~{E;exp}~)^2^ + epsilon [1-(sigma~A~)^2^] sigma~{E;exp}~ = uncertainties of normalized observed structure factors epsilon = multiplicity of the diffracting plane Ref: Murshudov, G. N., Vagin, A. A. & Dodson, E. J. (1997). Acta Cryst. D53, 240-255.
        Returns:
        FloatColumn

      • getPdbxAverageFscOverall

        public FloatColumn getPdbxAverageFscOverall()
        Overall average Fourier Shell Correlation (avgFSC) between model and observed structure factors for all reflections. The average FSC is a measure of the agreement between observed and calculated structure factors. sum(N~i~ FSC~i~) avgFSC = ---------------- sum(N~i~) N~i~ = the number of all reflections in the resolution shell i FSC~i~ = FSC for all reflections in the i-th resolution shell calculated as: (sum(|F~o~| |F~c~| fom cos(phi~c~-phi~o~))) FSC~i~ = ------------------------------------------- (sum(|F~o~|^2^) (sum(|F~c~|^2^)))^1/2^ |F~o~| = amplitude of observed structure factor |F~c~| = amplitude of calculated structure factor phi~o~ = phase of observed structure factor phi~c~ = phase of calculated structure factor fom = figure of merit of the experimental phases. Summation of FSC~i~ is carried over all reflections in the resolution shell. Summation of avgFSC is carried over all resolution shells. Ref: Rosenthal P.B., Henderson R. "Optimal determination of particle orientation, absolute hand, and contrast loss in single-particle electron cryomicroscopy. Journal of Molecular Biology. 2003;333(4):721-745, equation (A6).
        Returns:
        FloatColumn

      • getPdbxAverageFscWork

        public FloatColumn getPdbxAverageFscWork()
        Average Fourier Shell Correlation (avgFSC) between model and observed structure factors for reflections included in refinement. The average FSC is a measure of the agreement between observed and calculated structure factors. sum(N~i~ FSC~work-i~) avgFSC~work~ = --------------------- sum(N~i~) N~i~ = the number of working reflections in the resolution shell i FSC~work-i~ = FSC for working reflections in the i-th resolution shell calculated as: (sum(|F~o~| |F~c~| fom cos(phi~c~-phi~o~))) FSC~work-i~ = ------------------------------------------- (sum(|F~o~|^2^) (sum(|F~c~|^2^)))^1/2^ |F~o~| = amplitude of observed structure factor |F~c~| = amplitude of calculated structure factor phi~o~ = phase of observed structure factor phi~c~ = phase of calculated structure factor fom = figure of merit of the experimental phases. Summation of FSC~work-i~ is carried over all working reflections in the resolution shell. Summation of avgFSC~work~ is carried over all resolution shells. Ref: Rosenthal P.B., Henderson R. "Optimal determination of particle orientation, absolute hand, and contrast loss in single-particle electron cryomicroscopy. Journal of Molecular Biology. 2003;333(4):721-745, equation (A6).
        Returns:
        FloatColumn

      • getPdbxAverageFscFree

        public FloatColumn getPdbxAverageFscFree()
        Average Fourier Shell Correlation (avgFSC) between model and observed structure factors for reflections not included in refinement. The average FSC is a measure of the agreement between observed and calculated structure factors. sum(N~i~ FSC~free-i~) avgFSC~free~ = --------------------- sum(N~i~) N~i~ = the number of free reflections in the resolution shell i FSC~free-i~ = FSC for free reflections in the i-th resolution shell calculated as: (sum(|F~o~| |F~c~| fom cos(phi~c~-phi~o~))) FSC~free-i~ = ------------------------------------------- (sum(|F~o~|^2^) (sum(|F~c~|^2^)))^1/2^ |F~o~| = amplitude of observed structure factor |F~c~| = amplitude of calculated structure factor phi~o~ = phase of observed structure factor phi~c~ = phase of calculated structure factor fom = figure of merit of the experimental phases. Summation of FSC~free-i~ is carried over all free reflections in the resolution shell. Summation of avgFSC~free~ is carried over all resolution shells. Ref: Rosenthal P.B., Henderson R. "Optimal determination of particle orientation, absolute hand, and contrast loss in single-particle electron cryomicroscopy. Journal of Molecular Biology. 2003;333(4):721-745, equation (A6).
        Returns:
        FloatColumn

      • getPdbxOverallESUB

        public FloatColumn getPdbxOverallESUB()
        Overall estimated standard uncertainties of thermal parameters based on Maximum likelihood residual. Overall ESU gives an idea about uncertainties of B-values of averagely defined atoms (atoms with B-values equal to average B-value) N_a (sigma_B)^2 = 8 ---------------------------------------------- sum~i~ {(1/Sigma - (E_o)^2 (1-m^2)(SUM_AS)s^4} SUM_AS = (sigma_A)^2/Sigma^2) N_a = number of atoms Sigma = (sigma_{E;exp})^2 + epsilon (1-{sigma_A)^2) E_o = normalized structure factors sigma_{E;exp} = experimental uncertainties of normalized structure factors sigma_A = <cos 2 pi s delta_x> SQRT(Sigma_P/Sigma_N) estimated using maximum likelihood Sigma_P = sum_{atoms in model} f^2 Sigma_N = sum_{atoms in crystal} f^2 f = is form factor of atoms delta_x = expected error m = is figure of merit of phases of reflection included in summation delta_x expected error s = reciprocal space vector epsilon = multiplicity of diffracting plane summation is over all reflections included in refinement Reference for sigma_A estimation: "Refinement of Macromolecular Structures by the Maximum-Likelihood Method:" G.N. Murshudov, A.A.Vagin and E.J.Dodson,(1997) Acta Crystallogr. D53, 240-255 Reference for ESU_ML estimation: "Simplified error estimation a la Cruickshank in macromolecular crystallography", Murshudov G.N. & Dodson E.J. in the "CCP4 Newsletter on protein crystallography" Number 33 ed. M.Winn
        Returns:
        FloatColumn

      • getPdbxOverallESUML

        public FloatColumn getPdbxOverallESUML()
        Overall estimated standard uncertainties of positional parameters based on Maximum likelihood residual. Overall ESU gives an idea about uncertainties in the position of averagely defined atoms (atoms with B-values equal to average B-value) 3 N_a (sigma_X)^2 = ----------------------------------------------------- 8 pi^2 sum~i~ {(1/Sigma - (E_o)^2 (1-m^2)(SUM_AS)s^2} SUM_AS = (sigma_A)^2/Sigma^2) N_a = number of atoms Sigma = (sigma_{E;exp})^2 + epsilon (1-{sigma_A)^2) E_o = normalized structure factors sigma_{E;exp} = experimental uncertainties of normalized structure factors sigma_A = <cos 2 pi s delta_x> SQRT(Sigma_P/Sigma_N) estimated using maximum likelihood Sigma_P = sum_{atoms in model} f^2 Sigma_N = sum_{atoms in crystal} f^2 f = is formfactor of atoms delta_x = expected error m = is figure of merit of phases of reflection included in summation delta_x expected error s = reciprocal space vector epsilon = multiplicity of diffracting plane summation is over all reflections included in refinement Reference for sigma_A estimation: "Refinement of Macromolecular Structures by the Maximum-Likelihood Method:" G.N. Murshudov, A.A.Vagin and E.J.Dodson,(1997) Acta Crystallogr. D53, 240-255 Reference for ESU_ML estimation: Simplified error estimation a la Cruickshank in macromolecular crystallograpy Murshudov G.N. & Dodson E.J. in the "CCP4 Newsletter on protein crystallography" Number 33 ed. M.Winn
        Returns:
        FloatColumn