Uses of Class
org.apache.commons.math3.geometry.euclidean.threed.Vector3D

Packages that use Vector3D

fr.cnes.sirius.patrius.assembly
fr.cnes.sirius.patrius.assembly.models
fr.cnes.sirius.patrius.assembly.models.cook
fr.cnes.sirius.patrius.assembly.properties
fr.cnes.sirius.patrius.assembly.properties.features
fr.cnes.sirius.patrius.bodies
fr.cnes.sirius.patrius.events
fr.cnes.sirius.patrius.events.sensor
fr.cnes.sirius.patrius.fieldsofview
fr.cnes.sirius.patrius.forces
fr.cnes.sirius.patrius.forces.radiation
fr.cnes.sirius.patrius.guidance
fr.cnes.sirius.patrius.signalpropagation
fr.cnes.sirius.patrius.signalpropagation.iono
fr.cnes.sirius.patrius.stela.bodies
fr.cnes.sirius.patrius.stela.forces.atmospheres
fr.cnes.sirius.patrius.stela.forces.drag
fr.cnes.sirius.patrius.stela.forces.noninertial
fr.cnes.sirius.patrius.stela.forces.radiation
fr.cnes.sirius.patrius.utils
fr.cnes.sirius.patrius.wrenches
org.apache.commons.math3.analysis	Parent package for common numerical analysis procedures, including root finding, function interpolation and integration.
org.apache.commons.math3.analysis.polynomials	Univariate real polynomials implementations, seen as differentiable univariate real functions.
org.apache.commons.math3.geometry.euclidean.threed	This package provides basic 3D geometry components.
org.orekit.attitudes	This package provides classes to represent simple attitudes.
org.orekit.attitudes.directions
org.orekit.attitudes.kinematics
org.orekit.bodies	This package provides interface to represent the position and geometry of space objects such as stars, planets or asteroids.
org.orekit.files.general	This package provides interfaces for orbit file representations and corresponding parsers.
org.orekit.forces	This package provides the interface for force models that will be used by the NumericalPropagator, as well as some classical spacecraft models for surface forces (spherical, box and solar array ...).
org.orekit.forces.atmospheres
org.orekit.forces.drag
org.orekit.forces.gravity
org.orekit.forces.gravity.tides
org.orekit.forces.gravity.variations
org.orekit.forces.maneuvers	This package provides models of simple maneuvers.
org.orekit.forces.radiation
org.orekit.forces.relativistic
org.orekit.frames	This package provides classes to handle frames and transforms between them.
org.orekit.frames.transformations
org.orekit.models.earth	This package provides models that simulate certain physical phenomena experienced in the atmosphere of the earth.
org.orekit.orbits	This package provides classes to represent orbits.
org.orekit.orbits.orbitalparameters
org.orekit.propagation.events	This package provides interfaces and classes dealing with events occurring during propagation.
org.orekit.propagation.numerical
org.orekit.propagation.precomputed
org.orekit.time	This independent package provides classes to handle epochs, time scales, and to compare instants together.
org.orekit.utils	This package provides useful objects.
org.orekit.wrenches

Uses of Vector3D in fr.cnes.sirius.patrius.assembly

Methods in fr.cnes.sirius.patrius.assembly with parameters of type Vector3D

void	AssemblyBuilder.addPart(String partName, String parentPartName, Vector3D translation, Rotation rotation) This method adds a new part to the currently built assembly.
void	Vehicle.addSolarPanel(Vector3D normalPanel, double areaPanel) Add a solar panel to the vehicle.

Uses of Vector3D in fr.cnes.sirius.patrius.assembly.models

Methods in fr.cnes.sirius.patrius.assembly.models that return Vector3D

Vector3D	DragLiftModel.dragAcceleration(SpacecraftState state, double density, Vector3D relativeVelocity) Method to compute the aero acceleration, based on the assembly.
Vector3D	GlobalAeroModel.dragAcceleration(SpacecraftState state, double density, Vector3D relativeVelocity) Method to compute the aero acceleration, based on the assembly.
Vector3D	AeroModel.dragAcceleration(SpacecraftState state, double density, Vector3D relativeVelocity) Method to compute the aero acceleration, based on the assembly.
protected static Vector3D	AeroModel.forceOnFacet(SpacecraftState state, IPart part, Assembly assembly, double density, Vector3D relativeVelocity) Method to compute the force for a plane model.
protected static Vector3D	DirectRadiativeModel.forceOnFacet(SpacecraftState state, IPart part, Vector3D flux) Method to compute the force for a plane model.
protected static Vector3D	AeroModel.forceOnSphere(SpacecraftState state, IPart part, double density, Vector3D relativeVelocity, Frame mainPartFrame) Method to compute the force for the part model (cylinder, parallelepiped, sphere).
protected static Vector3D	DirectRadiativeModel.forceOnSphere(SpacecraftState state, IPart part, Vector3D flux, Frame mainPartFrame) Method to compute the force for a spherical model.
Vector3D	MagneticMoment.getMagneticMoment(AbsoluteDate date) Get the magnetic moment at given date, in the main frame of the spacecraft
Vector3D	MagneticMomentProvider.getMagneticMoment(AbsoluteDate date) Get the magnetic moment at given date, in the main frame of the spacecraft
Vector3D	InertiaSimpleModel.getMassCenter(Frame frame, AbsoluteDate date) Getter for the mass center.
Vector3D	InertiaComputedModel.getMassCenter(Frame frame, AbsoluteDate date) Getter for the mass center.
Vector3D	IInertiaModel.getMassCenter(Frame frame, AbsoluteDate date) Getter for the mass center.
Vector3D	SensorModel.getNormalisedTargetVectorInSensorFrame(AbsoluteDate date) Computes the target vector at a date in the sensor's frame.
Vector3D[]	SensorModel.getRefrenceAxis(Frame frame, AbsoluteDate date) Computes the reference axis of the sensor in a given frame at a date
Vector3D	DragCoefficient.getScAbs() Get the absorption part in satellite frame.
Vector3D	DragCoefficient.getScDiffAr() Get the diffuse part (rear) in satellite frame.
Vector3D	DragCoefficient.getScDiffAv() Get the diffuse part (front) in satellite frame.
Vector3D	DragCoefficient.getScSpec() Get the specular part in satellite frame.
Vector3D	SensorModel.getSightAxis(Frame frame, AbsoluteDate date) Computes the sight axis of the sensor in a given frame at a date
Vector3D	SensorModel.getTargetVectorInSensorFrame(AbsoluteDate date) Computes the target vector at a date in the sensor's frame.
Vector3D	DirectRadiativeModel.radiationPressureAcceleration(SpacecraftState state, Vector3D flux) Method to compute the radiation pressure acceleration, based on the assembly.
Vector3D	RediffusedRadiativeModel.rediffusedRadiationPressureAcceleration(SpacecraftState state, ElementaryFlux flux) Method to compute the rediffused radiation pressure acceleration, based on the assembly.

Methods in fr.cnes.sirius.patrius.assembly.models with parameters of type Vector3D

void	DragLiftModel.addDDragAccDParam(SpacecraftState s, Parameter param, double density, Vector3D relativeVelocity, double[] dAccdParam) Compute acceleration derivatives with respect to ballistic coefficient.
void	GlobalAeroModel.addDDragAccDParam(SpacecraftState s, Parameter param, double density, Vector3D relativeVelocity, double[] dAccdParam) Compute acceleration derivatives with respect to additional parameters (the ballistic coefficient).
void	AeroModel.addDDragAccDParam(SpacecraftState s, Parameter param, double density, Vector3D relativeVelocity, double[] dAccdParam) Compute acceleration derivatives with respect to ballistic coefficient.
void	DragLiftModel.addDDragAccDState(SpacecraftState s, double[][] dAccdPos, double[][] dAccdVel, double density, Vector3D acceleration, Vector3D relativeVelocity, boolean computeGradientPosition, boolean computeGradientVelocity) Compute acceleration derivatives with respect to state parameters (position and velocity).
void	GlobalAeroModel.addDDragAccDState(SpacecraftState s, double[][] dAccdPos, double[][] dAccdVel, double density, Vector3D acceleration, Vector3D relativeVelocity, boolean computeGradientPosition, boolean computeGradientVelocity) Compute acceleration derivatives with respect to state parameters (position and velocity).
void	AeroModel.addDDragAccDState(SpacecraftState s, double[][] dAccdPos, double[][] dAccdVel, double density, Vector3D acceleration, Vector3D relativeVelocity, boolean computeGradientPosition, boolean computeGradientVelocity) Compute acceleration derivatives with respect to state parameters (position and velocity).
void	DirectRadiativeModel.addDSRPAccDParam(SpacecraftState s, Parameter param, double[] dAccdParam, Vector3D satSunVector) Compute acceleration derivatives with respect to additional parameters.
void	DirectRadiativeModel.addDSRPAccDState(SpacecraftState s, double[][] dAccdPos, double[][] dAccdVel, Vector3D satSunVector) Compute acceleration derivatives with respect to state parameters.
Vector3D	DragLiftModel.dragAcceleration(SpacecraftState state, double density, Vector3D relativeVelocity) Method to compute the aero acceleration, based on the assembly.
Vector3D	GlobalAeroModel.dragAcceleration(SpacecraftState state, double density, Vector3D relativeVelocity) Method to compute the aero acceleration, based on the assembly.
Vector3D	AeroModel.dragAcceleration(SpacecraftState state, double density, Vector3D relativeVelocity) Method to compute the aero acceleration, based on the assembly.
Wrench	AeroWrenchModel.dragWrench(SpacecraftState state, double density, Vector3D relativeVelocity)
Wrench	AeroWrenchModel.dragWrench(SpacecraftState state, double density, Vector3D relativeVelocity, Vector3D origin, Frame frame) Compute the torque due to radiation pressire.
protected static Vector3D	AeroModel.forceOnFacet(SpacecraftState state, IPart part, Assembly assembly, double density, Vector3D relativeVelocity) Method to compute the force for a plane model.
protected static Vector3D	DirectRadiativeModel.forceOnFacet(SpacecraftState state, IPart part, Vector3D flux) Method to compute the force for a plane model.
protected static Vector3D	AeroModel.forceOnSphere(SpacecraftState state, IPart part, double density, Vector3D relativeVelocity, Frame mainPartFrame) Method to compute the force for the part model (cylinder, parallelepiped, sphere).
protected static Vector3D	DirectRadiativeModel.forceOnSphere(SpacecraftState state, IPart part, Vector3D flux, Frame mainPartFrame) Method to compute the force for a spherical model.
DragCoefficient	DragCoefficientProvider.getCoefficients(Vector3D relativeVelocity, AtmosphereData atmoData, Assembly assembly) Provides drag coefficient (x surface).
DragCoefficient	GlobalDragCoefficientProvider.getCoefficients(Vector3D relativeVelocity, AtmosphereData atmoData, Assembly assembly)
Matrix3D	InertiaSimpleModel.getInertiaMatrix(Frame frame, AbsoluteDate date, Vector3D inertiaReferencePoint) Getter for the inertia matrix of the spacecraft, once expressed with respect to a point that can be different from the mass center.
Matrix3D	InertiaComputedModel.getInertiaMatrix(Frame frame, AbsoluteDate date, Vector3D inertiaReferencePoint) Getter for the inertia matrix of the spacecraft, once expressed with respect to a point that can be different from the mass center.
Matrix3D	IInertiaModel.getInertiaMatrix(Frame frame, AbsoluteDate date, Vector3D inertiaReferencePoint) Getter for the inertia matrix of the spacecraft, once expressed with respect to a point that can be different from the mass center.
Vector3D	DirectRadiativeModel.radiationPressureAcceleration(SpacecraftState state, Vector3D flux) Method to compute the radiation pressure acceleration, based on the assembly.
Wrench	DirectRadiativeWrenchModel.radiationWrench(SpacecraftState state, Vector3D flux) Compute the torque due to radiation pressire.
Wrench	DirectRadiativeWrenchModel.radiationWrench(SpacecraftState state, Vector3D flux, Vector3D origin, Frame frame) Compute the torque due to radiation pressire.
void	InertiaSimpleModel.updateMassCenter(Vector3D massCenter) Updates the mass center.

Constructors in fr.cnes.sirius.patrius.assembly.models with parameters of type Vector3D

DragCoefficient(Vector3D scAbsIn, Vector3D scSpecIn, Vector3D scDiffAvIn, Vector3D scDiffArIn)
Constructor.

InertiaSimpleModel(double mass, Vector3D massCenter, Matrix3D inertiaMatrix, Frame frame, String partName)
Constructor for a simple inertia model.

InertiaSimpleModel(double mass, Vector3D massCenter, Matrix3D inertiaMatrix, Vector3D inertiaReferencePoint, Frame frame, String partName)
Constructor for a simple inertia model; the inertia matrix is expressed with respect to a point that can be different from the mass center.

MagneticMoment(Vector3D moment)
Create a magnetic moment expressed in spacecraft main frame (incl.

Uses of Vector3D in fr.cnes.sirius.patrius.assembly.models.cook

Methods in fr.cnes.sirius.patrius.assembly.models.cook with parameters of type Vector3D

double	ConstantWallGasTemperature.getWallGasTemperature(SpacecraftState state, Vector3D relativeVelocity, double theta) Compute wall gas temperature.
double	CookWallGasTemperature.getWallGasTemperature(SpacecraftState state, Vector3D relativeVelocity, double theta) Compute wall gas temperature.
double	WallGasTemperatureProvider.getWallGasTemperature(SpacecraftState state, Vector3D relativeVelocity, double theta) Compute wall gas temperature.
double	GinsWallGasTemperature.getWallGasTemperature(SpacecraftState state, Vector3D relativeVelocity, double theta) Compute wall gas temperature.

Uses of Vector3D in fr.cnes.sirius.patrius.assembly.properties

Methods in fr.cnes.sirius.patrius.assembly.properties that return Vector3D

Vector3D	RadiativeApplicationPoint.getApplicationPoint() Get the application point in the part frame
Vector3D	AeroApplicationPoint.getApplicationPoint() Get the application point in the given frame at the given date.
Vector3D	SensorProperty.getInSightAxis()
Vector3D	AbstractInertiaProperty.getMassCenter()
Vector3D	IInertiaProperty.getMassCenter()
Vector3D[]	SensorProperty.getReferenceAxis()

Methods in fr.cnes.sirius.patrius.assembly.properties with parameters of type Vector3D

double	AeroSphereProperty.getCrossSection(SpacecraftState state, Vector3D relativeVelocity, Frame mainPartFrame, Frame partFrame)
double	RadiativeSphereProperty.getCrossSection(SpacecraftState state, Vector3D flux, Frame mainPartFrame, Frame partFrame)
double	RadiativeCrossSectionProperty.getCrossSection(SpacecraftState state, Vector3D flux, Frame mainPartFrame, Frame partFrame) Compute the cross section of main shape using the relative velocity in the part (having the aero property) frame as the direction to provider to the CrossSectionProvider.getCrossSection(Vector3D).
double	AeroCrossSectionProperty.getCrossSection(SpacecraftState state, Vector3D relativeVelocity, Frame mainPartFrame, Frame partFrame) Compute the cross section of main shape using the relative velocity in the part (having the aero property) frame as the direction to provider to the CrossSectionProvider.getCrossSection(Vector3D).
double	AeroGlobalProperty.getCrossSection(Vector3D velocityPartFrame) Compute the cross section of main shape using the relative velocity in the part (having the aero property) frame as the direction to provider to the CrossSectionProvider.getCrossSection(Vector3D).
double	CrossSectionProviderProperty.getCrossSection(Vector3D direction) Computes the cross section of the geometry from a direction defined by a Vector3D.
protected void	AbstractInertiaProperty.setMassCenter(Vector3D massCenter) Sets the mass center.
void	InertiaSimpleProperty.setMassCenter(Vector3D massCenter) Sets the mass center.
void	SensorProperty.setReferenceAxis(Vector3D[] refAxis) Sets the reference axis

Constructors in fr.cnes.sirius.patrius.assembly.properties with parameters of type Vector3D

AbstractInertiaProperty(Vector3D massCenter, Matrix3D inertiaMatrix, MassProperty mass)
Constructor for the abstract inertia property.

AbstractInertiaProperty(Vector3D massCenter, Matrix3D inertiaMatrix, Vector3D inertiaReferencePoint, MassProperty mass)
Constructor for the abstract inertia property.

AeroApplicationPoint(Vector3D applicationPoint)
Create a drag force application point property.

AeroSphereProperty(double inSphereRadius, double density, Vector3D relativeVelocity)
Constructor of this property.

InertiaSimpleProperty(Vector3D massCenter, Matrix3D inertiaMatrix, MassProperty mass)
Constructor for the simple inertia property

InertiaSimpleProperty(Vector3D massCenter, Matrix3D inertiaMatrix, Vector3D inertiaReferencePoint, MassProperty mass)
Constructor for the simple inertia property; the inertia matrix is expressed with respect to a point that can be different from the mass center.

RadiativeApplicationPoint(Vector3D applicationPoint)
Create a radiative force application point property.

SensorProperty(Vector3D sightAxis)
Constructor of the generic sensor property

Uses of Vector3D in fr.cnes.sirius.patrius.assembly.properties.features

Methods in fr.cnes.sirius.patrius.assembly.properties.features that return Vector3D

Vector3D

Facet.getNormal()

Methods in fr.cnes.sirius.patrius.assembly.properties.features with parameters of type Vector3D

double

Facet.getCrossSection(Vector3D direction)

Constructors in fr.cnes.sirius.patrius.assembly.properties.features with parameters of type Vector3D

Facet(Vector3D inNormal, double inArea)
Simple constructor.

Uses of Vector3D in fr.cnes.sirius.patrius.bodies

Methods in fr.cnes.sirius.patrius.bodies that return Vector3D

Vector3D

BasicBoardSun.getVector(PVCoordinatesProvider pvCoord, AbsoluteDate date, Frame frame) Get the direction of the sun.

Uses of Vector3D in fr.cnes.sirius.patrius.events

Constructors in fr.cnes.sirius.patrius.events with parameters of type Vector3D

CentralBodyMaskCircularFOVDetector(PVCoordinatesProvider occultedBody, double occultedBodyRadius, GeometricBodyShape occultingBody, boolean totalEclipseFlag, Vector3D center, double halfAperture)
Constructor with default maxcheck and default threshold, creating a circularFOVDetector and an EllipsoidEclipseDetector

CentralBodyMaskCircularFOVDetector(PVCoordinatesProvider occultedBody, double occultedBodyRadius, GeometricBodyShape occultingBody, boolean totalEclipseFlag, Vector3D center, double halfAperture, double maxCheck, double threshold)
Constructor with user maxcheck and threshold creating a circularFOVDetector and an EllipsoidEclipseDetector

CentralBodyMaskCircularFOVDetector(PVCoordinatesProvider occultedBody, double occultedBodyRadius, GeometricBodyShape occultingBody, boolean totalEclipseFlag, Vector3D center, double halfAperture, double maxCheck, double threshold, EventDetector.Action action)
Constructor with user maxcheck and threshold creating a circularFOVDetector and an EllipsoidEclipseDetector

CentralBodyMaskCircularFOVDetector(PVCoordinatesProvider occultedBody, double occultedBodyRadius, GeometricBodyShape occultingBody, boolean totalEclipseFlag, Vector3D center, double halfAperture, double maxCheck, double threshold, EventDetector.Action action, boolean remove)
Constructor with user maxcheck and threshold creating a circularFOVDetector and an EllipsoidEclipseDetector

Uses of Vector3D in fr.cnes.sirius.patrius.events.sensor

Methods in fr.cnes.sirius.patrius.events.sensor that return Vector3D

protected Vector3D	AbstractDetectorWithTropoCorrection.getCorrectedVector(SpacecraftState s) Compute the apparent vector from the station to the spacecraft with tropospheric effects.
Vector3D	ExtremaSightAxisDetector.getSightAxis() Get the sight axis

Constructors in fr.cnes.sirius.patrius.events.sensor with parameters of type Vector3D

ExtremaSightAxisDetector(int extremumType, PVCoordinatesProvider target, Vector3D sightAxisDirection)
Constructor to use without assembly.

ExtremaSightAxisDetector(int extremumType, PVCoordinatesProvider target, Vector3D sightAxisDirection, double maxCheck, double threshold)
Constructor to use without assembly.

ExtremaSightAxisDetector(int extremumType, PVCoordinatesProvider target, Vector3D sightAxisDirection, double maxCheck, double threshold, EventDetector.Action action)
Constructor to use without assembly.

ExtremaSightAxisDetector(int extremumType, PVCoordinatesProvider target, Vector3D sightAxisDirection, double maxCheck, double threshold, EventDetector.Action action, boolean remove)
Constructor to use without assembly.

ExtremaSightAxisDetector(PVCoordinatesProvider target, Vector3D sightAxisDirection, double maxCheck, double threshold, EventDetector.Action actionMin, EventDetector.Action actionMax)
Constructor to use without assembly for both minimal and maximal angle detection.

ExtremaSightAxisDetector(PVCoordinatesProvider target, Vector3D sightAxisDirection, double maxCheck, double threshold, EventDetector.Action actionMin, EventDetector.Action actionMax, boolean removeMin, boolean removeMax)
Constructor to use without assembly for both minimal and maximal angle detection.

Uses of Vector3D in fr.cnes.sirius.patrius.fieldsofview

Methods in fr.cnes.sirius.patrius.fieldsofview that return Vector3D

Vector3D	RectangleField.getU() Get the U axis
Vector3D	RectangleField.getV() Get the V axis
Vector3D	RectangleField.getW() Get the W axis.

Methods in fr.cnes.sirius.patrius.fieldsofview with parameters of type Vector3D

double	FieldAngularFace.computeMinAngle(Vector3D direction) Computes the minimal angle between this and a given direction.
double	RectangleField.getAngularDistance(Vector3D direction) Computes the angular distance between a vector and the border of the field.
double	PyramidalField.getAngularDistance(Vector3D direction)
double	BooleanField.getAngularDistance(Vector3D direction) Computes the angular distance between a vector and the border of the field.
double	SectorField.getAngularDistance(Vector3D direction) Computes the angular distance between a vector and the border of the field.
double	CircularField.getAngularDistance(Vector3D direction) Computes the angular distance between a vector and the border of the field.
double	InvertField.getAngularDistance(Vector3D direction) Computes the angular distance between a vector and the border of the field.
double	EllipticField.getAngularDistance(Vector3D direction) Computes the angular distance between a vector and the border of the field.
double	AzimuthElevationField.getAngularDistance(Vector3D direction) Computes the angular distance between a vector and the border of the field.
double	OmnidirectionalField.getAngularDistance(Vector3D direction) this method has no sense in the case of an omnidirectional field.
double	IFieldOfView.getAngularDistance(Vector3D direction) Computes the angular distance between a vector and the border of the field.
boolean	RectangleField.isInTheField(Vector3D direction)
boolean	PyramidalField.isInTheField(Vector3D direction)
boolean	BooleanField.isInTheField(Vector3D direction)
boolean	SectorField.isInTheField(Vector3D direction)
boolean	CircularField.isInTheField(Vector3D direction)
boolean	InvertField.isInTheField(Vector3D direction)
boolean	EllipticField.isInTheField(Vector3D direction)
boolean	AzimuthElevationField.isInTheField(Vector3D direction)
boolean	OmnidirectionalField.isInTheField(Vector3D direction) Any vector being in the field, this method always return true
boolean	IFieldOfView.isInTheField(Vector3D direction)

Constructors in fr.cnes.sirius.patrius.fieldsofview with parameters of type Vector3D

CircularField(String name, double angularAperture, Vector3D mainDirection)
Constructor for a circular field of view.

EllipticField(String name, Vector3D origin, Vector3D mainDirection, Vector3D majorSemiAxisDirection, double angleA, double angleB)
Constructor for an elliptic field of view.

FieldAngularFace(Vector3D firstVector, Vector3D secondVector)
Constructor.

PyramidalField(String name, Vector3D[] directions)
Constructor for a pyramidal field of view.

RectangleField(String name, Vector3D mainDirection, Vector3D approximativeU, double angularApertureU, double angularApertureV)
Constructor for a field of view defined by a rectangle cone.

SectorField(String name, Vector3D vectorPole, Vector3D vectorV1, Vector3D vectorV2)
Constructor for the "sector" field of view.

Uses of Vector3D in fr.cnes.sirius.patrius.forces

Methods in fr.cnes.sirius.patrius.forces that return Vector3D

Vector3D	EmpiricalForce.computeAcceleration(PVCoordinates pv, LocalOrbitalFrame localFrameValidation, Vector3D vectorS, Frame frame, SpacecraftState state) Method to compute the acceleration.
Vector3D	ConstantThrustManeuver.computeAcceleration(SpacecraftState s) Compute the acceleration due to the force.
Vector3D	EmpiricalForce.computeAcceleration(SpacecraftState state)
Vector3D	VariableThrustManeuver.computeAcceleration(SpacecraftState s)
Vector3D	VariableThrustManeuver.getDirection(SpacecraftState s) Get the thrust direction.
Vector3D	EmpiricalForce.getVectorS()

Methods in fr.cnes.sirius.patrius.forces with parameters of type Vector3D

Vector3D	EmpiricalForce.computeAcceleration(PVCoordinates pv, LocalOrbitalFrame localFrameValidation, Vector3D vectorS, Frame frame, SpacecraftState state) Method to compute the acceleration.
double[]	EmpiricalForce.computeCosSin(PVCoordinates pv, Vector3D vectorS) Private method to compute the cos(nwt) and sin(nwt) values.

Constructors in fr.cnes.sirius.patrius.forces with parameters of type Vector3D

ConstantThrustManeuver(AbsoluteDate date, double duration, double thrust, double isp, Vector3D inDirection, MassProvider massProvider, String partNameIn)
Constructor for a constant direction in satellite frame and constant thrust.

ConstantThrustManeuver(AbsoluteDate date, double duration, double thrust, double isp, Vector3D inDirection, MassProvider massProvider, String partNameIn, Frame frameIn)
Constructor for a constant direction in provided frame and constant thrust.

ConstantThrustManeuver(AbsoluteDate date, double duration, double thrust, double isp, Vector3D inDirection, MassProvider massProvider, String partNameIn, LOFType lofTyp)
Constructor for a constant direction in provided local orbital frame and constant thrust.

ConstantThrustManeuver(AbsoluteDate date, double duration, Parameter thrust, Parameter flowRate, Vector3D inDirection, MassProvider massProvider, String partNameIn)
Constructor for a constant direction in satellite frame and constant thrust using Parameter.

ConstantThrustManeuver(AbsoluteDate date, double duration, Parameter thrust, Parameter flowRate, Vector3D inDirection, MassProvider massProvider, String partNameIn, Frame frameIn)
Constructor for a constant dDirection in provided frame and constant thrust using Parameter.

ConstantThrustManeuver(AbsoluteDate date, double duration, Parameter thrust, Parameter flowRate, Vector3D inDirection, MassProvider massProvider, String partNameIn, LOFType lofTyp)
Constructor for a constant direction in provided local orbital frame and constant thrust using Parameter with a local orbital frame defined by its type.

ConstantThrustManeuver(AbsoluteDate date, double duration, PropulsiveProperty engine, Parameter flowRate, Vector3D inDirection, MassProvider massProvider, TankProperty tank)
Constructor for a constant direction in satellite frame and constant thrust using Parameter, PropulsiveProperty and TankProperty.

ConstantThrustManeuver(AbsoluteDate date, double duration, PropulsiveProperty engine, Parameter flowRate, Vector3D inDirection, MassProvider massProvider, TankProperty tank, Frame frameIn)
Constructor for a constant direction in satellite frame and constant thrust using Parameter, PropulsiveProperty and TankProperty.

ConstantThrustManeuver(AbsoluteDate date, double duration, PropulsiveProperty engine, Parameter flowRate, Vector3D inDirection, MassProvider massProvider, TankProperty tank, LOFType lofTyp)
Constructor for a constant direction in satellite frame and constant thrust using Parameter, PropulsiveProperty and TankProperty.

ConstantThrustManeuver(AbsoluteDate date, double duration, PropulsiveProperty engine, Vector3D inDirection, MassProvider massProvider, TankProperty tank)
Constructor for a constant direction in satellite frame and constant thrust, using PropulsiveProperty and TankProperty.

ConstantThrustManeuver(AbsoluteDate date, double duration, PropulsiveProperty engine, Vector3D inDirection, MassProvider massProvider, TankProperty tank, Frame frameIn)
Constructor for a constant direction in provided frame and constant thrust, using PropulsiveProperty and TankProperty.

ConstantThrustManeuver(AbsoluteDate date, double duration, PropulsiveProperty engine, Vector3D inDirection, MassProvider massProvider, TankProperty tank, LOFType lofTyp)
Constructor for a constant direction in provided local orbital frame and constant thrust, using PropulsiveProperty and TankProperty.

ConstantThrustManeuver(EventDetector startEventDetector, EventDetector stopEventDetector, double thrust, double isp, Vector3D inDirection, MassProvider massProvider, String partNameIn)
Constructor for a constant direction in satellite frame and constant thrust.

ConstantThrustManeuver(EventDetector startEventDetector, EventDetector stopEventDetector, double thrust, double isp, Vector3D inDirection, MassProvider massProvider, String partNameIn, Frame frameIn)
Constructor for a constant direction in provided frame and constant thrust.

ConstantThrustManeuver(EventDetector startEventDetector, EventDetector stopEventDetector, double thrust, double isp, Vector3D inDirection, MassProvider massProvider, String partNameIn, LOFType lofTyp)
Constructor for a constant direction in provided local orbital frame and constant thrust.

ConstantThrustManeuver(EventDetector startEventDetector, EventDetector stopEventDetector, PropulsiveProperty engine, Vector3D inDirection, MassProvider massProvider, TankProperty tank)
Constructor for a constant direction in satellite frame and constant thrust with PropulsiveProperty and TankProperty properties.

ConstantThrustManeuver(EventDetector startEventDetector, EventDetector stopEventDetector, PropulsiveProperty engine, Vector3D inDirection, MassProvider massProvider, TankProperty tank, Frame frameIn)
Constructor for a constant direction in provided frame and constant thrust with PropulsiveProperty and TankProperty properties.

ConstantThrustManeuver(EventDetector startEventDetector, EventDetector stopEventDetector, PropulsiveProperty engine, Vector3D inDirection, MassProvider massProvider, TankProperty tank, LOFType lofTyp)
Constructor for a constant direction in local orbital frame and constant thrust with PropulsiveProperty and TankProperty properties.

EmpiricalForce(int harmonicFactor, Vector3D vectorS, IParamDiffFunction ax, IParamDiffFunction ay, IParamDiffFunction az, IParamDiffFunction bx, IParamDiffFunction by, IParamDiffFunction bz, IParamDiffFunction cx, IParamDiffFunction cy, IParamDiffFunction cz, Frame coeffsFrame)
Simple constructor for an empiric force using parameterizable functions for A; B and C coef with a given frame.

EmpiricalForce(int harmonicFactor, Vector3D vectorS, IParamDiffFunction ax, IParamDiffFunction ay, IParamDiffFunction az, IParamDiffFunction bx, IParamDiffFunction by, IParamDiffFunction bz, IParamDiffFunction cx, IParamDiffFunction cy, IParamDiffFunction cz, LOFType coeffsFrameLOFType)
Simple constructor for an empiric force using parameterizable functions for A; B and C coef with a given LOF frame.

EmpiricalForce(int harmonicFactor, Vector3D vectorS, Parameter ax, Parameter ay, Parameter az, Parameter bx, Parameter by, Parameter bz, Parameter cx, Parameter cy, Parameter cz, Frame coeffsFrame)
Simple constructor for an empiric force using Parameter for A; B and C coef with a given frame.

EmpiricalForce(int harmonicFactor, Vector3D vectorS, Parameter ax, Parameter ay, Parameter az, Parameter bx, Parameter by, Parameter bz, Parameter cx, Parameter cy, Parameter cz, LOFType coeffsFrameLOFType)
Simple constructor for an empiric force using Parameter for A; B and C coef with a given LOF frame.

EmpiricalForce(int harmonicFactor, Vector3D vectorS, Vector3D a, Vector3D b, Vector3D c, Frame coeffsFrame)
Simple constructor for an empiric force, assigning a generic frame to the A, B, C coefficients frame.

EmpiricalForce(int harmonicFactor, Vector3D vectorS, Vector3D a, Vector3D b, Vector3D c, LOFType coeffsFrameLOFType)
Simple constructor for an empiric force.

Uses of Vector3D in fr.cnes.sirius.patrius.forces.radiation

Methods in fr.cnes.sirius.patrius.forces.radiation that return Vector3D

Vector3D

PatriusSolarRadiationPressure.computeAcceleration(SpacecraftState s)

Methods in fr.cnes.sirius.patrius.forces.radiation with parameters of type Vector3D

static double

PatriusSolarRadiationPressure.getLightningRatio(PVCoordinatesProvider sun, Vector3D satSunVector, GeometricBodyShape earthModel, Vector3D position, Frame frame, AbsoluteDate date) Get the lightning ratio ([0-1]).

Uses of Vector3D in fr.cnes.sirius.patrius.guidance

Methods in fr.cnes.sirius.patrius.guidance that return Vector3D

Vector3D	Vector3DPolynomialSegment.getVector3D(AbsoluteDate date) Get the angular velocity from the vector 3D polynomials at a given date.
Vector3D	Vector3DPolynomialSegment.integral(double x0, double xf) Returns the integral of the vector function in the given interval.

Uses of Vector3D in fr.cnes.sirius.patrius.signalpropagation

Methods in fr.cnes.sirius.patrius.signalpropagation that return Vector3D

Vector3D

SignalPropagation.getVector(Frame expressionFrame)

Constructors in fr.cnes.sirius.patrius.signalpropagation with parameters of type Vector3D

SignalPropagation(Vector3D propagationVector, AbsoluteDate inEmissionDate, AbsoluteDate inReceptionDate, Frame refFrame, SignalPropagationModel.FixedDate fixedDate)
Constructor with computation of one of the dates

Uses of Vector3D in fr.cnes.sirius.patrius.signalpropagation.iono

Methods in fr.cnes.sirius.patrius.signalpropagation.iono with parameters of type Vector3D

double	BentModel.computeElectronicCont(AbsoluteDate date, Vector3D satellite, Frame frameSat) Computation of the electric content between the station and the satellite at a date.
double	BentModel.computeSignalDelay(AbsoluteDate date, Vector3D satellite, Frame frameSat)
double	IonosphericCorrection.computeSignalDelay(AbsoluteDate date, Vector3D satellite, Frame satFrame) Calculates the ionospheric signal delay for the signal path from the position of the transmitter and the receiver and the current date.

Constructors in fr.cnes.sirius.patrius.signalpropagation.iono with parameters of type Vector3D

BentModel(R12Provider r12Provider, SolarActivityDataProvider solarActivity, USKProvider uskProvider, BodyShape earth, Vector3D inStation, Frame inFrameSta, double freq)
Constructor for the Bent ionospheric correction model.

Uses of Vector3D in fr.cnes.sirius.patrius.stela.bodies

Methods in fr.cnes.sirius.patrius.stela.bodies with parameters of type Vector3D

double	GeodPosition.getGeodeticAltitude(Vector3D position) Compute geodetic altitude.
double	GeodPosition.getGeodeticLatitude(Vector3D position) Compute geodetic latitude.
double	GeodPosition.getGeodeticLongitude(Vector3D position, AbsoluteDate date) Compute the geodetic longitude at a given date.
double	GeodPosition.getTloc(Vector3D position, Vector3D positionSun, AbsoluteDate date) Compute the local solar time at a given date.

Uses of Vector3D in fr.cnes.sirius.patrius.stela.forces.atmospheres

Methods in fr.cnes.sirius.patrius.stela.forces.atmospheres that return Vector3D

Vector3D

MSIS00Adapter.getVelocity(AbsoluteDate date, Vector3D position, Frame frame)

Methods in fr.cnes.sirius.patrius.stela.forces.atmospheres with parameters of type Vector3D

AtmosphereData	MSIS00Adapter.getData(AbsoluteDate date, Vector3D position, Frame frame) Get detailed atmospheric data.
double	MSIS00Adapter.getDensity(AbsoluteDate date, Vector3D position, Frame frame) Get the local density.
double	MSIS00Adapter.getSpeedOfSound(AbsoluteDate date, Vector3D position, Frame frame) Get the local speed of sound.
Vector3D	MSIS00Adapter.getVelocity(AbsoluteDate date, Vector3D position, Frame frame)

Uses of Vector3D in fr.cnes.sirius.patrius.stela.forces.drag

Methods in fr.cnes.sirius.patrius.stela.forces.drag that return Vector3D

Vector3D

StelaAeroModel.dragAcceleration(SpacecraftState state, double density, Vector3D relativeVelocity) Return the drag acceleration in the CIRF frame.

Methods in fr.cnes.sirius.patrius.stela.forces.drag with parameters of type Vector3D

void	StelaAeroModel.addDDragAccDParam(SpacecraftState s, Parameter param, double density, Vector3D relativeVelocity, double[] dAccdParam)
void	StelaAeroModel.addDDragAccDState(SpacecraftState s, double[][] dAccdPos, double[][] dAccdVel, double density, Vector3D acceleration, Vector3D relativeVelocity, boolean computeGradientPosition, boolean computeGradientVelocity)
Vector3D	StelaAeroModel.dragAcceleration(SpacecraftState state, double density, Vector3D relativeVelocity) Return the drag acceleration in the CIRF frame.
double	StelaCd.getCd(Vector3D position) Compute the value of the Cd coefficient depending on spacecraft altitude.

Uses of Vector3D in fr.cnes.sirius.patrius.stela.forces.noninertial

Methods in fr.cnes.sirius.patrius.stela.forces.noninertial that return Vector3D

Vector3D	NonInertialContribution.computeOmega(AbsoluteDate date, Frame frame1, Frame frame2) Compute rotation vector of frame2 with respect to frame1 expressed in frame2, which is the rotation vector from frame1 to frame2.
Vector3D	NonInertialContribution.computeOmegaDerivative(AbsoluteDate date, Frame frame1, Frame frame2, double dt) Compute rotation vector derivative from frame1 to frame2 using finite differences.

Uses of Vector3D in fr.cnes.sirius.patrius.stela.forces.radiation

Methods in fr.cnes.sirius.patrius.stela.forces.radiation that return Vector3D

Vector3D

SRPSquaring.computeAcceleration(StelaEquinoctialOrbit orbit, PVCoordinates satSunVector) Compute the acceleration due to the force.

Uses of Vector3D in fr.cnes.sirius.patrius.utils

Methods in fr.cnes.sirius.patrius.utils with parameters of type Vector3D

static double	AngleTools.getAngleBewteen2Vector3D(Vector3D vector1, Vector3D vector2) Computes the angle between 2 vectors 3D.
static double	AngleTools.getOrientedAngleBewteen2Vector3D(Vector3D vector1, Vector3D vector2, Vector3D vector3) Computes the oriented angle between 2 vectors 3D.

Uses of Vector3D in fr.cnes.sirius.patrius.wrenches

Methods in fr.cnes.sirius.patrius.wrenches that return Vector3D

Vector3D	SolarRadiationWrench.computeTorque(SpacecraftState s) Compute the resulting torque at the mass centre of the spacecraft in the frame of the main part.
Vector3D	GravitationalAttractionWrench.computeTorque(SpacecraftState s) Compute the resulting torque at the mass centre of the spacecraft in the frame of the main part.
Vector3D	DragWrench.computeTorque(SpacecraftState s) Compute the resulting torque at the mass centre of the spacecraft in the frame of the main part.
Vector3D	GenericWrenchModel.computeTorque(SpacecraftState s) Compute the resulting torque at the mass centre of the spacecraft in the frame of the main part.
Vector3D	MagneticWrench.computeTorque(SpacecraftState s) Compute the resulting torque at the mass centre of the spacecraft in the frame of the main part.
Vector3D	SolarRadiationWrench.computeTorque(SpacecraftState s, Vector3D origin, Frame frame) Compute the resulting wrench.
Vector3D	GravitationalAttractionWrench.computeTorque(SpacecraftState s, Vector3D origin, Frame frame) Compute the resulting wrench.
Vector3D	DragWrench.computeTorque(SpacecraftState s, Vector3D origin, Frame frame) Compute the resulting wrench.
Vector3D	GenericWrenchModel.computeTorque(SpacecraftState s, Vector3D origin, Frame frame) Compute the resulting wrench.
Vector3D	MagneticWrench.computeTorque(SpacecraftState s, Vector3D origin, Frame frame) Compute the resulting wrench.

Methods in fr.cnes.sirius.patrius.wrenches with parameters of type Vector3D

Vector3D	SolarRadiationWrench.computeTorque(SpacecraftState s, Vector3D origin, Frame frame) Compute the resulting wrench.
Vector3D	GravitationalAttractionWrench.computeTorque(SpacecraftState s, Vector3D origin, Frame frame) Compute the resulting wrench.
Vector3D	DragWrench.computeTorque(SpacecraftState s, Vector3D origin, Frame frame) Compute the resulting wrench.
Vector3D	GenericWrenchModel.computeTorque(SpacecraftState s, Vector3D origin, Frame frame) Compute the resulting wrench.
Vector3D	MagneticWrench.computeTorque(SpacecraftState s, Vector3D origin, Frame frame) Compute the resulting wrench.
Wrench	SolarRadiationWrench.computeWrench(SpacecraftState s, Vector3D origin, Frame frame) Compute the resulting wrench.
Wrench	GravitationalAttractionWrench.computeWrench(SpacecraftState s, Vector3D origin, Frame frame) Compute the resulting wrench.
Wrench	DragWrench.computeWrench(SpacecraftState s, Vector3D origin, Frame frame) Compute the resulting wrench.
Wrench	GenericWrenchModel.computeWrench(SpacecraftState s, Vector3D origin, Frame frame) Compute the resulting wrench.
Wrench	MagneticWrench.computeWrench(SpacecraftState s, Vector3D origin, Frame frame) Compute the resulting wrench.
Wrench	DragWrenchSensitive.dragWrench(SpacecraftState state, double density, Vector3D relativeVelocity) Compute the torque due to radiation pressire.
Wrench	DragWrenchSensitive.dragWrench(SpacecraftState state, double density, Vector3D relativeVelocity, Vector3D origin, Frame frame) Compute the torque due to radiation pressire.
Wrench	RadiationWrenchSensitive.radiationWrench(SpacecraftState state, Vector3D flux) Compute the torque due to radiation pressire.
Wrench	RadiationWrenchSensitive.radiationWrench(SpacecraftState state, Vector3D flux, Vector3D origin, Frame frame) Compute the torque due to radiation pressire.

Constructors in fr.cnes.sirius.patrius.wrenches with parameters of type Vector3D

GenericWrenchModel(ForceModel force, Vector3D origin)
Create a generic wrench model.

Uses of Vector3D in org.apache.commons.math3.analysis

Methods in org.apache.commons.math3.analysis that return Vector3D

Vector3D

IDependentVectorVariable.value(T x) Compute the value of the T-dependent 3D vector.

Uses of Vector3D in org.apache.commons.math3.analysis.polynomials

Methods in org.apache.commons.math3.analysis.polynomials with parameters of type Vector3D

double

HelmholtzPolynomial.computeHelmholtzPolynomial(Vector3D point) Calculate the value of the polynomial in a given point.

Uses of Vector3D in org.apache.commons.math3.geometry.euclidean.threed

Fields in org.apache.commons.math3.geometry.euclidean.threed declared as Vector3D

static Vector3D	Vector3D.MINUS_I Opposite of the first canonical vector (coordinates: -1, 0, 0).
static Vector3D	Vector3D.MINUS_J Opposite of the second canonical vector (coordinates: 0, -1, 0).
static Vector3D	Vector3D.MINUS_K Opposite of the third canonical vector (coordinates: 0, 0, -1).
static Vector3D	Vector3D.NaN A vector with all coordinates set to NaN.
static Vector3D	Vector3D.NEGATIVE_INFINITY A vector with all coordinates set to negative infinity.
static Vector3D	Vector3D.PLUS_I First canonical vector (coordinates: 1, 0, 0).
static Vector3D	Vector3D.PLUS_J Second canonical vector (coordinates: 0, 1, 0).
static Vector3D	Vector3D.PLUS_K Third canonical vector (coordinates: 0, 0, 1).
static Vector3D	Vector3D.POSITIVE_INFINITY A vector with all coordinates set to positive infinity.
static Vector3D	Vector3D.ZERO Null vector (coordinates: 0, 0, 0).

Methods in org.apache.commons.math3.geometry.euclidean.threed that return Vector3D

Vector3D	Vector3D.add(double factor, Vector<Euclidean3D> v) Add a scaled vector to the instance.
Vector3D	Vector3D.add(Vector<Euclidean3D> v) Add a vector to the instance.
Vector3D	Rotation.applyInverseTo(Vector3D u) Apply the inverse of the rotation to a vector.
Vector3D	Rotation.applyTo(Vector3D u) Apply the rotation to a vector.
Vector3D	Line.closestPoint(Line line) Compute the point of the instance closest to another line.
Vector3D[]	RectangleCone.closestPointTo(Line line) Computes the points of the shape and the line realizing the shortest distance.
Vector3D[]	RightCircularCylinder.closestPointTo(Line line) Computes the points of the shape and the line realizing the shortest distance.
Vector3D[]	InfiniteEllipticCone.closestPointTo(Line line) Calculate the closest point to a line
Vector3D[]	Plate.closestPointTo(Line line) Computes the points of the shape and the line realizing the shortest distance.
Vector3D[]	InfiniteRectangleCone.closestPointTo(Line line) Computes the points of the shape and the line realizing the shortest distance.
Vector3D[]	InfiniteRightCircularCylinder.closestPointTo(Line line) Computes the points of the shape and the line realizing the shortest distance.
Vector3D[]	Plane.closestPointTo(Line line) Computes the points of the shape and the line realizing the shortest distance.
Vector3D[]	Shape.closestPointTo(Line line) Computes the points of the shape and the line realizing the shortest distance.
Vector3D[]	EllipticCylinder.closestPointTo(Line line) Computes the points of the shape and the line realizing the shortest distance.
Vector3D[]	SphericalCap.closestPointTo(Line line) Computes the points of the shape and the line realizing the shortest distance.
Vector3D[]	LineSegment.closestPointTo(Line line) Computation of the closest point to a line, and the associated point of the line;
Vector3D[]	Ellipsoid.closestPointTo(Line line) This method computes the point on the line that is the closest to the ellipsoid.
Vector3D[]	AbstractEllipse.closestPointTo(Line line) Computes the points of the shape and the line realizing the shortest distance.
Vector3D[]	InfiniteRightCircularCone.closestPointTo(Line line) Computes the points of the shape and the line realizing the shortest distance.
Vector3D[]	Line.closestPointTo(Line line) Computes the points of this and another line realizing the shortest distance.
Vector3D[]	InfiniteRectangleCylinder.closestPointTo(Line line) Computes the points of the shape and the line realizing the shortest distance.
Vector3D[]	EllipticCone.closestPointTo(Line line) Computes the points of the shape and the line realizing the shortest distance.
Vector3D[]	Sphere.closestPointTo(Line line) Computes the points of the shape and the line realizing the shortest distance.
Vector3D[]	RightCircularCone.closestPointTo(Line line) Computes the points of the shape and the line realizing the shortest distance.
Vector3D[]	InfiniteEllipticCylinder.closestPointTo(Line line) Calculate closest point to a line
Vector3D[]	Parallelepiped.closestPointTo(Line line) Computes the points of the shape and the line realizing the shortest distance.
Vector3D	IEllipsoid.closestPointTo(Vector3D point) Computes the point, on the ellipsoid surface, that is the closest to a point of space.
Vector3D	InfiniteEllipticCone.closestPointTo(Vector3D point) Computes the closest point on the cone to a user specified point
Vector3D	Ellipsoid.closestPointTo(Vector3D point) Computes the point, on the ellipsoid surface, that is the closest to a point of space.
Vector3D	AbstractEllipse.closestPointTo(Vector3D point) Computes the point on the ellipse closest to a point.
Vector3D	Sphere.closestPointTo(Vector3D point) Computes the point, on the ellipsoid surface, that is the closest to a point of space.
Vector3D	InfiniteEllipticCylinder.closestPointTo(Vector3D point) Computes the closest point on the cone to a user specified point
Vector3D	Vector3D.crossProduct(Vector<Euclidean3D> v) Compute the cross-product of the instance with another vector.
static Vector3D	Vector3D.crossProduct(Vector3D v1, Vector3D v2) Compute the cross-product of two vectors.
Vector3D	RotationOrder.getA1() Get the axis of the first rotation.
Vector3D	RotationOrder.getA2() Get the axis of the second rotation.
Vector3D	RotationOrder.getA3() Get the axis of the second rotation.
Vector3D	InfiniteEllipticCone.getAffineLocalExpression(Vector3D myVector) Express a Vector3D in spheroid local frame.
Vector3D	Ellipsoid.getAffineLocalExpression(Vector3D myVector) Express a Vector3D in ellipsoid local basis.
Vector3D	InfiniteEllipticCylinder.getAffineLocalExpression(Vector3D myVector) Express a Vector3D in spheroid local frame.
Vector3D	InfiniteEllipticCone.getAffineStandardExpression(Vector3D vector) Express a Vector3D in standard basis.
Vector3D	Ellipsoid.getAffineStandardExpression(Vector3D myVector) Express a Vector3D in standard basis.
Vector3D	InfiniteEllipticCylinder.getAffineStandardExpression(Vector3D myVector) Express a Vector3D in standard basis.
Vector3D	InfiniteRectangleCone.getAxis()
Vector3D	InfiniteRightCircularCone.getAxis()
Vector3D	Rotation.getAxis() Get the normalized axis of the rotation.
Vector3D	Plate.getC1()
Vector3D	Plate.getC2()
Vector3D	Plate.getC3()
Vector3D	Plate.getC4()
Vector3D	IEllipsoid.getCenter() Get ellipsoids' center
Vector3D	Plate.getCenter()
Vector3D	Ellipsoid.getCenter() Get ellipsoid center
Vector3D	AbstractEllipse.getCenter()
Vector3D	Sphere.getCenter()
Vector3D	Parallelepiped.getCenter()
Vector3D[]	Parallelepiped.getCorners()
Vector3D	RectangleCone.getDirection()
Vector3D	RightCircularCylinder.getDirection()
Vector3D	InfiniteRightCircularCylinder.getDirection()
Vector3D	EllipticCylinder.getDirection()
Vector3D	LineSegment.getDirection()
Vector3D	Line.getDirection() Get the normalized direction vector.
Vector3D	InfiniteRectangleCylinder.getDirection()
Vector3D	EllipticCone.getDirection()
Vector3D	RightCircularCone.getDirection()
Vector3D	InfiniteEllipticCylinder.getDirection() This method returns the main axis of the cylinder
Vector3D	Segment.getEnd() Get the end point of the segment.
Vector3D	LineSegment.getEnd()
Vector3D[]	RectangleCone.getIntersectionPoints(Line line) Compute the intersection points with a line.
Vector3D[]	RightCircularCylinder.getIntersectionPoints(Line line) Compute the intersection points with a line.
Vector3D[]	InfiniteEllipticCone.getIntersectionPoints(Line line) This methods computes and returns the intersection points between a line and the cone.
Vector3D[]	Plate.getIntersectionPoints(Line line) Compute the intersection points with a line.
Vector3D[]	InfiniteRectangleCone.getIntersectionPoints(Line line) Compute the intersection points with a line.
Vector3D[]	InfiniteRightCircularCylinder.getIntersectionPoints(Line line) Compute the intersection points with a line.
Vector3D[]	Plane.getIntersectionPoints(Line line) Compute the intersection points with a line.
Vector3D[]	Shape.getIntersectionPoints(Line line) Compute the intersection points with a line.
Vector3D[]	EllipticCylinder.getIntersectionPoints(Line line) Compute the intersection points with a line.
Vector3D[]	SphericalCap.getIntersectionPoints(Line line) Returns a list of intersection points between the line and the spherical cap. Only the border points are given.
Vector3D[]	Ellipsoid.getIntersectionPoints(Line line) If more than one intersection points are found, the closest to the line's origin is returned first
Vector3D[]	AbstractEllipse.getIntersectionPoints(Line line) Compute the intersection points with a line.
Vector3D[]	InfiniteRightCircularCone.getIntersectionPoints(Line line) Compute the intersection points with a line.
Vector3D[]	Line.getIntersectionPoints(Line line) Compute the intersection points with another line if it exists.
Vector3D[]	InfiniteRectangleCylinder.getIntersectionPoints(Line line) Compute the intersection points with a line.
Vector3D[]	EllipticCone.getIntersectionPoints(Line line) Compute the intersection points with a line.
Vector3D[]	Sphere.getIntersectionPoints(Line line) Compute the intersection points with a line.
Vector3D[]	RightCircularCone.getIntersectionPoints(Line line) Compute the intersection points with a line.
Vector3D[]	InfiniteEllipticCylinder.getIntersectionPoints(Line line) This methods computes and returns the intersection points between a line and the cylinder.
Vector3D[]	Parallelepiped.getIntersectionPoints(Line line) Compute the intersection points with a line.
Vector3D	Plane.getNormal() Get the normalized normal vector.
Vector3D	AbstractEllipse.getNormal()
Vector3D	IEllipsoid.getNormal(Vector3D point) Computes the normal vector to the surface in local basis
Vector3D	Ellipsoid.getNormal(Vector3D point) Computes the normal vector to the surface in local basis
Vector3D	Sphere.getNormal(Vector3D point) Computes the normal vector to the surface
Vector3D	RectangleCone.getOrigin()
Vector3D	RightCircularCylinder.getOrigin()
Vector3D	InfiniteEllipticCone.getOrigin() This method returns the origin of the cone
Vector3D	InfiniteRectangleCone.getOrigin()
Vector3D	InfiniteRightCircularCylinder.getOrigin()
Vector3D	InfiniteCone.getOrigin()
Vector3D	Screw.getOrigin()
Vector3D	Plane.getOrigin() Get the origin point of the plane frame.
Vector3D	EllipticCylinder.getOrigin()
Vector3D	LineSegment.getOrigin()
Vector3D	InfiniteRightCircularCone.getOrigin()
Vector3D	Line.getOrigin() Get the line point closest to the origin.
Vector3D	InfiniteRectangleCylinder.getOrigin()
Vector3D	EllipticCone.getOrigin()
Vector3D	RightCircularCone.getOrigin()
Vector3D	InfiniteEllipticCylinder.getOrigin() This method returns the position of the cylinder on the Oxy plane
Vector3D	Plane.getPointAt(Vector2D inPlane, double offset) Get one point from the 3D-space.
Vector3D	Screw.getRotation()
Vector3D	Ellipsoid.getSemiPrincipalX()
Vector3D	Ellipsoid.getSemiPrincipalY()
Vector3D	Ellipsoid.getSemiPrincipalZ()
Vector3D	Segment.getStart() Get the start point of the segment.
Vector3D	Screw.getTranslation()
Vector3D	RectangleCone.getU()
Vector3D	Plate.getU()
Vector3D	InfiniteRectangleCone.getU()
Vector3D	Plane.getU() Get the plane first canonical vector.
Vector3D	EllipticCylinder.getU()
Vector3D	AbstractEllipse.getU()
Vector3D	InfiniteRectangleCylinder.getU()
Vector3D	EllipticCone.getU()
Vector3D	Parallelepiped.getU()
Vector3D	RectangleCone.getV()
Vector3D	Plate.getV()
Vector3D	InfiniteRectangleCone.getV()
Vector3D	Plane.getV() Get the plane second canonical vector.
Vector3D	EllipticCylinder.getV()
Vector3D	AbstractEllipse.getV()
Vector3D	InfiniteRectangleCylinder.getV()
Vector3D	EllipticCone.getV()
Vector3D	Parallelepiped.getV()
Vector3D	InfiniteEllipticCone.getVectorialLocalExpression(Vector3D myVector) Express a Vector3D in spheroid local frame.
Vector3D	Ellipsoid.getVectorialLocalExpression(Vector3D myVector) Express a Vector3D in ellipsoid local basis.
Vector3D	InfiniteEllipticCylinder.getVectorialLocalExpression(Vector3D myVector) Express a Vector3D in spheroid local frame.
Vector3D	InfiniteEllipticCone.getVectorialStandardExpression(Vector3D vector) Express a Vector3D in standard basis.
Vector3D	Ellipsoid.getVectorialStandardExpression(Vector3D myVector) Express a Vector3D in standard basis.
Vector3D	InfiniteEllipticCylinder.getVectorialStandardExpression(Vector3D myVector) Express a Vector3D in standard basis.
Vector3D	Parallelepiped.getW()
Vector3D	Vector3D.getZero() Get the null vector of the vectorial space or origin point of the affine space.
Vector3D	Plane.intersection(Line line) Get the intersection of a line with the instance.
Vector3D	Line.intersection(Line line) Get the intersection point of the instance and another line.
static Vector3D	Plane.intersection(Plane plane1, Plane plane2, Plane plane3) Get the intersection point of three planes.
Vector3D	SubLine.intersection(SubLine subLine, boolean includeEndPoints) Get the intersection of the instance and another sub-line.
Vector3D	Matrix3D.multiply(Vector3D mult) Computes the multiplication between a Matrix3D and a Vector3D
Vector3D	Vector3D.negate() Get the opposite of the instance.
Vector3D	Vector3D.normalize() Get a normalized vector aligned with the instance.
Vector3D	Vector3D.orthogonal() Get a vector orthogonal to the instance.
Vector3D	Vector3DFormat.parse(String source) Parses a string to produce a Vector3D object.
Vector3D	Vector3DFormat.parse(String source, ParsePosition pos) Parses a string to produce a Vector3D object.
Vector3D	Line.pointAt(double abscissa) Get one point from the line.
Vector3D	Vector3D.scalarMultiply(double a) Multiply the instance by a scalar.
Vector3D	Vector3D.subtract(double factor, Vector<Euclidean3D> v) Subtract a scaled vector from the instance.
Vector3D	Vector3D.subtract(Vector<Euclidean3D> v) Subtract a vector from the instance.
Vector3D	Line.toSpace(Vector<Euclidean1D> point) Transform a sub-space point into a space point.
Vector3D	Plane.toSpace(Vector<Euclidean2D> point) Transform an in-plane point into a 3D space point.
Vector3D	FieldVector3D.toVector3D() Convert to a constant vector without derivatives.
Vector3D	Matrix3D.transposeAndMultiply(Vector3D vector) Computes the multiplication of the transposed matrix of this Matrix3D with a Vector3D

Methods in org.apache.commons.math3.geometry.euclidean.threed with parameters of type Vector3D

FieldVector3D<T>	FieldVector3D.add(double factor, Vector3D v) Add a scaled vector to the instance.
FieldVector3D<T>	FieldVector3D.add(T factor, Vector3D v) Add a scaled vector to the instance.
FieldVector3D<T>	FieldVector3D.add(Vector3D v) Add a vector to the instance.
static <T extends RealFieldElement<T>> T	FieldVector3D.angle(FieldVector3D<T> v1, Vector3D v2) Compute the angular separation between two vectors.
static <T extends RealFieldElement<T>> T	FieldVector3D.angle(Vector3D v1, FieldVector3D<T> v2) Compute the angular separation between two vectors.
static double	Vector3D.angle(Vector3D v1, Vector3D v2) Compute the angular separation between two vectors.
FieldVector3D<T>	FieldRotation.applyInverseTo(Vector3D u) Apply the inverse of the rotation to a vector.
Vector3D	Rotation.applyInverseTo(Vector3D u) Apply the inverse of the rotation to a vector.
FieldVector3D<T>	FieldRotation.applyTo(Vector3D u) Apply the rotation to a vector.
Vector3D	Rotation.applyTo(Vector3D u) Apply the rotation to a vector.
Vector3D	IEllipsoid.closestPointTo(Vector3D point) Computes the point, on the ellipsoid surface, that is the closest to a point of space.
Vector3D	InfiniteEllipticCone.closestPointTo(Vector3D point) Computes the closest point on the cone to a user specified point
Vector3D	Ellipsoid.closestPointTo(Vector3D point) Computes the point, on the ellipsoid surface, that is the closest to a point of space.
Vector3D	AbstractEllipse.closestPointTo(Vector3D point) Computes the point on the ellipse closest to a point.
Vector3D	Sphere.closestPointTo(Vector3D point) Computes the point, on the ellipsoid surface, that is the closest to a point of space.
Vector3D	InfiniteEllipticCylinder.closestPointTo(Vector3D point) Computes the closest point on the cone to a user specified point
boolean	Plane.contains(Vector3D p) Check if the instance contains a point.
boolean	Line.contains(Vector3D p) Check if the instance contains a point.
static Line	Line.createLine(Vector3D point, Vector3D direction) Creates a Line object from a point of space and a direction vector.
static <T extends RealFieldElement<T>> FieldVector3D<T>	FieldVector3D.crossProduct(FieldVector3D<T> v1, Vector3D v2) Compute the cross-product of two vectors.
FieldVector3D<T>	FieldVector3D.crossProduct(Vector3D v) Compute the cross-product of the instance with another vector.
static <T extends RealFieldElement<T>> FieldVector3D<T>	FieldVector3D.crossProduct(Vector3D v1, FieldVector3D<T> v2) Compute the cross-product of two vectors.
static Vector3D	Vector3D.crossProduct(Vector3D v1, Vector3D v2) Compute the cross-product of two vectors.
static Screw	Screw.displace(Screw s, Vector3D newOrigin) Displace this screw, using Chasles
Screw	Screw.displace(Vector3D newOrigin) Displace this screw, using Chasles
static <T extends RealFieldElement<T>> T	FieldVector3D.distance(FieldVector3D<T> v1, Vector3D v2) Compute the distance between two vectors according to the L2 norm.
T	FieldVector3D.distance(Vector3D v) Compute the distance between the instance and another vector according to the L2 norm.
double	Line.distance(Vector3D p) Compute the distance between the instance and a point.
static <T extends RealFieldElement<T>> T	FieldVector3D.distance(Vector3D v1, FieldVector3D<T> v2) Compute the distance between two vectors according to the L2 norm.
static double	Vector3D.distance(Vector3D v1, Vector3D v2) Compute the distance between two vectors according to the L2 norm.
static <T extends RealFieldElement<T>> T	FieldVector3D.distance1(FieldVector3D<T> v1, Vector3D v2) Compute the distance between two vectors according to the L1 norm.
T	FieldVector3D.distance1(Vector3D v) Compute the distance between the instance and another vector according to the L1 norm.
static <T extends RealFieldElement<T>> T	FieldVector3D.distance1(Vector3D v1, FieldVector3D<T> v2) Compute the distance between two vectors according to the L1 norm.
static double	Vector3D.distance1(Vector3D v1, Vector3D v2) Compute the distance between two vectors according to the L1 norm.
static <T extends RealFieldElement<T>> T	FieldVector3D.distanceInf(FieldVector3D<T> v1, Vector3D v2) Compute the distance between two vectors according to the L∞ norm.
T	FieldVector3D.distanceInf(Vector3D v) Compute the distance between the instance and another vector according to the L∞ norm.
static <T extends RealFieldElement<T>> T	FieldVector3D.distanceInf(Vector3D v1, FieldVector3D<T> v2) Compute the distance between two vectors according to the L∞ norm.
static double	Vector3D.distanceInf(Vector3D v1, Vector3D v2) Compute the distance between two vectors according to the L∞ norm.
static <T extends RealFieldElement<T>> T	FieldVector3D.distanceSq(FieldVector3D<T> v1, Vector3D v2) Compute the square of the distance between two vectors.
T	FieldVector3D.distanceSq(Vector3D v) Compute the square of the distance between the instance and another vector.
static <T extends RealFieldElement<T>> T	FieldVector3D.distanceSq(Vector3D v1, FieldVector3D<T> v2) Compute the square of the distance between two vectors.
static double	Vector3D.distanceSq(Vector3D v1, Vector3D v2) Compute the square of the distance between two vectors.
double	InfiniteEllipticCone.distanceTo(Vector3D point)
double	Plane.distanceTo(Vector3D point) Computes the distance between this plane and a point of space.
double	Ellipsoid.distanceTo(Vector3D point) Computes the distance to the closest point on the ellipsoid.
double	AbstractEllipse.distanceTo(Vector3D point) Computes the shortest distance from a point to the ellipse.
double	Sphere.distanceTo(Vector3D point) Computes the distance to a point of space.
double	InfiniteEllipticCylinder.distanceTo(Vector3D point)
static <T extends RealFieldElement<T>> T	FieldVector3D.dotProduct(FieldVector3D<T> v1, Vector3D v2) Compute the dot-product of two vectors.
T	FieldVector3D.dotProduct(Vector3D v) Compute the dot-product of the instance and another vector.
static <T extends RealFieldElement<T>> T	FieldVector3D.dotProduct(Vector3D v1, FieldVector3D<T> v2) Compute the dot-product of two vectors.
static double	Vector3D.dotProduct(Vector3D v1, Vector3D v2) Compute the dot-product of two vectors.
SubHyperplane<Euclidean3D>	PolyhedronsSet.firstIntersection(Vector3D point, Line line) Get the first sub-hyperplane crossed by a semi-infinite line.
double	Line.getAbscissa(Vector3D point) Get the abscissa of a point with respect to the line.
Vector3D	InfiniteEllipticCone.getAffineLocalExpression(Vector3D myVector) Express a Vector3D in spheroid local frame.
Vector3D	Ellipsoid.getAffineLocalExpression(Vector3D myVector) Express a Vector3D in ellipsoid local basis.
Vector3D	InfiniteEllipticCylinder.getAffineLocalExpression(Vector3D myVector) Express a Vector3D in spheroid local frame.
Vector3D	InfiniteEllipticCone.getAffineStandardExpression(Vector3D vector) Express a Vector3D in standard basis.
Vector3D	Ellipsoid.getAffineStandardExpression(Vector3D myVector) Express a Vector3D in standard basis.
Vector3D	InfiniteEllipticCylinder.getAffineStandardExpression(Vector3D myVector) Express a Vector3D in standard basis.
double	RightCircularCylinder.getCrossSection(Vector3D crossDirection) Computes the cross section from the direction defined by a Vector3D.
double	Plate.getCrossSection(Vector3D direction) Computes the cross section from the direction defined by a Vector3D.
double	Sphere.getCrossSection(Vector3D direction) Computes the cross section from the direction defined by a Vector3D.
double	Parallelepiped.getCrossSection(Vector3D direction) Computes the cross section from the direction defined by a Vector3D.
double	CrossSectionProvider.getCrossSection(Vector3D direction) Computes the cross section from the direction defined by a Vector3D.
double[]	Ellipsoid.getEllipsoidicCoordinates(Vector3D point) Convert from Cartesian to Ellipsoid coordinates
Vector3D	IEllipsoid.getNormal(Vector3D point) Computes the normal vector to the surface in local basis
Vector3D	Ellipsoid.getNormal(Vector3D point) Computes the normal vector to the surface in local basis
Vector3D	Sphere.getNormal(Vector3D point) Computes the normal vector to the surface
Vector3D	InfiniteEllipticCone.getVectorialLocalExpression(Vector3D myVector) Express a Vector3D in spheroid local frame.
Vector3D	Ellipsoid.getVectorialLocalExpression(Vector3D myVector) Express a Vector3D in ellipsoid local basis.
Vector3D	InfiniteEllipticCylinder.getVectorialLocalExpression(Vector3D myVector) Express a Vector3D in spheroid local frame.
Vector3D	InfiniteEllipticCone.getVectorialStandardExpression(Vector3D vector) Express a Vector3D in standard basis.
Vector3D	Ellipsoid.getVectorialStandardExpression(Vector3D myVector) Express a Vector3D in standard basis.
Vector3D	InfiniteEllipticCylinder.getVectorialStandardExpression(Vector3D myVector) Express a Vector3D in standard basis.
boolean	InfiniteEllipticCone.isInside(Vector3D point) Return true if point is inside cone
boolean	InfiniteEllipticCone.isStrictlyInside(Vector3D point) Return true if point is inside cone
Vector3D	Matrix3D.multiply(Vector3D mult) Computes the multiplication between a Matrix3D and a Vector3D
void	Plane.reset(Vector3D p, Vector3D normal) Reset the instance as if built from a point and a normal.
void	Line.reset(Vector3D p1, Vector3D p2) Reset the instance as if built from two points.
Plane	Plane.rotate(Vector3D center, Rotation rotation) Rotate the plane around the specified point.
PolyhedronsSet	PolyhedronsSet.rotate(Vector3D center, Rotation rotation) Rotate the region around the specified point.
FieldVector3D<T>	FieldVector3D.subtract(double factor, Vector3D v) Subtract a scaled vector from the instance.
FieldVector3D<T>	FieldVector3D.subtract(T factor, Vector3D v) Subtract a scaled vector from the instance.
FieldVector3D<T>	FieldVector3D.subtract(Vector3D v) Subtract a vector from the instance.
Plane	Plane.translate(Vector3D translation) Translate the plane by the specified amount.
PolyhedronsSet	PolyhedronsSet.translate(Vector3D translation) Translate the region by the specified amount.
Vector3D	Matrix3D.transposeAndMultiply(Vector3D vector) Computes the multiplication of the transposed matrix of this Matrix3D with a Vector3D

Constructors in org.apache.commons.math3.geometry.euclidean.threed with parameters of type Vector3D

AbstractEllipse(Vector3D inCenter, Vector3D inNormal, Vector3D inUvector, double inRadiusA, double inRadiusB)
Build an ellipse in the 3D space from its center, normal vector, approximative U vector of the local frame, and two radiuses.

Disk(Vector3D center, Vector3D normal, double radius)
Constructs the disk.

Ellipse(Vector3D inCenter, Vector3D inNormal, Vector3D inUvector, double inRadiusA, double inRadiusB)
Build an ellipse in the 3D space from its center, normal vector, approximative U vector of the local frame, and two radiuses.

Ellipsoid(Vector3D myPosition, Vector3D myRevAxis, Vector3D myXAxis, double myA, double myB, double myC)
This constructor builds a ellipsoid from its centers position, its revolution axis and its transverse and conjugate radii.

EllipticCone(Vector3D inOrigin, Vector3D inDirection, Vector3D inUvector, double inAngleU, double inAngleV, double inHeight)
Build an oblique circular cone from its radius, the height, the origin (apex), the approximative u vector of the local frame and direction of its axis.

EllipticCylinder(Vector3D inOrigin, Vector3D inDirection, Vector3D inUvector, double inRadiusA, double inRadiusB, double inHeight)
Build an oblique circular cylinder from its radiuses, the height, the origin, the approximative u vector of the local frame and the direction of its axis.

FieldVector3D(T a, Vector3D u)
Multiplicative constructor Build a vector from another one and a scale factor.

FieldVector3D(T a1, Vector3D u1, T a2, Vector3D u2)
Linear constructor Build a vector from two other ones and corresponding scale factors.

FieldVector3D(T a1, Vector3D u1, T a2, Vector3D u2, T a3, Vector3D u3)
Linear constructor Build a vector from three other ones and corresponding scale factors.

FieldVector3D(T a1, Vector3D u1, T a2, Vector3D u2, T a3, Vector3D u3, T a4, Vector3D u4)
Linear constructor Build a vector from four other ones and corresponding scale factors.

InfiniteEllipticCone(Vector3D aorigin, Vector3D aDirection, Vector3D aaxisU, double aalpha, double bbeta)
This is the constructor for the class InfiniteObliqueCircularCone.

InfiniteEllipticCylinder(Vector3D myLocalOrigin, Vector3D myDirection, Vector3D myXAxis, double myA, double myB)
This is the constructor for the class InfiniteEllipticCylinder.

InfiniteRectangleCone(Vector3D inOrigin, Vector3D inDirection, Vector3D inUvector, double inAngleU, double inAngleV)
Build an infinite rectangle cone from the position of its origin, its axis, a vector defining the orientation of the rectangle and two angles

InfiniteRectangleCylinder(Line inDirection, Vector3D inUVector, double inLength, double inWidth)
Build an infinite rectangle cylinder from its dimensions, orientation and the origin and direction of its axis

InfiniteRectangleCylinder(Vector3D inOrigin, Vector3D inDirection, Vector3D inUvector, double inLength, double inWidth)
Build an infinite rectangle cylinder from its dimensions, orientation and the origin and direction of its axis

InfiniteRightCircularCone(Vector3D inOrigin, Vector3D inDirection, double inAngle)
Build an infinite elliptic cone from its angle, the position of its origin and its axis

InfiniteRightCircularCylinder(Vector3D inOrigin, Vector3D inDirection, double inRadius)
Build an infinite right circular cylinder from its radius and the origin and direction of its axis

Line(Vector3D p1, Vector3D p2)
Build a line from two points.

LineSegment(Vector3D inOrigin, Vector3D inDirection, double inLength)
Build a line segment from its origin, direction and length.

Matrix3D(Vector3D vector)
Constructor
Builds a cross product matrix M from a vector u such as : M(u) * v = u^v

OutlineExtractor(Vector3D u, Vector3D v)
Build an extractor for a specific projection plane.

Parallelepiped(Vector3D inCenter, Vector3D inU, Vector3D inV, double inLength, double inWidth, double inHeight)
Build a parallelepiped from the position of its center, two vectors to describe its local frame and dimensions.

Plane(Line line, Vector3D vector)
Build a plane from a line and a vector.

Plane(Vector3D normal)
Build a plane normal to a given direction and containing the origin.

Plane(Vector3D point, Line line)
Build a plane from a line and a point out of the line.

Plane(Vector3D p, Vector3D normal)
Build a plane from a point and a normal.

Plane(Vector3D p1, Vector3D p2, Vector3D p3)
Build a plane from three points.

Plane(Vector3D p, Vector3D v1, Vector3D v2, boolean isFrame)
Build a plane from a point and two vectors.

Plate(Vector3D inCenter, Vector3D inU, Vector3D inV, double inLength, double inWidth)
Build a plate from the position of its center and two vectors to describe its local frame and dimensions.

RectangleCone(Vector3D inOrigin, Vector3D inDirection, Vector3D inUvector, double inLength, double inWidth, double inHeight)
Build a rectangle cone from its apex (origin), axis' direction, approximative U vector of the local frame and dimensions.

RightCircularCone(Vector3D inOrigin, Vector3D inDirection, double inAngle, double inLength)
Build a elliptic cone from its radius, the height, the origin (apex) and direction of its axis

RightCircularCylinder(Vector3D inOrigin, Vector3D inDirection, double inRadius, double inHeight)
Build an infinite right circular cylinder from its radius and the origin and direction of its axis

Rotation(Vector3D axis, double angle)
Build a rotation from an axis and an angle.

Rotation(Vector3D u, Vector3D v)
Build one of the rotations that transform one vector into another one.

Rotation(Vector3D u1, Vector3D u2, Vector3D v1, Vector3D v2)
Build the rotation that transforms a pair of vector into another pair.

Screw(Vector3D inOrigin, Vector3D inTranslation, Vector3D inRotation)
Constructor

Segment(Vector3D start, Vector3D end, Line line)
Build a segment.

Sphere(Vector3D inCenter, double inRadius)
Build a sphere from its radius and the position of its center

Spheroid(Vector3D myPosition, Vector3D myRevAxis, double equatorialRadius, double polarRadius)
This constructor builds a spheroid from its centers position, its revolution axis and its equatorial and polar radius.

SubLine(Vector3D start, Vector3D end)
Create a sub-line from two endpoints.

Vector3D(double a, Vector3D u)
Multiplicative constructor Build a vector from another one and a scale factor.

Vector3D(double a1, Vector3D u1, double a2, Vector3D u2)
Linear constructor Build a vector from two other ones and corresponding scale factors.

Vector3D(double a1, Vector3D u1, double a2, Vector3D u2, double a3, Vector3D u3)
Linear constructor Build a vector from three other ones and corresponding scale factors.

Vector3D(double a1, Vector3D u1, double a2, Vector3D u2, double a3, Vector3D u3, double a4, Vector3D u4)
Linear constructor Build a vector from four other ones and corresponding scale factors.

Uses of Vector3D in org.orekit.attitudes

Fields in org.orekit.attitudes declared as Vector3D

protected Vector3D

AbstractIsisSpinBiasSlew.slewAxis Axis of the rotation associated to the spin bias slew.

Methods in org.orekit.attitudes that return Vector3D

Vector3D	Attitude.getRotationAcceleration() Get the satellite rotation acceleration.
Vector3D	Attitude.getSpin() Get the satellite spin.
Vector3D	TwoSpinBiasSlew.getSpinDerivatives(AbsoluteDate date, Frame frame) get the spin derivatives (default implementation : finite differences differentiator).
protected Vector3D	GroundPointingWrapper.getTargetPoint(PVCoordinatesProvider pvProv, AbsoluteDate date, Frame frame) Compute the target point in specified frame.
protected Vector3D	TargetGroundPointing.getTargetPoint(PVCoordinatesProvider pvProv, AbsoluteDate date, Frame frame) Compute the target point in specified frame.
protected Vector3D	BodyCenterGroundPointing.getTargetPoint(PVCoordinatesProvider pvProv, AbsoluteDate date, Frame frame)
protected Vector3D	LofOffsetPointing.getTargetPoint(PVCoordinatesProvider pvProv, AbsoluteDate date, Frame frame) Compute the target point in specified frame.
protected Vector3D	NadirPointing.getTargetPoint(PVCoordinatesProvider pvProv, AbsoluteDate date, Frame frame) Compute the target point in specified frame.
protected abstract Vector3D	GroundPointing.getTargetPoint(PVCoordinatesProvider pvProv, AbsoluteDate date, Frame frame) Compute the target point in specified frame.

Constructors in org.orekit.attitudes with parameters of type Vector3D

Attitude(AbsoluteDate date, Frame referenceFrame, Rotation attitude, Vector3D spin)
Creates a new instance.

Attitude(AbsoluteDate date, Frame referenceFrame, Rotation attitude, Vector3D spin, Vector3D acceleration)
Creates a new instance.

CelestialBodyPointed(Frame pCelestialFrame, PVCoordinatesProvider pPointedBody, Vector3D pPhasingCel, Vector3D pPointingSat, Vector3D pPhasingSat)
Creates new instance.

DirectionTrackingOrientation(IDirection direction, Vector3D satelliteAxis, Vector3D satelliteFixedAxis)
Constructor.

LofOffsetPointing(BodyShape shape, AttitudeProvider attLaw, Vector3D satPointingVector)
Creates new instance.

SpinStabilized(AttitudeLaw pNonRotatingLaw, AbsoluteDate pStart, Vector3D pAxis, double pRate)
Creates a new instance.

SunPointing(CelestialBody body, Vector3D firstAxis, Vector3D secondAxis)
Constructor of the sun pointing attitude law.

SunPointing(CelestialBody body, Vector3D firstAxis, Vector3D secondAxis, CelestialBody sun)
Constructor of the sun pointing attitude law.

SunPointing(Vector3D firstAxis, Vector3D secondAxis)
Constructor of the sun pointing attitude law.

SunPointing(Vector3D firstAxis, Vector3D secondAxis, CelestialBody sun)
Constructor of the sun pointing attitude law.

TargetGroundPointing(BodyShape bodyShape, Vector3D target)
Creates a new instance from body shape and target expressed in cartesian coordinates.

TargetPointing(Frame bodyFrame, Vector3D target)
Creates a new instance from body frame and target expressed in cartesian coordinates.

TwoDirectionsAttitude(IDirection firstDirection, IDirection secondDirection, Vector3D firstAxis, Vector3D secondAxis)
Constructor with default step values for spin and spin derivatives computation using finite differences (0.2s for spin, 0.001s for spin derivative).

TwoDirectionsAttitude(IDirection firstDirection, IDirection secondDirection, Vector3D firstAxis, Vector3D secondAxis, double dtSpin, double dtAcc)
Constructor.

YawSteering(GroundPointing groundPointingLaw, PVCoordinatesProvider sun, Vector3D phasingAxis)
Creates a new instance.

Uses of Vector3D in org.orekit.attitudes.directions

Methods in org.orekit.attitudes.directions that return Vector3D

Vector3D	IDirection.getVector(PVCoordinatesProvider pvCoord, AbsoluteDate date, Frame frame) Provides the direction vector at a given date in a given frame.
Vector3D	NadirDirection.getVector(PVCoordinatesProvider pvCoord, AbsoluteDate date, Frame frame)
Vector3D	MomentumDirection.getVector(PVCoordinatesProvider origin, AbsoluteDate date, Frame frame) Provides the direction vector at a given date in a given frame.
Vector3D	GlintApproximatePointingDirection.getVector(PVCoordinatesProvider origin, AbsoluteDate date, Frame frame) Provides the direction vector at a given date in a given frame.
Vector3D	EarthToCelestialBodyCenterDirection.getVector(PVCoordinatesProvider pvCoord, AbsoluteDate date, Frame frame) Provides the direction vector at a given date in a given frame.
Vector3D	GenericTargetDirection.getVector(PVCoordinatesProvider origin, AbsoluteDate date, Frame frame) Provides the direction vector at a given date in a given frame.
Vector3D	ConstantVectorDirection.getVector(PVCoordinatesProvider pvCoord, AbsoluteDate date, Frame frame) Provides the direction vector at a given date in a given frame.
Vector3D	EarthCenterDirection.getVector(PVCoordinatesProvider pvCoord, AbsoluteDate date, Frame frame) Provides the direction vector at a given date in a given frame.
Vector3D	CrossProductDirection.getVector(PVCoordinatesProvider pvCoord, AbsoluteDate date, Frame frame) Provides the cross product of direction1 vector and dirction2 vector.
Vector3D	GroundVelocityDirection.getVector(PVCoordinatesProvider pvCoord, AbsoluteDate date, Frame frame)
Vector3D	CelestialBodyPolesAxisDirection.getVector(PVCoordinatesProvider pvCoord, AbsoluteDate date, Frame frame) Provides the direction vector at a given date in a given frame.
Vector3D	VelocityDirection.getVector(PVCoordinatesProvider origin, AbsoluteDate date, Frame frame) Provides the direction vector at a given date in a given frame.
Vector3D	ToCelestialBodyCenterDirection.getVector(PVCoordinatesProvider origin, AbsoluteDate date, Frame frame) Provides the direction vector at a given date in a given frame.

Constructors in org.orekit.attitudes.directions with parameters of type Vector3D

ConstantVectorDirection(Vector3D inVector, Frame inFrame)
Build a direction from a frame and a vector constant in this frame

Uses of Vector3D in org.orekit.attitudes.kinematics

Methods in org.orekit.attitudes.kinematics that return Vector3D

Vector3D	AbstractOrientationFunction.computeSpin(AbsoluteDate date) Estimate the spin at a given date from the current OrientationFunction using the quaternions formula: Ω = 2 * Q' dQ, where Q' is the conjugate of the quaternion and dQ is the derivative of the quaternion at the given date.
static Vector3D	KinematicsToolkit.computeSpin(double[] ang, double[] angd, RotationOrder order) Compute spin knowing the instantaneous quaternion and its derivative.
static Vector3D	KinematicsToolkit.computeSpin(Quaternion q, Quaternion qd) Compute spin knowing the instantaneous quaternion and its derivative.
Vector3D	AbstractOrientationFunction.estimateRate(AbsoluteDate date, double dt) Estimate the spin at a given date from the current OrientationFunction using the AngularCoordinates.estimateRate(Rotation, Rotation, double) method.
static Vector3D	KinematicsToolkit.estimateSpin(Rotation start, Rotation end, double dt) Estimate spin between two orientations. Estimation is based on a simple fixed rate rotation during the time interval between the two attitude.
abstract Vector3D	AbstractVector3DFunction.getVector3D(AbsoluteDate date) Get the vector at a given date.
Vector3D	Vector3DFunction.getVector3D(AbsoluteDate date) Get the vector at a given date.
Vector3D	AbstractVector3DFunction.integral(double x0, double xf) Returns the integral of the vector function in the given interval.
Vector3D	Vector3DFunction.integral(double x0, double xf) Returns the integral of the vector function in the given interval.

Methods in org.orekit.attitudes.kinematics with parameters of type Vector3D

static Quaternion

KinematicsToolkit.differentiateQuaternion(Quaternion q, Vector3D spin) Compute the derivative of a quaternion knowing the instantaneous spin.

Uses of Vector3D in org.orekit.bodies

Methods in org.orekit.bodies that return Vector3D

Vector3D	GeodeticPoint.getEast() Get the direction to the east of point, expressed in parent shape frame.
Vector3D[]	GeometricBodyShape.getIntersectionPoints(Line line, Frame frame, AbsoluteDate date) Compute the intersection points with a line.
Vector3D[]	ExtendedOneAxisEllipsoid.getIntersectionPoints(Line line, Frame frame, AbsoluteDate date)
Vector3D	GeodeticPoint.getNadir() Get the direction below the point, expressed in parent shape frame.
Vector3D	ExtendedOneAxisEllipsoid.getNormal(Vector3D point) Return the normal vector to the surface from the ellipsoid
Vector3D	GeodeticPoint.getNorth() Get the direction to the north of point, expressed in parent shape frame.
Vector3D	IAUPole.getPole(AbsoluteDate date) Get the body North pole direction in EME2000 frame.
Vector3D	GeodeticPoint.getSouth() Get the direction to the south of point, expressed in parent shape frame.
Vector3D	GeodeticPoint.getWest() Get the direction to the west of point, expressed in parent shape frame.
Vector3D	GeodeticPoint.getZenith() Get the direction above the point, expressed in parent shape frame.
Vector3D	BodyShape.transform(GeodeticPoint point) Transform a surface-relative point to a cartesian point.
Vector3D	ExtendedOneAxisEllipsoid.transform(GeodeticPoint point)
Vector3D	OneAxisEllipsoid.transform(GeodeticPoint point) Transform a surface-relative point to a cartesian point.
Vector3D	OneAxisEllipsoid.transformAndComputeJacobian(GeodeticPoint geodeticPoint, double[][] jacobian) Transform a surface-relative point to a cartesian point and compute the jacobian of the transformation.

Methods in org.orekit.bodies with parameters of type Vector3D

GeodeticPoint	BodyShape.getIntersectionPoint(Line line, Vector3D close, Frame frame, AbsoluteDate date) Get the intersection point of a line with the surface of the body.
GeodeticPoint	ExtendedOneAxisEllipsoid.getIntersectionPoint(Line line, Vector3D close, Frame frame, AbsoluteDate date)
GeodeticPoint	OneAxisEllipsoid.getIntersectionPoint(Line line, Vector3D close, Frame frame, AbsoluteDate date) Get the intersection point of a line with the surface of the body.
double	GeometricBodyShape.getLocalRadius(Vector3D position, Frame frame, AbsoluteDate date, PVCoordinatesProvider occultedBody) Calculate the apparent radius.
double	ExtendedOneAxisEllipsoid.getLocalRadius(Vector3D position, Frame frame, AbsoluteDate date, PVCoordinatesProvider occultedBody) Calculate the apparent radius.
Vector3D	ExtendedOneAxisEllipsoid.getNormal(Vector3D point) Return the normal vector to the surface from the ellipsoid
GeodeticPoint	BodyShape.transform(Vector3D point, Frame frame, AbsoluteDate date) Transform a cartesian point to a surface-relative point.
GeodeticPoint	ExtendedOneAxisEllipsoid.transform(Vector3D point, Frame frame, AbsoluteDate date)
GeodeticPoint	OneAxisEllipsoid.transform(Vector3D point, Frame frame, AbsoluteDate date) Transform a cartesian point to a surface-relative point.
GeodeticPoint	OneAxisEllipsoid.transformAndComputeJacobian(Vector3D point, Frame frame, AbsoluteDate date, double[][] jacobian) Transform a cartesian point to a surface-relative point and compute the jacobian of the transformation.

Uses of Vector3D in org.orekit.files.general

Constructors in org.orekit.files.general with parameters of type Vector3D

SatelliteTimeCoordinate(AbsoluteDate time, Vector3D pos, double clock)
Creates a new SatelliteTimeCoordinate object with a given epoch and position coordinate.

Uses of Vector3D in org.orekit.forces

Methods in org.orekit.forces that return Vector3D

Vector3D

ForceModel.computeAcceleration(SpacecraftState s) Compute the acceleration due to the force.

Uses of Vector3D in org.orekit.forces.atmospheres

Methods in org.orekit.forces.atmospheres that return Vector3D

Vector3D	DTM2000.getVelocity(AbsoluteDate date, Vector3D position, Frame frame) Get the inertial velocity of atmosphere molecules.
Vector3D	Atmosphere.getVelocity(AbsoluteDate date, Vector3D position, Frame frame) Get the spacecraft velocity relative to the atmosphere.
Vector3D	HarrisPriester.getVelocity(AbsoluteDate date, Vector3D position, Frame frame) Get the inertial velocity of atmosphere molecules.
Vector3D	SimpleExponentialAtmosphere.getVelocity(AbsoluteDate date, Vector3D position, Frame frame) Get the spacecraft velocity relative to the atmosphere.
Vector3D	MSISE2000.getVelocity(AbsoluteDate date, Vector3D position, Frame frame) Get the spacecraft velocity relative to the atmosphere.
Vector3D	US76.getVelocity(AbsoluteDate date, Vector3D position, Frame frame) Get the spacecraft velocity relative to the atmosphere.
Vector3D	JB2006.getVelocity(AbsoluteDate date, Vector3D position, Frame frame) Get the inertial velocity of atmosphere molecules.

Methods in org.orekit.forces.atmospheres with parameters of type Vector3D

AtmosphereData	DTM2000.getData(AbsoluteDate date, Vector3D position, Frame frame) Get detailed atmospheric data.
AtmosphereData	ExtendedAtmosphere.getData(AbsoluteDate date, Vector3D position, Frame frame) Get detailed atmospheric data.
AtmosphereData	MSISE2000.getData(AbsoluteDate date, Vector3D position, Frame frame) Get detailed atmospheric data.
double	DTM2000.getDensity(AbsoluteDate date, Vector3D position, Frame frame) Get the local density.
double	Atmosphere.getDensity(AbsoluteDate date, Vector3D position, Frame frame) Get the local density.
double	HarrisPriester.getDensity(AbsoluteDate date, Vector3D position, Frame frame) Get the local density.
double	SimpleExponentialAtmosphere.getDensity(AbsoluteDate date, Vector3D position, Frame frame) Get the local density.
double	MSISE2000.getDensity(AbsoluteDate date, Vector3D position, Frame frame) Get the local density.
double	US76.getDensity(AbsoluteDate date, Vector3D position, Frame frame) Get the local density for altitude in interval [0, 1E6] m
double	JB2006.getDensity(AbsoluteDate date, Vector3D position, Frame frame) Get the local density.
double	HarrisPriester.getDensity(double sunRAsc, double sunDecl, Vector3D satPos, double satAlt) Get the local density.
double	US76.getPress(AbsoluteDate date, Vector3D position, Frame frame) Get the local pressure for altitude in interval [0, 1E6] m
double	DTM2000.getSpeedOfSound(AbsoluteDate date, Vector3D position, Frame frame) Get the local speed of sound.
double	Atmosphere.getSpeedOfSound(AbsoluteDate date, Vector3D position, Frame frame) Get the local speed of sound.
double	HarrisPriester.getSpeedOfSound(AbsoluteDate date, Vector3D position, Frame frame) Get the local speed of sound.
double	SimpleExponentialAtmosphere.getSpeedOfSound(AbsoluteDate date, Vector3D position, Frame frame) Get the local speed of sound.
double	MSISE2000.getSpeedOfSound(AbsoluteDate date, Vector3D position, Frame frame) Get the local speed of sound.
double	US76.getSpeedOfSound(AbsoluteDate date, Vector3D position, Frame frame) Get the local speed of sound.
double	JB2006.getSpeedOfSound(AbsoluteDate date, Vector3D position, Frame frame) Get the local speed of sound.
double	US76.getTemp(AbsoluteDate date, Vector3D position, Frame frame) Get the local temperature for altitude in interval [0, 1E6] m
Vector3D	DTM2000.getVelocity(AbsoluteDate date, Vector3D position, Frame frame) Get the inertial velocity of atmosphere molecules.
Vector3D	Atmosphere.getVelocity(AbsoluteDate date, Vector3D position, Frame frame) Get the spacecraft velocity relative to the atmosphere.
Vector3D	HarrisPriester.getVelocity(AbsoluteDate date, Vector3D position, Frame frame) Get the inertial velocity of atmosphere molecules.
Vector3D	SimpleExponentialAtmosphere.getVelocity(AbsoluteDate date, Vector3D position, Frame frame) Get the spacecraft velocity relative to the atmosphere.
Vector3D	MSISE2000.getVelocity(AbsoluteDate date, Vector3D position, Frame frame) Get the spacecraft velocity relative to the atmosphere.
Vector3D	US76.getVelocity(AbsoluteDate date, Vector3D position, Frame frame) Get the spacecraft velocity relative to the atmosphere.
Vector3D	JB2006.getVelocity(AbsoluteDate date, Vector3D position, Frame frame) Get the inertial velocity of atmosphere molecules.

Uses of Vector3D in org.orekit.forces.drag

Methods in org.orekit.forces.drag that return Vector3D

static Vector3D	DragForce.computeAcceleration(PVCoordinates pv, Frame frame, Atmosphere atm, AbsoluteDate date, double kD, double mass) Method to compute the acceleration.
Vector3D	DragForce.computeAcceleration(SpacecraftState s) Compute the acceleration due to the force.
Vector3D	DragSensitive.dragAcceleration(SpacecraftState state, double density, Vector3D relativeVelocity) Compute the acceleration due to drag and the lift.

Methods in org.orekit.forces.drag with parameters of type Vector3D

void	DragSensitive.addDDragAccDParam(SpacecraftState s, Parameter param, double density, Vector3D relativeVelocity, double[] dAccdParam) Compute acceleration derivatives with respect to additional parameters (the ballistic coefficient).
void	DragSensitive.addDDragAccDState(SpacecraftState s, double[][] dAccdPos, double[][] dAccdVel, double density, Vector3D acceleration, Vector3D relativeVelocity, boolean computeGradientPosition, boolean computeGradientVelocity) Compute acceleration derivatives with respect to state parameters (position and velocity).
Vector3D	DragSensitive.dragAcceleration(SpacecraftState state, double density, Vector3D relativeVelocity) Compute the acceleration due to drag and the lift.

Uses of Vector3D in org.orekit.forces.gravity

Methods in org.orekit.forces.gravity that return Vector3D

Vector3D	BalminoAttractionModel.computeAcceleration(PVCoordinates pv) Acceleration in body frame.
Vector3D	DrozinerAttractionModel.computeAcceleration(PVCoordinates pv, AbsoluteDate date) Method to compute the acceleration.
Vector3D	CunninghamAttractionModel.computeAcceleration(PVCoordinates pv, AbsoluteDate date) Method to compute the acceleration.
Vector3D	ThirdBodyAttraction.computeAcceleration(PVCoordinates pv, Frame frame, AbsoluteDate date) Method to compute the acceleration.
Vector3D	NewtonianAttraction.computeAcceleration(PVCoordinates pv, Frame frame, AbsoluteDate date) Method to compute the acceleration.
Vector3D	BalminoAttractionModel.computeAcceleration(SpacecraftState s) Compute the acceleration due to the force.
Vector3D	DrozinerAttractionModel.computeAcceleration(SpacecraftState s) Compute the acceleration due to the force.
Vector3D	ThirdBodyAttraction.computeAcceleration(SpacecraftState s) Compute the acceleration due to the force.
Vector3D	CunninghamAttractionModel.computeAcceleration(SpacecraftState s) Compute the acceleration due to the force.
Vector3D	NewtonianAttraction.computeAcceleration(SpacecraftState s) Compute the acceleration due to the force.
static Vector3D	GravityToolbox.computeBalminoAcceleration(PVCoordinates pv, double[][] coefficientsC, double[][] coefficientsS, double muc, double eqRadius, int degree, int order, HelmholtzPolynomial helm) Method to compute the acceleration, from Balmino algorithm (see BalminoAttractionModel).
static Vector3D	GravityToolbox.computeCunninghamAcceleration(PVCoordinates pv, double equatorialRadius, double[][] coefC, double[][] coefS, int degree, int order, double mu) Method to compute the acceleration.
static Vector3D	GravityToolbox.computeDrozinerAcceleration(PVCoordinates pv, Frame frame, double[][] coefficientsC, double[][] coefficientsS, double muc, double eqRadius, double threshold, int degree, int order) Method to compute the acceleration, from Droziner algorithm (see DrozinerAttractionModel).

Uses of Vector3D in org.orekit.forces.gravity.tides

Methods in org.orekit.forces.gravity.tides that return Vector3D

Vector3D	AbstractTides.computeAcceleration(PVCoordinates pv, Frame frame, AbsoluteDate date) Method to compute the acceleration, from Balmino algorithm (see BalminoAttractionModel class).
Vector3D	AbstractTides.computeAcceleration(SpacecraftState s) Compute the acceleration due to the force.

Uses of Vector3D in org.orekit.forces.gravity.variations

Methods in org.orekit.forces.gravity.variations that return Vector3D

Vector3D	VariablePotentialAttractionModel.computeAcceleration(AbsoluteDate date, PVCoordinates pv) Compute acceleration in rotating frame
Vector3D	VariablePotentialAttractionModel.computeAcceleration(SpacecraftState s) Compute the acceleration due to the force.

Uses of Vector3D in org.orekit.forces.maneuvers

Methods in org.orekit.forces.maneuvers that return Vector3D

Vector3D	ConstantThrustError.computeAcceleration(SpacecraftState s) Compute the acceleration due to the force.
Vector3D	ImpulseManeuver.getDeltaVSat() Get the velocity increment in satellite frame.
Vector3D	SmallManeuverAnalyticalModel.getInertialDV() Get the inertial velocity increment of the maneuver.

Constructors in org.orekit.forces.maneuvers with parameters of type Vector3D

ImpulseManeuver(EventDetector trigger, Vector3D deltaVSat, double isp, MassProvider massModel, String part)
Build a new instance.

ImpulseManeuver(EventDetector trigger, Vector3D deltaVSat, double isp, MassProvider massModel, String part, LOFType lofType)
Build a new instance with a LocalOrbitalFrame.

ImpulseManeuver(EventDetector trigger, Vector3D deltaVSat, Frame frame, double isp, MassProvider massModel, String part)
Build a new instance.

SmallManeuverAnalyticalModel(SpacecraftState state0, Frame frame, Vector3D dV, double isp, String partName)
Build a maneuver defined in user-specified frame.

SmallManeuverAnalyticalModel(SpacecraftState state0, Vector3D dV, double isp, String partName)
Build a maneuver defined in spacecraft frame.

Uses of Vector3D in org.orekit.forces.radiation

Methods in org.orekit.forces.radiation that return Vector3D

Vector3D	RediffusedRadiationPressure.computeAcceleration(SpacecraftState s) Compute the acceleration due to the force.
Vector3D	SolarRadiationPressure.computeAcceleration(SpacecraftState s) Compute the acceleration due to the force.
Vector3D	ElementaryFlux.getDirFlux() get the direction flux
Vector3D	RadiationSensitive.radiationPressureAcceleration(SpacecraftState state, Vector3D flux) Compute the acceleration due to radiation pressure.
Vector3D	RediffusedRadiationSensitive.rediffusedRadiationPressureAcceleration(SpacecraftState state, ElementaryFlux flux) rediffused radiative pressure acceleration

Methods in org.orekit.forces.radiation with parameters of type Vector3D

void	RadiationSensitive.addDSRPAccDParam(SpacecraftState s, Parameter param, double[] dAccdParam, Vector3D satSunVector) Compute acceleration derivatives with respect to additional parameters.
void	RadiationSensitive.addDSRPAccDState(SpacecraftState s, double[][] dAccdPos, double[][] dAccdVel, Vector3D satSunVector) Compute acceleration derivatives with respect to state parameters.
double	SolarRadiationPressure.getLightningRatio(Vector3D position, Frame frame, AbsoluteDate date) Get the lightning ratio ([0-1]).
Vector3D	RadiationSensitive.radiationPressureAcceleration(SpacecraftState state, Vector3D flux) Compute the acceleration due to radiation pressure.

Constructors in org.orekit.forces.radiation with parameters of type Vector3D

ElementaryFlux(Vector3D edirFlux, double eAlbedoPressure, double eInfraRedPressure)
Constructor of elementary pressure

Uses of Vector3D in org.orekit.forces.relativistic

Methods in org.orekit.forces.relativistic that return Vector3D

Vector3D	SchwarzschildRelativisticEffect.computeAcceleration(SpacecraftState s) Compute the acceleration due to the force.
Vector3D	LenseThirringRelativisticEffect.computeAcceleration(SpacecraftState s) Compute the acceleration due to the force.
Vector3D	CoriolisRelativisticEffect.computeAcceleration(SpacecraftState s) Compute the acceleration due to the force.

Uses of Vector3D in org.orekit.frames

Methods in org.orekit.frames that return Vector3D

Vector3D	TopocentricFrame.getEast() Get the east direction of topocentric frame, expressed in parent shape frame.
Vector3D	TopocentricFrame.getNadir() Get the nadir direction of topocentric frame, expressed in parent shape frame.
Vector3D	TopocentricFrame.getNorth() Get the north direction of topocentric frame, expressed in parent shape frame.
Vector3D	TopocentricFrame.getSouth() Get the south direction of topocentric frame, expressed in parent shape frame.
Vector3D	TopocentricFrame.getWest() Get the west direction of topocentric frame, expressed in parent shape frame.
Vector3D	TopocentricFrame.getZenith() Get the zenith direction of topocentric frame, expressed in parent shape frame.
Vector3D	TopocentricFrame.transformFromCardanToPosition(CardanMountPosition cardan) Transform a Cardan mounting into Cartesian coordinates (only position) expressed in this local topocentric frame.
Vector3D	TopocentricFrame.transformFromTopocentricToPosition(TopocentricPosition topoCoord) Transform topocentric set of coordinates frame into Cartesian position coordinates expressed in this local topocentric.

Methods in org.orekit.frames with parameters of type Vector3D

double	TopocentricFrame.getAzimuth(Vector3D extPoint, Frame frame, AbsoluteDate date) Get the azimuth of a point with regards to the topocentric frame center point.
double	TopocentricFrame.getElevation(Vector3D extPoint, Frame frame, AbsoluteDate date) Get the elevation of a point with regards to the local point.
double	TopocentricFrame.getRange(Vector3D extPoint, Frame frame, AbsoluteDate date) Get the range of a point with regards to the topocentric frame center point.
double	TopocentricFrame.getXangleCardan(Vector3D extPoint, Frame frame, AbsoluteDate date) Get the Cardan x angle of a point.
double	TopocentricFrame.getYangleCardan(Vector3D extPoint, Frame frame, AbsoluteDate date) Get the Cardan y angle of a point with regards to the projection point on the plane defined by the zenith and the west axis.
CardanMountPosition	TopocentricFrame.transformFromPositionToCardan(Vector3D extPoint, Frame frame, AbsoluteDate date) Transform a Cartesian position coordinates into Cardan mounting in this local topocentric frame.
TopocentricPosition	TopocentricFrame.transformFromPositionToTopocentric(Vector3D extPoint, Frame frame, AbsoluteDate date) Transform a Cartesian position coordinates into topocentric coordinates in this local topocentric frame.

Uses of Vector3D in org.orekit.frames.transformations

Methods in org.orekit.frames.transformations that return Vector3D

Vector3D	Transform.getAcceleration() Get the second time derivative of the translation.
Vector3D	Transform.getRotationAcceleration() Get the second time derivative of the rotation.
Vector3D	Transform.getRotationRate() Get the rotation rate of the "destination" frame in the "origin" one.
Vector3D	Transform.getTranslation() Get the position of the "destination" frame in the "origin" one.
Vector3D	Transform.getVelocity() Get the velocity of the "destination" frame in the "origin" one.
Vector3D	Transform.transformPosition(Vector3D position) Transform a position vector (including translation effects).
Vector3D	Transform.transformVector(Vector3D vector) Transform a vector (ignoring translation effects).

Methods in org.orekit.frames.transformations with parameters of type Vector3D

Vector3D	Transform.transformPosition(Vector3D position) Transform a position vector (including translation effects).
Vector3D	Transform.transformVector(Vector3D vector) Transform a vector (ignoring translation effects).

Constructors in org.orekit.frames.transformations with parameters of type Vector3D

Transform(AbsoluteDate date, Rotation rotation, Vector3D rotationRate)
Build a rotation transform.

Transform(AbsoluteDate date, Rotation rotation, Vector3D rotationRate, Vector3D rotationAcceleration)
Build a rotation transform.

Transform(AbsoluteDate date, Vector3D translation)
Build a translation transform.

Transform(AbsoluteDate date, Vector3D translation, Vector3D velocity)
Build a translation transform, with its first time derivative.

Transform(AbsoluteDate date, Vector3D translation, Vector3D velocity, Vector3D acceleration)
Build a translation transform, with its first and second time derivatives.

Uses of Vector3D in org.orekit.models.earth

Methods in org.orekit.models.earth that return Vector3D

Vector3D

GeoMagneticElements.getFieldVector() Returns the magnetic field vector in the topocentric frame (North=X, East=Y, Nadir=Z) in nTesla.

Methods in org.orekit.models.earth with parameters of type Vector3D

GeoMagneticElements

GeoMagneticField.calculateField(Vector3D point, Frame frame, AbsoluteDate date) Calculate the magnetic field at the specified point identified by the coordinates of the point and the reference point.

Constructors in org.orekit.models.earth with parameters of type Vector3D

GeoMagneticElements(Vector3D b)
Construct a new element with the given field vector.

Uses of Vector3D in org.orekit.orbits

Methods in org.orekit.orbits with parameters of type Vector3D

protected static void	Orbit.fillHalfRow(double a, Vector3D v, double[] row, int j) Fill a Jacobian half row with a single vector.
protected static void	Orbit.fillHalfRow(double a1, Vector3D v1, double a2, Vector3D v2, double[] row, int j) Fill a Jacobian half row with a linear combination of vectors.
protected static void	Orbit.fillHalfRow(double a1, Vector3D v1, double a2, Vector3D v2, double a3, Vector3D v3, double[] row, int j) Fill a Jacobian half row with a linear combination of vectors.
protected static void	Orbit.fillHalfRow(double a1, Vector3D v1, double a2, Vector3D v2, double a3, Vector3D v3, double a4, Vector3D v4, double[] row, int j) Fill a Jacobian half row with a linear combination of vectors.
protected static void	Orbit.fillHalfRow(double a1, Vector3D v1, double a2, Vector3D v2, double a3, Vector3D v3, double a4, Vector3D v4, double a5, Vector3D v5, double[] row, int j) Fill a Jacobian half row with a linear combination of vectors.
protected static void	Orbit.fillHalfRow(double a1, Vector3D v1, double a2, Vector3D v2, double a3, Vector3D v3, double a4, Vector3D v4, double a5, Vector3D v5, double a6, Vector3D v6, double[] row, int j) Fill a Jacobian half row with a linear combination of vectors.

Uses of Vector3D in org.orekit.orbits.orbitalparameters

Methods in org.orekit.orbits.orbitalparameters that return Vector3D

Vector3D	CartesianParameters.getPosition() Get the position.
Vector3D	CartesianParameters.getVelocity() Get the velocity.

Constructors in org.orekit.orbits.orbitalparameters with parameters of type Vector3D

CartesianParameters(Vector3D position, Vector3D velocity, Vector3D acceleration, double mu)
Constructor with position and velocity.

Uses of Vector3D in org.orekit.propagation.events

Methods in org.orekit.propagation.events that return Vector3D

Vector3D	DihedralFieldOfViewDetector.getAxis1() Get the direction of fov 1st dihedral axis.
Vector3D	DihedralFieldOfViewDetector.getAxis2() Get the direction of fov 2nd dihedral axis.
Vector3D	DihedralFieldOfViewDetector.getCenter() Get the direction of fov center.
Vector3D	CircularFieldOfViewDetector.getCenter() Get the direction of fov center.

Methods in org.orekit.propagation.events with parameters of type Vector3D

double	ConstantRadiusProvider.getLocalRadius(Vector3D position, Frame frame, AbsoluteDate date, PVCoordinatesProvider occultedBodyIn) Calculate the apparent radius.
double	VariableRadiusProvider.getLocalRadius(Vector3D position, Frame frame, AbsoluteDate date, PVCoordinatesProvider occultedBodyIn) Calculate the apparent radius.
double	LocalRadiusProvider.getLocalRadius(Vector3D position, Frame frame, AbsoluteDate date, PVCoordinatesProvider occultedBodyIn) Calculate the apparent radius.

Constructors in org.orekit.propagation.events with parameters of type Vector3D

CircularFieldOfViewDetector(PVCoordinatesProvider pvTarget, Vector3D center, double halfAperture, double maxCheck)
Build a new instance.

CircularFieldOfViewDetector(PVCoordinatesProvider pvTarget, Vector3D center, double halfAperture, double maxCheck, double threshold)
Build a new instance.

CircularFieldOfViewDetector(PVCoordinatesProvider pvTarget, Vector3D center, double halfAperture, double maxCheck, double threshold, EventDetector.Action entry, EventDetector.Action exit)
Build a new instance with defined actions at fov entry and exit.

CircularFieldOfViewDetector(PVCoordinatesProvider pvTarget, Vector3D center, double halfAperture, double maxCheck, double threshold, EventDetector.Action entry, EventDetector.Action exit, boolean removeEntry, boolean removeExit)
Build a new instance with defined actions at fov entry and exit.

DihedralFieldOfViewDetector(PVCoordinatesProvider pvTarget, Vector3D center, Vector3D axis1, double halfAperture1, Vector3D axis2, double halfAperture2, double maxCheck)
Build a new instance.

DihedralFieldOfViewDetector(PVCoordinatesProvider pvTarget, Vector3D center, Vector3D axis1, double halfAperture1, Vector3D axis2, double halfAperture2, double maxCheck, double epsilon)
Build a new instance.

DihedralFieldOfViewDetector(PVCoordinatesProvider pvTarget, Vector3D center, Vector3D axis1, double halfAperture1, Vector3D axis2, double halfAperture2, double maxCheck, EventDetector.Action entry, EventDetector.Action exit)
Build a new instance.

DihedralFieldOfViewDetector(PVCoordinatesProvider pvTarget, Vector3D center, Vector3D axis1, double halfAperture1, Vector3D axis2, double halfAperture2, double maxCheck, EventDetector.Action entry, EventDetector.Action exit, boolean removeEntry, boolean removeExit)
Build a new instance.

DihedralFieldOfViewDetector(PVCoordinatesProvider pvTarget, Vector3D center, Vector3D axis1, double halfAperture1, Vector3D axis2, double halfAperture2, double maxCheck, EventDetector.Action entry, EventDetector.Action exit, boolean removeEntry, boolean removeExit, double epsilon)
Build a new instance.

DihedralFieldOfViewDetector(PVCoordinatesProvider pvTarget, Vector3D center, Vector3D axis1, double halfAperture1, Vector3D axis2, double halfAperture2, double maxCheck, EventDetector.Action entry, EventDetector.Action exit, double epsilon)
Build a new instance.

Uses of Vector3D in org.orekit.propagation.numerical

Methods in org.orekit.propagation.numerical with parameters of type Vector3D

void	TimeDerivativesEquations.addAcceleration(Vector3D gamma, Frame frame) Add the contribution of an acceleration expressed in some inertial frame.

Uses of Vector3D in org.orekit.propagation.precomputed

Constructors in org.orekit.propagation.precomputed with parameters of type Vector3D

HermiteEphemeris(SpacecraftState[] tabStates, Vector3D[] tabAcc)
Deprecated. Constructor of class HermiteEphemeris, where a search index algorithm is passed on the constructor.

HermiteEphemeris(SpacecraftState[] tab, Vector3D[] tabAcc, ISearchIndex algo)
Deprecated. Constructor of class HermiteEphemeris, where a search index algorithm is passed on the constructor.

Uses of Vector3D in org.orekit.time

Methods in org.orekit.time with parameters of type Vector3D

double	LocalTimeAngle.computeMeanLocalTimeAngle(AbsoluteDate date, Vector3D pos, Frame frame) Compute mean local time angle in TIRF frame in the range [-Π, Π[.
double	LocalTimeAngle.computeTrueLocalTimeAngle(AbsoluteDate date, Vector3D pos, Frame frame) Compute true local time angle in TIRF frame in the range [-Π, Π[.

Uses of Vector3D in org.orekit.utils

Methods in org.orekit.utils that return Vector3D

static Vector3D	AngularCoordinates.estimateRate(Rotation start, Rotation end, double dt) Estimate rotation rate between two orientations.
static Vector3D	PVCoordinates.estimateVelocity(Vector3D start, Vector3D end, double dt) Estimate velocity between two positions.
Vector3D	PVCoordinates.getAcceleration() Gets the acceleration.
Vector3D	PVCoordinates.getAngularVelocity() Get the angular velocity (spin) of this point as seen from the origin.
Vector3D	PVCoordinates.getMomentum() Gets the momentum.
Vector3D	PVCoordinates.getPosition() Gets the position.
Vector3D	Position.getPosition() Gets the position.
Vector3D	TopocentricPV.getPosition()
Vector3D	TopocentricPosition.getPosition()
Vector3D	CardanMountPV.getPosition()
Vector3D	CardanMountPosition.getPosition()
Vector3D	AngularCoordinates.getRotationAcceleration() Get the rotation acceleration.
Vector3D	AngularCoordinates.getRotationRate() Get the rotation rate.
Vector3D	PVCoordinates.getVelocity() Gets the velocity.
Vector3D	TopocentricPV.getVelocity()
Vector3D	CardanMountPV.getVelocity()
Vector3D	PV.getVelocity() Gets the velocity.
static Vector3D	ReferencePointsDisplacement.solidEarthTidesCorrections(AbsoluteDate date, Vector3D point, Vector3D sun, Vector3D moon) Computes the displacement of reference points due to the effect of the solid Earth tides.

Methods in org.orekit.utils with parameters of type Vector3D

static Vector3D	PVCoordinates.estimateVelocity(Vector3D start, Vector3D end, double dt) Estimate velocity between two positions.
static Vector3D	ReferencePointsDisplacement.solidEarthTidesCorrections(AbsoluteDate date, Vector3D point, Vector3D sun, Vector3D moon) Computes the displacement of reference points due to the effect of the solid Earth tides.

Constructors in org.orekit.utils with parameters of type Vector3D

AngularCoordinates(Rotation rotation, Vector3D rotationRate)
Builds a rotation/rotation rate triplet (acceleration set to ZERO).

AngularCoordinates(Rotation rotation, Vector3D rotationRate, Vector3D rotationAcceleration)
Builds a rotation/rotation rate/rotation acceleration triplet.

EphemerisPvHermite(PVCoordinates[] tabPV, int order, Vector3D[] tabAcc, Frame frame, AbsoluteDate[] tabDate, ISearchIndex algo)
Creates an instance of EphemerisPvHermite.

EphemerisPvHermite(PVCoordinates[] tabPV, Vector3D[] tabAcc, Frame frame, AbsoluteDate[] tabDate, ISearchIndex algo)
Creates an instance of EphemerisPvHermite with default interpolation order = 2.

EphemerisPvHermite(SpacecraftState[] tabState, int order, Vector3D[] tabAcc, ISearchIndex algo)
Creates an instance of EphemerisPvHermite from a SpacecraftState table

EphemerisPvHermite(SpacecraftState[] tabState, Vector3D[] tabAcc, ISearchIndex algo)
Creates an instance of EphemerisPvHermite from a SpacecraftState table with default interpolation order = 2.

PVCoordinates(Vector3D position, Vector3D velocity)
Builds a PVCoordinates triplet with zero acceleration.

PVCoordinates(Vector3D position, Vector3D velocity, Vector3D acceleration)
Builds a PVCoordinates triplet.

TimeStampedAngularCoordinates(AbsoluteDate date, Rotation rotation, Vector3D rotationRate, Vector3D rotationAcceleration)
Builds a rotation/rotation rate pair.

TimeStampedPVCoordinates(AbsoluteDate date, Vector3D position, Vector3D velocity)
Build from position and velocity.

TimeStampedPVCoordinates(AbsoluteDate date, Vector3D position, Vector3D velocity, Vector3D acceleration)
Builds a TimeStampedPVCoordinates triplet.

Uses of Vector3D in org.orekit.wrenches

Methods in org.orekit.wrenches that return Vector3D

Vector3D	WrenchModel.computeTorque(SpacecraftState s) Compute the resulting torque at the mass centre of the spacecraft in the frame of the main part.
Vector3D	WrenchModel.computeTorque(SpacecraftState s, Vector3D origin, Frame frame) Compute the resulting wrench.
Vector3D	Wrench.getForce()
Vector3D	Wrench.getOrigin()
Vector3D	Wrench.getTorque()
Vector3D	Wrench.getTorque(Vector3D origin) Get the torque expressed in another point.

Methods in org.orekit.wrenches with parameters of type Vector3D

Vector3D	WrenchModel.computeTorque(SpacecraftState s, Vector3D origin, Frame frame) Compute the resulting wrench.
Wrench	WrenchModel.computeWrench(SpacecraftState s, Vector3D origin, Frame frame) Compute the resulting wrench.
Wrench	Wrench.displace(Vector3D newOrigin) Displace current wrench.
static Wrench	Wrench.displace(Wrench wrench, Vector3D newOrigin) Displace current wrench.
Vector3D	Wrench.getTorque(Vector3D origin) Get the torque expressed in another point.

Constructors in org.orekit.wrenches with parameters of type Vector3D

Wrench(Vector3D origin, Vector3D force, Vector3D torque)
Create a wrench with given force and torque.