Package org.rcsb.cif.schema.mm

Class Refine

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

  • Constructor Details

  • Method Details

    • createDelegate

      protected Column createDelegate​(String columnName, Column column)
      Overrides:
      createDelegate in class DelegatingCategory

    • 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

    • getPdbxRComplete

      public FloatColumn getPdbxRComplete()
      The crystallographic reliability index Rcomplete 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 Ref: Luebben, J., Gruene, T., (2015). Proc.Nat.Acad.Sci. 112(29) 8999-9003
      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