Basic Communications

// Get a Reference to the Earth's CentralBody context
EarthCentralBody earth = CentralBodiesFacet.getFromContext().getEarth();

// Create a simple digital transmitter in LA, then uplink to the satellite.
SimpleDigitalTransmitter policeTransmitter = new SimpleDigitalTransmitter();

// Let's change the transmitting power
policeTransmitter.setEffectiveIsotropicRadiatedPower(350.0);  // Watts

Cartographic losAngelesPD = new Cartographic(-2.0637416544, 0.5943235692, 30.0);
Cartographic losAngelesMedCenter = new Cartographic(-2.062997065, 0.594448304, 40.0);
policeTransmitter.setLocationPoint(new PointCartographic(earth, losAngelesPD));

// Create a reference direction vector, used in the AxesTargetingLink type.
// By using PlatformLocationPoint instead of specifying policeTransmitter.LocationPoint directly,
// we will always get the current policeTransmitter.LocationPoint property, even if we change its
// value later on, the Vector will refer to the new value.
Vector localZAxis = new VectorFixed(new AxesEastNorthUp(earth, new PlatformLocationPoint(policeTransmitter)), Cartesian.toCartesian(UnitCartesian.getUnitZ()));

// Create a receiver
SimpleReceiver medCenterReceiver = new SimpleReceiver();
medCenterReceiver.setLocationPoint(new PointCartographic(earth, losAngelesMedCenter));
// Add noise to the Receiver
medCenterReceiver.setNoiseFactor(2.0);

// Create a link between them
CommunicationSystem commSys = new CommunicationSystem();
IServiceProvider link = commSys.getLinks().add(policeTransmitter, medCenterReceiver);

// Orient them towards each other.
// Note that we could allow the CommunicationSystem to orient these towards each other
// by calling commSys.configureAntennaTargeting(),  this just shows how to perform targeting manually.
policeTransmitter.setOrientationAxes(new AxesTargetingLink(link, LinkRole.TRANSMITTER, localZAxis));
medCenterReceiver.setOrientationAxes(new AxesTargetingLink(link, LinkRole.RECEIVER, localZAxis));

// In order to access the resulting link budget, we call GetLinkBudgetEvaluator.  We can then
// use the returned evaluator to request results at any specified time.  Note that GetLinkBudgetEvaluator
// is an expensive call, so you should only reacquire a new evaluator if one of your objects' definition
// has changed.  Otherwise, store lbEval in a member variable and use it when you need results.
// For more information on evaluators, see the "Evaluators And Evaluator Groups" topic under "Patterns".
Evaluator<LinkBudget> lbEval = commSys.getLinkBudgetEvaluator(link, new IntendedSignalByTransmitter(policeTransmitter));
LinkBudget lb = lbEval.evaluate(new JulianDate(new GregorianDate(2011, 7, 28, 13, 49, 43.0)));

// This relay transceiver has an isotropic receiver antenna gain pattern and accepts a BPSK modulation scheme.
// On retransmisson of the received signal, it uses a GaussianGainPattern and a QPSK modulation scheme.
Transceiver relay = new Transceiver();
relay.setName("Relay Transceiver");
relay.setModulation(new ModulationBpsk());
relay.setInputAntennaGainPattern(new IsotropicGainPattern());
relay.setCarrierFrequency(policeTransmitter.getCarrierFrequency());

GaussianGainPattern transmitterPattern = new GaussianGainPattern();
transmitterPattern.setBacklobeGain(0.001); // decimal
transmitterPattern.setDiameter(1.0); // meters
transmitterPattern.setEfficiency(0.55); // ratio between zero and one
relay.setOutputAntennaGainPattern(transmitterPattern);

// Change the output gain to 10
relay.setOutputGain(10.0);

// Create a location for the Transceiver - 970 meters above the Police station, which is 30 meters high
Cartographic transceiverLocation = new Cartographic(-2.0637416544, 0.5943235692, 1000.0);
relay.getInputAntenna().setLocationPoint(new PointCartographic(earth, transceiverLocation));

// Offset the transceiver's transmitter from the receiver by 1 meter east.
// First create a reference frame that is east, north and up from the input antenna.
ReferenceFrame enuFrame = new ReferenceFrame(relay.getInputAntenna().getLocationPoint(), new AxesEastNorthUp(earth, relay.getInputAntenna().getLocationPoint()));
// Now create a fixed offset from that frame and assign it to the output antenna.
relay.getOutputAntenna().setLocationPoint(new PointFixedOffset(enuFrame, new Cartesian(1.0, 0.0, 0.0)));

// Hook up a filter on the relay
relay.setFilter(new RectangularFilter());
// Set the filters Frequency to the frequency that will be retransmitted.
relay.getFilter().setFrequency(policeTransmitter.getCarrierFrequency());
// Define a 2 MHz bandwidth for the filter.
relay.getFilter().setLowerBandwidthLimit(-1e6);
relay.getFilter().setUpperBandwidthLimit(1e6);

// In the previous examples, we created a Transmitter from a Los Angeles Police Station, and a Receiver
// at a Medical Center.  We evaluated the Link Budget for the pair, but now we've added a Transceiver 1000 meters above the city.
// We've set the OrientationAxes of the transmitter and receiver back to null and will now let the Comm System autoOrient everything for us.
commSys = new CommunicationSystem();

// Add a chain of comm objects to the Links collection, in the order they communicate.
commSys.getLinks().addChain(policeTransmitter, relay, medCenterReceiver);
 // Let's set the DefaultReferenceVector to something different
commSys.setDefaultReferenceVector(localZAxis);
// Orient the antennas automatically.
commSys.configureAntennaTargeting();

// Now let's find a reference to the downlink, so we can get a Link Budget for it.
IServiceProvider myLink = commSys.getLinks().findFirst(medCenterReceiver, LinkRole.RECEIVER);

// Now we can get a Link Budget from the commSys, for the downlink
lbEval = commSys.getLinkBudgetEvaluator(myLink, new IntendedSignalByTransmitter(policeTransmitter));
lb = lbEval.evaluate(new JulianDate(new GregorianDate(2011, 7, 28, 13, 49, 43.0)));

// Optical transmitter configuration parameters
double xmtrDivergenceAngle = 75.0e-6; // radians
double xmtrApertureDiameter = 7.62e-2; // meters
double xmtrOpticalEfficiency = 1.0; // 100%
double xmtrOpticalPointingError = 0.0;
double xmtPower = 1.0; // Watts
double xmtrWavelength = 1550e-9;
double xmtrDataRate = 1.0e9;
ModulationOok xmtrDigitalModulation = new ModulationOok();

// Optical receiver configuration parameters
double rcvrApertureDiameter = 7.62e-2; // meters
double rcvrDivergenceAngle = 75.0e-6; // radians
double rcvrOpticalEfficiency = 1.0; // 100%
double rcvrOpticalPointingError = 0.0;
double rcvrFieldOfView = Trig.degreesToRadians(5.0);
double rcvrPhotodetectorQuantumEfficiency = 0.8; // 80%
double rcvrNoiseTemperature = 10.0; // Kelvin
double rcvrDarkCurrent = 1.0e-16; // amps
double rcvrLoadImpedance = 1.0e8; // ohms
double rcvrApdExcessNoiseFactor = 0.0;
double rcvrApdGain = 500.0;

// Ground terminal Lat, Lon, Alt
double gteLat = Trig.degreesToRadians(37.713717);
double gteLon = Trig.degreesToRadians(-121.702683);
double gteAlt = 152.0;

// Air terminal Lat, Lon, Alt
double ateLat = Trig.degreesToRadians(37.120803);
double ateLon = Trig.degreesToRadians(-119.924024);
double ateAlt = 1524.0;

// Maximum altitude used in atmospheric propagation computations
double maximumAltitude = 22860.0; // meters

// Beer-Lambert Law extinction coefficient model
double extinctionCoefficientModel = 0.00013;

EarthCentralBody earth = CentralBodiesFacet.getFromContext().getEarth();

// Construct the ground terminal's Point and Axes objects
Cartographic groundCart = new Cartographic(gteLon, gteLat, gteAlt);
PointCartographic groundPoint = new PointCartographic(earth, groundCart);
AxesEastNorthUp groundAxes = new AxesEastNorthUp(earth, groundPoint);

// Construct the air terminal's Point and Axes objects
Cartographic airCart = new Cartographic(ateLon, ateLat, ateAlt);
PointCartographic airPoint = new PointCartographic(earth, airCart);
AxesEastNorthUp airAxes = new AxesEastNorthUp(earth, airPoint);

// Construct the optics gain pattern for the transmitter
GaussianOpticalGainPattern xmtrAntennaPattern = new GaussianOpticalGainPattern(xmtrApertureDiameter, xmtrDivergenceAngle, xmtrOpticalEfficiency,
        xmtrOpticalPointingError);

// Construct the transmitter instance
OpticalTransmitter xmtr = new OpticalTransmitter("ATETransmitter", airPoint, airAxes, xmtrDigitalModulation, xmtrAntennaPattern, xmtrWavelength, xmtPower,
        xmtrDataRate, null);

// Construct the optics gain pattern for the receiver
GaussianOpticalGainPattern rcvrAntenna = new GaussianOpticalGainPattern(rcvrApertureDiameter, rcvrDivergenceAngle, rcvrOpticalEfficiency,
        rcvrOpticalPointingError);

// Construct the photodetector and receiver instance
AvalanchePhotodiode rcvrPhotodetector = new AvalanchePhotodiode();
OpticalReceiver rcvr = new OpticalReceiver("GTEReceiver", groundPoint, groundAxes, rcvrPhotodetector, rcvrAntenna);
rcvrPhotodetector.setParentReceiver(rcvr);
rcvrPhotodetector.setCentralBody(earth);
rcvrPhotodetector.setFieldOfView(rcvrFieldOfView);
rcvrPhotodetector.setWavelength(xmtrWavelength);
rcvrPhotodetector.setBandwidth(xmtrDataRate);
rcvrPhotodetector.setOpticalBandpassFilterBandwidth(2.0 * xmtrDataRate);
rcvrPhotodetector.setEfficiency(rcvrPhotodetectorQuantumEfficiency);
rcvrPhotodetector.setNoiseFactor(rcvrApdExcessNoiseFactor);
rcvrPhotodetector.setNoiseTemperature(rcvrNoiseTemperature);
rcvrPhotodetector.setDarkCurrent(rcvrDarkCurrent);
rcvrPhotodetector.setLoadImpedance(rcvrLoadImpedance);
rcvrPhotodetector.setGain(rcvrApdGain);
rcvrPhotodetector.setSkySpectralRadiance(new SkySpectralRadianceCurveFit()); // Construct our custom sky spectral radiance model
rcvrPhotodetector.setSunSpectralRadiantEmittance(SignalComputation.toSignalComputation(0.0)); // We're not modeling sun spectral radiant emittance in this example, so set to zero

// Construct the CommunicationSystem instance
CommunicationSystem cs = new CommunicationSystem();

// Construct the refractive index structure parameter model
HufnagelValleyRefractiveIndexStructureParameterModel cn2Model = new HufnagelValleyRefractiveIndexStructureParameterModel();

// Tropospheric scintillation loss model
TropoScintAttenuationModelItuRP1814 scintModel = new TropoScintAttenuationModelItuRP1814(maximumAltitude, cn2Model, earth);

// Beer-Lamber Law Atmospheric Absorption Model configured with a constant extinction coefficient
BeerLambertLawAtmosphericAttenuationModel atmosLossModel = new BeerLambertLawAtmosphericAttenuationModel(SignalComputation
        .toSignalComputation(extinctionCoefficientModel), maximumAltitude, earth);

// Add the default propagation models to the CommunicationSystem instance
cs.getLinks().getDefaultPropagationModels().add(atmosLossModel);
cs.getLinks().getDefaultPropagationModels().add(scintModel);

// Using the CommSystem's Links collection, add a new link between the OpticalTransmitter and OpticalReceiver
cs.getLinks().add(xmtr, rcvr);

// Configure the optical antenna pointing
cs.configureAntennaTargeting();

// When retrieving evaluators, we need to specify our desired signal.
IntendedSignalByTransmitter intendedSignal = new IntendedSignalByTransmitter(xmtr);

// Create an Evaluator group to optimize the evaluator calculations.
// Since the CommunicationSystem has many evaluators within it, you should always create an EvaluatorGroup
EvaluatorGroup group = new EvaluatorGroup();

// Get the link budgets scalars object using the link that was created by the CommunicationSystem and the intended signal strategy
LinkBudgetScalars lbs = cs.getLinkBudgetScalars(cs.getLinks().get(0), intendedSignal);

// Get each of the desired evaluators passing the evaluator group for later optimization
ScalarEvaluator outputPowerEval = lbs.getPowerAtReceiverOutput().getEvaluator(group);
ScalarEvaluator xmtGainEval = lbs.getTransmitterAntennaGainInLinkDirection().getEvaluator(group);
ScalarEvaluator rcvGainEval = lbs.getReceiverAntennaGainInLinkDirection().getEvaluator(group);
ScalarEvaluator propLossEval = lbs.getPropagationLoss().getEvaluator(group);
ScalarEvaluator ripEval = lbs.getReceivedIsotropicPower().getEvaluator(group);
ScalarEvaluator cOverNEval = lbs.getCarrierToNoise().getEvaluator(group);
ScalarEvaluator berEval = lbs.getBitErrorRate().getEvaluator(group);

// Optimize the evaluators
group.optimizeEvaluators();

JulianDate time = new JulianDate(GregorianDate.parse("5 Oct 2015 22:35:00"));

// Evaluate each evaluator instance given the desired time.
double xmtGain = CommunicationAnalysis.toDecibels(xmtGainEval.evaluate(time));
double outputPower = CommunicationAnalysis.toDecibels(outputPowerEval.evaluate(time));
double rcvGain = CommunicationAnalysis.toDecibels(rcvGainEval.evaluate(time));
double propLoss = CommunicationAnalysis.toDecibels(propLossEval.evaluate(time));
double rip = CommunicationAnalysis.toDecibels(ripEval.evaluate(time));
double opticsOutputPower = rip + rcvGain;
double cOverN = CommunicationAnalysis.toDecibels(cOverNEval.evaluate(time));
double ber = berEval.evaluate(time);

public static final class SkySpectralRadianceCurveFit extends SignalComputation {
    public SkySpectralRadianceCurveFit() {}

    private SkySpectralRadianceCurveFit(SignalComputation existingInstance, CopyContext context) {
        super(existingInstance, context);
    }

    @Override
    protected boolean checkForSameDefinition(SignalComputation other) {
        return other instanceof SkySpectralRadianceCurveFit;
    }

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

    @Override
    public IEvaluator1<Double> getEvaluator(EvaluatorGroup group) {
        return group.createEvaluator(getEvaluatorCallback, getParameter());
    }

    private static IEvaluator1<Double> createEvaluator(EvaluatorGroup group, SignalParameter parameter) {
        return new SkySpectralRadianceEvaluator(group, parameter.getEvaluator(group));
    }

    private static final EvaluatorGroup.Callback1<IEvaluator1<Double>, SignalParameter> getEvaluatorCallback =
            EvaluatorGroup.Callback1.of(SkySpectralRadianceCurveFit::createEvaluator);

    private static final class SkySpectralRadianceEvaluator extends Evaluator<Double> {
        public SkySpectralRadianceEvaluator(EvaluatorGroup group, ParameterEvaluator<Signal> signalEvaluator) {
            super(group);
            m_signalEvaluator = signalEvaluator;
        }

        private SkySpectralRadianceEvaluator(SkySpectralRadianceEvaluator existingInstance, CopyContext context) {
            super(existingInstance, context);
            m_signalEvaluator = existingInstance.m_signalEvaluator;
            updateEvaluatorReferences(context);
        }

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

        @Override
        public Double evaluate(JulianDate date) {
            Signal signal = m_signalEvaluator.evaluate(date);
            double waveLength = Constants.SpeedOfLight / signal.getFrequency() * 1.0e9; // in nm

            // Curve fit from section 6 of the ITU-R P.1814 recommendation
            return 8.97e-13 * Math.pow(waveLength, 5) -
                    4.65e-9 * Math.pow(waveLength, 4) +
                    9.37e-6 * Math.pow(waveLength, 3) -
                    9.067e-3 * waveLength * waveLength +
                    4.05 * waveLength - 5.70;
        }

        @Override
        public boolean isAvailable(JulianDate date) {
            return m_signalEvaluator.isAvailable(date);
        }

        @Override
        public TimeIntervalCollection getAvailabilityIntervals(TimeIntervalCollection consideredIntervals) {
            return m_signalEvaluator.getAvailabilityIntervals(consideredIntervals);
        }

        @Override
        public boolean getIsThreadSafe() {
            return m_signalEvaluator.getIsThreadSafe();
        }

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

        @Override
        protected void dispose(boolean disposing) {
            if (disposing) {
                m_signalEvaluator.close();
            }
        }

        @Override
        public boolean getIsTimeVarying() {
            return m_signalEvaluator.getIsTimeVarying();
        }

        private ParameterEvaluator<Signal> m_signalEvaluator;
    }
}