public TrackingExteriorCrackLSM(IPropagator propagator, double tipEnrichmentAreaRadius, IHeavisideSingularityResolver singularityResolver) { this.propagator = propagator; this.tipEnrichmentAreaRadius = tipEnrichmentAreaRadius; this.crackPath = new List <CartesianPoint>(); this.levelSetsBody = new Dictionary <XNode, double>(); this.levelSetsTip = new Dictionary <XNode, double>(); this.tipElements = new List <XContinuumElement2D>(); this.crackBodyNodesAll = new HashSet <XNode>(); this.crackBodyNodesModified = new HashSet <XNode>(); this.crackBodyNodesNearModified = new HashSet <XNode>(); this.crackBodyNodesNew = new HashSet <XNode>(); this.crackBodyNodesRejected = new HashSet <XNode>(); this.crackTipNodesNew = new HashSet <XNode>(); this.crackTipNodesOld = new HashSet <XNode>(); this.ElementsModified = new HashSet <XContinuumElement2D>(); //this.levelSetUpdater = new LevelSetUpdaterOLD(); this.levelSetUpdater = new LevelSetUpdaterStolarska(); //this.meshInteraction = new StolarskaMeshInteraction(this); //this.meshInteraction = new HybridMeshInteraction(this); this.meshInteraction = new SerafeimMeshInteraction(this); this.SingularityResolver = singularityResolver; }
public MultiplePingSimulation(float speed, float time, Mesh polyhedraMesh, IPropagator propagator, int startVertex = 0) : base(speed, time) { this.propagator = propagator; this.startVertex = startVertex; pingQueue = new Queue <int>(); pings = new SortedSet <Tuple <double, int> >(); }
public double GetMinimalCost(Goal goal, IPropagator propagator) { var countermeasure_goals = _model.Resolutions().Select(x => x.ResolvingGoalIdentifier).Distinct(); // Initialize vector var mapping = Enumerable.Zip(Enumerable.Range(0, countermeasure_goals.Count()), countermeasure_goals, (arg1, arg2) => new { arg1, arg2 }) .ToDictionary(item => item.arg1, item => item.arg2); double[] sampling = GetInitialSampling(countermeasure_goals, mapping); var random = new Random(); var rho = .1; int i = 0; while (Iterations < StoppingCriterion & i < MaxIterations) { var gammaT = IterateCost(goal, propagator, sampling, mapping, random, rho); if (Math.Abs(gammaT - lastGammaT) <= EPSILON) { Iterations++; } else { Iterations = 0; } lastGammaT = gammaT; Console.WriteLine($"{gammaT:0.00} | " + string.Join(" ", sampling.Select(x => $"{x:0.00}"))); i++; } return(lastGammaT); }
private double GetScore(Goal goal, IPropagator propagator, HashSet <string> selection) { double maxSatRate; var r = _model.Resolutions().Where(x => selection.Contains(x.ResolvingGoalIdentifier)); // Integrate the selection foreach (var resolution in r) { integrator.Integrate(resolution); } var satRate = (DoubleSatisfactionRate)propagator.GetESR(goal); //var all_goals_satisfied = (satRate.SatisfactionRate > goal.RDS); //if (all_goals_satisfied) { var cost = selection.Count(); maxSatRate = satRate.SatisfactionRate; foreach (var resolution in r) { integrator.Remove(resolution); } return(maxSatRate); }
public TracerShim(Trace.Tracer tracer, IPropagator textFormat) { this.tracer = tracer ?? throw new ArgumentNullException(nameof(tracer)); this.propagator = textFormat ?? throw new ArgumentNullException(nameof(textFormat)); this.ScopeManager = new ScopeManagerShim(this.tracer); }
private static SpanContext ExtractPropagatedContext(IPropagator propagator, HttpRequest request) { try { // extract propagation details from http headers var requestHeaders = request.Headers; if (requestHeaders != null) { var headersCollection = new DictionaryHeadersCollection(); foreach (var header in requestHeaders) { string key = header.Key; string[] values = header.Value.ToArray(); if (key != null && values.Length > 0) { headersCollection.Add(key, values); } } return(propagator.Extract(headersCollection)); } } catch (Exception ex) { Log.Error(ex, "Error extracting propagated HTTP headers."); } return(null); }
private double GetScore(IEnumerable <Goal> goals, IPropagator propagator, HashSet <string> selection, out IEnumerable <string> rootsSatisfied) { var r = _model.Resolutions().Where(x => selection.Contains(x.ResolvingGoalIdentifier)); var rootGoalsSatisfied = new HashSet <string> (); integrator = new SoftResolutionIntegrator(_model); Console.WriteLine("---- Computing score for " + string.Join(",", selection) + "."); // Integrate the selection foreach (var resolution in r) { Console.WriteLine("Integrate " + resolution.ResolvingGoalIdentifier); integrator.Integrate(resolution); } var p2 = new BDDBasedPropagator(_model); //var all_goals_satisfied = true; var avg_sat_rate = 0.0; foreach (var goal in goals) { var satRate = ((DoubleSatisfactionRate)p2.GetESR(goal)); avg_sat_rate += satRate.SatisfactionRate; if (satRate.SatisfactionRate >= goal.RDS) { rootGoalsSatisfied.Add(goal.Identifier); } Console.WriteLine("Cost " + selection.Count); Console.WriteLine("Selected cm: " + string.Join(",", selection)); Console.WriteLine($"{goal.Identifier} : {satRate.SatisfactionRate} >= {goal.RDS}."); } //var all_goals_satisfied = (satRate.SatisfactionRate > goal.RDS); var cost = selection.Count(); foreach (var resolution in r) { integrator.Remove(resolution); } //if (!all_goals_satisfied) //{ // Console.WriteLine("---- not all goal satisfied, returning score = 0"); // return 0; //} rootsSatisfied = rootGoalsSatisfied; //if (satRate > goal.RDS) { Console.WriteLine("---- returning score = " + (avg_sat_rate / goals.Count())); return(avg_sat_rate / goals.Count()); //} else { // return 0; //} }
public ApplicationInsightsTracer(TelemetryConfiguration config, IScopeManager scopeManager, IPropagator <ITextMap> propagator, ITimeProvider timeProvider, Endpoint localEndpoint) { Client = new TelemetryClient(config); _config = config; ScopeManager = scopeManager; _propagator = propagator; TimeProvider = timeProvider; LocalEndpoint = localEndpoint; }
/// <summary> /// Add a new propagator to a stack. /// </summary> /// <param name="propagator"></param> /// <returns></returns> /// <exception cref="ArgumentNullException"></exception> public PropagatorStack AddPropagator(IPropagator propagator) { if (propagator == null) { throw new ArgumentNullException(nameof(propagator)); } Propagators.Add(propagator); return(this); }
public CompositeTextMapPropagatorTests() { _multiplexer = new CompositeTextMapPropagator( new[] { new ExamplePropagatorStub("propagator-1", "propagation-1", canExtract: false), new ExamplePropagatorStub("propagator-2", "propagation-2", canExtract: true), new ExamplePropagatorStub("propagator-3", "propagation-3", canExtract: true) }); }
/// <summary> /// Add a new propagator to a stack. /// </summary> /// <param name="propagator"></param> /// <returns></returns> /// <exception cref="ArgumentNullException"></exception> public PropagatorStack AddPropagator(IPropagator propagator) { if (propagator == null) { throw new ArgumentNullException(nameof(propagator)); } _logger.Trace($"Adding {propagator.GetType()} to PropagatorStack."); Propagators.Add(propagator); return(this); }
public ZipkinTracer(ZipkinTracerOptions options) { _propagator = options.Propagator ?? new B3Propagator(); _reporter = options.Reporter; LocalEndpoint = options.LocalEndpoint; TimeProvider = options.TimeProvider ?? new DateTimeOffsetTimeProvider(); ScopeManager = options.ScopeManager ?? new AsyncLocalScopeManager(); IdProvider = options.IdProvider ?? ThreadLocalRngSpanIdProvider.TraceId128BitProvider; Sampler = options.Sampler ?? NoSampler.Instance; Options = options; }
public MockZipkinTracer(Endpoint localEndpoint = null, ITimeProvider timeProvider = null, ISpanIdProvider idProvider = null, IScopeManager scopeManager = null, IPropagator <ITextMap> propagtor = null, ITraceSampler sampler = null) { LocalEndpoint = localEndpoint ?? Endpoint.Testing; TimeProvider = timeProvider ?? new DateTimeOffsetTimeProvider(); IdProvider = idProvider ?? ThreadLocalRngSpanIdProvider.TraceId128BitProvider; ScopeManager = scopeManager ?? NoOp.ScopeManager; _propagator = propagtor ?? new B3Propagator(); Sampler = sampler ?? NoSampler.Instance; CollectedSpans = new ConcurrentQueue <Span>(); }
public void Register(string format, IPropagator propagator) { if (string.IsNullOrWhiteSpace(format)) { throw new ArgumentException("The format can not be null, empty or whitespace"); } if (propagator == null) { throw new ArgumentNullException(nameof(propagator)); } propagators[format] = propagator; }
public IPropagator AddDependent(IPropagator dependent, bool biDirectional) { if (!_dependencyList.Contains(dependent)) { _dependencyList.Add(dependent); } if (biDirectional) { dependent.AddDependent(this, false); } return(this); }
public IPropagator RemoveDependent(IPropagator dependent, bool biDirectional) { if (_dependencyList.Contains(dependent)) { _dependencyList.Remove(dependent); if (biDirectional) { dependent.RemoveDependent(this, false); } } return(this); }
private IEnumerable <Candidate> Iterate(IEnumerable <Goal> goals, IPropagator propagator, double[] sampling, Dictionary <int, string> mapping, Random random, double rho) { var candidates = new List <Candidate>(); for (int i = 0; i < N; i++) { HashSet <string> selection = GetRandomSelection(sampling, mapping, random); var satRate = GetScore(goals, propagator, selection, out IEnumerable <string> nb_root_sat); candidates.Add(new Candidate(selection, satRate, nb_root_sat)); } for (int i = 0; i < N; i++) { candidates[i].Rank = 1 + candidates.Count(x => candidates[i].Dominate(x)); } candidates = candidates.OrderBy(x => x.Rank).ToList(); for (int i = 0; i < N; i++) { var c = candidates[i]; Console.WriteLine($"{c.Rank:00} | {c.cost} {c.nb_root_sat} {c.score:0.00} | " + string.Join(",", c.cm)); } Console.WriteLine(); var gammaT = candidates[(int)Math.Ceiling((1 - rho) * N)].Rank; var new_sampling = new double[sampling.Length]; var normalizationFactor = 0; for (int i = 0; i < sampling.Length; i++) { int c = candidates.Count(x => x.Rank <= gammaT & x.cm.Contains(mapping[i])); new_sampling[i] = c; normalizationFactor += c; //Console.WriteLine($"sampling[{i}] = {c}"); } for (int i = 0; i < sampling.Length; i++) { sampling[i] = alpha * sampling[i] + (1 - alpha) * (new_sampling[i] / normalizationFactor); } Console.WriteLine($"{gammaT:0.00} | " + string.Join(" ", sampling.Select(x => $"{x:0.00}"))); return(candidates.Where(x => x.Rank == 1)); }
private double Iterate(double minCost, Goal goal, IPropagator propagator, double[] sampling, Dictionary <int, string> mapping, Random random, double rho) { var candidates = new List <Candidate>(); for (int i = 0; i < N; i++) { HashSet <string> selection = GetRandomSelection(sampling, mapping, random); if (selection.Count() > minCost) { // Ignore solution candidates.Add(new Candidate(selection, 0)); } else { var maxSatRate = GetScore(goal, propagator, selection); if (maxSatRate > goal.RDS) { candidates.Add(new Candidate(selection, maxSatRate)); } else { candidates.Add(new Candidate(selection, 0)); } } } candidates = candidates.OrderBy(x => x.score).ToList(); var gammaT = candidates[(int)Math.Ceiling((1 - rho) * N)].score; var normalizationFactor = 0; for (int i = 0; i < sampling.Length; i++) { int c = candidates.Count(x => x.score >= gammaT & x.cm.Contains(mapping[i])); sampling[i] = c; normalizationFactor += c; //Console.WriteLine($"sampling[{i}] = {c}"); } for (int i = 0; i < sampling.Length; i++) { sampling[i] /= normalizationFactor; } return(gammaT); }
private Tracer(IScopeManager scopeManager, IPropagator propagator, Options options, ISpanRecorder spanRecorder) { ScopeManager = scopeManager; _spanRecorder = spanRecorder; _propagator = propagator; _options = options; var protocol = _options.Satellite.UsePlaintext ? "http" : "https"; // TODO: refactor to support changing proto var url = $"{protocol}://{_options.Satellite.SatelliteHost}:{_options.Satellite.SatellitePort}/{LightStepConstants.SatelliteReportPath}"; _httpClient = new LightStepHttpClient(url, _options); // assignment to a variable here is to suppress warnings that we're not awaiting an async method _reportLoop = new Timer(e => Flush(), null, TimeSpan.Zero, _options.ReportPeriod); }
private Tracer(IScopeManager scopeManager, IPropagator propagator, Options options, ISpanRecorder spanRecorder, ILightStepHttpClient client) { ScopeManager = scopeManager; _spanRecorder = spanRecorder; _propagator = propagator; _options = options; _logger.Debug( $"Creating new tracer with GUID {_options.TracerGuid}. Project Access Token: {_options.AccessToken}, Report Period: {_options.ReportPeriod}, Report Timeout: {_options.ReportTimeout}."); var protocol = _options.Satellite.UsePlaintext ? "http" : "https"; var url = $"{protocol}://{_options.Satellite.SatelliteHost}:{_options.Satellite.SatellitePort}/{LightStepConstants.SatelliteReportPath}"; _httpClient = client ?? new LightStepHttpClient(url, _options); _logger.Debug($"Tracer is reporting to {url}."); _reportLoop = new Timer(e => Flush(), null, TimeSpan.Zero, _options.ReportPeriod); _firstReportHasRun = false; }
public void Process(StateChange newState, StateChangeOptions options, IPropagator sender) { System.Console.WriteLine(options); if ((options & StateChangeOptions.Update) != 0) { Process(newState); } if ((options & StateChangeOptions.Notify) != 0) { _dependencyList.ForEach(x => { if (x != sender) { x.Process(newState, options, this); } }); } }
public IEnumerable <OptimalSelection> GetOptimalSelections(HashSet <Goal> goals, IPropagator propagator) { var countermeasure_goals = _model.Resolutions().Select(x => x.ResolvingGoalIdentifier).Distinct(); // Initialize vector var mapping = Enumerable.Zip(Enumerable.Range(0, countermeasure_goals.Count()), countermeasure_goals, (arg1, arg2) => new { arg1, arg2 }) .ToDictionary(item => item.arg1, item => item.arg2); double[] sampling = GetInitialSampling(countermeasure_goals, mapping); var random = new Random(); int i = 0; var paretoFront = new HashSet <Candidate>(); Iterations = 0; while (Iterations < StoppingCriterion & i < MaxIterations) { Console.WriteLine("iterate"); var paretoFrontIteration = Iterate(goals, propagator, sampling, mapping, random, rho); var spf = paretoFront.Count; // Add all new non-dominated solutions foreach (var item in paretoFrontIteration) { paretoFront.Add(item); } //Console.WriteLine("Before"); //Console.WriteLine(string.Join("\n", paretoFront.Select(x => x.score + " " + x.cost + " | " + string.Join(",", x.cm)))); // Remove all dominated solutions paretoFront = paretoFront.Where(x => !paretoFront.Any(y => y.Dominate(x))).ToHashSet(); //Console.WriteLine("After"); //Console.WriteLine(string.Join("\n", paretoFront.Select(x => x.score + " " + x.cost + " | " + string.Join(",", x.cm)))); if (spf == paretoFront.Count) { Iterations++; } else { Iterations = 0; } //Console.WriteLine($"{paretoFront.Count,-4} | " + string.Join(" ", sampling.Select(x => $"{x:0.00}"))); i++; } Console.WriteLine("Pareto Front:"); Console.WriteLine(string.Join("\n", paretoFront.Select(x => x.score + " " + x.nb_root_sat + " " + x.cost + " | " + string.Join(",", x.cm)))); var solution = new List <OptimalSelection>(); foreach (var candidate in paretoFront) { var activeResolutions = _model.Resolutions().Where(x => candidate.cm.Contains(x.ResolvingGoalIdentifier)); solution.Add(new OptimalSelection(activeResolutions, candidate.cost, candidate.score, candidate.sat_root)); } return(solution); }
public void RegisterPropagator(IPropagator p) { _influenceMap.RegisterPropagator(p); }
public IEnumerable <OptimalSelection> GetOptimalSelections(Goal goal, IPropagator propagator) { return(GetOptimalSelections(new HashSet <Goal>(new[] { goal }), propagator)); }
public void DeletePropagator(IPropagator p) { _influenceMap.DeletePropagator(p); PropagationUpdate(); }
public static SpanContext Extract(this IPropagator propagator, IHeadersCollection headers) { return(propagator.Extract(headers, ExtractFromHeadersCollection)); }
public static void Inject(this IPropagator propagator, SpanContext context, IHeadersCollection headers) { propagator.Inject(context, headers, InjectToHeadersCollection); }
public TrackingExteriorCrackLSM(IPropagator propagator, double tipEnrichmentAreaRadius = 0.0) : this(propagator, tipEnrichmentAreaRadius, null) { this.SingularityResolver = new RelativeAreaResolver(1E-4); }
/// <summary> /// Registers the given propagator for the given carrier format. /// </summary> /// <param name="format">The format for the given carrier type.</param> /// <param name="propagator">The propagator to register.</param> /// <typeparam name="TCarrier">The type of the carrier.</typeparam> public void Register <TCarrier>(IFormat <TCarrier> format, IPropagator propagator) { propagators[format] = propagator; }
/// <summary> /// Register custom propagator to support various formats. /// </summary> /// <typeparam name="TCarrier">The carrier type.</typeparam> /// <param name="format">The format for the given carrier type.</param> /// <param name="propagator">The propagator to register.</param> /// <returns><see cref="this"/></returns> public Builder RegisterPropagator <TCarrier>(IFormat <TCarrier> format, IPropagator propagator) { registry.Register(format, propagator); return(this); }
public void RegisterPropagator(IPropagator p) { _propagators.Add(p); }