spectre.Domain.CoordinateMaps

class spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToGrid1D

inv_jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToGrid1D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV1BlockLogical, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → Tensor<DataVector, brigand::list<brigand::integral_constant<int, 2>, brigand::integral_constant<int, 1> >, brigand::list<Tensor_detail::TensorIndexType<1ul, (UpLo)0, Frame::BlockLogical, (IndexType)0>, Tensor_detail::TensorIndexType<1ul, (UpLo)1, Frame::Grid, (IndexType)0> > >

inv_jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToGrid1D) → bool

inverse(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToGrid1D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorID1Grid, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → spectre.DataStructures.Tensor._Pybindings.TensorID1BlockLogical | None

is_identity(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToGrid1D) → bool

jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToGrid1D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV1BlockLogical, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → Tensor<DataVector, brigand::list<brigand::integral_constant<int, 2>, brigand::integral_constant<int, 1> >, brigand::list<Tensor_detail::TensorIndexType<1ul, (UpLo)0, Frame::Grid, (IndexType)0>, Tensor_detail::TensorIndexType<1ul, (UpLo)1, Frame::BlockLogical, (IndexType)0> > >

jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToGrid1D) → bool

class spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToGrid2D

inv_jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToGrid2D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV2BlockLogical, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → Tensor<DataVector, brigand::list<brigand::integral_constant<int, 2>, brigand::integral_constant<int, 1> >, brigand::list<Tensor_detail::TensorIndexType<2ul, (UpLo)0, Frame::BlockLogical, (IndexType)0>, Tensor_detail::TensorIndexType<2ul, (UpLo)1, Frame::Grid, (IndexType)0> > >

inv_jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToGrid2D) → bool

inverse(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToGrid2D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorID2Grid, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → spectre.DataStructures.Tensor._Pybindings.TensorID2BlockLogical | None

is_identity(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToGrid2D) → bool

jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToGrid2D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV2BlockLogical, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → Tensor<DataVector, brigand::list<brigand::integral_constant<int, 2>, brigand::integral_constant<int, 1> >, brigand::list<Tensor_detail::TensorIndexType<2ul, (UpLo)0, Frame::Grid, (IndexType)0>, Tensor_detail::TensorIndexType<2ul, (UpLo)1, Frame::BlockLogical, (IndexType)0> > >

jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToGrid2D) → bool

class spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToGrid3D

inv_jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToGrid3D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV3BlockLogical, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → Tensor<DataVector, brigand::list<brigand::integral_constant<int, 2>, brigand::integral_constant<int, 1> >, brigand::list<Tensor_detail::TensorIndexType<3ul, (UpLo)0, Frame::BlockLogical, (IndexType)0>, Tensor_detail::TensorIndexType<3ul, (UpLo)1, Frame::Grid, (IndexType)0> > >

inv_jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToGrid3D) → bool

inverse(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToGrid3D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorID3Grid, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → spectre.DataStructures.Tensor._Pybindings.TensorID3BlockLogical | None

is_identity(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToGrid3D) → bool

jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToGrid3D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV3BlockLogical, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → Tensor<DataVector, brigand::list<brigand::integral_constant<int, 2>, brigand::integral_constant<int, 1> >, brigand::list<Tensor_detail::TensorIndexType<3ul, (UpLo)0, Frame::Grid, (IndexType)0>, Tensor_detail::TensorIndexType<3ul, (UpLo)1, Frame::BlockLogical, (IndexType)0> > >

jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToGrid3D) → bool

class spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToInertial1D

inv_jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToInertial1D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV1BlockLogical, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → Tensor<DataVector, brigand::list<brigand::integral_constant<int, 2>, brigand::integral_constant<int, 1> >, brigand::list<Tensor_detail::TensorIndexType<1ul, (UpLo)0, Frame::BlockLogical, (IndexType)0>, Tensor_detail::TensorIndexType<1ul, (UpLo)1, Frame::Inertial, (IndexType)0> > >

inv_jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToInertial1D) → bool

inverse(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToInertial1D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorID1Inertial, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → spectre.DataStructures.Tensor._Pybindings.TensorID1BlockLogical | None

is_identity(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToInertial1D) → bool

jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToInertial1D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV1BlockLogical, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → Tensor<DataVector, brigand::list<brigand::integral_constant<int, 2>, brigand::integral_constant<int, 1> >, brigand::list<Tensor_detail::TensorIndexType<1ul, (UpLo)0, Frame::Inertial, (IndexType)0>, Tensor_detail::TensorIndexType<1ul, (UpLo)1, Frame::BlockLogical, (IndexType)0> > >

jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToInertial1D) → bool

class spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToInertial2D

inv_jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToInertial2D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV2BlockLogical, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → Tensor<DataVector, brigand::list<brigand::integral_constant<int, 2>, brigand::integral_constant<int, 1> >, brigand::list<Tensor_detail::TensorIndexType<2ul, (UpLo)0, Frame::BlockLogical, (IndexType)0>, Tensor_detail::TensorIndexType<2ul, (UpLo)1, Frame::Inertial, (IndexType)0> > >

inv_jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToInertial2D) → bool

inverse(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToInertial2D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorID2Inertial, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → spectre.DataStructures.Tensor._Pybindings.TensorID2BlockLogical | None

is_identity(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToInertial2D) → bool

jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToInertial2D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV2BlockLogical, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → Tensor<DataVector, brigand::list<brigand::integral_constant<int, 2>, brigand::integral_constant<int, 1> >, brigand::list<Tensor_detail::TensorIndexType<2ul, (UpLo)0, Frame::Inertial, (IndexType)0>, Tensor_detail::TensorIndexType<2ul, (UpLo)1, Frame::BlockLogical, (IndexType)0> > >

jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToInertial2D) → bool

class spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToInertial3D

inv_jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToInertial3D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV3BlockLogical, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → Tensor<DataVector, brigand::list<brigand::integral_constant<int, 2>, brigand::integral_constant<int, 1> >, brigand::list<Tensor_detail::TensorIndexType<3ul, (UpLo)0, Frame::BlockLogical, (IndexType)0>, Tensor_detail::TensorIndexType<3ul, (UpLo)1, Frame::Inertial, (IndexType)0> > >

inv_jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToInertial3D) → bool

inverse(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToInertial3D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorID3Inertial, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → spectre.DataStructures.Tensor._Pybindings.TensorID3BlockLogical | None

is_identity(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToInertial3D) → bool

jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToInertial3D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV3BlockLogical, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → Tensor<DataVector, brigand::list<brigand::integral_constant<int, 2>, brigand::integral_constant<int, 1> >, brigand::list<Tensor_detail::TensorIndexType<3ul, (UpLo)0, Frame::Inertial, (IndexType)0>, Tensor_detail::TensorIndexType<3ul, (UpLo)1, Frame::BlockLogical, (IndexType)0> > >

jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapBlockLogicalToInertial3D) → bool

class spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapDistortedToInertial1D

inv_jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapDistortedToInertial1D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV1Distorted, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → Tensor<DataVector, brigand::list<brigand::integral_constant<int, 2>, brigand::integral_constant<int, 1> >, brigand::list<Tensor_detail::TensorIndexType<1ul, (UpLo)0, Frame::Distorted, (IndexType)0>, Tensor_detail::TensorIndexType<1ul, (UpLo)1, Frame::Inertial, (IndexType)0> > >

inv_jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapDistortedToInertial1D) → bool

inverse(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapDistortedToInertial1D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorID1Inertial, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → spectre.DataStructures.Tensor._Pybindings.TensorID1Distorted | None

is_identity(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapDistortedToInertial1D) → bool

jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapDistortedToInertial1D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV1Distorted, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → Tensor<DataVector, brigand::list<brigand::integral_constant<int, 2>, brigand::integral_constant<int, 1> >, brigand::list<Tensor_detail::TensorIndexType<1ul, (UpLo)0, Frame::Inertial, (IndexType)0>, Tensor_detail::TensorIndexType<1ul, (UpLo)1, Frame::Distorted, (IndexType)0> > >

jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapDistortedToInertial1D) → bool

class spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapDistortedToInertial2D

inv_jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapDistortedToInertial2D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV2Distorted, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → Tensor<DataVector, brigand::list<brigand::integral_constant<int, 2>, brigand::integral_constant<int, 1> >, brigand::list<Tensor_detail::TensorIndexType<2ul, (UpLo)0, Frame::Distorted, (IndexType)0>, Tensor_detail::TensorIndexType<2ul, (UpLo)1, Frame::Inertial, (IndexType)0> > >

inv_jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapDistortedToInertial2D) → bool

inverse(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapDistortedToInertial2D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorID2Inertial, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → spectre.DataStructures.Tensor._Pybindings.TensorID2Distorted | None

is_identity(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapDistortedToInertial2D) → bool

jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapDistortedToInertial2D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV2Distorted, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → Tensor<DataVector, brigand::list<brigand::integral_constant<int, 2>, brigand::integral_constant<int, 1> >, brigand::list<Tensor_detail::TensorIndexType<2ul, (UpLo)0, Frame::Inertial, (IndexType)0>, Tensor_detail::TensorIndexType<2ul, (UpLo)1, Frame::Distorted, (IndexType)0> > >

jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapDistortedToInertial2D) → bool

class spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapDistortedToInertial3D

inv_jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapDistortedToInertial3D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV3Distorted, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → Tensor<DataVector, brigand::list<brigand::integral_constant<int, 2>, brigand::integral_constant<int, 1> >, brigand::list<Tensor_detail::TensorIndexType<3ul, (UpLo)0, Frame::Distorted, (IndexType)0>, Tensor_detail::TensorIndexType<3ul, (UpLo)1, Frame::Inertial, (IndexType)0> > >

inv_jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapDistortedToInertial3D) → bool

inverse(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapDistortedToInertial3D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorID3Inertial, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → spectre.DataStructures.Tensor._Pybindings.TensorID3Distorted | None

is_identity(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapDistortedToInertial3D) → bool

jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapDistortedToInertial3D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV3Distorted, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → Tensor<DataVector, brigand::list<brigand::integral_constant<int, 2>, brigand::integral_constant<int, 1> >, brigand::list<Tensor_detail::TensorIndexType<3ul, (UpLo)0, Frame::Inertial, (IndexType)0>, Tensor_detail::TensorIndexType<3ul, (UpLo)1, Frame::Distorted, (IndexType)0> > >

jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapDistortedToInertial3D) → bool

class spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToBlockLogical1D

inv_jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToBlockLogical1D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV1ElementLogical, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → Tensor<DataVector, brigand::list<brigand::integral_constant<int, 2>, brigand::integral_constant<int, 1> >, brigand::list<Tensor_detail::TensorIndexType<1ul, (UpLo)0, Frame::ElementLogical, (IndexType)0>, Tensor_detail::TensorIndexType<1ul, (UpLo)1, Frame::BlockLogical, (IndexType)0> > >

inv_jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToBlockLogical1D) → bool

inverse(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToBlockLogical1D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorID1BlockLogical, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → spectre.DataStructures.Tensor._Pybindings.TensorID1ElementLogical | None

is_identity(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToBlockLogical1D) → bool

jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToBlockLogical1D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV1ElementLogical, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → Tensor<DataVector, brigand::list<brigand::integral_constant<int, 2>, brigand::integral_constant<int, 1> >, brigand::list<Tensor_detail::TensorIndexType<1ul, (UpLo)0, Frame::BlockLogical, (IndexType)0>, Tensor_detail::TensorIndexType<1ul, (UpLo)1, Frame::ElementLogical, (IndexType)0> > >

jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToBlockLogical1D) → bool

class spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToBlockLogical2D

inv_jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToBlockLogical2D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV2ElementLogical, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → Tensor<DataVector, brigand::list<brigand::integral_constant<int, 2>, brigand::integral_constant<int, 1> >, brigand::list<Tensor_detail::TensorIndexType<2ul, (UpLo)0, Frame::ElementLogical, (IndexType)0>, Tensor_detail::TensorIndexType<2ul, (UpLo)1, Frame::BlockLogical, (IndexType)0> > >

inv_jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToBlockLogical2D) → bool

inverse(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToBlockLogical2D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorID2BlockLogical, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → spectre.DataStructures.Tensor._Pybindings.TensorID2ElementLogical | None

is_identity(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToBlockLogical2D) → bool

jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToBlockLogical2D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV2ElementLogical, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → Tensor<DataVector, brigand::list<brigand::integral_constant<int, 2>, brigand::integral_constant<int, 1> >, brigand::list<Tensor_detail::TensorIndexType<2ul, (UpLo)0, Frame::BlockLogical, (IndexType)0>, Tensor_detail::TensorIndexType<2ul, (UpLo)1, Frame::ElementLogical, (IndexType)0> > >

jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToBlockLogical2D) → bool

class spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToBlockLogical3D

inv_jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToBlockLogical3D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV3ElementLogical, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → Tensor<DataVector, brigand::list<brigand::integral_constant<int, 2>, brigand::integral_constant<int, 1> >, brigand::list<Tensor_detail::TensorIndexType<3ul, (UpLo)0, Frame::ElementLogical, (IndexType)0>, Tensor_detail::TensorIndexType<3ul, (UpLo)1, Frame::BlockLogical, (IndexType)0> > >

inv_jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToBlockLogical3D) → bool

inverse(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToBlockLogical3D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorID3BlockLogical, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → spectre.DataStructures.Tensor._Pybindings.TensorID3ElementLogical | None

is_identity(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToBlockLogical3D) → bool

jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToBlockLogical3D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV3ElementLogical, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → Tensor<DataVector, brigand::list<brigand::integral_constant<int, 2>, brigand::integral_constant<int, 1> >, brigand::list<Tensor_detail::TensorIndexType<3ul, (UpLo)0, Frame::BlockLogical, (IndexType)0>, Tensor_detail::TensorIndexType<3ul, (UpLo)1, Frame::ElementLogical, (IndexType)0> > >

jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToBlockLogical3D) → bool

class spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToInertial1D

inv_jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToInertial1D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV1ElementLogical, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → spectre.DataStructures.Tensor._Pybindings.JacobianDV1InertialToElementLogical

inv_jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToInertial1D) → bool

inverse(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToInertial1D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorID1Inertial, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → spectre.DataStructures.Tensor._Pybindings.TensorID1ElementLogical | None

is_identity(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToInertial1D) → bool

jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToInertial1D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV1ElementLogical, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → spectre.DataStructures.Tensor._Pybindings.JacobianDV1ElementLogicalToInertial

jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToInertial1D) → bool

class spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToInertial2D

inv_jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToInertial2D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV2ElementLogical, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → spectre.DataStructures.Tensor._Pybindings.JacobianDV2InertialToElementLogical

inv_jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToInertial2D) → bool

inverse(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToInertial2D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorID2Inertial, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → spectre.DataStructures.Tensor._Pybindings.TensorID2ElementLogical | None

is_identity(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToInertial2D) → bool

jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToInertial2D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV2ElementLogical, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → spectre.DataStructures.Tensor._Pybindings.JacobianDV2ElementLogicalToInertial

jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToInertial2D) → bool

class spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToInertial3D

inv_jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToInertial3D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV3ElementLogical, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → spectre.DataStructures.Tensor._Pybindings.JacobianDV3InertialToElementLogical

inv_jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToInertial3D) → bool

inverse(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToInertial3D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorID3Inertial, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → spectre.DataStructures.Tensor._Pybindings.TensorID3ElementLogical | None

is_identity(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToInertial3D) → bool

jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToInertial3D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV3ElementLogical, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → spectre.DataStructures.Tensor._Pybindings.JacobianDV3ElementLogicalToInertial

jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapElementLogicalToInertial3D) → bool

class spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToDistorted1D

inv_jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToDistorted1D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV1Grid, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → Tensor<DataVector, brigand::list<brigand::integral_constant<int, 2>, brigand::integral_constant<int, 1> >, brigand::list<Tensor_detail::TensorIndexType<1ul, (UpLo)0, Frame::Grid, (IndexType)0>, Tensor_detail::TensorIndexType<1ul, (UpLo)1, Frame::Distorted, (IndexType)0> > >

inv_jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToDistorted1D) → bool

inverse(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToDistorted1D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorID1Distorted, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → spectre.DataStructures.Tensor._Pybindings.TensorID1Grid | None

is_identity(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToDistorted1D) → bool

jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToDistorted1D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV1Grid, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → Tensor<DataVector, brigand::list<brigand::integral_constant<int, 2>, brigand::integral_constant<int, 1> >, brigand::list<Tensor_detail::TensorIndexType<1ul, (UpLo)0, Frame::Distorted, (IndexType)0>, Tensor_detail::TensorIndexType<1ul, (UpLo)1, Frame::Grid, (IndexType)0> > >

jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToDistorted1D) → bool

class spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToDistorted2D

inv_jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToDistorted2D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV2Grid, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → Tensor<DataVector, brigand::list<brigand::integral_constant<int, 2>, brigand::integral_constant<int, 1> >, brigand::list<Tensor_detail::TensorIndexType<2ul, (UpLo)0, Frame::Grid, (IndexType)0>, Tensor_detail::TensorIndexType<2ul, (UpLo)1, Frame::Distorted, (IndexType)0> > >

inv_jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToDistorted2D) → bool

inverse(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToDistorted2D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorID2Distorted, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → spectre.DataStructures.Tensor._Pybindings.TensorID2Grid | None

is_identity(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToDistorted2D) → bool

jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToDistorted2D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV2Grid, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → Tensor<DataVector, brigand::list<brigand::integral_constant<int, 2>, brigand::integral_constant<int, 1> >, brigand::list<Tensor_detail::TensorIndexType<2ul, (UpLo)0, Frame::Distorted, (IndexType)0>, Tensor_detail::TensorIndexType<2ul, (UpLo)1, Frame::Grid, (IndexType)0> > >

jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToDistorted2D) → bool

class spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToDistorted3D

inv_jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToDistorted3D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV3Grid, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → Tensor<DataVector, brigand::list<brigand::integral_constant<int, 2>, brigand::integral_constant<int, 1> >, brigand::list<Tensor_detail::TensorIndexType<3ul, (UpLo)0, Frame::Grid, (IndexType)0>, Tensor_detail::TensorIndexType<3ul, (UpLo)1, Frame::Distorted, (IndexType)0> > >

inv_jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToDistorted3D) → bool

inverse(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToDistorted3D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorID3Distorted, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → spectre.DataStructures.Tensor._Pybindings.TensorID3Grid | None

is_identity(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToDistorted3D) → bool

jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToDistorted3D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV3Grid, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → Tensor<DataVector, brigand::list<brigand::integral_constant<int, 2>, brigand::integral_constant<int, 1> >, brigand::list<Tensor_detail::TensorIndexType<3ul, (UpLo)0, Frame::Distorted, (IndexType)0>, Tensor_detail::TensorIndexType<3ul, (UpLo)1, Frame::Grid, (IndexType)0> > >

jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToDistorted3D) → bool

class spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToInertial1D

inv_jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToInertial1D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV1Grid, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → Tensor<DataVector, brigand::list<brigand::integral_constant<int, 2>, brigand::integral_constant<int, 1> >, brigand::list<Tensor_detail::TensorIndexType<1ul, (UpLo)0, Frame::Grid, (IndexType)0>, Tensor_detail::TensorIndexType<1ul, (UpLo)1, Frame::Inertial, (IndexType)0> > >

inv_jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToInertial1D) → bool

inverse(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToInertial1D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorID1Inertial, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → spectre.DataStructures.Tensor._Pybindings.TensorID1Grid | None

is_identity(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToInertial1D) → bool

jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToInertial1D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV1Grid, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → Tensor<DataVector, brigand::list<brigand::integral_constant<int, 2>, brigand::integral_constant<int, 1> >, brigand::list<Tensor_detail::TensorIndexType<1ul, (UpLo)0, Frame::Inertial, (IndexType)0>, Tensor_detail::TensorIndexType<1ul, (UpLo)1, Frame::Grid, (IndexType)0> > >

jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToInertial1D) → bool

class spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToInertial2D

inv_jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToInertial2D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV2Grid, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → Tensor<DataVector, brigand::list<brigand::integral_constant<int, 2>, brigand::integral_constant<int, 1> >, brigand::list<Tensor_detail::TensorIndexType<2ul, (UpLo)0, Frame::Grid, (IndexType)0>, Tensor_detail::TensorIndexType<2ul, (UpLo)1, Frame::Inertial, (IndexType)0> > >

inv_jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToInertial2D) → bool

inverse(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToInertial2D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorID2Inertial, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → spectre.DataStructures.Tensor._Pybindings.TensorID2Grid | None

is_identity(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToInertial2D) → bool

jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToInertial2D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV2Grid, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → Tensor<DataVector, brigand::list<brigand::integral_constant<int, 2>, brigand::integral_constant<int, 1> >, brigand::list<Tensor_detail::TensorIndexType<2ul, (UpLo)0, Frame::Inertial, (IndexType)0>, Tensor_detail::TensorIndexType<2ul, (UpLo)1, Frame::Grid, (IndexType)0> > >

jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToInertial2D) → bool

class spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToInertial3D

inv_jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToInertial3D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV3Grid, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → Tensor<DataVector, brigand::list<brigand::integral_constant<int, 2>, brigand::integral_constant<int, 1> >, brigand::list<Tensor_detail::TensorIndexType<3ul, (UpLo)0, Frame::Grid, (IndexType)0>, Tensor_detail::TensorIndexType<3ul, (UpLo)1, Frame::Inertial, (IndexType)0> > >

inv_jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToInertial3D) → bool

inverse(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToInertial3D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorID3Inertial, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → spectre.DataStructures.Tensor._Pybindings.TensorID3Grid | None

is_identity(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToInertial3D) → bool

jacobian(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToInertial3D, source_point: spectre.DataStructures.Tensor._Pybindings.TensorIDV3Grid, time: Optional[float] = None, functions_of_time: Optional[dict[str, domain::FunctionsOfTime::FunctionOfTime]] = None) → Tensor<DataVector, brigand::list<brigand::integral_constant<int, 2>, brigand::integral_constant<int, 1> >, brigand::list<Tensor_detail::TensorIndexType<3ul, (UpLo)0, Frame::Inertial, (IndexType)0>, Tensor_detail::TensorIndexType<3ul, (UpLo)1, Frame::Grid, (IndexType)0> > >

jacobian_is_time_dependent(self: spectre.Domain.CoordinateMaps._Pybindings.CoordinateMapGridToInertial3D) → bool

class spectre.Domain.CoordinateMaps._Pybindings.Distribution

Members:

Linear

Equiangular

Logarithmic

Inverse

Projective

Equiangular = <Distribution.Equiangular: 1>

Inverse = <Distribution.Inverse: 3>

Linear = <Distribution.Linear: 0>

Logarithmic = <Distribution.Logarithmic: 2>

Projective = <Distribution.Projective: 4>

property name

property value

class spectre.Domain.CoordinateMaps._Pybindings.DistributionAndSingularityPosition