empyrean.NonGravParams¶

class NonGravParams(table, **kwargs)[source]

Bases: Table

Non-gravitational acceleration parameters.

Model types:: “marsden_water” – Marsden-Sekanina with standard H2O sublimation g(r) “inverse_square” – Marsden-Sekanina with g(r) = 1/r^2 (Yarkovsky) “marsden” – Marsden-Sekanina with custom g(r) exponents “srp” – Solar radiation pressure from AMRAT (a1 = AMRAT in m^2/kg)
For “marsden”, the g(r) function is:: g(r) = alpha * (r/r0)^{-m} * (1 + (r/r0)^n)^{-k}

Methods

`__init__`(table, **kwargs)
`apply_mask`(mask)	Return a new table with rows filtered to match a boolean mask.
`as_column`([nullable, metadata])	Embed the Table as a column in another Table.
`attributes`()	Return a dictionary of the table's attributes.
`chunk_counts`()	Returns the number of discrete memory chunks that make up each of the Table's underlying arrays.
`column`(column_name)	Returns the column with the given name as a raw pyarrow ChunkedArray.
`drop_duplicates`([subset, keep])	Drop duplicate rows from a ~quivr.Table.
`empty`(**kwargs)	Create an empty instance of the table.
`flattened_table`()	Completely flatten the Table's underlying Arrow table, taking into account any nested structure, and return the data table itself.
`fragmented`()	Returns true if the Table has any fragmented arrays.
`from_csv`(input_file[, validate])	Read a table from a CSV file.
`from_dataframe`(df[, validate])	Load a DataFrame into the Table.
`from_feather`(path[, validate])	Read a table from a Feather file.
`from_flat_dataframe`(df[, validate])	Load a flattened DataFrame into the Table.
`from_kwargs`([validate, permit_nulls])	Create a Table instance from keyword arguments.
`from_parquet`(path[, memory_map, ...])	Read a table from a Parquet file.
`from_pyarrow`(table[, validate, permit_nulls])	Create a new table from a pyarrow Table.
`invalid_mask`()	Return a boolean mask indicating which rows are invalid.
`is_valid`()	Validate the table against the schema.
`null_mask`()	Return a boolean mask indicating which rows of the entire table are null.
`nulls`(size, **kwargs)	Create a table with nulls.
`select`(column_name, value)	Select from the table by exact match, returning a new Table which only contains rows for which the value in column_name equals value.
`separate_invalid`()	Separates rows that have invalid data from those that have valid data.
`set_column`(name, data)	Return a copy of the table with a particular column replaced with new data.
`sort_by`(by)	Sorts the Table by the given column name (or multiple columns).
`take`(row_indices)	Return a new Table with only the rows at the given indices.
`to_csv`(path[, attribute_columns])	Write the table to a CSV file.
`to_dataframe`([flatten, attr_handling])	Returns self as a pandas DataFrame.
`to_feather`(path, **kwargs)	Write the table to a Feather file.
`to_parquet`(path, **kwargs)	Write the table to a Parquet file.
`to_structarray`()	Returns self as a StructArray.
`unique_indices`([subset, keep])	Get the indices of the first or last occurrence of each unique row in the table.
`validate`()	Validate the table against the schema, raising an exception if invalid.
`where`(expr)	Return a new table with rows filtered to match an expression.
`with_table`(table)

Attributes

`a1`	A column for storing 64-bit floating point numbers.
`a2`	A column for storing 64-bit floating point numbers.
`a3`	A column for storing 64-bit floating point numbers.
`alpha`	A column for storing 64-bit floating point numbers.
`cr`	A column for storing 64-bit floating point numbers.
`dt`	A column for storing 64-bit floating point numbers.
`k`	A column for storing 64-bit floating point numbers.
`m`	A column for storing 64-bit floating point numbers.
`model`	A column for storing large strings (over 2³¹ bytes long).
`n`	A column for storing 64-bit floating point numbers.
`r0`	A column for storing 64-bit floating point numbers.
`schema`
`table`

Parameters:

table (Table)
kwargs (AttributeValueType)

a1: A column for storing 64-bit floating point numbers.

a2: A column for storing 64-bit floating point numbers.

a3: A column for storing 64-bit floating point numbers.

model: A column for storing large strings (over 2³¹ bytes long). Large string data is stored in variable-length chunks.

alpha: A column for storing 64-bit floating point numbers.

r0: A column for storing 64-bit floating point numbers.

m: A column for storing 64-bit floating point numbers.

n: A column for storing 64-bit floating point numbers.

k: A column for storing 64-bit floating point numbers.

cr: A column for storing 64-bit floating point numbers.

dt: A column for storing 64-bit floating point numbers.

schema: ClassVar[Schema] = a1: double not null a2: double not null a3: double not null model: large_string not null alpha: double r0: double m: double n: double k: double cr: double dt: double