AccessComputation

java.lang.Object
- agi.foundation.infrastructure.DefinitionalObject
- - agi.foundation.access.AccessComputation

All Implemented Interfaces:

ICloneWithContext, IEnumerateDependencies, IEquatableDefinition, IFreezable
```
public class AccessComputation
extends DefinitionalObject
```
Computes Access, or inter-visibility, between two objects.

Though AccessComputation has its use cases we recommend using constraints directly as AccessQueries rather than attaching them to AccessComputations. AccessQueries have much more flexibility in the sorts of networks that they can represent. Most notably AccessComputations are limited to calculating Access for a single pair of Platforms.

When talking about whether one object can "access" another object, we are typically talking about inter-visibility. When can my satellite see my facility? Determining when a satellite can see a facility might involve checking any number of requirements, depending on the specific problem being solved. For starters, you would likely want to require that the surface of the Earth not lie between the satellite and the facility. This might involve the use of an idealized, spheroidal model of the Earth. Or it might involve checking for actual terrain obstructing the line of sight. Next, you may want to model a specific sensor on the satellite in order to further restrict what it is able to see. All of these things are AccessConstraints.

An AccessComputation without any constraints will report that Access is always available. Each constraint that is added to the computation further restricts Access availability. Conceptually, the overall intervals when Access is available are the intersection of the intervals when each constraint is satisfied. In actuality, AccessComputation attempts to work faster by not evaluating intervals for a constraint if those intervals have already been eliminated by a previous constraint. AccessComputation will also evaluate the least computationally expensive constraints first in the hope that significant chunks of time will be eliminated from consideration before the more expensive constraints must be evaluated.

The Transmitter (get / set) and Receiver (get / set) are the two objects involved in the Access computation. The names "Transmitter" and "Receiver" serve only to distinguish the two objects. AccessComputation itself does not treat the two objects any differently. Specific AccessConstraints, however, may impart additional meaning to one or both of these roles. When this is the case, the documentation for the AccessConstraint should make it clear.

The only requirement of the two objects is that they implement IServiceProvider. Constraints will require additional capabilities from the object and they will obtain the additional capabilities through the IServiceProvider interface. The documentation for each constraint will describe the service interfaces that are required by the constraint. Consider using Platform to represent your objects involved in Access computations.

Internally, AccessComputation uses TimeIntervalFinder and JulianDateFunctionExplorer to evaluate the constraints.

Note that AccessComputation will create links based on the light time delay settings, but will not add any extensions to the links themselves. So, if a constraint (e.g. CommunicationLinkConstraint) requires additional information on the link, AccessComputation will not work. For these cases, use the constraints as AccessQuery objects and specify the links explicitly. For more information, see the documentation overview on using AccessQuery.

Constructor Summary

Constructors
Modifier	Constructor and Description
	`AccessComputation()` Initializes a new instance.
`protected`	`AccessComputation(AccessComputation existingInstance, CopyContext context)` Initializes a new instance as a copy of an existing instance.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected boolean`	`checkForSameDefinition(AccessComputation other)` Checks to determine if another instance has the same definition as this instance and returns `true` if it does.
`protected boolean`	`checkForSameDefinition(DefinitionalObject other)` Checks to determine if another instance has the same definition as this instance and returns `true` if it does.
`Object`	`clone(CopyContext context)` Clones this object using the specified context.
`protected int`	`computeCurrentDefinitionHashCode()` Computes a hash code based on the current properties of this object.
`AccessEvaluationResult`	`computeIntervals(JulianDate start, JulianDate end)` Finds the intervals during which all constraints are satisfied.
`AccessEvaluationResult`	`computeIntervals(JulianDate start, JulianDate end, ITrackCalculationProgress tracker)` Finds the intervals during which all constraints are satisfied.
`AccessEvaluationResult`	`computeIntervals(TimeIntervalCollection computationIntervals)` Finds the intervals during which all constraints are satisfied.
`AccessEvaluationResult`	`computeIntervals(TimeIntervalCollection computationIntervals, ITrackCalculationProgress tracker)` Finds the intervals during which all constraints are satisfied.
`AccessQuery`	`createQuery()` Creates an `AccessQuery` from this computation.
`void`	`enumerateDependencies(DependencyEnumerator enumerator)` Enumerates the dependencies of this object by calling `DependencyEnumerator#enumerate(T)` for each object that this object directly depends upon.
`protected void`	`freezeAggregatedObjects()` Called by `DefinitionalObject.freeze()` to also freeze any objects that are considered to be a part of this object.
`boolean`	`getCalculateCompleteIntervalsPerConstraint()` Gets a value indicating whether satisfaction intervals are computed for each constraint in the Access computation.
`HierarchicalLogger`	`getDebuggingLogger()` Gets a logger to which debugging information will be written.
`AccessEvaluator`	`getEvaluator()` Gets an evaluator that can be used to determine whether Access is available for individual Julian dates.
`AccessEvaluator`	`getEvaluator(EvaluatorGroup group)` Gets an evaluator that can be used to determine whether Access is available for individual Julian dates.
`AccessEventTimes`	`getEventTimes()` Gets the manner in which event times are to be reported.
`ReferenceFrame`	`getInertialFrameForLightTravel()` Gets the inertial reference frame in which light travel is modeled.
`double`	`getLightTravelTimeConvergenceTolerance()` Gets the convergence tolerance used in determining the light travel time.
`AccessSignalModel`	`getModel()` Gets which effects are to be consider in modeling the signal path and observation.
`boolean`	`getOverrideConstraintSampling()` Gets a value indicating whether the sampling parameters specified by `Sampling` (`get`) should be applied to all constraints, overriding the sampling parameters specified by the constraints themselves.
`IServiceProvider`	`getReceiver()` Gets the `IServiceProvider` for the object that is receiving the signal for purposes of the Access computation.
`AccessConstraintCollection`	`getReceiverConstraints()` Gets a list of constraints that are applied to the `Receiver` (`get` / `set`).
`VectorVelocity`	`getReceiverVelocityVectorForAberration()` Gets the velocity vector used in modeling the affect of aberration on the observed signal at the location of the receiver.
`JulianDateFunctionSampling`	`getSampling()` Gets an instance describing how all constraints are to be sampled as part of this `AccessComputation` if `OverrideConstraintSampling` (`get` / `set`) is `true`.
`IServiceProvider`	`getTransmitter()` Gets the `IServiceProvider` for the object that is transmitting the signal for purposes of the Access computation.
`AccessConstraintCollection`	`getTransmitterConstraints()` Gets a list of constraints that are applied to the `Transmitter` (`get` / `set`).
`VectorVelocity`	`getTransmitterVelocityVectorForAberration()` Gets the velocity vector used in modeling the affect of aberration on the observed signal at the location of the transmitter.
`void`	`setCalculateCompleteIntervalsPerConstraint(boolean value)` Sets a value indicating whether satisfaction intervals are computed for each constraint in the Access computation.
`void`	`setDebuggingLogger(HierarchicalLogger value)` Sets a logger to which debugging information will be written.
`void`	`setEventTimes(AccessEventTimes value)` Sets the manner in which event times are to be reported.
`void`	`setInertialFrameForLightTravel(ReferenceFrame value)` Sets the inertial reference frame in which light travel is modeled.
`void`	`setLightTravelTimeConvergenceTolerance(double value)` Sets the convergence tolerance used in determining the light travel time.
`void`	`setModel(AccessSignalModel value)` Sets which effects are to be consider in modeling the signal path and observation.
`void`	`setOverrideConstraintSampling(boolean value)` Sets a value indicating whether the sampling parameters specified by `Sampling` (`get`) should be applied to all constraints, overriding the sampling parameters specified by the constraints themselves.
`void`	`setReceiver(IServiceProvider value)` Sets the `IServiceProvider` for the object that is receiving the signal for purposes of the Access computation.
`void`	`setReceiverVelocityVectorForAberration(VectorVelocity value)` Sets the velocity vector used in modeling the affect of aberration on the observed signal at the location of the receiver.
`void`	`setTransmitter(IServiceProvider value)` Sets the `IServiceProvider` for the object that is transmitting the signal for purposes of the Access computation.
`void`	`setTransmitterVelocityVectorForAberration(VectorVelocity value)` Sets the velocity vector used in modeling the affect of aberration on the observed signal at the location of the transmitter.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - AccessComputation
```
public AccessComputation()
```
    Initializes a new instance.
  - AccessComputation
```
protected AccessComputation(@Nonnull
                            AccessComputation existingInstance,
                            @Nonnull
                            CopyContext context)
```
    Initializes a new instance as a copy of an existing instance.
    See ICloneWithContext.clone(CopyContext) for more information about how to implement this constructor in a derived class.
    
    Parameters:
    
    existingInstance - The existing instance to copy.
    
    context - A CopyContext that controls the depth of the copy.
    
    Throws:
    
    ArgumentNullException - Thrown when existingInstance or context is null.
- Method Detail
  - clone
```
public Object clone(CopyContext context)
```
    Clones this object using the specified context.
    
    This method should be implemented to call a copy constructor on the class of the object being cloned. The copy constructor should take the CopyContext as a parameter in addition to the existing instance to copy. The copy constructor should first call CopyContext.addObjectMapping(T, T) to identify the newly constructed instance as a copy of the existing instance. It should then copy all fields, using CopyContext.updateReference(T) to copy any reference fields.
    
    A typical implementation of ICloneWithContext:
```
public static class MyClass implements ICloneWithContext {
    public MyClass(MyClass existingInstance, CopyContext context) {
        context.addObjectMapping(existingInstance, this);
        someReference = context.updateReference(existingInstance.someReference);
    }

    @Override
    public final Object clone(CopyContext context) {
        return new MyClass(this, context);
    }

    private Object someReference;
}
```
    In general, all fields that are reference types should be copied with a call to CopyContext.updateReference(T). There are a couple of exceptions:
    1. Fields that are aggregate parts of the object should always be copied. A referenced object is an aggregate if properties or methods on the object being copied can modify the externally-visible value of the referenced object.
    2. If the semantics of the referenced object require that it have a single parent, owner, context, etc., and the object being copied is that parent, owner, or context, then the referenced object should always be copied.
    If one of these exceptions applies, the CopyContext should be given an opportunity to update the reference before the reference is copied explicitly. Use CopyContext.updateReference(T) to update the reference. If CopyContext.updateReference(T) returns the original object, indicating that the context does not have a replacement registered, then copy the object manually by invoking a Clone method, a copy constructor, or by manually constructing a new instance and copying the values.
```
alwaysCopy = context.updateReference(existingInstance.alwaysCopy);
if (existingInstance.alwaysCopy != null && alwaysCopy == existingInstance.alwaysCopy) {
    alwaysCopy = (AlwaysCopy) existingInstance.alwaysCopy.clone(context);
}
```
    If you are implementing an evaluator (a class that implements IEvaluator), the IEvaluator.updateEvaluatorReferences(agi.foundation.infrastructure.CopyContext) method shares some responsibilities with the copy context constructor. Code duplication can be avoided by doing the following:
    1. For references to other evaluators ONLY, simply assign the reference in the constructor instead of calling CopyContext.updateReference(T). You should still call CopyContext.updateReference(T) on any references to non-evaluators.
    2. Call IEvaluator.updateEvaluatorReferences(agi.foundation.infrastructure.CopyContext) as the last line in the constructor and pass it the same CopyContext passed to the constructor.
    3. Implement IEvaluator.updateEvaluatorReferences(agi.foundation.infrastructure.CopyContext) as normal. See the reference documentation for IEvaluator.updateEvaluatorReferences(agi.foundation.infrastructure.CopyContext) for more information on implementing that method.
```
public MyClass(MyClass existingInstance, CopyContext context) {
    super(existingInstance, context);
    someReference = context.updateReference(existingInstance.someReference);
    evaluatorReference = existingInstance.evaluatorReference;
    updateEvaluatorReferences(context);
}

@Override
public void updateEvaluatorReferences(CopyContext context) {
    evaluatorReference = context.updateReference(evaluatorReference);
}

@Override
public Object clone(CopyContext context) {
    return new MyClass(this, context);
}

private Object someReference;
private IEvaluator evaluatorReference;
```
    Specified by:
    
    clone in interface ICloneWithContext
    
    Specified by:
    
    clone in class DefinitionalObject
    
    Parameters:
    
    context - The context to use to perform the copy.
    
    Returns:
    
    A new instance which is a copy of this object.
  - checkForSameDefinition
```
protected final boolean checkForSameDefinition(DefinitionalObject other)
```
    Checks to determine if another instance has the same definition as this instance and returns true if it does. Derived classes MUST override this method and check all new fields introduced by the derived class for definitional equivalence. It is NOT necessary to check base class fields because the base class will already have done that. When overriding this method, you should NOT call the base implementation because it will return false for all derived-class instances. Derived classes should check the type of other to preserve the symmetric nature of IEquatableDefinition.isSameDefinition(java.lang.Object).
    
    Specified by:
    
    checkForSameDefinition in class DefinitionalObject
    
    Parameters:
    
    other - The other instance to compare to this one.
    
    Returns:
    
    true if the two objects are defined equivalently; otherwise false.
  - checkForSameDefinition
```
protected boolean checkForSameDefinition(AccessComputation other)
```
    Checks to determine if another instance has the same definition as this instance and returns true if it does. Derived classes MUST override this method and check all new fields introduced by the derived class for definitional equivalence. It is NOT necessary to check base class fields because the base class will already have done that. When overriding this method, you should NOT call the base implementation because it will return false for all derived-class instances. Derived classes should check the type of other to preserve the symmetric nature of IEquatableDefinition.isSameDefinition(java.lang.Object).
    
    Parameters:
    
    other - The other instance to compare to this one.
    
    Returns:
    
    true if the two objects are defined equivalently; otherwise false.
  - computeCurrentDefinitionHashCode
```
protected int computeCurrentDefinitionHashCode()
```
    Computes a hash code based on the current properties of this object. Derived classes MUST override this method and compute a hash code that combines: a unique hash code seed, the base implementation result, and the hash codes of all new fields introduced by the derived class which are used in the AccessComputation.checkForSameDefinition(agi.foundation.infrastructure.DefinitionalObject) method.
    
    Overrides:
    
    computeCurrentDefinitionHashCode in class DefinitionalObject
    
    Returns:
    
    The computed hash code.
  - enumerateDependencies
```
public void enumerateDependencies(DependencyEnumerator enumerator)
```
    Enumerates the dependencies of this object by calling DependencyEnumerator#enumerate(T) for each object that this object directly depends upon. Derived classes which contain additional dependencies MUST override this method, call the base implementation, and enumerate dependencies introduced by the derived class.
    
    Specified by:
    
    enumerateDependencies in interface IEnumerateDependencies
    
    Overrides:
    
    enumerateDependencies in class DefinitionalObject
    
    Parameters:
    
    enumerator - The enumerator that is informed of the dependencies of this object.
  - freezeAggregatedObjects
```
protected void freezeAggregatedObjects()
```
    Called by DefinitionalObject.freeze() to also freeze any objects that are considered to be a part of this object. Derived classes which contain additional aggregated objects MUST override this method, call the base implementation, and freeze aggregated objects introduced by the derived class. The objects that need to be frozen in this method are frequently created in this object's constructor and are not settable via properties.
    
    Overrides:
    
    freezeAggregatedObjects in class DefinitionalObject
  - getTransmitter
```
public final IServiceProvider getTransmitter()
```
    Gets the IServiceProvider for the object that is transmitting the signal for purposes of the Access computation.
    
    The services that are required to be provided by this provider depend on the constraints being used in the Access computation. If this object provides IAccessConstraintsService then the constraints offered by that service will be used in addition to the TransmitterConstraints (get). If this object provides IParentService, parents of this object will be inspected for IAccessConstraintsService as well, and Access to/from the parent objects will be considered as well, according to those constraints.
    
    AccessComputation does not treat the Transmitter any differently from the Receiver (get / set). However, an AccessConstraint involved in the computation might make a distinction.
  - setTransmitter
```
public final void setTransmitter(IServiceProvider value)
```
    Sets the IServiceProvider for the object that is transmitting the signal for purposes of the Access computation.
    
    The services that are required to be provided by this provider depend on the constraints being used in the Access computation. If this object provides IAccessConstraintsService then the constraints offered by that service will be used in addition to the TransmitterConstraints (get). If this object provides IParentService, parents of this object will be inspected for IAccessConstraintsService as well, and Access to/from the parent objects will be considered as well, according to those constraints.
    
    AccessComputation does not treat the Transmitter any differently from the Receiver (get / set). However, an AccessConstraint involved in the computation might make a distinction.
  - getReceiver
```
public final IServiceProvider getReceiver()
```
    Gets the IServiceProvider for the object that is receiving the signal for purposes of the Access computation.
    
    The services that are required to be provided by this provider depend on the constraints being used in the Access computation. If this object provides IAccessConstraintsService then the constraints offered by that service will be used in addition to the ReceiverConstraints (get). If this object provides IParentService, parents of this object will be inspected for IAccessConstraintsService as well, and Access to/from the parent objects will be considered as well, according to those constraints.
    
    AccessComputation does not treat the Receiver any differently from the Transmitter (get / set). However, an AccessConstraint involved in the computation might make a distinction.
  - setReceiver
```
public final void setReceiver(IServiceProvider value)
```
    Sets the IServiceProvider for the object that is receiving the signal for purposes of the Access computation.
    
    The services that are required to be provided by this provider depend on the constraints being used in the Access computation. If this object provides IAccessConstraintsService then the constraints offered by that service will be used in addition to the ReceiverConstraints (get). If this object provides IParentService, parents of this object will be inspected for IAccessConstraintsService as well, and Access to/from the parent objects will be considered as well, according to those constraints.
    
    AccessComputation does not treat the Receiver any differently from the Transmitter (get / set). However, an AccessConstraint involved in the computation might make a distinction.
  - getTransmitterConstraints
```
@Nonnull
public final AccessConstraintCollection getTransmitterConstraints()
```
    Gets a list of constraints that are applied to the Transmitter (get / set).
  - getReceiverConstraints
```
@Nonnull
public final AccessConstraintCollection getReceiverConstraints()
```
    Gets a list of constraints that are applied to the Receiver (get / set).
  - getModel
```
@Nonnull
public final AccessSignalModel getModel()
```
    Gets which effects are to be consider in modeling the signal path and observation.
    When using a signal model which accounts for light travel time, the transmitter and receiver must have availability which exceeds the interval over which access is computed. When reporting receiver event times, the requirement arises from the need to know the relative position of the transmitter when the signal is emitted such that it arrives at the receiver at the beginning of the interval over which access is to be determined. Similarly, when reporting transmitter event times, the requirement arises from the need to know the relative position of the receiver when the signal is detected such that it leaves the transmitter at the ending of the interval over which access is to be determined.
  - setModel
```
public final void setModel(@Nonnull
                           AccessSignalModel value)
```
    Sets which effects are to be consider in modeling the signal path and observation.
    When using a signal model which accounts for light travel time, the transmitter and receiver must have availability which exceeds the interval over which access is computed. When reporting receiver event times, the requirement arises from the need to know the relative position of the transmitter when the signal is emitted such that it arrives at the receiver at the beginning of the interval over which access is to be determined. Similarly, when reporting transmitter event times, the requirement arises from the need to know the relative position of the receiver when the signal is detected such that it leaves the transmitter at the ending of the interval over which access is to be determined.
  - getEventTimes
```
@Nonnull
public final AccessEventTimes getEventTimes()
```
    Gets the manner in which event times are to be reported.
  - setEventTimes
```
public final void setEventTimes(@Nonnull
                                AccessEventTimes value)
```
    Sets the manner in which event times are to be reported.
  - getLightTravelTimeConvergenceTolerance
```
public final double getLightTravelTimeConvergenceTolerance()
```
    Gets the convergence tolerance used in determining the light travel time.
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown if the user attempts to set a tolerance less than or equal to zero.
  - setLightTravelTimeConvergenceTolerance
```
public final void setLightTravelTimeConvergenceTolerance(double value)
```
    Sets the convergence tolerance used in determining the light travel time.
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown if the user attempts to set a tolerance less than or equal to zero.
  - getInertialFrameForLightTravel
```
public final ReferenceFrame getInertialFrameForLightTravel()
```
    Gets the inertial reference frame in which light travel is modeled.
  - setInertialFrameForLightTravel
```
public final void setInertialFrameForLightTravel(ReferenceFrame value)
```
    Sets the inertial reference frame in which light travel is modeled.
  - getTransmitterVelocityVectorForAberration
```
public final VectorVelocity getTransmitterVelocityVectorForAberration()
```
    Gets the velocity vector used in modeling the affect of aberration on the observed signal at the location of the transmitter.
    
    Typically, the VectorVelocity of the Point associated with the Transmitter (get / set) expressed in the InertialFrameForLightTravel (get / set) would be used when modeling the total effect of aberration on the apparent displacement vector.
```
Platform receiver = createReceiver();
Platform transmitter = createTransmitter();

CentralBodyObstructionConstraint constraint = new CentralBodyObstructionConstraint();
ReferenceFrame inertialFrame = CentralBodiesFacet.getFromContext().getEarth().getInertialFrame();

VectorVelocity receiverTotalAberrationVector = new VectorVelocity(receiver.getLocationPoint(), inertialFrame);
VectorVelocity transmitterTotalAberrationVector = new VectorVelocity(transmitter.getLocationPoint(), inertialFrame);

constraint.setConstrainedLink(new LinkSpeedOfLight(transmitter, receiver, inertialFrame,
        VectorApparentDisplacement.DefaultLightTimeConvergenceTolerance, 
        transmitterTotalAberrationVector, receiverTotalAberrationVector));
```
    Annual aberration can be modeled by using the VectorVelocity of the CenterOfMassPoint (get / set) associated with the Transmitter (get / set) expressed in the InertialFrameForLightTravel (get / set). The InertialFrame (get / set) should be used as the InertialFrameForLightTravel (get / set).
```
Platform receiver = createReceiver();
Platform transmitter = createTransmitter();

CentralBodyObstructionConstraint constraint = new CentralBodyObstructionConstraint();

ReferenceFrame inertialFrame = CentralBodiesFacet.getFromContext().getSolarSystemBarycenter().getInertialFrame();
VectorVelocity annualAberrationVector = 
        new VectorVelocity(CentralBodiesFacet.getFromContext().getEarth().getCenterOfMassPoint(), inertialFrame);

constraint.setConstrainedLink(new LinkSpeedOfLight(transmitter, receiver, inertialFrame,
        VectorApparentDisplacement.DefaultLightTimeConvergenceTolerance, 
        annualAberrationVector, annualAberrationVector));
```
  - setTransmitterVelocityVectorForAberration
```
public final void setTransmitterVelocityVectorForAberration(VectorVelocity value)
```
    Sets the velocity vector used in modeling the affect of aberration on the observed signal at the location of the transmitter.
    
    Typically, the VectorVelocity of the Point associated with the Transmitter (get / set) expressed in the InertialFrameForLightTravel (get / set) would be used when modeling the total effect of aberration on the apparent displacement vector.
```
Platform receiver = createReceiver();
Platform transmitter = createTransmitter();

CentralBodyObstructionConstraint constraint = new CentralBodyObstructionConstraint();
ReferenceFrame inertialFrame = CentralBodiesFacet.getFromContext().getEarth().getInertialFrame();

VectorVelocity receiverTotalAberrationVector = new VectorVelocity(receiver.getLocationPoint(), inertialFrame);
VectorVelocity transmitterTotalAberrationVector = new VectorVelocity(transmitter.getLocationPoint(), inertialFrame);

constraint.setConstrainedLink(new LinkSpeedOfLight(transmitter, receiver, inertialFrame,
        VectorApparentDisplacement.DefaultLightTimeConvergenceTolerance, 
        transmitterTotalAberrationVector, receiverTotalAberrationVector));
```
    Annual aberration can be modeled by using the VectorVelocity of the CenterOfMassPoint (get / set) associated with the Transmitter (get / set) expressed in the InertialFrameForLightTravel (get / set). The InertialFrame (get / set) should be used as the InertialFrameForLightTravel (get / set).
```
Platform receiver = createReceiver();
Platform transmitter = createTransmitter();

CentralBodyObstructionConstraint constraint = new CentralBodyObstructionConstraint();

ReferenceFrame inertialFrame = CentralBodiesFacet.getFromContext().getSolarSystemBarycenter().getInertialFrame();
VectorVelocity annualAberrationVector = 
        new VectorVelocity(CentralBodiesFacet.getFromContext().getEarth().getCenterOfMassPoint(), inertialFrame);

constraint.setConstrainedLink(new LinkSpeedOfLight(transmitter, receiver, inertialFrame,
        VectorApparentDisplacement.DefaultLightTimeConvergenceTolerance, 
        annualAberrationVector, annualAberrationVector));
```
  - getReceiverVelocityVectorForAberration
```
public final VectorVelocity getReceiverVelocityVectorForAberration()
```
    Gets the velocity vector used in modeling the affect of aberration on the observed signal at the location of the receiver.
    
    Typically, the VectorVelocity of the Point associated with the Receiver (get / set) expressed in the InertialFrameForLightTravel (get / set) would be used when modeling the total effect of aberration on the apparent displacement vector.
```
Platform receiver = createReceiver();
Platform transmitter = createTransmitter();

CentralBodyObstructionConstraint constraint = new CentralBodyObstructionConstraint();
ReferenceFrame inertialFrame = CentralBodiesFacet.getFromContext().getEarth().getInertialFrame();

VectorVelocity receiverTotalAberrationVector = new VectorVelocity(receiver.getLocationPoint(), inertialFrame);
VectorVelocity transmitterTotalAberrationVector = new VectorVelocity(transmitter.getLocationPoint(), inertialFrame);

constraint.setConstrainedLink(new LinkSpeedOfLight(transmitter, receiver, inertialFrame,
        VectorApparentDisplacement.DefaultLightTimeConvergenceTolerance, 
        transmitterTotalAberrationVector, receiverTotalAberrationVector));
```
    Annual aberration can be modeled by using the VectorVelocity of the CenterOfMassPoint (get / set) associated with the Receiver (get / set) expressed in the InertialFrameForLightTravel (get / set). The InertialFrame (get / set) should be used as the InertialFrameForLightTravel (get / set).
```
Platform receiver = createReceiver();
Platform transmitter = createTransmitter();

CentralBodyObstructionConstraint constraint = new CentralBodyObstructionConstraint();

ReferenceFrame inertialFrame = CentralBodiesFacet.getFromContext().getSolarSystemBarycenter().getInertialFrame();
VectorVelocity annualAberrationVector = 
        new VectorVelocity(CentralBodiesFacet.getFromContext().getEarth().getCenterOfMassPoint(), inertialFrame);

constraint.setConstrainedLink(new LinkSpeedOfLight(transmitter, receiver, inertialFrame,
        VectorApparentDisplacement.DefaultLightTimeConvergenceTolerance, 
        annualAberrationVector, annualAberrationVector));
```
  - setReceiverVelocityVectorForAberration
```
public final void setReceiverVelocityVectorForAberration(VectorVelocity value)
```
    Sets the velocity vector used in modeling the affect of aberration on the observed signal at the location of the receiver.
    
    Typically, the VectorVelocity of the Point associated with the Receiver (get / set) expressed in the InertialFrameForLightTravel (get / set) would be used when modeling the total effect of aberration on the apparent displacement vector.
```
Platform receiver = createReceiver();
Platform transmitter = createTransmitter();

CentralBodyObstructionConstraint constraint = new CentralBodyObstructionConstraint();
ReferenceFrame inertialFrame = CentralBodiesFacet.getFromContext().getEarth().getInertialFrame();

VectorVelocity receiverTotalAberrationVector = new VectorVelocity(receiver.getLocationPoint(), inertialFrame);
VectorVelocity transmitterTotalAberrationVector = new VectorVelocity(transmitter.getLocationPoint(), inertialFrame);

constraint.setConstrainedLink(new LinkSpeedOfLight(transmitter, receiver, inertialFrame,
        VectorApparentDisplacement.DefaultLightTimeConvergenceTolerance, 
        transmitterTotalAberrationVector, receiverTotalAberrationVector));
```
    Annual aberration can be modeled by using the VectorVelocity of the CenterOfMassPoint (get / set) associated with the Receiver (get / set) expressed in the InertialFrameForLightTravel (get / set). The InertialFrame (get / set) should be used as the InertialFrameForLightTravel (get / set).
```
Platform receiver = createReceiver();
Platform transmitter = createTransmitter();

CentralBodyObstructionConstraint constraint = new CentralBodyObstructionConstraint();

ReferenceFrame inertialFrame = CentralBodiesFacet.getFromContext().getSolarSystemBarycenter().getInertialFrame();
VectorVelocity annualAberrationVector = 
        new VectorVelocity(CentralBodiesFacet.getFromContext().getEarth().getCenterOfMassPoint(), inertialFrame);

constraint.setConstrainedLink(new LinkSpeedOfLight(transmitter, receiver, inertialFrame,
        VectorApparentDisplacement.DefaultLightTimeConvergenceTolerance, 
        annualAberrationVector, annualAberrationVector));
```
  - getCalculateCompleteIntervalsPerConstraint
```
public final boolean getCalculateCompleteIntervalsPerConstraint()
```
    Gets a value indicating whether satisfaction intervals are computed for each constraint in the Access computation. If this value is set to true, ConstraintResults (get / set) will contain an entry for each constraint, and SatisfactionIntervals (get / set) will be filled with the intervals over which the constraint was satisfied. If this value is set to false, ConstraintResults (get / set) will be null. The value of this property will not affect OverallSatisfactionIntervals (get / set). Generally, setting this property to false will result in much better performance.
  - setCalculateCompleteIntervalsPerConstraint
```
public final void setCalculateCompleteIntervalsPerConstraint(boolean value)
```
    Sets a value indicating whether satisfaction intervals are computed for each constraint in the Access computation. If this value is set to true, ConstraintResults (get / set) will contain an entry for each constraint, and SatisfactionIntervals (get / set) will be filled with the intervals over which the constraint was satisfied. If this value is set to false, ConstraintResults (get / set) will be null. The value of this property will not affect OverallSatisfactionIntervals (get / set). Generally, setting this property to false will result in much better performance.
  - getSampling
```
public final JulianDateFunctionSampling getSampling()
```
    Gets an instance describing how all constraints are to be sampled as part of this AccessComputation if OverrideConstraintSampling (get / set) is true. If OverrideConstraintSampling (get / set) is false, this property is ignored.
  - getOverrideConstraintSampling
```
public final boolean getOverrideConstraintSampling()
```
    Gets a value indicating whether the sampling parameters specified by Sampling (get) should be applied to all constraints, overriding the sampling parameters specified by the constraints themselves. By default, this value is true.
  - setOverrideConstraintSampling
```
public final void setOverrideConstraintSampling(boolean value)
```
    Sets a value indicating whether the sampling parameters specified by Sampling (get) should be applied to all constraints, overriding the sampling parameters specified by the constraints themselves. By default, this value is true.
  - getDebuggingLogger
```
@Nullable
public final HierarchicalLogger getDebuggingLogger()
```
    Gets a logger to which debugging information will be written.
  - setDebuggingLogger
```
public final void setDebuggingLogger(@Nullable
                                     HierarchicalLogger value)
```
    Sets a logger to which debugging information will be written.
  - createQuery
```
@Nonnull
public final AccessQuery createQuery()
```
    Creates an AccessQuery from this computation.
    
    Returns:
    
    A query which is equivalent to this computation.
  - computeIntervals
```
@Nonnull
public final AccessEvaluationResult computeIntervals(@Nonnull
                                                               JulianDate start,
                                                               @Nonnull
                                                               JulianDate end)
```
    Finds the intervals during which all constraints are satisfied.
    Takes advantage of the ThreadingPolicy in order to improve performance by computing in multiple threads simultaneously.
    
    Parameters:
    
    start - The earliest date to consider.
    
    end - The latest date to consider.
    
    Returns:
    
    The result of the Access evaluation.
  - computeIntervals
```
public final AccessEvaluationResult computeIntervals(@Nonnull
                                                     JulianDate start,
                                                     @Nonnull
                                                     JulianDate end,
                                                     @Nullable
                                                     ITrackCalculationProgress tracker)
```
    Finds the intervals during which all constraints are satisfied.
    Takes advantage of the ThreadingPolicy in order to improve performance by computing in multiple threads simultaneously.
    
    Parameters:
    
    start - The earliest date to consider.
    
    end - The latest date to consider.
    
    tracker - The object to which progress is reported and that is able to cancel this operation before it is complete, or null.
    
    Returns:
    
    The result of the Access evaluation, or null if the evaluation was canceled.
  - computeIntervals
```
@Nonnull
public final AccessEvaluationResult computeIntervals(@Nonnull
                                                               TimeIntervalCollection computationIntervals)
```
    Finds the intervals during which all constraints are satisfied.
    Takes advantage of the ThreadingPolicy in order to improve performance by computing in multiple threads simultaneously.
    
    Parameters:
    
    computationIntervals - The list of intervals over which to compute Access.
    
    Returns:
    
    The result of the Access evaluation.
  - computeIntervals
```
public final AccessEvaluationResult computeIntervals(@Nonnull
                                                     TimeIntervalCollection computationIntervals,
                                                     @Nullable
                                                     ITrackCalculationProgress tracker)
```
    Finds the intervals during which all constraints are satisfied.
    Takes advantage of the ThreadingPolicy in order to improve performance by computing in multiple threads simultaneously.
    
    Parameters:
    
    computationIntervals - The list of intervals over which to compute Access.
    
    tracker - The object to which progress is reported and that is able to cancel this operation before it is complete, or null.
    
    Returns:
    
    The result of the Access evaluation, or null if the evaluation was canceled.
    
    Throws:
    
    IllegalStateException - Thrown when no access constraints were configured when this method is called.
  - getEvaluator
```
@Nonnull
public final AccessEvaluator getEvaluator()
```
    Gets an evaluator that can be used to determine whether Access is available for individual Julian dates.
    
    Returns:
    
    The evaluator.
  - getEvaluator
```
@Nonnull
public final AccessEvaluator getEvaluator(@Nonnull
                                                    EvaluatorGroup group)
```
    Gets an evaluator that can be used to determine whether Access is available for individual Julian dates.
    
    Parameters:
    
    group - The group with which to associate the new evaluator. By grouping evaluators that are often evaluated at the same Julian dates, common computations can be performed only once for the entire group instead of multiple times for each evaluator.
    
    Returns:
    
    The evaluator.

Class AccessComputation

Constructor Summary

Method Summary

Methods inherited from class agi.foundation.infrastructure.DefinitionalObject

Methods inherited from class java.lang.Object

Constructor Detail

AccessComputation

Method Detail

clone

checkForSameDefinition

checkForSameDefinition

computeCurrentDefinitionHashCode

enumerateDependencies

freezeAggregatedObjects

getTransmitter

setTransmitter

getReceiver

setReceiver

getTransmitterConstraints

getReceiverConstraints

getModel

setModel

getEventTimes

setEventTimes

getLightTravelTimeConvergenceTolerance

setLightTravelTimeConvergenceTolerance

getInertialFrameForLightTravel

setInertialFrameForLightTravel

getTransmitterVelocityVectorForAberration

setTransmitterVelocityVectorForAberration

getReceiverVelocityVectorForAberration

setReceiverVelocityVectorForAberration

getCalculateCompleteIntervalsPerConstraint

setCalculateCompleteIntervalsPerConstraint

getSampling

getOverrideConstraintSampling

setOverrideConstraintSampling

getDebuggingLogger

setDebuggingLogger

createQuery

computeIntervals

computeIntervals

computeIntervals

computeIntervals

getEvaluator

getEvaluator