yt.lagos Physical and Derived Data Objects
yt.lagos.BaseDataTypes Data Containers and Physical Objects
yt provides a number of data containers, defined such that they satisfy a
logical need. Each of these provides only the finest-resolution cells, unless
an option is available to restrict the levels from which they draw, as is the
case with AMRCoveringGrid.
Each of these implements the same primary protocol - all data values can be
accessed dictionary-style:
>>> object["Density"]
>>> object["Density"].max()
For more information about objects, see Object Methodology and
Using and Manipulating Objects and Fields.
Base Classes
-
class yt.lagos.AMRData(pf, fields, **kwargs)
Generic AMRData container. By itself, will attempt to
generate field, read fields (method defined by derived classes)
and deal with passing back and forth field parameters.
Typically this is never called directly, but only due to inheritance.
It associates a StaticOutput with the class,
sets its initial set of fields, and the remainder of the arguments
are passed as field_parameters.
-
clear_cache()
- Clears out all cache, freeing memory.
-
clear_data()
- Clears out all data from the AMRData instance, freeing memory.
-
convert(datatype)
- This will attempt to convert a given unit to cgs from code units.
It either returns the multiplicative factor or throws a KeyError.
-
get_field_parameter(name, default=None)
- This is typically only used by derived field functions, but
it returns parameters used to generate fields.
-
has_field_parameter(name)
- Checks if a field parameter is set.
-
has_key(key)
- Checks if a data field already exists.
-
save_object(name, filename=None)
- Save an object. If filename is supplied, it will be stored in
a shelve file of that name. Otherwise, it will be stored via
yt.lagos.AMRHierarchy.save_object().
-
set_field_parameter(name, val)
- Here we set up dictionaries that get passed up and down and ultimately
to derived fields.
-
class yt.lagos.AMR1DData(pf, fields, **kwargs)
Bases: yt.lagos.BaseDataTypes.AMRData, yt.lagos.BaseDataTypes.GridPropertiesMixin
-
clear_cache()
- Clears out all cache, freeing memory.
-
clear_data()
- Clears out all data from the AMRData instance, freeing memory.
-
convert(datatype)
- This will attempt to convert a given unit to cgs from code units.
It either returns the multiplicative factor or throws a KeyError.
-
get_field_parameter(name, default=None)
- This is typically only used by derived field functions, but
it returns parameters used to generate fields.
-
has_field_parameter(name)
- Checks if a field parameter is set.
-
has_key(key)
- Checks if a data field already exists.
-
save_object(name, filename=None)
- Save an object. If filename is supplied, it will be stored in
a shelve file of that name. Otherwise, it will be stored via
yt.lagos.AMRHierarchy.save_object().
-
select_grids(level)
- Return all grids on a given level.
-
set_field_parameter(name, val)
- Here we set up dictionaries that get passed up and down and ultimately
to derived fields.
-
class yt.lagos.AMR2DData(axis, fields, pf=None, **kwargs)
Bases: yt.lagos.BaseDataTypes.AMRData, yt.lagos.BaseDataTypes.GridPropertiesMixin, yt.lagos.ParallelTools.ParallelAnalysisInterface
Prepares the AMR2DData, normal to axis. If axis is 4, we are not
aligned with any axis.
-
clear_cache()
- Clears out all cache, freeing memory.
-
clear_data()
- Clears out all data from the AMRData instance, freeing memory.
-
convert(datatype)
- This will attempt to convert a given unit to cgs from code units.
It either returns the multiplicative factor or throws a KeyError.
-
get_data(fields=None)
- Iterates over the list of fields and generates/reads them all.
-
get_field_parameter(name, default=None)
- This is typically only used by derived field functions, but
it returns parameters used to generate fields.
-
has_field_parameter(name)
- Checks if a field parameter is set.
-
has_key(key)
- Checks if a data field already exists.
-
interpolate_discretize(LE, RE, field, side, log_spacing=True)
- This returns a uniform grid of points between LE and RE,
interpolated using the nearest neighbor method, with side points on a
side.
-
save_object(name, filename=None)
- Save an object. If filename is supplied, it will be stored in
a shelve file of that name. Otherwise, it will be stored via
yt.lagos.AMRHierarchy.save_object().
-
select_grids(level)
- Return all grids on a given level.
-
set_field_parameter(name, val)
- Here we set up dictionaries that get passed up and down and ultimately
to derived fields.
-
class yt.lagos.AMR3DData(center, fields, pf=None, **kwargs)
Bases: yt.lagos.BaseDataTypes.AMRData, yt.lagos.BaseDataTypes.GridPropertiesMixin
Returns an instance of AMR3DData, or prepares one. Usually only
used as a base class. Note that center is supplied, but only used
for fields and quantities that require it.
-
clear_cache()
- Clears out all cache, freeing memory.
-
clear_data()
- Clears out all data from the AMRData instance, freeing memory.
-
convert(datatype)
- This will attempt to convert a given unit to cgs from code units.
It either returns the multiplicative factor or throws a KeyError.
-
cut_region(field_cuts)
- Return an InLineExtractedRegion, where the grid cells are cut on the
fly with a set of field_cuts.
- This function will create a set of contour objects, defined
by having connected cell structures, which can then be
studied and used to ‘paint’ their source grids, thus enabling
them to be plotted.
- Return an ExtractedRegion where the points contained in it are defined
as the points in this data object with the given indices.
-
get_field_parameter(name, default=None)
- This is typically only used by derived field functions, but
it returns parameters used to generate fields.
-
has_field_parameter(name)
- Checks if a field parameter is set.
-
has_key(key)
- Checks if a data field already exists.
-
paint_grids(field, value, default_value=None)
This function paints every cell in our dataset with a given value.
If default_value is given, the other values for the given in every grid
are discarded and replaced with default_value. Otherwise, the field is
mandated to ‘know how to exist’ in the grid.
Note that this only paints the cells in the dataset, so cells in grids
with child cells are left untouched.
-
save_object(name, filename=None)
- Save an object. If filename is supplied, it will be stored in
a shelve file of that name. Otherwise, it will be stored via
yt.lagos.AMRHierarchy.save_object().
-
select_grids(level)
- Return all grids on a given level.
-
set_field_parameter(name, val)
- Here we set up dictionaries that get passed up and down and ultimately
to derived fields.
-
class yt.lagos.FakeGridForParticles(grid)
- Mock up a grid to insert particle positions and radii
into for purposes of confinement in an AMR3DData.
1D Data Containers
Each of these inherits from AMR1DData, and so has all the
member functions defined there.
-
class yt.lagos.AMROrthoRayBase(axis, coords, fields=None, pf=None, **kwargs)
Bases: yt.lagos.BaseDataTypes.AMR1DData
Dimensionality is reduced to one, and an ordered list of points at an
(x,y) tuple along axis are available.
2D Data Containers
-
class yt.lagos.AMRSliceBase(axis, coord, fields=None, center=None, pf=None, node_name=False, **kwargs)
Bases: yt.lagos.BaseDataTypes.AMR2DData
AMRSlice is an orthogonal slice through the data, taking all the points
at the finest resolution available and then indexing them. It is more
appropriately thought of as a slice ‘operator’ than an object,
however, as its field and coordinate can both change.
Slice along axisHow do I specify an axis?, at the coordinate coord.
Optionally supply fields.
-
reslice(coord)
- Change the entire dataset, clearing out the current data and slicing at
a new location. Not terribly useful except for in-place plot changes.
-
shift(val)
- Moves the slice coordinate up by either a floating point value, or an
integer number of indices of the finest grid.
-
class yt.lagos.AMRCuttingPlaneBase(normal, center, fields=None, node_name=None, **kwargs)
Bases: yt.lagos.BaseDataTypes.AMR2DData
AMRCuttingPlane is an oblique plane through the data,
defined by a normal vector and a coordinate. It attempts to guess
an ‘up’ vector, which cannot be overridden, and then it pixelizes
the appropriate data onto the plane without interpolation.
The Cutting Plane slices at an oblique angle, where we use
the normal vector and the center to define the viewing plane.
The ‘up’ direction is guessed at automatically.
-
class yt.lagos.AMRProjBase(axis, field, weight_field=None, max_level=None, center=None, pf=None, source=None, node_name=None, field_cuts=None, preload_style='level', serialize=True, **kwargs)
Bases: yt.lagos.BaseDataTypes.AMR2DData
AMRProj is a projection of a field along an axis. The field
can have an associated weight_field, in which case the values are
multiplied by a weight before being summed, and then divided by the sum
of that weight.
3D Data Containers
-
class yt.lagos.AMRSphereBase(center, radius, fields=None, pf=None, **kwargs)
Bases: yt.lagos.BaseDataTypes.AMR3DData
A sphere of points
The most famous of all the data objects, we define it via a
center and a radius.
-
volume(unit='unitary')
- Return the volume of the sphere in units unit.
-
class yt.lagos.AMRRegionBase(center, left_edge, right_edge, fields=None, pf=None, **kwargs)
Bases: yt.lagos.BaseDataTypes.AMR3DData
AMRRegions are rectangular prisms of data.
We create an object with a set of three left_edge coordinates,
three right_edge coordinates, and a center that need not be the
center.
-
volume(unit='unitary')
- Return the volume of the region in units unit.
-
class yt.lagos.AMRCylinderBase(center, normal, radius, height, fields=None, pf=None, **kwargs)
Bases: yt.lagos.BaseDataTypes.AMR3DData
We can define a cylinder (or disk) to act as a data object.
By providing a center, a normal, a radius and a height we
can define a cylinder of any proportion. Only cells whose centers are
within the cylinder will be selected.
-
volume(unit='unitary')
- Return the volume of the cylinder in units of unit.
-
class yt.lagos.AMRGridCollectionBase(center, grid_list, fields=None, pf=None, **kwargs)
Bases: yt.lagos.BaseDataTypes.AMR3DData
An arbitrary selection of grids, within which we accept all points.
By selecting an arbitrary grid_list, we can act on those grids.
Child cells are not returned.
-
class yt.lagos.AMRCoveringGridBase(level, left_edge, dims, fields=None, pf=None, num_ghost_zones=0, use_pbar=True, **kwargs)
Bases: yt.lagos.BaseDataTypes.AMR3DData
-
flush_data(field=None)
- Any modifications made to the data in this object are pushed back
to the originating grids, except the cells where those grids are both
below the current level and have child cells.
-
class yt.lagos.AMRSmoothedCoveringGridBase(*args, **kwargs)
- Bases: yt.lagos.BaseDataTypes.AMRFloatCoveringGridBase
Bases: yt.lagos.BaseDataTypes.AMR3DData
ExtractedRegions are arbitrarily defined containers of data, useful
for things like selection along a baryon field.
yt.lagos.DerivedQuantities Derived Quantities
All of these are accessed via the .quantities[] object, and feeding it the
function name without the leading underscore. For instance:
my_sphere.quantities["TotalMass"]()
They all accept the lazy_reader option, which governs whether the
calculation is performed out of core or not. For more information, see
Derived Quantities.
-
yt.lagos.DerivedQuantities._AngularMomentumVector(data)
- This function returns the mass-weighted average angular momentum vector.
-
yt.lagos.DerivedQuantities._BaryonSpinParameter(data)
- This function returns the spin parameter for the baryons, but it uses
the particles in calculating enclosed mass.
-
yt.lagos.DerivedQuantities._BulkVelocity(data)
- This function returns the mass-weighted average velocity in the object.
-
yt.lagos.DerivedQuantities._CenterOfMass(data)
- This function takes no arguments and returns the location of the center
of mass of the non-particle data in the object.
-
yt.lagos.DerivedQuantities._Extrema(data, fields, filter=None)
This function returns the extrema of a set of fields
Parameters: |
- fields – A field name, or a list of field names
- filter – a string to be evaled to serve as a data filter.
|
-
yt.lagos.DerivedQuantities._IsBound(data, truncate=True, include_thermal_energy=False)
This returns whether or not the object is gravitationally bound
Parameters: |
- truncate – Should the calculation stop once the ratio of
gravitational:kinetic is 1.0?
- include_thermal_energy – Should we add the energy from ThermalEnergy
on to the kinetic energy to calculate
binding energy?
|
-
yt.lagos.DerivedQuantities._MaxLocation(data, field)
- This function returns the location of the maximum of a set
of fields.
-
yt.lagos.DerivedQuantities._ParticleSpinParameter(data)
- This function returns the spin parameter for the baryons, but it uses
the particles in calculating enclosed mass.
-
yt.lagos.DerivedQuantities._TotalMass(data)
- This function takes no arguments and returns the sum of cell masses and
particle masses in the object.
-
yt.lagos.DerivedQuantities._TotalQuantity(data, fields)
This function sums up a given field over the entire region
Parameter: | fields – The fields to sum up |
-
yt.lagos.DerivedQuantities._WeightedAverageQuantity(data, field, weight)
This function returns an averaged quantity.
Parameters: |
- field – The field to average
- weight – The field to weight by
|
yt.lagos.FieldInfoContainer Derived Field Objects
-
class yt.lagos.FieldInfoContainer
This is a generic field container. It contains a list of potential derived
fields, all of which know how to act on a data object and return a value. This
object handles converting units as well as validating the availability of a
given field.
-
add_field(name, function=None, **kwargs)
- Add a new field, along with supplemental metadata, to the list of
available fields. This respects a number of arguments, all of which
are passed on to the constructor for DerivedField.
-
keys()
- Return all the field names this object knows about.
-
class yt.lagos.EnzoFieldContainer
- This is a container for Enzo-specific fields.
-
class yt.lagos.OrionFieldContainer
- All Orion-specific fields are stored in here.
-
class yt.lagos.DerivedField(name, function, convert_function=None, particle_convert_function=None, units='', projected_units='', take_log=True, validators=None, particle_type=False, vector_field=False, display_field=True, not_in_all=False, display_name=None, projection_conversion='cm')
This is the base class used to describe a cell-by-cell derived field.
Parameters: |
- name – is the name of the field.
- function – is a function handle that defines the field
- convert_function – must convert to CGS, if it needs to be done
- units – is a mathtext-formatted string that describes the field
- projected_units – if we display a projection, what should the units be?
- take_log – describes whether the field should be logged
- validators – is a list of FieldValidator objects
- particle_type – is this field based on particles?
- vector_field – describes the dimensionality of the field
- display_field – governs its appearance in the dropdowns in reason
- not_in_all – is used for baryon fields from the data that are not in
all the grids
- display_name – a name used in the plots
- projection_conversion – which unit should we multiply by in a
projection?
|
-
check_available(data)
- This raises an exception of the appropriate type if the set of
validation mechanisms are not met, and otherwise returns True.
-
get_dependencies(*args, **kwargs)
- This returns a list of names of fields that this field depends on.
-
get_label(projected=False)
- Return a data label for the given field, inluding units.
-
get_projected_units()
- Return a string describing the units if the field has been projected.
-
get_source()
- Return a string containing the source of the function (if possible.)
-
get_units()
- Return a string describing the units.
-
class yt.lagos.ValidateParameter(parameters)
- This validator ensures that the parameter file has a given parameter.
-
class yt.lagos.ValidateDataField(field)
- This validator ensures that the output file has a given data field stored
in it.
-
class yt.lagos.ValidateProperty(prop)
- This validator ensures that the data object has a given python attribute.
-
class yt.lagos.ValidateSpatial(ghost_zones=0, fields=None)
- This validator ensures that the data handed to the field is of spatial
nature – that is to say, 3-D.
-
class yt.lagos.ValidateGridType
- This validator ensures that the data handed to the field is an actual
grid patch, not a covering grid of any kind.
yt.lagos.Profiles Profiling
Profiling in yt is a means of generating arbitrary histograms – for instance,
phase diagrams, radial profiles, and even more complicated 3D examinations.
-
class yt.lagos.BinnedProfile1D(data_source, n_bins, bin_field, lower_bound, upper_bound, log_space=True, lazy_reader=False, end_collect=False)
Bases: yt.lagos.Profiles.BinnedProfile
A ‘Profile’ produces either a weighted (or unweighted) average or a
straight sum of a field in a bin defined by another field. In the case
of a weighted average, we have: p_i = sum( w_i * v_i ) / sum(w_i)
We accept a data_source, which will be binned into n_bins
by the field bin_field between the lower_bound and the
upper_bound. These bins may or may not be equally divided
in log_space, and the lazy_reader flag controls whether we
use a memory conservative approach. If end_collect is True,
take all values outside the given bounds and store them in the
0 and n_bins-1 values.
-
add_fields(fields, weight='CellMassMsun', accumulation=False, fractional=False)
- We accept a list of fields which will be binned if weight is not
None and otherwise summed. accumulation determines whether or not
they will be accumulated from low to high along the appropriate axes.
-
write_out(filename, format='%0.16e', bin_style='left')
- Write out data in ascii file, using format and
bin_style (left, right, center, both).
-
write_out_h5(filename, group_prefix=None, bin_style='left')
- Write out data in an hdf5 file filename. Each profile is
put into a group, named by the axis fields. Optionally a
group_prefix can be prepended to the group name. If the
group already exists, it will delete and replace. However,
due to hdf5 functionality, in only unlinks the data, so an
h5repack may be necessary to conserve space. Axes values are
saved in group attributes. Bins will be saved based on
bin_style (left, right, center, both).
-
class yt.lagos.BinnedProfile2D(data_source, x_n_bins, x_bin_field, x_lower_bound, x_upper_bound, x_log, y_n_bins, y_bin_field, y_lower_bound, y_upper_bound, y_log, lazy_reader=False, end_collect=False)
Bases: yt.lagos.Profiles.BinnedProfile
A ‘Profile’ produces either a weighted (or unweighted) average
or a straight sum of a field in a bin defined by two other
fields. In the case of a weighted average, we have: p_i =
sum( w_i * v_i ) / sum(w_i)
We accept a data_source, which will be binned into
x_n_bins by the field x_bin_field between the
x_lower_bound and the x_upper_bound and then again binned
into y_n_bins by the field y_bin_field between the
y_lower_bound and the y_upper_bound. These bins may or
may not be equally divided in log-space as specified by
x_log and y_log, and the lazy_reader flag controls
whether we use a memory conservative approach. If
end_collect is True, take all values outside the given
bounds and store them in the 0 and n_bins-1 values.
-
add_fields(fields, weight='CellMassMsun', accumulation=False, fractional=False)
- We accept a list of fields which will be binned if weight is not
None and otherwise summed. accumulation determines whether or not
they will be accumulated from low to high along the appropriate axes.
-
write_out(filename, format='%0.16e', bin_style='left')
- Write out the values of x,y,v in ascii to filename for every
field in the profile. Optionally a format can be specified.
Bins will be saved based on bin_style (left, right, center,
both).
-
write_out_h5(filename, group_prefix=None, bin_style='left')
- Write out data in an hdf5 file. Each profile is put into a
group, named by the axis fields. Optionally a group_prefix
can be prepended to the group name. If the group already
exists, it will delete and replace. However, due to hdf5
functionality, in only unlinks the data, so an h5repack may be
necessary to conserve space. Axes values are saved in group
attributes. Bins will be saved based on bin_style (left,
right, center, both).
-
class yt.lagos.BinnedProfile3D(data_source, x_n_bins, x_bin_field, x_lower_bound, x_upper_bound, x_log, y_n_bins, y_bin_field, y_lower_bound, y_upper_bound, y_log, z_n_bins, z_bin_field, z_lower_bound, z_upper_bound, z_log, lazy_reader=False, end_collect=False)
Bases: yt.lagos.Profiles.BinnedProfile
A ‘Profile’ produces either a weighted (or unweighted) average
or a straight sum of a field in a bin defined by two other
fields. In the case of a weighted average, we have: p_i =
sum( w_i * v_i ) / sum(w_i)
We accept a data_source, which will be binned into
(x,y,z)_n_bins by the field (x,y,z)_bin_field between the
(x,y,z)_lower_bound and the (x,y,z)_upper_bound. These bins may or
may not be equally divided in log-space as specified by
(x,y,z)_log, and the lazy_reader flag controls
whether we use a memory conservative approach. If
end_collect is True, take all values outside the given
bounds and store them in the 0 and n_bins-1 values.
-
add_fields(fields, weight='CellMassMsun', accumulation=False, fractional=False)
- We accept a list of fields which will be binned if weight is not
None and otherwise summed. accumulation determines whether or not
they will be accumulated from low to high along the appropriate axes.
-
store_profile(name, force=False)
- By identifying the profile with a fixed, user-input name we can
store it in the serialized data section of the hierarchy file. force
governs whether or not an existing profile with that name will be
overwritten.
-
write_out_h5(filename, group_prefix=None, bin_style='left')
- Write out data in an hdf5 file. Each profile is put into a
group, named by the axis fields. Optionally a group_prefix
can be prepended to the group name. If the group already
exists, it will delete and replace. However, due to hdf5
functionality, in only unlinks the data, so an h5repack may be
necessary to conserve space. Axes values are saved in group
attributes.
-
class yt.lagos.StoredBinnedProfile3D(pf, name)
Bases: yt.lagos.Profiles.BinnedProfile3D
Given a pf parameterfile and the name of a stored profile, retrieve
it into a read-only data structure.
yt.lagos.ContourFinder Contour Finding
Typically this is done via the extract_connected_sets() on a data object.
However, you can call it manually, as is done in the clump finding scripts.
-
yt.lagos.identify_contours(data_source, field, min_val, max_val, cached_fields=None)
-
class yt.lagos.GridConsiderationQueue(white_list, priority_func=None)
- This class exists to serve the contour finder. It ensures that
we can create a cascading set of queue dependencies, and if
a grid is touched again ahead of time we can bump it to the top
of the queue again. It like has few uses.
yt.lagos.HaloFinding Halo Finding
yt now includes the HOP algorithm and implementation from the Enzo source
distribution, with some modifications by both Stephen Skory and Matthew Turk.
-
yt.lagos.HaloFinder
- alias of HOPHaloFinder
-
class yt.lagos.HaloList(data_source, dm_only=True)
Run hop on data_source with a given density threshold. If
dm_only is set, only run it on the dark matter particles, otherwise
on all particles. Returns an iterable collection of HopGroup items.
-
nearest_neighbors_2D(haloID, num_neighbors=7, search_radius=0.20000000000000001, proj_dim=0)
- for halo haloID, find up to num_neighbors nearest neighbors in 2D
using the kd tree. Search over search_radius in code units.
The halo positions are projected along dimension proj_dim.
Returns a list of the neighbors distances and ID with format
[distance,haloID].
-
nearest_neighbors_3D(haloID, num_neighbors=7, search_radius=0.20000000000000001)
- for halo haloID, find up to num_neighbors nearest neighbors in 3D
using the kd tree. Search over search_radius in code units.
Returns a list of the neighbors distances and ID with format
[distance,haloID].
-
write_out(filename)
- Write out standard HOP information to filename.
-
write_particle_lists_txt(prefix, fp=None)
- Write out the location of halo data in hdf5 files to prefix.
-
class yt.lagos.Halo(halo_list, id, indices=None, size=None, CoM=None, max_dens_point=None, group_total_mass=None, max_radius=None, bulk_vel=None, tasks=None)
A data source that returns particle information about the members of a
HOP-identified halo.
-
bulk_velocity()
- Returns the mass-weighted average velocity.
-
center_of_mass()
- Calculate and return the center of mass.
-
get_sphere(center_of_mass=True)
- Returns an EnzoSphere centered on either the point of maximum density
or the center_of_mass, with the maximum radius of the halo.
-
maximum_density()
- Return the HOP-identified maximum density.
-
maximum_density_location()
- Return the location HOP identified as maximally dense.
-
maximum_radius(center_of_mass=True)
- Returns the maximum radius in the halo for all particles,
either from the point of maximum density or from the (default)
center_of_mass.
-
total_mass()
- Returns the total mass in solar masses of the halo.
-
virial_bin(virial_overdensity=200.0, bins=300)
- Return the bin index for the virial radius for the given halo.
Returns -1 if the halo is not virialized to the set
virial_overdensity.
-
virial_info(bins=300)
- Calculate the virial profile bins for this halo, using only the particles
in the halo (no baryonic information used).
Calculate using bins number of bins.
-
virial_mass(virial_overdensity=200.0, bins=300)
- Return the virial mass of the halo in Msun, using only the particles
in the halo (no baryonic information used).
Calculate using bins number of bins and virial_overdensity density
threshold. Returns -1 if the halo is not virialized.
-
virial_radius(virial_overdensity=200.0, bins=300)
- Return the virial radius of the halo in code units, using only the
particles in the halo (no baryonic information used).
Calculate using bins number of bins and virial_overdensity density
threshold. Returns -1 if the halo is not virialized.
The specific halo finding algorithm can be specified by selecting the
appropriate HaloFinder object. By default, HOP is used.
-
class yt.lagos.HOPHaloFinder(pf, threshold=160, dm_only=True, padding=0.02)
-
class yt.lagos.FOFHaloFinder(pf, link=0.20000000000000001, dm_only=True, padding=0.02)