Abschnitte der Dokumentation

Nach einem Zielwert auflösen

POSThttps://rftools.io/api/py/v1/calculate/solve

Findet den Wert einer Eingabe eines Rechners, der eine seiner Ausgaben auf einen Zielwert bringt (die Leiterbahnbreite für 50 Ω, den Abstand für eine Ziel-Differenzimpedanz), und gibt ihn mit dem Vorwärtsergebnis genau bei diesem Wert zurück. Ein gezählter Aufruf ersetzt die Vorwärtsaufrufe, die ein Client sonst für die Suche von Hand aufwenden würde.

Wie die Suche abläuft

Die Suche läuft über die angegebenen Grenzen von solveFor, eingeengt durch range, wo eines angegeben ist; eine Eingabe ohne angegebene Grenze braucht range. Wo grid angegeben ist, wird der zurückgegebene value auf das nächste Vielfache des Rasters innerhalb des Bereichs gerundet, und unrounded trägt die exakte Lösung; ohne grid sind value und unrounded dieselbe Zahl. In jedem Fall ist result (genau das, was /calculate für diese Eingaben zurückgibt, Provenienz eingeschlossen) der Vorwärtslauf des Rechners genau beim zurückgegebenen value, sodass ein Client stets eine echte Vorwärtsberechnung anzeigt, nie die eigene Schätzung des Lösers.

Request-Body

SolveRequest
Feld	Beschreibung
slugerforderlichstring	Der Rechner.
inputserforderlichobject of numbers	Jede Eingabe außer solveFor. Ein für solveFor angegebener Wert ist nur der Startpunkt der Suche, mit dem zwischen mehreren Lösungen entschieden wird.
solveForerforderlichstring	Eine deklarierte numerische Eingabe des Rechners.
target.outputerforderlichstring	Ein Ausgabeschlüssel, den der Rechner zurückgibt.
target.valueerforderlichnumber	Der Wert, den diese Ausgabe erreichen soll.
gridnumber	Ein positives Fertigungsraster; der zurückgegebene Wert wird auf das nächste Vielfache innerhalb des Bereichs gerundet.
range[number, number]	Engt die angegebenen Grenzen von solveFor ein; erforderlich, wenn es keine angibt.

Antwort

SolveResponse
Feld	Beschreibung
valuenumber	Der gefundene Wert, auf grid gerundet, wenn eines angegeben war.
unroundednumber	Die exakte Lösung, vor dem Runden auf das Raster.
reachedboolean	Ob der Zielwert erreicht wurde; false trägt trotzdem den nächstgelegenen gefundenen Wert, keine Schätzung.
evaluationsinteger	Wie viele Vorwärtsberechnungen die Suche gebraucht hat.
warningsstring[]	Die eigenen Befunde der Lösung: eine weitere Lösung im Bereich oder ein nicht erreichter Zielwert.
resultobject	Genau das, was /calculate für die Eingaben mit solveFor auf value gesetzt zurückgibt: values, warnings, errors und provenance.
slug, solveFor, target, gridecho	Die Felder der Anfrage, wie angegeben; grid ist null, wenn keines angegeben war.

Kosten und Mehrdeutigkeit

Kosten

Ein gezählter Aufruf, abgerechnet wie bei /calculate nach allen unten genannten Prüfungen und gutgeschrieben, wenn der Dienst danach scheitert. Ein Zielwert, den die Suche nicht erreichen kann, ist trotzdem ein Erfolg und wird trotzdem abgerechnet, mit reached: false und dem nächstgelegenen gefundenen Wert: Der Aufrufer hat etwas angefragt, das der Dienst geliefert hat.

Mehr als eine Lösung

Kreuzt die Ausgabe den Zielwert innerhalb des Bereichs mehr als einmal, liefert der Aufruf den Schnittpunkt, der dem Startwert am nächsten liegt (dem Wert des Aufrufers für solveFor, sonst dem Standardwert des Rechners), und fügt eine Warnung hinzu, die den anderen nennt.

Ablehnungen

Eine Anfrage, die sich nicht lösen lässt, wird abgelehnt, bevor etwas abgerechnet wird, und param nennt das fehlerhafte Feld:

Ablehnungen von Solve
Status	Wann
404	Den Rechner-Slug gibt es nicht.
400	solveFor ist keine der deklarierten numerischen Eingaben des Rechners (param: solveFor, mit allowed).
400	target.output ist keine der Ausgaben des Rechners (param: target.output, mit allowed).
400	grid ist angegeben und keine endliche, positive Zahl oder hat kein Vielfaches im Bereich.
400	Ein angegebener Wert (eine Eingabe, target.value oder eine Bereichsgrenze) ist nicht endlich.
400	solveFor hat keine angegebene Grenze und der Body gibt keinen range an, oder der angegebene Bereich liegt außerhalb der angegebenen Grenzen oder ist leer.
400	Eine feste Eingabe überschreitet ein Limit, das der Rechner für seine eigene Laufzeit durchsetzt, wie bei /calculate.

curl -X POST https://rftools.io/api/py/v1/calculate/solve \
  -H "X-API-Key: $RFTOOLS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "slug": "microstrip-impedance",
    "inputs": {
      "substrateHeight": 1.51,
      "dielectricConstant": 4.5,
      "copperThickness": 35
    },
    "solveFor": "traceWidth",
    "target": {
      "output": "impedance",
      "value": 50
    },
    "grid": 0.001
  }'

import rftools

client = rftools.Client()  # reads RFTOOLS_API_KEY, or the key `rftools login` saved

result = client.solve(
    "microstrip-impedance",
    {
        "substrateHeight": 1.51,
        "dielectricConstant": 4.5,
        "copperThickness": 35,
    },
    "traceWidth", "impedance", 50,
    grid=0.001,
)
print(result.value, result.reached)
print(result.result.values)

const response = await fetch("https://rftools.io/api/py/v1/calculate/solve", {
  method: "POST",
  headers: {
    "X-API-Key": process.env.RFTOOLS_API_KEY,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "slug": "microstrip-impedance",
    "inputs": {
      "substrateHeight": 1.51,
      "dielectricConstant": 4.5,
      "copperThickness": 35
    },
    "solveFor": "traceWidth",
    "target": {
      "output": "impedance",
      "value": 50
    },
    "grid": 0.001
  }),
});
console.log(response.status, await response.json());

package main

import (
	"bytes"
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	body := []byte(`{
	  "slug": "microstrip-impedance",
	  "inputs": {
	    "substrateHeight": 1.51,
	    "dielectricConstant": 4.5,
	    "copperThickness": 35
	  },
	  "solveFor": "traceWidth",
	  "target": {
	    "output": "impedance",
	    "value": 50
	  },
	  "grid": 0.001
	}`)
	req, err := http.NewRequest("POST", "https://rftools.io/api/py/v1/calculate/solve", bytes.NewReader(body))
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("RFTOOLS_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
	out, _ := io.ReadAll(res.Body)
	fmt.Println(res.Status, string(out))
}

application/json

{
  "slug": "microstrip-impedance",
  "solveFor": "traceWidth",
  "target": {
    "output": "impedance",
    "value": 50
  },
  "grid": 0.001,
  "value": 2.781,
  "unrounded": 2.780720522734193,
  "reached": true,
  "evaluations": 68,
  "warnings": [],
  "result": {
    "slug": "microstrip-impedance",
    "values": {
      "impedance": 49.99705984469245,
      "effectiveDielectric": 3.3944336801230706,
      "propagationDelay": 6.145581196647901,
      "guidedWavelength": 67.79939168226058,
      "quarterWavelength": 16.949847920565144
    },
    "warnings": [],
    "errors": [],
    "provenance": {
      "method": "calculator:microstrip-impedance",
      "version": "api@3f2c1a9b04de",
      "formulaRef": "Hammerstad & Jensen (1980); Wadell, \"Transmission Line Design Handbook\" 1991",
      "assumptions": [
        {
          "code": "quasi-static",
          "text": "Quasi-static: Z₀ and εeff are the Hammerstad–Jensen static values, with no frequency dependence; dispersion is not modelled."
        },
        {
          "code": "bare-microstrip",
          "text": "Bare microstrip: air above the trace, with no soldermask or other cover layer."
        },
        {
          "code": "homogeneous-substrate",
          "text": "One homogeneous, isotropic, non-magnetic substrate of relative permittivity εr over a solid ground plane, both extending well beyond the trace."
        },
        {
          "code": "thickness-effective-width",
          "text": "Copper thickness t is modelled as an effective width increase Δw = (t/π)(1 + ln(2h/t)), applied to both Z₀ and εeff."
        },
        {
          "code": "lossless",
          "text": "Lossless: conductor and dielectric losses are neglected, so Z₀ is real and the propagation delay is √εeff/c."
        }
      ],
      "validRange": {
        "status": "inside",
        "bounds": {
          "traceWidth": {
            "min": 0.01,
            "max": 50,
            "unit": "mm"
          },
          "substrateHeight": {
            "min": 0.05,
            "max": 10,
            "unit": "mm"
          },
          "dielectricConstant": {
            "min": 1,
            "max": 100,
            "unit": ""
          },
          "copperThickness": {
            "min": 1,
            "max": 200,
            "unit": "μm"
          },
          "frequency": {
            "min": 0.001,
            "max": 300,
            "unit": "GHz"
          }
        },
        "outside": [],
        "model": null
      },
      "computedAt": "2026-09-24T14:05:11.004Z",
      "inputs": {
        "traceWidth": 2.781,
        "substrateHeight": 1.51,
        "dielectricConstant": 4.5,
        "copperThickness": 35,
        "frequency": 2.4
      },
      "seed": null,
      "elapsedSeconds": 0.004
    }
  }
}

Die Leiterbahnbreite, die auf 1,51 mm FR-4 50 Ω erreicht, auf einem Raster von 0,001 mm.

{
  "detail": "'impedance' is not an input of 'microstrip-impedance', so it cannot be solved for. Its inputs: traceWidth, substrateHeight, dielectricConstant, copperThickness, frequency.",
  "errorKind": "invalid_request",
  "param": "solveFor",
  "allowed": [
    "traceWidth",
    "substrateHeight",
    "dielectricConstant",
    "copperThickness",
    "frequency"
  ]
}

Eine Ausgabe als solveFor angegeben. Es wurde nichts abgerechnet.

{
  "detail": "Calculator 'microstrip' not found",
  "errorKind": "invalid_request"
}

Ein Slug, den es nicht gibt.