Basic Communications

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

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

// Let's change the transmitting power
policeTransmitter.EffectiveIsotropicRadiatedPower = 350; // Watts

Cartographic losAngelesPD = new Cartographic(-2.0637416544, 0.5943235692, 30);
Cartographic losAngelesMedCenter = new Cartographic(-2.062997065, 0.594448304, 40);
policeTransmitter.LocationPoint = 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)), UnitCartesian.UnitZ);

// Create a receiver
SimpleReceiver medCenterReceiver = new SimpleReceiver();
medCenterReceiver.LocationPoint = new PointCartographic(earth, losAngelesMedCenter);
// Add noise to the Receiver
medCenterReceiver.NoiseFactor = 2;

// Create a link between them
CommunicationSystem commSys = new CommunicationSystem();
IServiceProvider link = commSys.Links.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.OrientationAxes = new AxesTargetingLink(link, LinkRole.Transmitter, localZAxis);
medCenterReceiver.OrientationAxes = 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)));

// 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.Name = "Relay Transceiver";
relay.Modulation = new ModulationBpsk();
relay.InputAntennaGainPattern = new IsotropicGainPattern();
relay.CarrierFrequency = policeTransmitter.CarrierFrequency;

GaussianGainPattern transmitterPattern = new GaussianGainPattern();
transmitterPattern.BacklobeGain = 0.001; // decimal
transmitterPattern.Diameter = 1.0; // meters
transmitterPattern.Efficiency = 0.55; // ratio between zero and one
relay.OutputAntennaGainPattern = transmitterPattern;

// Change the output gain to 10;
relay.OutputGain = 10;

// 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);
relay.InputAntenna.LocationPoint = 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.InputAntenna.LocationPoint, new AxesEastNorthUp(earth, relay.InputAntenna.LocationPoint));
// Now create a fixed offset from that frame and assign it to the output antenna.
relay.OutputAntenna.LocationPoint = new PointFixedOffset(enuFrame, new Cartesian(1, 0, 0));

// Hook up a filter on the relay
relay.Filter = new RectangularFilter();
// Set the filter's Frequency to the frequency that will be retransmitted.
relay.Filter.Frequency = policeTransmitter.CarrierFrequency;
// Define a 2 MHz bandwidth for the filter.
relay.Filter.LowerBandwidthLimit = -1e6;
relay.Filter.UpperBandwidthLimit = 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.Links.AddChain(policeTransmitter, relay, medCenterReceiver);
// Let's set the DefaultReferenceVector to something different
commSys.DefaultReferenceVector = 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.Links.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)));

// 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;
var 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;

var earth = CentralBodiesFacet.GetFromContext().Earth;

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

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

// Construct the optics gain pattern for the transmitter
var xmtrAntennaPattern = new GaussianOpticalGainPattern(xmtrApertureDiameter, xmtrDivergenceAngle,
                                                        xmtrOpticalEfficiency, xmtrOpticalPointingError);
// Construct the transmitter instance
var xmtr = new OpticalTransmitter("ATETransmitter", airPoint, airAxes, xmtrDigitalModulation,
                                  xmtrAntennaPattern, xmtrWavelength, xmtPower, xmtrDataRate, null);

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

// Construct the photodetector and receiver instance
var rcvrPhotodetector = new AvalanchePhotodiode();
var rcvr = new OpticalReceiver("GTEReceiver", groundPoint, groundAxes, rcvrPhotodetector, rcvrAntenna);

// Configure the avalanche potodetector
rcvrPhotodetector.ParentReceiver = rcvr;
rcvrPhotodetector.CentralBody = earth;
rcvrPhotodetector.FieldOfView = rcvrFieldOfView;
rcvrPhotodetector.Wavelength = xmtrWavelength;
rcvrPhotodetector.Bandwidth = xmtrDataRate;
rcvrPhotodetector.OpticalBandpassFilterBandwidth = 2.0 * xmtrDataRate;
rcvrPhotodetector.Efficiency = rcvrPhotodetectorQuantumEfficiency;
rcvrPhotodetector.NoiseFactor = rcvrApdExcessNoiseFactor;
rcvrPhotodetector.NoiseTemperature = rcvrNoiseTemperature;
rcvrPhotodetector.DarkCurrent = rcvrDarkCurrent;
rcvrPhotodetector.LoadImpedance = rcvrLoadImpedance;
rcvrPhotodetector.Gain = rcvrApdGain;
rcvrPhotodetector.SkySpectralRadiance = new SkySpectralRadianceCurveFit(); // Construct our custom sky spectral radiance model
rcvrPhotodetector.SunSpectralRadiantEmittance = 0.0; // We're not modeling sun spectral radiant emittance in this example, so set to zero

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

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

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

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

// Add the default propagation models to the CommunicationSystem instance
cs.Links.DefaultPropagationModels.Add(atmosLossModel);
cs.Links.DefaultPropagationModels.Add(scintModel);

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

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

// When retrieving evaluators, we need to specify our desired signal.
var 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
var group = new EvaluatorGroup();

// Get the link budgets scalars object using the link that was created by the CommunicationSystem and the intended signal strategy
var lbs = cs.GetLinkBudgetScalars(cs.Links[0], intendedSignal);

// Get each of the desired evaluators passing the evaluator group for later optimization
var outputPowerEval = lbs.PowerAtReceiverOutput.GetEvaluator(group);
var xmtGainEval = lbs.TransmitterAntennaGainInLinkDirection.GetEvaluator(group);
var rcvGainEval = lbs.ReceiverAntennaGainInLinkDirection.GetEvaluator(group);
var propLossEval = lbs.PropagationLoss.GetEvaluator(group);
var ripEval = lbs.ReceivedIsotropicPower.GetEvaluator(group);
var cOverNEval = lbs.CarrierToNoise.GetEvaluator(group);
var berEval = lbs.BitErrorRate.GetEvaluator(group);

// Optimize the evaluators
group.OptimizeEvaluators();

var 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 sealed class SkySpectralRadianceCurveFit : SignalComputation
{
    public SkySpectralRadianceCurveFit()
    {
    }

    private SkySpectralRadianceCurveFit(SignalComputation existingInstance, CopyContext context)
        : base(existingInstance, context)
    {
    }

    protected override bool CheckForSameDefinition(SignalComputation other)
    {
        return other is SkySpectralRadianceCurveFit;
    }

    public override object Clone(CopyContext context)
    {
        return new SkySpectralRadianceCurveFit(this, context);
    }

    public override IEvaluator<double> GetEvaluator(EvaluatorGroup group)
    {
        return group.CreateEvaluator<IEvaluator<double>, SignalParameter>(CreateEvaluator, Parameter);
    }

    private static IEvaluator<double> CreateEvaluator(EvaluatorGroup group, SignalParameter parameter)
    {
        return new SkySpectralRadianceEvaluator(group, parameter.GetEvaluator(group));
    }

    private sealed class SkySpectralRadianceEvaluator : Evaluator<double>
    {
        public SkySpectralRadianceEvaluator(EvaluatorGroup group, ParameterEvaluator<Signal> signalEvaluator)
            : base(group)
        {
            m_signalEvaluator = signalEvaluator;
        }

        private SkySpectralRadianceEvaluator(SkySpectralRadianceEvaluator existingInstance, CopyContext context)
            : base(existingInstance, context)
        {
            m_signalEvaluator = existingInstance.m_signalEvaluator;
            UpdateEvaluatorReferences(context);
        }

        public override void UpdateEvaluatorReferences(CopyContext context)
        {
            m_signalEvaluator = context.UpdateReference(m_signalEvaluator);
        }

        public override double Evaluate(JulianDate date)
        {
            Signal signal = m_signalEvaluator.Evaluate(date);
            double waveLength = Constants.SpeedOfLight / signal.Frequency * 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;
        }

        public override bool IsAvailable(JulianDate date)
        {
            return m_signalEvaluator.IsAvailable(date);
        }

        public override TimeIntervalCollection GetAvailabilityIntervals(TimeIntervalCollection consideredIntervals)
        {
            return m_signalEvaluator.GetAvailabilityIntervals(consideredIntervals);
        }

        public override bool IsThreadSafe
        {
            get { return m_signalEvaluator.IsThreadSafe; }
        }

        public override object Clone(CopyContext context)
        {
            return new SkySpectralRadianceEvaluator(this, context);
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing)
                m_signalEvaluator.Dispose();
        }

        public override bool IsTimeVarying
        {
            get { return m_signalEvaluator.IsTimeVarying; }
        }

        private ParameterEvaluator<Signal> m_signalEvaluator;
    }
}