Package org.rcsb.cif.schema.core

Class Refine

java.lang.Object
org.rcsb.cif.schema.DelegatingCategory.DelegatingCifCoreCategory
org.rcsb.cif.schema.core.Refine
All Implemented Interfaces:
Category
@Generated("org.rcsb.cif.schema.generator.SchemaGenerator")
public class Refine
extends DelegatingCategory.DelegatingCifCoreCategory
The CATEGORY of data items used to specify information about the refinement of the structural model.

  • Constructor Details

  • Method Details

    • getDetails

      public StrColumn getDetails()
      Details of the refinement not specified by other data items.
      Returns:
      StrColumn

    • getSpecialDetails

      public StrColumn getSpecialDetails()
      Details of the refinement not specified by other data items.
      Returns:
      StrColumn

    • getDiffDensityMax

      public FloatColumn getDiffDensityMax()
      Maximum density value in a difference Fourier map.
      Returns:
      FloatColumn

    • getDensityMax

      public FloatColumn getDensityMax()
      Maximum density value in a difference Fourier map.
      Returns:
      FloatColumn

    • getDiffDensityMaxEsd

      public FloatColumn getDiffDensityMaxEsd()
      Standard Uncertainty of the Maximum density value in a difference Fourier map.
      Returns:
      FloatColumn

    • getDensityMaxSu

      public FloatColumn getDensityMaxSu()
      Standard Uncertainty of the Maximum density value in a difference Fourier map.
      Returns:
      FloatColumn

    • getDiffDensityMin

      public FloatColumn getDiffDensityMin()
      Miniumum density value in a difference Fourier map.
      Returns:
      FloatColumn

    • getDensityMin

      public FloatColumn getDensityMin()
      Miniumum density value in a difference Fourier map.
      Returns:
      FloatColumn

    • getDiffDensityMinEsd

      public FloatColumn getDiffDensityMinEsd()
      Standard Uncertainty of the Miniumum density value in a difference Fourier map.
      Returns:
      FloatColumn

    • getDensityMinSu

      public FloatColumn getDensityMinSu()
      Standard Uncertainty of the Miniumum density value in a difference Fourier map.
      Returns:
      FloatColumn

    • getDiffDensityRms

      public FloatColumn getDiffDensityRms()
      Root mean square density value in a 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 *_min and *_max values, and also for defining suitable contour levels.
      Returns:
      FloatColumn

    • getDensityRms

      public FloatColumn getDensityRms()
      Root mean square density value in a 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 *_min and *_max values, and also for defining suitable contour levels.
      Returns:
      FloatColumn

    • getDiffDensityRmsEsd

      public FloatColumn getDiffDensityRmsEsd()
      Standard Uncertainty of the Root mean square density value in a difference Fourier map.
      Returns:
      FloatColumn

    • getDensityRmsSu

      public FloatColumn getDensityRmsSu()
      Standard Uncertainty of the Root mean square density value in a difference Fourier map.
      Returns:
      FloatColumn

    • getLsAbsStructureDetails

      public StrColumn getLsAbsStructureDetails()
      Details on the absolute structure and how it was determined.
      Returns:
      StrColumn

    • getAbsStructureDetails

      public StrColumn getAbsStructureDetails()
      Details on the absolute structure and how it was determined.
      Returns:
      StrColumn

    • getLsAbsStructureFlack

      public FloatColumn getLsAbsStructureFlack()
      The measure of absolute structure 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 (e.s.d.) u must be supplied. The _enumeration.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

    • getAbsStructureFlack

      public FloatColumn getAbsStructureFlack()
      The measure of absolute structure 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 (e.s.d.) u must be supplied. The _enumeration.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()
      Standard Uncertainty of the The measure of absolute structure as defined by Flack (1983).
      Returns:
      FloatColumn

    • getAbsStructureFlackSu

      public FloatColumn getAbsStructureFlackSu()
      Standard Uncertainty of the The measure of absolute structure as defined by Flack (1983).
      Returns:
      FloatColumn

    • getLsAbsStructureRogers

      public FloatColumn getLsAbsStructureRogers()
      The measure of absolute structure as defined by Rogers (1981). The value must lie in the 99.97% Gaussian confidence interval -1 -3u =< \h =< 1 + 3u and a standard uncertainty (e.s.d.) u must be supplied. The _enumeration.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

    • getAbsStructureRogers

      public FloatColumn getAbsStructureRogers()
      The measure of absolute structure as defined by Rogers (1981). The value must lie in the 99.97% Gaussian confidence interval -1 -3u =< \h =< 1 + 3u and a standard uncertainty (e.s.d.) u must be supplied. The _enumeration.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()
      Standard Uncertainty of the The measure of absolute structure as defined by Rogers (1981).
      Returns:
      FloatColumn

    • getAbsStructureRogersSu

      public FloatColumn getAbsStructureRogersSu()
      Standard Uncertainty of the The measure of absolute structure as defined by Rogers (1981).
      Returns:
      FloatColumn

    • getLsDResHigh

      public FloatColumn getLsDResHigh()
      Highest resolution for the reflections used in refinement. This corresponds to the smallest interpanar d value.
      Returns:
      FloatColumn

    • getDResHigh

      public FloatColumn getDResHigh()
      Highest resolution for the reflections used in refinement. This corresponds to the smallest interpanar d value.
      Returns:
      FloatColumn

    • getLsDResLow

      public FloatColumn getLsDResLow()
      Lowest resolution for the reflections used in refinement. This corresponds to the largest interpanar d value.
      Returns:
      FloatColumn

    • getDResLow

      public FloatColumn getDResLow()
      Lowest resolution for the reflections used in refinement. This corresponds to the largest interpanar d value.
      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. 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-147, 148-153. Zachariasen, W. H. (1967). Acta Cryst. 23, 558-564. Larson, A. C. (1967). Acta Cryst. 23, 664-665.
      Returns:
      FloatColumn

    • getExtinctionCoef

      public FloatColumn getExtinctionCoef()
      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. 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-147, 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()
      Standard Uncertainty of the extinction coefficient
      Returns:
      FloatColumn

    • getExtinctionCoefSu

      public FloatColumn getExtinctionCoefSu()
      Standard Uncertainty of the extinction coefficient
      Returns:
      FloatColumn

    • getLsExtinctionExpression

      public StrColumn getLsExtinctionExpression()
      Description of or reference to the extinction-correction equation used to apply the data item _refine_ls.extinction_coef. This information should be sufficient to reproduce the extinction- correction factors applied to the structure factors.
      Returns:
      StrColumn

    • getExtinctionExpression

      public StrColumn getExtinctionExpression()
      Description of or reference to the extinction-correction equation used to apply the data item _refine_ls.extinction_coef. This information should be sufficient to reproduce the extinction- correction factors applied to the structure factors.
      Returns:
      StrColumn

    • getLsExtinctionMethod

      public StrColumn getLsExtinctionMethod()
      Description of the extinction correction method applied with the data item _refine_ls.extinction_coef. 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 are 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 the _refine_ls.extinction_coef and must be listed in _refine.special_details. Ref: Becker, P. J. & Coppens, P. (1974). Acta Cryst. A30, 129-153. Zachariasen, W. H. (1967). Acta Cryst. 23, 558-564. Larson, A. C. (1967). Acta Cryst. 23, 664-665.
      Returns:
      StrColumn

    • getExtinctionMethod

      public StrColumn getExtinctionMethod()
      Description of the extinction correction method applied with the data item _refine_ls.extinction_coef. 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 are 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 the _refine_ls.extinction_coef and must be listed in _refine.special_details. Ref: Becker, P. J. & Coppens, P. (1974). Acta Cryst. A30, 129-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()
      Least-squares goodness-of-fit parameter S for all reflections after the final cycle of refinement. Ideally, account should be taken of parameters restrained in the least squares. { sum { w [ Y(meas) - Y(calc) ]^2^ } }^1/2^ S = { ------------------------------------ } { Nref - Nparam } Y(meas) = the measured 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

    • getGoodnessOfFitAll

      public FloatColumn getGoodnessOfFitAll()
      Least-squares goodness-of-fit parameter S for all reflections after the final cycle of refinement. Ideally, account should be taken of parameters restrained in the least squares. { sum { w [ Y(meas) - Y(calc) ]^2^ } }^1/2^ S = { ------------------------------------ } { Nref - Nparam } Y(meas) = the measured 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

    • getLsGoodnessOfFitAllEsd

      public FloatColumn getLsGoodnessOfFitAllEsd()
      Standard Uncertainty of the Least-squares goodness-of-fit parameter S for all reflections after the final cycle of refinement.
      Returns:
      FloatColumn

    • getGoodnessOfFitAllSu

      public FloatColumn getGoodnessOfFitAllSu()
      Standard Uncertainty of the Least-squares goodness-of-fit parameter S for all reflections after the final cycle of refinement.
      Returns:
      FloatColumn

    • getLsGoodnessOfFitObs

      public FloatColumn getLsGoodnessOfFitObs()
      Least-squares goodness-of-fit parameter S for significantly intense reflections, (i.e. 'observed' reflections with values greater-than the threshold set in _reflns.threshold_expression), after the final cycle. Ideally, account should be taken of parameters restrained in the least-squares refinement. { sum { w [ Y(meas_gt) - Y(calc) ]^2^ } }^1/2^ S = { --------------------------------------- } { Nref - Nparam } Y(meas_gt) = 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

    • getLsGoodnessOfFitGt

      public FloatColumn getLsGoodnessOfFitGt()
      Least-squares goodness-of-fit parameter S for significantly intense reflections, (i.e. 'observed' reflections with values greater-than the threshold set in _reflns.threshold_expression), after the final cycle. Ideally, account should be taken of parameters restrained in the least-squares refinement. { sum { w [ Y(meas_gt) - Y(calc) ]^2^ } }^1/2^ S = { --------------------------------------- } { Nref - Nparam } Y(meas_gt) = 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

    • getGoodnessOfFitGt

      public FloatColumn getGoodnessOfFitGt()
      Least-squares goodness-of-fit parameter S for significantly intense reflections, (i.e. 'observed' reflections with values greater-than the threshold set in _reflns.threshold_expression), after the final cycle. Ideally, account should be taken of parameters restrained in the least-squares refinement. { sum { w [ Y(meas_gt) - Y(calc) ]^2^ } }^1/2^ S = { --------------------------------------- } { Nref - Nparam } Y(meas_gt) = 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

    • getLsGoodnessOfFitGtEsd

      public FloatColumn getLsGoodnessOfFitGtEsd()
      Standard Uncertainty of the Least-squares goodness-of-fit parameter S for gt reflections after the final cycle of refinement.
      Returns:
      FloatColumn

    • getLsGoodnessOfFitObsEsd

      public FloatColumn getLsGoodnessOfFitObsEsd()
      Standard Uncertainty of the Least-squares goodness-of-fit parameter S for gt reflections after the final cycle of refinement.
      Returns:
      FloatColumn

    • getGoodnessOfFitGtSu

      public FloatColumn getGoodnessOfFitGtSu()
      Standard Uncertainty of the Least-squares goodness-of-fit parameter S for gt reflections after the final cycle of refinement.
      Returns:
      FloatColumn

    • getLsGoodnessOfFitRef

      public FloatColumn getLsGoodnessOfFitRef()
      Least-squares goodness-of-fit parameter S for those reflections included in the final cycle of refinement. Account should be taken of restrained parameters. { sum { w [ Y(meas) - Y(calc) ]^2^ } }^1/2^ S = { ------------------------------------ } { Nref - Nparam } Y(meas) = the measured 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

    • getGoodnessOfFitRef

      public FloatColumn getGoodnessOfFitRef()
      Least-squares goodness-of-fit parameter S for those reflections included in the final cycle of refinement. Account should be taken of restrained parameters. { sum { w [ Y(meas) - Y(calc) ]^2^ } }^1/2^ S = { ------------------------------------ } { Nref - Nparam } Y(meas) = the measured 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

    • getLsHydrogenTreatment

      public StrColumn getLsHydrogenTreatment()
      Code identifying how hydrogen atoms were treated in the refinement.
      Returns:
      StrColumn

    • getHydrogenTreatment

      public StrColumn getHydrogenTreatment()
      Code identifying how hydrogen atoms were treated in the refinement.
      Returns:
      StrColumn

    • getLsMatrixType

      public StrColumn getLsMatrixType()
      Code identifying the matrix type used for least-squares derivatives.
      Returns:
      StrColumn

    • getMatrixType

      public StrColumn getMatrixType()
      Code identifying the matrix type used for least-squares derivatives.
      Returns:
      StrColumn

    • getLsNumberConstraints

      public IntColumn getLsNumberConstraints()
      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.special_details.
      Returns:
      IntColumn

    • getNumberConstraints

      public IntColumn getNumberConstraints()
      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.special_details.
      Returns:
      IntColumn

    • getLsNumberParameters

      public IntColumn getLsNumberParameters()
      Number of parameters refined in the least-squares process. If possible this number should include 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

    • getNumberParameters

      public IntColumn getNumberParameters()
      Number of parameters refined in the least-squares process. If possible this number should include 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()
      Number of unique reflections used in the least-squares refinement.
      Returns:
      IntColumn

    • getNumberReflns

      public IntColumn getNumberReflns()
      Number of unique reflections used in the least-squares refinement.
      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

    • getNumberReflnsGt

      public IntColumn getNumberReflnsGt()
      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

    • getLsNumberRestraints

      public IntColumn getLsNumberRestraints()
      Number of restrained parameters in the least-squares refinement. These parameters do not directly dependent on another refined parameter. Often restrained parameters involve geometry or energy dependencies. See also _atom_site.constraints and _atom_site.refinement_flags. A description of refinement constraints may appear in _refine.special_details.
      Returns:
      IntColumn

    • getNumberRestraints

      public IntColumn getNumberRestraints()
      Number of restrained parameters in the least-squares refinement. These parameters do not directly dependent on another refined parameter. Often restrained parameters involve geometry or energy dependencies. See also _atom_site.constraints and _atom_site.refinement_flags. A description of refinement constraints may appear in _refine.special_details.
      Returns:
      IntColumn

    • getLsRFactorAll

      public FloatColumn getLsRFactorAll()
      Residual factor for all reflections satisfying the resolution limits specified by _refine_ls.d_res_high and _refine_ls.d_res_low. This is the conventional R factor. See also wR factor definitions. sum | F(meas) - F(calc) | R = ------------------------ sum | F(meas) | F(meas) = the measured structure-factor amplitudes F(calc) = the calculated structure-factor amplitudes and the sum is taken over the specified reflections
      Returns:
      FloatColumn

    • getRFactorAll

      public FloatColumn getRFactorAll()
      Residual factor for all reflections satisfying the resolution limits specified by _refine_ls.d_res_high and _refine_ls.d_res_low. This is the conventional R factor. See also wR factor definitions. sum | F(meas) - F(calc) | R = ------------------------ sum | F(meas) | F(meas) = the measured structure-factor amplitudes F(calc) = the calculated structure-factor amplitudes and the sum is taken over the specified reflections
      Returns:
      FloatColumn

    • getLsRFactorObs

      public FloatColumn getLsRFactorObs()
      Residual factor for the reflections judged significantly intense (see _reflns.number_gt and _reflns.threshold_expression) and included in the refinement. The reflections also satisfy the resolution limits specified by _refine_ls.d_res_high and _refine_ls.d_res_low. This is the conventional R factor. sum | F(meas_gt) - F(calc) | R = ----------------------------- sum | F(meas_gt) | F(meas_gt) = the 'observed' structure-factor amplitudes F(calc) = the calculated structure-factor amplitudes and the sum is taken over the specified reflections
      Returns:
      FloatColumn

    • getLsRFactorGt

      public FloatColumn getLsRFactorGt()
      Residual factor for the reflections judged significantly intense (see _reflns.number_gt and _reflns.threshold_expression) and included in the refinement. The reflections also satisfy the resolution limits specified by _refine_ls.d_res_high and _refine_ls.d_res_low. This is the conventional R factor. sum | F(meas_gt) - F(calc) | R = ----------------------------- sum | F(meas_gt) | F(meas_gt) = the 'observed' structure-factor amplitudes F(calc) = the calculated structure-factor amplitudes and the sum is taken over the specified reflections
      Returns:
      FloatColumn

    • getRFactorGt

      public FloatColumn getRFactorGt()
      Residual factor for the reflections judged significantly intense (see _reflns.number_gt and _reflns.threshold_expression) and included in the refinement. The reflections also satisfy the resolution limits specified by _refine_ls.d_res_high and _refine_ls.d_res_low. This is the conventional R factor. sum | F(meas_gt) - F(calc) | R = ----------------------------- sum | F(meas_gt) | F(meas_gt) = the 'observed' structure-factor amplitudes F(calc) = the calculated structure-factor amplitudes and the sum is taken over the specified reflections
      Returns:
      FloatColumn

    • getLsRFsqdFactorObs

      public FloatColumn getLsRFsqdFactorObs()
      Residual factor R(Fsqd), calculated on the squared amplitudes of the measured and calculated structure factors, for significantly intense reflections (satisfying _reflns.threshold_expression) and included in the refinement. The reflections also satisfy the resolution limits specified by _refine_ls.d_res_high and _refine_ls.d_res_low. sum | F(meas_gt)^2^ - F(calc)^2^ | R(Fsqd) = ------------------------------------ sum F(meas_gt)^2^ F(meas_gt)^2^ = squares of the 'observed' structure-factor F(calc)^2^ = squares of the calculated structure-factor and the sum is taken over the specified reflections
      Returns:
      FloatColumn

    • getRFsqdFactor

      public FloatColumn getRFsqdFactor()
      Residual factor R(Fsqd), calculated on the squared amplitudes of the measured and calculated structure factors, for significantly intense reflections (satisfying _reflns.threshold_expression) and included in the refinement. The reflections also satisfy the resolution limits specified by _refine_ls.d_res_high and _refine_ls.d_res_low. sum | F(meas_gt)^2^ - F(calc)^2^ | R(Fsqd) = ------------------------------------ sum F(meas_gt)^2^ F(meas_gt)^2^ = squares of the 'observed' structure-factor F(calc)^2^ = squares of the calculated structure-factor and the sum is taken over the specified reflections
      Returns:
      FloatColumn

    • getLsRIFactorObs

      public FloatColumn getLsRIFactorObs()
      Residual factor R(I) for significantly intense reflections (satisfying _reflns.threshold_expression) and included in the refinement. This is most often calculated in Rietveld refinements of powder data, where it is referred to as R~B~ or R~Bragg~. sum | I(meas_gt) - I(calc) | R(I) = ----------------------------- sum | I(meas_gt) | I(meas_gt) = the net 'observed' intensities I(calc) = the net calculated intensities and the sum is taken over the specified reflections
      Returns:
      FloatColumn

    • getRIFactor

      public FloatColumn getRIFactor()
      Residual factor R(I) for significantly intense reflections (satisfying _reflns.threshold_expression) and included in the refinement. This is most often calculated in Rietveld refinements of powder data, where it is referred to as R~B~ or R~Bragg~. sum | I(meas_gt) - I(calc) | R(I) = ----------------------------- sum | I(meas_gt) | I(meas_gt) = the net 'observed' intensities I(calc) = the net calculated intensities and the sum is taken over the specified reflections
      Returns:
      FloatColumn

    • getLsRestrainedSAll

      public FloatColumn getLsRestrainedSAll()
      Least-squares goodness-of-fit parameter S' for all reflections after the final cycle of least squares. This parameter explicitly includes the restraints applied in the least-squares process. See also _refine_ls.goodness_of_fit_all definition. {sum { w [ Y(meas) - Y(calc) ]^2^ } }^1/2^ { + sum~r~ { w~r~ [ P(calc) - P(targ) ]^2^ } } S' = { -------------------------------------------------- } { N~ref~ + N~restr~ - N~param~ } Y(meas) = the measured 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/square of standard uncertainty (e.s.d.)] 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) 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 sum~r~ is taken over the restraints
      Returns:
      FloatColumn

    • getRestrainedSAll

      public FloatColumn getRestrainedSAll()
      Least-squares goodness-of-fit parameter S' for all reflections after the final cycle of least squares. This parameter explicitly includes the restraints applied in the least-squares process. See also _refine_ls.goodness_of_fit_all definition. {sum { w [ Y(meas) - Y(calc) ]^2^ } }^1/2^ { + sum~r~ { w~r~ [ P(calc) - P(targ) ]^2^ } } S' = { -------------------------------------------------- } { N~ref~ + N~restr~ - N~param~ } Y(meas) = the measured 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/square of standard uncertainty (e.s.d.)] 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) 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 sum~r~ is taken over the restraints
      Returns:
      FloatColumn

    • getLsRestrainedSObs

      public FloatColumn getLsRestrainedSObs()
      Least-squares goodness-of-fit parameter S' for significantly intense reflections (satisfying _reflns.threshold_expression) after the final cycle of least squares. This parameter explicitly includes the restraints applied. The expression for S' is given in _refine_ls.restrained_S_all. {sum { w [ Y(meas_gt) - Y(calc) ]^2^ } }^1/2^ { + sum~r~ { w~r~ [ P(calc) - P(targ) ]^2^ } } S' = { -------------------------------------------------- } { N~ref~ + N~restr~ - N~param~ } Y(meas_gt) = 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/square of standard uncertainty (e.s.d.)] 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) 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 sum~r~ is taken over the restraints
      Returns:
      FloatColumn

    • getRestrainedSGt

      public FloatColumn getRestrainedSGt()
      Least-squares goodness-of-fit parameter S' for significantly intense reflections (satisfying _reflns.threshold_expression) after the final cycle of least squares. This parameter explicitly includes the restraints applied. The expression for S' is given in _refine_ls.restrained_S_all. {sum { w [ Y(meas_gt) - Y(calc) ]^2^ } }^1/2^ { + sum~r~ { w~r~ [ P(calc) - P(targ) ]^2^ } } S' = { -------------------------------------------------- } { N~ref~ + N~restr~ - N~param~ } Y(meas_gt) = 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/square of standard uncertainty (e.s.d.)] 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) 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 sum~r~ 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 (s.u., formerly described as estimated standard deviation, e.s.d.).
      Returns:
      FloatColumn

    • getLsShiftOverSuMax

      public FloatColumn getLsShiftOverSuMax()
      The largest ratio of the final least-squares parameter shift to the final standard uncertainty (s.u., formerly described as estimated standard deviation, e.s.d.).
      Returns:
      FloatColumn

    • getShiftOverSuMax

      public FloatColumn getShiftOverSuMax()
      The largest ratio of the final least-squares parameter shift to the final standard uncertainty (s.u., formerly described as estimated standard deviation, e.s.d.).
      Returns:
      FloatColumn

    • getLsShiftOverSuMaxLt

      public FloatColumn getLsShiftOverSuMaxLt()
      Upper limit for the largest ratio of the final l-s parameter shift divided by 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

    • getShiftOverSuMaxLt

      public FloatColumn getShiftOverSuMaxLt()
      Upper limit for the largest ratio of the final l-s parameter shift divided by 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

    • getLsShiftOverEsdMean

      public FloatColumn getLsShiftOverEsdMean()
      The average ratio of the final least-squares parameter shift to the final standard uncertainty (s.u., formerly described as estimated standard deviation, e.s.d.).
      Returns:
      FloatColumn

    • getLsShiftOverSuMean

      public FloatColumn getLsShiftOverSuMean()
      The average ratio of the final least-squares parameter shift to the final standard uncertainty (s.u., formerly described as estimated standard deviation, e.s.d.).
      Returns:
      FloatColumn

    • getShiftOverSuMean

      public FloatColumn getShiftOverSuMean()
      The average ratio of the final least-squares parameter shift to the final standard uncertainty (s.u., formerly described as estimated standard deviation, e.s.d.).
      Returns:
      FloatColumn

    • getLsShiftOverSuMeanLt

      public FloatColumn getLsShiftOverSuMeanLt()
      Upper limit for the average ratio of the final l-s parameter shift divided by 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

    • getShiftOverSuMeanLt

      public FloatColumn getShiftOverSuMeanLt()
      Upper limit for the average ratio of the final l-s parameter shift divided by 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

    • getLsStructureFactorCoef

      public StrColumn getLsStructureFactorCoef()
      Structure-factor coefficient used in the least-squares process.
      Returns:
      StrColumn

    • getStructureFactorCoef

      public StrColumn getStructureFactorCoef()
      Structure-factor coefficient used in the least-squares process.
      Returns:
      StrColumn

    • getLsWeightingDetails

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

    • getWeightingDetails

      public StrColumn getWeightingDetails()
      Description of special aspects of the weighting scheme used in the 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()
      General description of the weighting scheme used in the least-squares. An enumerated code should be contained in this description.
      Returns:
      StrColumn

    • getWeightingScheme

      public StrColumn getWeightingScheme()
      General description of the weighting scheme used in the least-squares. An enumerated code should be contained in this description.
      Returns:
      StrColumn

    • getLsWRFactorAll

      public FloatColumn getLsWRFactorAll()
      Weighted residual factors for all reflections satisfying the resolution limits specified by _refine_ls.d_res_high and _refine_ls.d_res_low. See also the _refine_ls.R_factor_all definition. ( sum w [ Y(meas) - Y(calc) ]^2^ )^1/2^ wR = ( ------------------------------ ) ( sum w Y(meas)^2^ ) Y(meas) = the measured amplitude _refine_ls.structure_factor_coef Y(calc) = the calculated amplitude _refine_ls.structure_factor_coef w = the least-squares weight and the sum is taken over the specified reflections
      Returns:
      FloatColumn

    • getWRFactorAll

      public FloatColumn getWRFactorAll()
      Weighted residual factors for all reflections satisfying the resolution limits specified by _refine_ls.d_res_high and _refine_ls.d_res_low. See also the _refine_ls.R_factor_all definition. ( sum w [ Y(meas) - Y(calc) ]^2^ )^1/2^ wR = ( ------------------------------ ) ( sum w Y(meas)^2^ ) Y(meas) = the measured amplitude _refine_ls.structure_factor_coef Y(calc) = the calculated amplitude _refine_ls.structure_factor_coef w = the least-squares weight and the sum is taken over the specified reflections
      Returns:
      FloatColumn

    • getLsWRFactorObs

      public FloatColumn getLsWRFactorObs()
      Weighted residual factors for significantly intense reflections (satisfying _reflns.threshold_expression) included in the refinement. The reflections must also satisfy the resolution limits established by _refine_ls.d_res_high and _refine_ls.d_res_low. ( sum w [ Y(meas_gt) - Y(calc) ]^2^ )^1/2^ wR = ( ---------------------------------- ) ( sum w Y(meas_gt)^2^ ) Y(meas_gt) = the 'observed' amplitude _refine_ls.structure_factor_coef Y(calc) = the calculated amplitude _refine_ls.structure_factor_coef w = the least-squares weight and the sum is taken over the specified reflections
      Returns:
      FloatColumn

    • getWRFactorGt

      public FloatColumn getWRFactorGt()
      Weighted residual factors for significantly intense reflections (satisfying _reflns.threshold_expression) included in the refinement. The reflections must also satisfy the resolution limits established by _refine_ls.d_res_high and _refine_ls.d_res_low. ( sum w [ Y(meas_gt) - Y(calc) ]^2^ )^1/2^ wR = ( ---------------------------------- ) ( sum w Y(meas_gt)^2^ ) Y(meas_gt) = the 'observed' amplitude _refine_ls.structure_factor_coef Y(calc) = the calculated amplitude _refine_ls.structure_factor_coef w = the least-squares weight and the sum is taken over the specified reflections
      Returns:
      FloatColumn