initial commit

.gitattributes

@@ -0,0 +1 @@
+*.safetensors filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,6 @@
+.ruff_cache/
+.venv/
+__pycache__/
+*.swp
+*.kate-swp
+*~

LICENSE

@@ -0,0 +1,474 @@
+Lowdown Labs Lovely License 1.0 (LLLL-1.0)
+
+Everything in this repository (the model weights, the configuration, and the code) is
+released by Lowdown Labs under two licenses that apply at the same time. To use this work
+you must comply with BOTH of them. Where a term in one is stricter than the other, the
+stricter term controls. "Lowdown Labs Lovely License 1.0" is a convenience name for this
+exact pair; it is not a new legal instrument.
+
+SPDX-License-Identifier: CC-BY-NC-4.0 AND LicenseRef-Hippocratic-3.0
+
+Commercial licensing. The grant below is non-commercial only. Commercial licenses are
+sold separately by Lowdown Labs on a per-customer basis. To use this work, its weights, or
+its outputs for any commercial purpose, contact Lowdown Labs to purchase a commercial
+license. A commercial license does not remove the Hippocratic ethical-use obligations in
+Part 2; those apply to commercial licensees as well.
+
+==============================================================================
+Part 1 of 2. Creative Commons Attribution-NonCommercial 4.0 International (CC BY-NC 4.0)
+==============================================================================
+
+You may share and adapt this work for non-commercial purposes, with attribution to
+Lowdown Labs. Commercial use is not granted under this license.
+
+  Full legal text:        https://creativecommons.org/licenses/by-nc/4.0/legalcode
+  Plain-language summary:  https://creativecommons.org/licenses/by-nc/4.0/
+  SPDX-License-Identifier: CC-BY-NC-4.0
+
+==============================================================================
+Part 2 of 2. The Hippocratic License 3.0 (ethical use)
+==============================================================================
+
+Module set enabled: bds, cl, eco, extr, ffd, law, media, mil, my, soc, sup, sv, usta.
+Canonical build: https://firstdonoharm.dev/build/?modules=bds,cl,eco,extr,ffd,law,media,mil,my,soc,sup,sv,usta
+
+The verbatim official Hippocratic License 3.0 text for exactly this module set follows,
+between the markers.
+
+--------------------- BEGIN OFFICIAL HIPPOCRATIC LICENSE 3.0 TEXT ---------------------
+
+HIPPOCRATIC LICENSE
+
+Version 3.0, October 2021
+
+https://firstdonoharm.dev/version/3/0/bds-cl-eco-extr-ffd-law-media-mil-my-soc-sup-sv-usta.txt
+
+TERMS AND CONDITIONS
+
+TERMS AND CONDITIONS FOR USE, COPY, MODIFICATION, PREPARATION OF DERIVATIVE
+WORK, REPRODUCTION, AND DISTRIBUTION:
+
+1. DEFINITIONS:
+
+This section defines certain terms used throughout this license agreement.
+
+1.1. “License” means the terms and conditions, as stated herein, for use, copy,
+modification, preparation of derivative work, reproduction, and distribution of
+Software (as defined below).
+
+1.2. “Licensor” means the copyright and/or patent owner or entity authorized by
+the copyright and/or patent owner that is granting the License.
+
+1.3. “Licensee” means the individual or entity exercising permissions granted by
+this License, including the use, copy, modification, preparation of derivative
+work, reproduction, and distribution of Software (as defined below).
+
+1.4. “Software” means any copyrighted work, including but not limited to
+software code, authored by Licensor and made available under this License.
+
+1.5. “Supply Chain” means the sequence of processes involved in the production
+and/or distribution of a commodity, good, or service offered by the Licensee.
+
+1.6. “Supply Chain Impacted Party” or “Supply Chain Impacted Parties” means any
+person(s) directly impacted by any of Licensee’s Supply Chain, including the
+practices of all persons or entities within the Supply Chain prior to a good or
+service reaching the Licensee.
+
+1.7. “Duty of Care” is defined by its use in tort law, delict law, and/or
+similar bodies of law closely related to tort and/or delict law, including
+without limitation, a requirement to act with the watchfulness, attention,
+caution, and prudence that a reasonable person in the same or similar
+circumstances would use towards any Supply Chain Impacted Party.
+
+1.8. “Worker” is defined to include any and all permanent, temporary, and agency
+workers, as well as piece-rate, salaried, hourly paid, legal young (minors),
+part-time, night, and migrant workers.
+
+2. INTELLECTUAL PROPERTY GRANTS:
+
+This section identifies intellectual property rights granted to a Licensee.
+
+2.1. Grant of Copyright License: Subject to the terms and conditions of this
+License, Licensor hereby grants to Licensee a worldwide, non-exclusive,
+no-charge, royalty-free copyright license to use, copy, modify, prepare
+derivative work, reproduce, or distribute the Software, Licensor authored
+modified software, or other work derived from the Software.
+
+2.2. Grant of Patent License: Subject to the terms and conditions of this
+License, Licensor hereby grants Licensee a worldwide, non-exclusive, no-charge,
+royalty-free patent license to make, have made, use, offer to sell, sell,
+import, and otherwise transfer Software.
+
+3. ETHICAL STANDARDS:
+
+This section lists conditions the Licensee must comply with in order to have
+rights under this License.
+
+The rights granted to the Licensee by this License are expressly made subject to
+the Licensee’s ongoing compliance with the following conditions:
+
+ * 3.1. The Licensee SHALL NOT, whether directly or indirectly, through agents
+   or assigns:
+   
+   * 3.1.1. Infringe upon any person’s right to life or security of person,
+     engage in extrajudicial killings, or commit murder, without lawful cause
+     (See Article 3, United Nations Universal Declaration of Human Rights;
+     Article 6, International Covenant on Civil and Political Rights)
+   
+   * 3.1.2. Hold any person in slavery, servitude, or forced labor (See Article
+     4, United Nations Universal Declaration of Human Rights; Article 8,
+     International Covenant on Civil and Political Rights);
+   
+   * 3.1.3. Contribute to the institution of slavery, slave trading, forced
+     labor, or unlawful child labor (See Article 4, United Nations Universal
+     Declaration of Human Rights; Article 8, International Covenant on Civil and
+     Political Rights);
+   
+   * 3.1.4. Torture or subject any person to cruel, inhumane, or degrading
+     treatment or punishment (See Article 5, United Nations Universal
+     Declaration of Human Rights; Article 7, International Covenant on Civil and
+     Political Rights);
+   
+   * 3.1.5. Discriminate on the basis of sex, gender, sexual orientation, race,
+     ethnicity, nationality, religion, caste, age, medical disability or
+     impairment, and/or any other like circumstances (See Article 7, United
+     Nations Universal Declaration of Human Rights; Article 2, International
+     Covenant on Economic, Social and Cultural Rights; Article 26, International
+     Covenant on Civil and Political Rights);
+   
+   * 3.1.6. Prevent any person from exercising his/her/their right to seek an
+     effective remedy by a competent court or national tribunal (including
+     domestic judicial systems, international courts, arbitration bodies, and
+     other adjudicating bodies) for actions violating the fundamental rights
+     granted to him/her/them by applicable constitutions, applicable laws, or by
+     this License (See Article 8, United Nations Universal Declaration of Human
+     Rights; Articles 9 and 14, International Covenant on Civil and Political
+     Rights);
+   
+   * 3.1.7. Subject any person to arbitrary arrest, detention, or exile (See
+     Article 9, United Nations Universal Declaration of Human Rights; Article 9,
+     International Covenant on Civil and Political Rights);
+   
+   * 3.1.8. Subject any person to arbitrary interference with a person’s
+     privacy, family, home, or correspondence without the express written
+     consent of the person (See Article 12, United Nations Universal Declaration
+     of Human Rights; Article 17, International Covenant on Civil and Political
+     Rights);
+   
+   * 3.1.9. Arbitrarily deprive any person of his/her/their property (See
+     Article 17, United Nations Universal Declaration of Human Rights);
+   
+   * 3.1.10. Forcibly remove indigenous peoples from their lands or territories
+     or take any action with the aim or effect of dispossessing indigenous
+     peoples from their lands, territories, or resources, including without
+     limitation the intellectual property or traditional knowledge of indigenous
+     peoples, without the free, prior, and informed consent of indigenous
+     peoples concerned (See Articles 8 and 10, United Nations Declaration on the
+     Rights of Indigenous Peoples);
+    * 3.1.11. Fossil Fuel Divestment: Be an individual or entity, or a
+      representative, agent, affiliate, successor, attorney, or assign of an
+      individual or entity, on the FFI Solutions Carbon Underground 200 list
+      [https://www.ffisolutions.com/research-analytics-index-solutions/research-screening/the-carbon-underground-200/?cn-reloaded=1];
+   
+    * 3.1.12. Ecocide: Commit ecocide:
+      
+      * 3.1.12.1. For the purpose of this section, “ecocide” means unlawful or
+        wanton acts committed with knowledge that there is a substantial
+        likelihood of severe and either widespread or long-term damage to the
+        environment being caused by those acts;
+      
+      * 3.1.12.2. For the purpose of further defining ecocide and the terms
+        contained in the previous paragraph:
+        
+        * 3.1.12.2.1. “Wanton” means with reckless disregard for damage which
+          would be clearly excessive in relation to the social and economic
+          benefits anticipated;
+        
+        * 3.1.12.2.2. “Severe” means damage which involves very serious adverse
+          changes, disruption, or harm to any element of the environment,
+          including grave impacts on human life or natural, cultural, or
+          economic resources;
+        
+        * 3.1.12.2.3. “Widespread” means damage which extends beyond a limited
+          geographic area, crosses state boundaries, or is suffered by an entire
+          ecosystem or species or a large number of human beings;
+        
+        * 3.1.12.2.4. “Long-term” means damage which is irreversible or which
+          cannot be redressed through natural recovery within a reasonable
+          period of time; and
+        
+        * 3.1.12.2.5. “Environment” means the earth, its biosphere, cryosphere,
+          lithosphere, hydrosphere, and atmosphere, as well as outer space
+          
+          (See Section II, Independent Expert Panel for the Legal Definition of
+          Ecocide, Stop Ecocide Foundation and the Promise Institute for Human
+          Rights at UCLA School of Law, June 2021);
+   
+    * 3.1.13. Extractive Industries: Be an individual or entity, or a
+      representative, agent, affiliate, successor, attorney, or assign of an
+      individual or entity, that engages in fossil fuel or mineral exploration,
+      extraction, development, or sale;
+   
+    * 3.1.14. Boycott / Divestment / Sanctions: Be an individual or entity, or a
+      representative, agent, affiliate, successor, attorney, or assign of an
+      individual or entity, identified by the Boycott, Divestment, Sanctions
+      (“BDS”) movement on its website (https://bdsmovement.net/
+      [https://bdsmovement.net/] and
+      https://bdsmovement.net/get-involved/what-to-boycott
+      [https://bdsmovement.net/get-involved/what-to-boycott]) as a target for
+      boycott;
+   
+    * 3.1.15. Myanmar: Be an individual or entity that:
+      
+      * 3.1.15.1. engages in any commercial transactions with the
+        Myanmar/Burmese military junta; or
+      
+      * 3.1.15.2. is a representative, agent, affiliate, successor, attorney, or
+        assign of the Myanmar/Burmese government;
+   
+    * 3.1.16. US Tariff Act: Be an individual or entity:
+      
+      * 3.1.16.1. which U.S. Customs and Border Protection (CBP) has currently
+        issued a Withhold Release Order (WRO) or finding against based on
+        reasonable suspicion of forced labor; or
+      
+      * 3.1.16.2. that is a representative, agent, affiliate, successor,
+        attorney, or assign of an individual or entity that does business with
+        an individual or entity which currently has a WRO or finding from CBP
+        issued against it based on reasonable suspicion of forced labor;
+   
+    * 3.1.17. Mass Surveillance: Be a government agency or multinational
+      corporation, or a representative, agent, affiliate, successor, attorney,
+      or assign of a government or multinational corporation, which participates
+      in mass surveillance programs;
+   
+    * 3.1.18. Military Activities: Be an entity or a representative, agent,
+      affiliate, successor, attorney, or assign of an entity which conducts
+      military activities;
+   
+    * 3.1.19. Law Enforcement: Be an individual or entity, or a representative,
+      agent, affiliate, successor, attorney, or assign of an individual or
+      entity, that provides good or services to, or otherwise enters into any
+      commercial contracts with, any local, state, or federal law enforcement
+      agency;
+   
+    * 3.1.20. Media: Be an individual or entity, or a representative, agent,
+      affiliate, successor, attorney, or assign of an individual or entity, that
+      broadcasts messages promoting killing, torture, or other forms of extreme
+      violence;
+   
+   * 3.1.21. Interfere with Workers’ free exercise of the right to organize and
+     associate (See Article 20, United Nations Universal Declaration of Human
+     Rights; C087 - Freedom of Association and Protection of the Right to
+     Organise Convention, 1948 (No. 87), International Labour Organization;
+     Article 8, International Covenant on Economic, Social and Cultural Rights);
+     and
+   
+   * 3.1.22. Harm the environment in a manner inconsistent with local, state,
+     national, or international law.
+
+ * 3.2. The Licensee SHALL:
+   
+    * 3.2.1. Social Auditing: Only use social auditing mechanisms that adhere to
+      Worker-Driven Social Responsibility Network’s Statement of Principles
+      (https://wsr-network.org/what-is-wsr/statement-of-principles/
+      [https://wsr-network.org/what-is-wsr/statement-of-principles/]) over
+      traditional social auditing mechanisms, to the extent the Licensee uses
+      any social auditing mechanisms at all;
+   
+    * 3.2.2. Supply Chain: Provide clear, accessible supply chain data to the
+      public in accordance with the following conditions:
+      
+      * 3.2.2.1. All data will be on Licensee’s website and/or, to the extent
+        Licensee is a representative, agent, affiliate, successor, attorney,
+        subsidiary, or assign, on Licensee’s principal’s or parent’s website or
+        some other online platform accessible to the public via an internet
+        search on a common internet search engine; and
+      
+      * 3.2.2.2. Data published will include, where applicable, manufacturers,
+        top tier suppliers, subcontractors, cooperatives, component parts
+        producers, and farms;
+   
+   * 3.2.3. Provide equal pay for equal work where the performance of such work
+     requires equal skill, effort, and responsibility, and which are performed
+     under similar working conditions, except where such payment is made
+     pursuant to:
+     
+     * 3.2.3.1. A seniority system;
+     
+     * 3.2.3.2. A merit system;
+     
+     * 3.2.3.3. A system which measures earnings by quantity or quality of
+       production; or
+     
+     * 3.2.3.4. A differential based on any other factor other than sex, gender,
+       sexual orientation, race, ethnicity, nationality, religion, caste, age,
+       medical disability or impairment, and/or any other like circumstances
+       (See 29 U.S.C.A. § 206(d)(1); Article 23, United Nations Universal
+       Declaration of Human Rights; Article 7, International Covenant on
+       Economic, Social and Cultural Rights; Article 26, International Covenant
+       on Civil and Political Rights); and
+   
+   * 3.2.4. Allow for reasonable limitation of working hours and periodic
+     holidays with pay (See Article 24, United Nations Universal Declaration of
+     Human Rights; Article 7, International Covenant on Economic, Social and
+     Cultural Rights).
+
+4. SUPPLY CHAIN IMPACTED PARTIES:
+
+This section identifies additional individuals or entities that a Licensee could
+harm as a result of violating the Ethical Standards section, the condition that
+the Licensee must voluntarily accept a Duty of Care for those individuals or
+entities, and the right to a private right of action that those individuals or
+entities possess as a result of violations of the Ethical Standards section.
+
+4.1. In addition to the above Ethical Standards, Licensee voluntarily accepts a
+Duty of Care for Supply Chain Impacted Parties of this License, including
+individuals and communities impacted by violations of the Ethical Standards. The
+Duty of Care is breached when a provision within the Ethical Standards section
+is violated by a Licensee, one of its successors or assigns, or by an individual
+or entity that exists within the Supply Chain prior to a good or service
+reaching the Licensee.
+
+4.2. Breaches of the Duty of Care, as stated within this section, shall create a
+private right of action, allowing any Supply Chain Impacted Party harmed by the
+Licensee to take legal action against the Licensee in accordance with applicable
+negligence laws, whether they be in tort law, delict law, and/or similar bodies
+of law closely related to tort and/or delict law, regardless if Licensee is
+directly responsible for the harms suffered by a Supply Chain Impacted Party.
+Nothing in this section shall be interpreted to include acts committed by
+individuals outside of the scope of his/her/their employment.
+
+5. NOTICE: This section explains when a Licensee must notify others of the
+License.
+
+5.1. Distribution of Notice: Licensee must ensure that everyone who receives a
+copy of or uses any part of Software from Licensee, with or without changes,
+also receives the License and the copyright notice included with Software (and
+if included by the Licensor, patent, trademark, and attribution notice).
+Licensee must ensure that License is prominently displayed so that any
+individual or entity seeking to download, copy, use, or otherwise receive any
+part of Software from Licensee is notified of this License and its terms and
+conditions. Licensee must cause any modified versions of the Software to carry
+prominent notices stating that Licensee changed the Software.
+
+5.2. Modified Software: Licensee is free to create modifications of the Software
+and distribute only the modified portion created by Licensee, however, any
+derivative work stemming from the Software or its code must be distributed
+pursuant to this License, including this Notice provision.
+
+5.3. Recipients as Licensees: Any individual or entity that uses, copies,
+modifies, reproduces, distributes, or prepares derivative work based upon the
+Software, all or part of the Software’s code, or a derivative work developed by
+using the Software, including a portion of its code, is a Licensee as defined
+above and is subject to the terms and conditions of this License.
+
+6. REPRESENTATIONS AND WARRANTIES:
+
+6.1. Disclaimer of Warranty: TO THE FULL EXTENT ALLOWED BY LAW, THIS SOFTWARE
+COMES “AS IS,” WITHOUT ANY WARRANTY, EXPRESS OR IMPLIED, AND LICENSOR SHALL NOT
+BE LIABLE TO ANY PERSON OR ENTITY FOR ANY DAMAGES OR OTHER LIABILITY ARISING
+FROM, OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR THIS LICENSE, UNDER ANY
+LEGAL CLAIM.
+
+6.2. Limitation of Liability: LICENSEE SHALL HOLD LICENSOR HARMLESS AGAINST ANY
+AND ALL CLAIMS, DEBTS, DUES, LIABILITIES, LIENS, CAUSES OF ACTION, DEMANDS,
+OBLIGATIONS, DISPUTES, DAMAGES, LOSSES, EXPENSES, ATTORNEYS’ FEES, COSTS,
+LIABILITIES, AND ALL OTHER CLAIMS OF EVERY KIND AND NATURE WHATSOEVER, WHETHER
+KNOWN OR UNKNOWN, ANTICIPATED OR UNANTICIPATED, FORESEEN OR UNFORESEEN, ACCRUED
+OR UNACCRUED, DISCLOSED OR UNDISCLOSED, ARISING OUT OF OR RELATING TO LICENSEE’S
+USE OF THE SOFTWARE. NOTHING IN THIS SECTION SHOULD BE INTERPRETED TO REQUIRE
+LICENSEE TO INDEMNIFY LICENSOR, NOR REQUIRE LICENSOR TO INDEMNIFY LICENSEE.
+
+7. TERMINATION
+
+7.1. Violations of Ethical Standards or Breaching Duty of Care: If Licensee
+violates the Ethical Standards section or Licensee, or any other person or
+entity within the Supply Chain prior to a good or service reaching the Licensee,
+breaches its Duty of Care to Supply Chain Impacted Parties, Licensee must remedy
+the violation or harm caused by Licensee within 30 days of being notified of the
+violation or harm. If Licensee fails to remedy the violation or harm within 30
+days, all rights in the Software granted to Licensee by License will be null and
+void as between Licensor and Licensee.
+
+7.2. Failure of Notice: If any person or entity notifies Licensee in writing
+that Licensee has not complied with the Notice section of this License, Licensee
+can keep this License by taking all practical steps to comply within 30 days
+after the notice of noncompliance. If Licensee does not do so, Licensee’s
+License (and all rights licensed hereunder) will end immediately.
+
+7.3. Judicial Findings: In the event Licensee is found by a civil, criminal,
+administrative, or other court of competent jurisdiction, or some other
+adjudicating body with legal authority, to have committed actions which are in
+violation of the Ethical Standards or Supply Chain Impacted Party sections of
+this License, all rights granted to Licensee by this License will terminate
+immediately.
+
+7.4. Patent Litigation: If Licensee institutes patent litigation against any
+entity (including a cross-claim or counterclaim in a suit) alleging that the
+Software, all or part of the Software’s code, or a derivative work developed
+using the Software, including a portion of its code, constitutes direct or
+contributory patent infringement, then any patent license, along with all other
+rights, granted to Licensee under this License will terminate as of the date
+such litigation is filed.
+
+7.5. Additional Remedies: Termination of the License by failing to remedy harms
+in no way prevents Licensor or Supply Chain Impacted Party from seeking
+appropriate remedies at law or in equity.
+
+8. MISCELLANEOUS:
+
+8.1. Conditions: Sections 3, 4.1, 5.1, 5.2, 7.1, 7.2, 7.3, and 7.4 are
+conditions of the rights granted to Licensee in the License.
+
+8.2. Equitable Relief: Licensor and any Supply Chain Impacted Party shall be
+entitled to equitable relief, including injunctive relief or specific
+performance of the terms hereof, in addition to any other remedy to which they
+are entitled at law or in equity.
+
+8.3. Copyleft: Modified software, source code, or other derivative work must be
+licensed, in its entirety, under the exact same conditions as this License.
+
+8.4. Severability: If any term or provision of this License is determined to be
+invalid, illegal, or unenforceable by a court of competent jurisdiction, any
+such determination of invalidity, illegality, or unenforceability shall not
+affect any other term or provision of this License or invalidate or render
+unenforceable such term or provision in any other jurisdiction. If the
+determination of invalidity, illegality, or unenforceability by a court of
+competent jurisdiction pertains to the terms or provisions contained in the
+Ethical Standards section of this License, all rights in the Software granted to
+Licensee shall be deemed null and void as between Licensor and Licensee.
+
+8.5. Section Titles: Section titles are solely written for organizational
+purposes and should not be used to interpret the language within each section.
+
+8.6. Citations: Citations are solely written to provide context for the source
+of the provisions in the Ethical Standards.
+
+8.7. Section Summaries: Some sections have a brief italicized description which
+is provided for the sole purpose of briefly describing the section and should
+not be used to interpret the terms of the License.
+
+8.8. Entire License: This is the entire License between the Licensor and
+Licensee with respect to the claims released herein and that the consideration
+stated herein is the only consideration or compensation to be paid or exchanged
+between them for this License. This License cannot be modified or amended except
+in a writing signed by Licensor and Licensee.
+
+8.9. Successors and Assigns: This License shall be binding upon and inure to the
+benefit of the Licensor’s and Licensee’s respective heirs, successors, and
+assigns.
+---------------------- END OFFICIAL HIPPOCRATIC LICENSE 3.0 TEXT ----------------------
+
+==============================================================================
+Attribution, commercial use, and warranty
+==============================================================================
+
+Attribution: cite this work as described in the model card (README.md), section
+"How to cite". Attribution to Lowdown Labs is required under CC BY-NC 4.0.
+
+Commercial use: CC BY-NC 4.0 does not grant commercial rights. Commercial licenses are
+sold by Lowdown Labs; contact Lowdown Labs to purchase one.
+
+No warranty: this work is provided as is, without warranty of any kind. See the model card
+for the intended use, the evaluated conditions, and the known limitations.

README.md

@@ -0,0 +1,218 @@
+---
+license: other
+license_name: lowdown-labs-lovely-license-1.0
+license_link: LICENSE
+tags:
+  - fela
+  - fourier-neural-operator
+  - fno
+  - cpu
+  - on-device
+  - pde-surrogate
+  - thermal-simulation
+  - battery
+library_name: transformers
+pipeline_tag: image-to-image
+---
+
+# DISCLAIMER
+
+This model is a research preview. Lowdown Labs has put together
+this model in the interest of advancing public science.
+
+# FELA PDE: on device 2D thermal field surrogate for battery packs
+
+Give FELA PDE the layout of a battery pack, its heat load, and how it is being cooled, and it
+tells you where the pack runs hot. It returns the full steady state temperature map in one fast
+pass, standing in for a slower finite volume solve. It runs on a plain CPU with no GPU, so it can
+sit inside a battery management tool, a design loop, or an on premises engineering app and flag
+hot spots without a cloud round trip.
+
+What ships in this repo is the small web lite version: 892,545 parameters, about 7.1 MB in fp32.
+The larger validated teacher is a separate line and is not shipped here.
+
+# What goes in, what comes out
+
+- Input: an 8 channel physics field on a 96x96 grid, shape `(1, 8, 96, 96)`. The channels, in
+  order, are `mask` (pack solid region), `q_source` (volumetric heat source, the hot spot),
+  `k_field` (thermal conductivity), `h_conv` (convective heat transfer coefficient), `T_amb`
+  (ambient temperature), `x_coord`, `y_coord` (normalized 0..1 coordinates), and
+  `log_domain_L` (log of the physical domain size). Each channel is standardized with the
+  training statistics that ship in `config.json`; `modeling.preprocess` does this for you.
+- Output: a 1 channel normalized temperature field, shape `(1, 1, 96, 96)`.
+  `modeling.denormalize` converts it to degrees Celsius using the training y statistics
+  (`Y_degC = Ynorm * y_std + y_mean`).
+- In plain terms: give it the pack geometry, the heat load, and the cooling conditions, and it
+  returns the predicted temperature map so an engineer can see where the pack runs hot.
+
+# Building an input (for battery and BMS engineers)
+
+You do not hand build the 8 channel tensor. `input_builder.py` (an add on shipped in this repo)
+builds it from ordinary pack parameters, matching the exact encoding the model was trained on
+(the coordinate planes, `log_domain_L`, and the per channel standardization from `config.json`).
+Two of the channels and `log_domain_L` are model conventions, not physics you supply. The
+physical channels and their units are:
+
+| Channel | Meaning | Units | Typical range |
+|---|---|---|---|
+| mask | 1 inside a cell, 0 in the coolant | none | 0 or 1 |
+| q_source | heat source density in the cells | W/m3 | derived from current, SoC, R0 |
+| k_field | thermal conductivity | W/(m K) | cell 1 to 30, coolant 0.1 to 1.5 |
+| h_conv | convective heat transfer coefficient | W/(m2 K) | 5 to 200 |
+| T_amb | ambient temperature | degC | 15 to 40 |
+| x_coord | normalized column position (the builder sets this) | none | 0 to 1 |
+| y_coord | normalized row position (the builder sets this) | none | 0 to 1 |
+| log_domain_L | natural log of the physical pack size (the builder sets this) | ln(m) | pack 0.02 to 0.12 m |
+
+The model was trained on this distribution; inputs well outside these ranges are not characterized.
+
+## The BMS path: from_pack
+
+Give it a cell layout and pack parameters. It computes the heat source
+(`P = current^2 * R0 * (1 + beta * (1 - SoC)^2)`, spread over the cell area), the conductivity map,
+and the rest, then returns a ready to run `(1, 8, 96, 96)` tensor:
+
+```python
+import torch
+from input_builder import from_pack, cylinder_mask
+from modeling import load_model, denormalize
+
+model = load_model(".")
+mask = cylinder_mask(rows=3, cols=4, radius_frac=0.4)     # a 3 by 4 cylindrical cell pack
+x = from_pack(
+    mask,
+    current_A=40.0, soc=0.3, R0_ohm=0.02,
+    k_cell_W_mK=20.0, k_coolant_W_mK=0.6,
+    h_conv_W_m2K=80.0, T_amb_degC=25.0, domain_L_m=0.08,
+)
+with torch.no_grad():
+    T = denormalize(model(x))[0, 0]                       # a 96 by 96 temperature map in degC
+print("peak", float(T.max()), "degC")
+```
+
+`cylinder_mask(rows, cols, radius_frac)` and `rect_mask(aspect, fill)` build the geometry mask.
+`example.py` runs this end to end and prints the peak temperature and hottest cell.
+
+## The field path: from_fields
+
+If you already have physical field maps (say from your own thermal model), pass them directly
+instead of pack parameters:
+
+```python
+from input_builder import from_fields
+x = from_fields(mask, q_source_W_m3, k_field_W_mK, h_conv_W_m2K, T_amb_degC, domain_L_m)
+```
+
+Each argument is a 96 by 96 array or a scalar (scalars are broadcast). The builder grids each to
+96 by 96, adds the coordinate and size channels, standardizes, and returns the model ready tensor.
+It is verified to reproduce the training encoding exactly.
+
+## From a file: from_csv and from_json
+
+If your pack parameters live in a file, point the builder at it. `pack.csv` (a header row plus one
+values row) or `pack.json` (a flat object) use the same field names as `from_pack`, plus a geometry
+(`rows`, `cols`, `radius_frac` for a cylindrical pack, or `aspect`, `fill` for a prismatic block):
+
+```python
+import torch
+from input_builder import from_csv
+from modeling import load_model, denormalize
+
+x = from_csv("pack.csv")                       # from_json("pack.json") works the same way
+with torch.no_grad():
+    T = denormalize(load_model(".")(x))[0, 0]
+```
+
+Example `pack.csv` and `pack.json` ship in this repo.
+
+NB - real battery data comes in many shapes this repo does not read yet, such as
+vendor spreadsheets with their own columns, CAD geometry like STEP or STL, and simulation exports
+from tools like COMSOL or ANSYS. `from_csv` and `from_json` handle the flat parameter case, which
+is the common one. If you already have a geometry or a field as numbers, load it into a 96 by 96
+array yourself and pass it to `from_fields`.
+
+# Why we built it this way
+
+A temperature field is smooth and slowly varying, so we mix information in the frequency domain
+rather than pixel by pixel. That is what a Fourier Neural Operator does, it learns filters that
+act on the field's frequencies (an FFT, a learned filter, an inverse FFT), which suits a smooth
+solution field well. The model is small and has no all pairs attention. One forward pass produces
+the whole 96x96 map on a plain CPU, far faster than solving the same field directly with a
+finite volume method.
+
+# Architecture
+
+- 2D FNO: a lifting `Conv2d(8 -> 32, 1x1)`, then 3 spectral plus pointwise residual blocks
+  (`SpectralConv2d` keeping 12x12 low and high Fourier modes plus a `Conv2d(32,32,1x1)` skip, GELU
+  residual), then a projection head `Conv2d(32 -> 128, 1x1) -> GELU -> Conv2d(128 -> 1, 1x1)`.
+- 892,545 parameters. The full architecture is in `modeling.py`; the arch dims and
+  normalization statistics are in `config.json`.
+
+# Training data
+
+- Self generated. Every training, validation, and test sample is produced on CPU by a
+  deterministic steady state heat equation finite volume solver (pure NumPy and SciPy). No external
+  dataset is downloaded, scraped, or redistributed. The PDE, the geometry parameterization, and
+  the input and target encoding are reproduced in `train.py` (`--smoke` regenerates the split and
+  asserts the sizes). Full details, seeds, and the split are in `train.py`.
+- License: none required. The generator is our own code; the finite volume method and the
+  Fourier Neural Operator (Li et al., ICLR 2021) are published methods, not licensed data.
+  Commercially clean.
+
+The shipped `train.py` reproduces the primary battery 2D training recipe (a larger `FNO2dV32`
+teacher with a length scale channel and an energy balance peak prior). The weights shipped here
+are the distilled web lite student described above.
+
+# How to run it
+
+```python
+from huggingface_hub import hf_hub_download
+import modeling
+
+path = hf_hub_download("lowdown-labs/fela-pde", "model.safetensors")
+model = modeling.load_model(path)              # or load_model("/path/to/weights_dir")
+
+# raw_field: an (8, 96, 96) physics field in physical units
+x = modeling.preprocess(raw_field)             # standardizes and validates shape
+import torch
+with torch.no_grad():
+    y_norm = model(x)                          # (1, 1, 96, 96) normalized temperature
+y_degc = modeling.denormalize(y_norm)          # degrees Celsius
+```
+
+`verify.py` runs a fixed sample input and checks the output shape and a verification value.
+
+# Serving artifacts
+
+- `model.safetensors` plus `config.json` for the safetensors load path (fp32).
+- `verify.py` runs a fixed sample input and checks the output shape and a verification value.
+
+# Intended use, limitations, and safety
+
+- This is a surrogate, not a certified thermal safety tool. Use its output as a fast screening
+  and design aid, not as the sole basis for a safety critical decision. Validate against a full
+  solver on your own configurations before relying on it.
+- Trained and evaluated only on the self generated battery thermal distribution described above.
+  Geometries, materials, and boundary conditions outside that distribution are not characterized
+  here.
+- This is the distilled web lite student. The larger validated checkpoints (battery and heatsink,
+  2D and 3D) are a separate line.
+
+# Acknowledgements and references
+
+- Fourier Neural Operator: Li, Z., Kovachki, N., Azizzadenesheli, K., et al. (2021). Fourier
+  Neural Operator for Parametric Partial Differential Equations. ICLR.
+  https://arxiv.org/abs/2010.08895
+- Finite volume heat transfer: Patankar, S. V. (1980). Numerical Heat Transfer and Fluid Flow.
+- SciPy: Virtanen, P., et al. (2020). Nature Methods 17, 261-272.
+- PyTorch: Paszke, A., et al. (2019). NeurIPS. https://arxiv.org/abs/1912.01703
+
+# Model family
+
+This is part of the FELA family from Lowdown Labs: one Fourier Neural Operator architecture
+across many modalities, all CPU native and subquadratic. Sibling repos are independently
+trained per modality and share no weights, so none carries a `base_model` link.
+
+# License
+
+Released under the Lowdown Labs Lovely License 1.0 (CC BY-NC 4.0 plus Hippocratic License 3.0). See LICENSE. For most LL models, a commercial license may be available; contact Lowdown Labs.

config.json

@@ -0,0 +1,82 @@
+{
+  "model_type": "fela_pde_fno2d",
+  "description": "battery pack thermal surrogate; 8 channel physics field in, temperature field out",
+  "architecture": "fno2d",
+  "framework": "pytorch",
+  "arch": {
+    "in_ch": 8,
+    "out_ch": 1,
+    "width": 32,
+    "modes": 12,
+    "layers": 3,
+    "proj_hidden": 128,
+    "grid_h": 96,
+    "grid_w": 96
+  },
+  "params": 892545,
+  "input_shape": [
+    1,
+    8,
+    96,
+    96
+  ],
+  "output_shape": [
+    1,
+    1,
+    96,
+    96
+  ],
+  "weights_safetensors": "model.safetensors",
+  "input_channels": [
+    "mask",
+    "q_source",
+    "k_field",
+    "h_conv",
+    "T_amb",
+    "x_coord",
+    "y_coord",
+    "log_domain_L"
+  ],
+  "norm": {
+    "x_mean": [
+      0.4555675685405731,
+      33879.58984375,
+      4.985158443450928,
+      58.90073013305664,
+      27.50713348388672,
+      0.5,
+      0.5,
+      -2.6601810455322266
+    ],
+    "x_std": [
+      0.4980228543281555,
+      89317.828125,
+      6.717851638793945,
+      51.0863151550293,
+      7.186279773712158,
+      0.29169902205467224,
+      0.29169902205467224,
+      0.3988337218761444
+    ],
+    "y_mean": 34.82331466674805,
+    "y_std": 18.65639305114746,
+    "amb_channel": 4
+  },
+  "interface": "Ynorm = model((X - x_mean)/x_std); Y_degC = Ynorm*y_std + y_mean",
+  "license": "lowdown-labs-lovely-license-1.0",
+  "architectures": [
+    "FelaPdeModel"
+  ],
+  "auto_map": {
+    "AutoConfig": "configuration_pde.FelaPdeConfig",
+    "AutoModel": "modeling_pde.FelaPdeModel"
+  },
+  "complex_keys": [
+    "sp.0.w1",
+    "sp.0.w2",
+    "sp.1.w1",
+    "sp.1.w2",
+    "sp.2.w1",
+    "sp.2.w2"
+  ]
+}

configuration_pde.py

@@ -0,0 +1,47 @@
+from transformers import PretrainedConfig
+
+
+class FelaPdeConfig(PretrainedConfig):
+    model_type = "fela_pde_fno2d"
+
+    def __init__(
+        self,
+        in_ch=8,
+        out_ch=1,
+        width=32,
+        modes=12,
+        layers=3,
+        proj_hidden=128,
+        grid_h=96,
+        grid_w=96,
+        arch=None,
+        **kwargs,
+    ):
+        if isinstance(arch, dict):
+            in_ch = arch.get("in_ch", in_ch)
+            out_ch = arch.get("out_ch", out_ch)
+            width = arch.get("width", width)
+            modes = arch.get("modes", modes)
+            layers = arch.get("layers", layers)
+            proj_hidden = arch.get("proj_hidden", proj_hidden)
+            grid_h = arch.get("grid_h", grid_h)
+            grid_w = arch.get("grid_w", grid_w)
+        self.in_ch = in_ch
+        self.out_ch = out_ch
+        self.width = width
+        self.modes = modes
+        self.layers = layers
+        self.proj_hidden = proj_hidden
+        self.grid_h = grid_h
+        self.grid_w = grid_w
+        self.arch = {
+            "in_ch": in_ch,
+            "out_ch": out_ch,
+            "width": width,
+            "modes": modes,
+            "layers": layers,
+            "proj_hidden": proj_hidden,
+            "grid_h": grid_h,
+            "grid_w": grid_w,
+        }
+        super().__init__(**kwargs)

example.py

@@ -0,0 +1,28 @@
+import torch
+
+from input_builder import cylinder_mask, from_pack
+from modeling import denormalize, load_model
+
+model = load_model(".")
+
+mask = cylinder_mask(rows=3, cols=4, radius_frac=0.4)
+x = from_pack(
+    mask,
+    current_A=40.0,
+    soc=0.3,
+    R0_ohm=0.02,
+    k_cell_W_mK=20.0,
+    k_coolant_W_mK=0.6,
+    h_conv_W_m2K=80.0,
+    T_amb_degC=25.0,
+    domain_L_m=0.08,
+)
+
+with torch.no_grad():
+    T = denormalize(model(x))[0, 0]
+
+hot = divmod(int(T.argmax()), T.shape[1])
+print("temperature grid:", tuple(T.shape))
+print("peak degC:", round(float(T.max()), 2))
+print("mean degC:", round(float(T.mean()), 2))
+print("hottest cell row,col:", [int(hot[0]), int(hot[1])])

input_builder.py

@@ -0,0 +1,117 @@
+import csv
+import json
+
+import numpy as np
+
+from modeling import preprocess
+
+N = 96
+
+
+def _coords():
+    yy, xx = np.meshgrid(np.linspace(0, 1, N), np.linspace(0, 1, N), indexing="ij")
+    return xx, yy
+
+
+def _to_field(v):
+    a = np.asarray(v, dtype=np.float64)
+    if a.ndim == 0:
+        return np.full((N, N), float(a))
+    if a.shape == (N, N):
+        return a
+    yi = np.linspace(0, a.shape[0] - 1, N).round().astype(int)
+    xi = np.linspace(0, a.shape[1] - 1, N).round().astype(int)
+    return a[yi][:, xi]
+
+
+def cylinder_mask(rows, cols, radius_frac=0.4):
+    xx, yy = _coords()
+    m = np.zeros((N, N))
+    px, py = 1.0 / cols, 1.0 / rows
+    r = radius_frac * min(px, py)
+    for i in range(rows):
+        cy = (i + 0.5) * py
+        for j in range(cols):
+            cx = (j + 0.5) * px
+            m[(xx - cx) ** 2 + (yy - cy) ** 2 <= r * r] = 1.0
+    return m
+
+
+def rect_mask(aspect=1.0, fill=0.7):
+    xx, yy = _coords()
+    m = np.zeros((N, N))
+    hh = min(0.98, (fill / aspect) ** 0.5)
+    ww = min(0.98, aspect * hh)
+    x0, x1 = 0.5 - ww / 2, 0.5 + ww / 2
+    y0, y1 = 0.5 - hh / 2, 0.5 + hh / 2
+    m[(xx >= x0) & (xx <= x1) & (yy >= y0) & (yy <= y1)] = 1.0
+    return m
+
+
+def from_fields(
+    mask, q_source_W_m3, k_field_W_mK, h_conv_W_m2K, T_amb_degC, domain_L_m
+):
+    m = (_to_field(mask) > 0.5).astype(np.float64)
+    q = _to_field(q_source_W_m3) * m
+    k = _to_field(k_field_W_mK)
+    h = _to_field(h_conv_W_m2K)
+    ta = _to_field(T_amb_degC)
+    xx, yy = _coords()
+    logL = np.full((N, N), float(np.log(domain_L_m)))
+    field = np.stack([m, q, k, h, ta, xx, yy, logL], 0).astype(np.float32)
+    return preprocess(field)
+
+
+def from_pack(
+    mask,
+    current_A,
+    soc,
+    R0_ohm,
+    k_cell_W_mK,
+    k_coolant_W_mK,
+    h_conv_W_m2K,
+    T_amb_degC,
+    domain_L_m,
+    beta=2.0,
+):
+    m = (_to_field(mask) > 0.5).astype(np.float64)
+    hg = domain_L_m / (N - 1)
+    R_int = R0_ohm * (1.0 + beta * (1.0 - soc) ** 2)
+    P_total = current_A**2 * R_int
+    area = max(m.sum() * hg * hg, hg * hg)
+    q = m * (P_total / area)
+    k = np.where(m > 0, k_cell_W_mK, k_coolant_W_mK)
+    return from_fields(m, q, k, h_conv_W_m2K, T_amb_degC, domain_L_m)
+
+
+def from_params(d):
+    if d.get("rows") not in (None, "") and d.get("cols") not in (None, ""):
+        mask = cylinder_mask(
+            int(float(d["rows"])),
+            int(float(d["cols"])),
+            float(d.get("radius_frac") or 0.4),
+        )
+    else:
+        mask = rect_mask(float(d.get("aspect") or 1.0), float(d.get("fill") or 0.7))
+    return from_pack(
+        mask,
+        float(d["current_A"]),
+        float(d["soc"]),
+        float(d["R0_ohm"]),
+        float(d["k_cell_W_mK"]),
+        float(d["k_coolant_W_mK"]),
+        float(d["h_conv_W_m2K"]),
+        float(d["T_amb_degC"]),
+        float(d["domain_L_m"]),
+        beta=float(d.get("beta") or 2.0),
+    )
+
+
+def from_json(path):
+    with open(path) as f:
+        return from_params(json.load(f))
+
+
+def from_csv(path):
+    with open(path) as f:
+        return from_params(next(csv.DictReader(f)))

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d7d0c9f3b6282896c4e4e21a453253561f7288390cd9f8e09c64d99cc81d6b0a
+size 7110540

modeling.py

@@ -0,0 +1,132 @@
+import json
+import os
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+CONFIG = None
+
+
+def _config():
+    global CONFIG
+    if CONFIG is None:
+        here = os.path.dirname(os.path.abspath(__file__))
+        with open(os.path.join(here, "config.json")) as f:
+            CONFIG = json.load(f)
+    return CONFIG
+
+
+class SpectralConv2d(nn.Module):
+    def __init__(self, ci, co, m1, m2):
+        super().__init__()
+        self.m1, self.m2 = (m1, m2)
+        s = 1 / (ci * co)
+        self.w1 = nn.Parameter(s * torch.rand(ci, co, m1, m2, dtype=torch.cfloat))
+        self.w2 = nn.Parameter(s * torch.rand(ci, co, m1, m2, dtype=torch.cfloat))
+
+    def forward(self, x):
+        B, C, Hh, Ww = x.shape
+        xf = torch.fft.rfft2(x)
+        o = torch.zeros(
+            B, self.w1.shape[1], Hh, Ww // 2 + 1, dtype=torch.cfloat, device=x.device
+        )
+        o[:, :, : self.m1, : self.m2] = torch.einsum(
+            "bixy,ioxy->boxy", xf[:, :, : self.m1, : self.m2], self.w1
+        )
+        o[:, :, -self.m1 :, : self.m2] = torch.einsum(
+            "bixy,ioxy->boxy", xf[:, :, -self.m1 :, : self.m2], self.w2
+        )
+        return torch.fft.irfft2(o, s=(Hh, Ww))
+
+
+class FNO2d(nn.Module):
+    def __init__(self, in_ch=8, modes=12, width=32, L=3, proj_hidden=128):
+        super().__init__()
+        self.lift = nn.Conv2d(in_ch, width, 1)
+        self.sp = nn.ModuleList(
+            [SpectralConv2d(width, width, modes, modes) for _ in range(L)]
+        )
+        self.w = nn.ModuleList([nn.Conv2d(width, width, 1) for _ in range(L)])
+        self.proj = nn.Sequential(
+            nn.Conv2d(width, proj_hidden, 1), nn.GELU(), nn.Conv2d(proj_hidden, 1, 1)
+        )
+
+    def forward(self, x):
+        h = self.lift(x)
+        for sp, w in zip(self.sp, self.w):
+            h = h + F.gelu(sp(h) + w(h))
+        return self.proj(h)
+
+
+def validate_input(x):
+    a = _config()["arch"]
+    if not isinstance(x, torch.Tensor):
+        raise TypeError(f"Expected a torch.Tensor, got {type(x)}")
+    if (
+        x.dim() != 4
+        or x.shape[1] != a["in_ch"]
+        or x.shape[2] != a["grid_h"]
+        or (x.shape[3] != a["grid_w"])
+    ):
+        raise ValueError(
+            f"Expected an input of shape (batch, {a['in_ch']}, {a['grid_h']}, {a['grid_w']}), got {tuple(x.shape)}."
+        )
+    return x
+
+
+def preprocess(raw_field, mean=None, std=None):
+    x = torch.as_tensor(raw_field, dtype=torch.float32)
+    if x.dim() == 3:
+        x = x.unsqueeze(0)
+    norm = _config()["norm"]
+    m = torch.as_tensor(
+        mean if mean is not None else norm["x_mean"], dtype=torch.float32
+    ).reshape(1, -1, 1, 1)
+    s = torch.as_tensor(
+        std if std is not None else norm["x_std"], dtype=torch.float32
+    ).reshape(1, -1, 1, 1)
+    x = (x - m) / torch.clamp(s, min=1e-06)
+    return validate_input(x)
+
+
+def denormalize(y_norm):
+    norm = _config()["norm"]
+    return torch.as_tensor(y_norm, dtype=torch.float32) * norm["y_std"] + norm["y_mean"]
+
+
+def _build():
+    a = _config()["arch"]
+    return FNO2d(
+        in_ch=a["in_ch"],
+        modes=a["modes"],
+        width=a["width"],
+        L=a["layers"],
+        proj_hidden=a["proj_hidden"],
+    )
+
+
+def load_model(path_or_repo, filename=None):
+    path = path_or_repo
+    fname = filename or _config()["weights_safetensors"]
+    if os.path.isdir(path):
+        path = os.path.join(path, fname)
+    elif not os.path.exists(path):
+        from huggingface_hub import hf_hub_download
+
+        path = hf_hub_download(path_or_repo, fname)
+    from safetensors.torch import load_file
+
+    state = load_file(path)
+    cplx = set(_config().get("complex_keys", []))
+    state = {
+        k: (torch.view_as_complex(v.contiguous()) if k in cplx else v)
+        for k, v in state.items()
+    }
+    model = _build()
+    model.load_state_dict(state, strict=True)
+    model.eval()
+    return model
+
+
+def from_pretrained(repo_id):
+    return load_model(repo_id)

modeling_pde.py

@@ -0,0 +1,61 @@
+import os
+import sys
+import types
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import torch
+import torch.nn as nn
+from transformers import PreTrainedModel
+from transformers.modeling_outputs import CausalLMOutput
+
+from .configuration_pde import FelaPdeConfig
+from .modeling import FNO2d, SpectralConv2d
+
+
+def _spectral_forward(self, x):
+    w1 = torch.view_as_complex(self.w1)
+    w2 = torch.view_as_complex(self.w2)
+    B, C, Hh, Ww = x.shape
+    xf = torch.fft.rfft2(x)
+    o = torch.zeros(
+        B, w1.shape[1], Hh, Ww // 2 + 1, dtype=torch.cfloat, device=x.device
+    )
+    o[:, :, : self.m1, : self.m2] = torch.einsum(
+        "bixy,ioxy->boxy", xf[:, :, : self.m1, : self.m2], w1
+    )
+    o[:, :, -self.m1 :, : self.m2] = torch.einsum(
+        "bixy,ioxy->boxy", xf[:, :, -self.m1 :, : self.m2], w2
+    )
+    return torch.fft.irfft2(o, s=(Hh, Ww))
+
+
+def _realify(model):
+    for m in model.modules():
+        if isinstance(m, SpectralConv2d):
+            m.w1 = nn.Parameter(torch.view_as_real(m.w1.detach()).contiguous())
+            m.w2 = nn.Parameter(torch.view_as_real(m.w2.detach()).contiguous())
+            m.forward = types.MethodType(_spectral_forward, m)
+
+
+class FelaPdeModel(PreTrainedModel):
+    config_class = FelaPdeConfig
+    base_model_prefix = "model"
+    main_input_name = "x"
+
+    def __init__(self, config):
+        super().__init__(config)
+        self.model = FNO2d(
+            in_ch=config.in_ch,
+            modes=config.modes,
+            width=config.width,
+            L=config.layers,
+            proj_hidden=config.proj_hidden,
+        )
+        _realify(self.model)
+        self.post_init()
+
+    def forward(self, x=None, input_values=None, **kwargs):
+        if x is None:
+            x = input_values
+        out = self.model(x)
+        return CausalLMOutput(logits=out)

pack.csv

@@ -0,0 +1,2 @@
+current_A,soc,R0_ohm,k_cell_W_mK,k_coolant_W_mK,h_conv_W_m2K,T_amb_degC,domain_L_m,rows,cols,radius_frac
+40,0.3,0.02,20,0.6,80,25,0.08,3,4,0.4

pack.json

@@ -0,0 +1,13 @@
+{
+  "current_A": 40,
+  "soc": 0.3,
+  "R0_ohm": 0.02,
+  "k_cell_W_mK": 20,
+  "k_coolant_W_mK": 0.6,
+  "h_conv_W_m2K": 80,
+  "T_amb_degC": 25,
+  "domain_L_m": 0.08,
+  "rows": 3,
+  "cols": 4,
+  "radius_frac": 0.4
+}

streaming/manifest.json

@@ -0,0 +1,14 @@
+{
+  "model": "pde",
+  "format": "fp16-streaming",
+  "note": "load order is smallest-first for progressive/streaming load",
+  "files": [
+    {
+      "file": "model_fp16.safetensors",
+      "source": "model.safetensors",
+      "dtype": "fp16",
+      "bytes": 3555962,
+      "approx_mb": 3.391
+    }
+  ]
+}

streaming/model_fp16.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:66cc543317c054e7c2c7ed7541d12248c9732e5a26d4b0e4814e4357164dc916
+size 3555962

train.py

@@ -0,0 +1,417 @@
+import os
+
+for _v in (
+    "OMP_NUM_THREADS",
+    "OPENBLAS_NUM_THREADS",
+    "MKL_NUM_THREADS",
+    "NUMEXPR_NUM_THREADS",
+):
+    os.environ.setdefault(_v, "1")
+import sys, time, json, argparse
+import numpy as np
+import scipy.sparse as sp
+from scipy.sparse.linalg import spsolve
+
+N = 96
+CH8 = [
+    "mask",
+    "q_source",
+    "k_field",
+    "h_conv",
+    "T_amb",
+    "x_coord",
+    "y_coord",
+    "log_domain_L",
+]
+SEED_TRAIN = 12340000
+SEED_HOT = 55000000
+SEED_HOLDOUT = 900000000
+SEED_EDGE = 900000000 + 500000000
+RANGES = dict(
+    domain_L=(0.02, 0.12),
+    cyl_rows=(2, 5),
+    cyl_cols=(2, 5),
+    cell_radius_frac=(0.3, 0.48),
+    aspect=(0.4, 2.5),
+    cell_fill=(0.55, 0.9),
+    current=(1.0, 60.0),
+    soc=(0.05, 1.0),
+    R0=(0.005, 0.05),
+    beta=(0.5, 4.0),
+    k_cell=(1.0, 30.0),
+    k_coolant=(0.1, 1.5),
+    h_conv=(5.0, 200.0),
+    T_amb=(15.0, 40.0),
+)
+
+
+def build_system(N, hg, k_field, q_field, h_conv, T_amb):
+    n = N * N
+    dx2 = hg * hg
+    k = k_field.astype(np.float64)
+    q = q_field.astype(np.float64)
+
+    def hmean(a, b):
+        return 2.0 * a * b / (a + b + 1e-30)
+
+    ids = np.arange(n).reshape(N, N)
+    rows = []
+    cols = []
+    vals = []
+    diag = np.zeros((N, N))
+    b = q * dx2
+    kf = hmean(k[1:, :], k[:-1, :])
+    p = ids[1:, :].ravel()
+    nb = ids[:-1, :].ravel()
+    kk = kf.ravel()
+    rows.append(p)
+    cols.append(nb)
+    vals.append(-kk)
+    diag[1:, :] += kf
+    p = ids[:-1, :].ravel()
+    nb = ids[1:, :].ravel()
+    rows.append(p)
+    cols.append(nb)
+    vals.append(-kk)
+    diag[:-1, :] += kf
+    kf = hmean(k[:, 1:], k[:, :-1])
+    p = ids[:, 1:].ravel()
+    nb = ids[:, :-1].ravel()
+    kk = kf.ravel()
+    rows.append(p)
+    cols.append(nb)
+    vals.append(-kk)
+    diag[:, 1:] += kf
+    p = ids[:, :-1].ravel()
+    nb = ids[:, 1:].ravel()
+    rows.append(p)
+    cols.append(nb)
+    vals.append(-kk)
+    diag[:, :-1] += kf
+    hdx = h_conv * hg
+    bmask = np.zeros((N, N))
+    bmask[0, :] += 1
+    bmask[-1, :] += 1
+    bmask[:, 0] += 1
+    bmask[:, -1] += 1
+    diag += hdx * bmask
+    b += hdx * T_amb * bmask
+    rows.append(ids.ravel())
+    cols.append(ids.ravel())
+    vals.append(diag.ravel())
+    rows = np.concatenate(rows)
+    cols = np.concatenate(cols)
+    vals = np.concatenate(vals)
+    A = sp.csr_matrix((vals, (rows, cols)), shape=(n, n))
+    return (A, b.ravel())
+
+
+def solve_steady(N, hg, k_field, q_field, h_conv, T_amb):
+    A, b = build_system(N, hg, k_field, q_field, h_conv, T_amb)
+    return spsolve(A.tocsc(), b).reshape(N, N)
+
+
+def sample_params(rng):
+    p = {}
+    p["domain_L"] = rng.uniform(*RANGES["domain_L"])
+    p["geom"] = "cyl" if rng.random() < 0.6 else "pris"
+    p["current"] = rng.uniform(*RANGES["current"])
+    p["soc"] = rng.uniform(*RANGES["soc"])
+    p["R0"] = rng.uniform(*RANGES["R0"])
+    p["beta"] = rng.uniform(*RANGES["beta"])
+    p["k_cell"] = rng.uniform(*RANGES["k_cell"])
+    p["k_coolant"] = rng.uniform(*RANGES["k_coolant"])
+    p["h_conv"] = rng.uniform(*RANGES["h_conv"])
+    p["T_amb"] = rng.uniform(*RANGES["T_amb"])
+    if p["geom"] == "cyl":
+        p["rows"] = int(rng.integers(RANGES["cyl_rows"][0], RANGES["cyl_rows"][1] + 1))
+        p["cols"] = int(rng.integers(RANGES["cyl_cols"][0], RANGES["cyl_cols"][1] + 1))
+        p["rfrac"] = rng.uniform(*RANGES["cell_radius_frac"])
+    else:
+        p["aspect"] = rng.uniform(*RANGES["aspect"])
+        p["fill"] = rng.uniform(*RANGES["cell_fill"])
+    return p
+
+
+def build_fields(N, p):
+    L = p["domain_L"]
+    hg = L / (N - 1)
+    yy, xx = np.meshgrid(np.linspace(0, 1, N), np.linspace(0, 1, N), indexing="ij")
+    mask = np.zeros((N, N), dtype=np.float64)
+    R_int = p["R0"] * (1.0 + p["beta"] * (1.0 - p["soc"]) ** 2)
+    P_total = p["current"] ** 2 * R_int
+    if p["geom"] == "cyl":
+        rows, cols = (p["rows"], p["cols"])
+        pitch_x = 1.0 / cols
+        pitch_y = 1.0 / rows
+        r = p["rfrac"] * min(pitch_x, pitch_y)
+        for i in range(rows):
+            cy = (i + 0.5) * pitch_y
+            for j in range(cols):
+                cx = (j + 0.5) * pitch_x
+                d = (xx - cx) ** 2 + (yy - cy) ** 2
+                mask[d <= r * r] = 1.0
+    else:
+        a = p["aspect"]
+        f = p["fill"]
+        hh = min(0.98, np.sqrt(f / a))
+        ww = min(0.98, a * hh)
+        x0, x1 = (0.5 - ww / 2, 0.5 + ww / 2)
+        y0, y1 = (0.5 - hh / 2, 0.5 + hh / 2)
+        mask[(xx >= x0) & (xx <= x1) & (yy >= y0) & (yy <= y1)] = 1.0
+    cell_area_phys = mask.sum() * hg * hg
+    if cell_area_phys <= 0:
+        cell_area_phys = hg * hg
+    q_field = mask * (P_total / cell_area_phys)
+    k_field = np.where(mask > 0, p["k_cell"], p["k_coolant"])
+    return (mask, k_field, q_field, hg)
+
+
+def build_X(p, mask, k_field, q_field):
+    yy, xx = np.meshgrid(np.linspace(0, 1, N), np.linspace(0, 1, N), indexing="ij")
+    logL = np.full((N, N), np.log(p["domain_L"]), dtype=np.float64)
+    return np.stack(
+        [
+            mask,
+            q_field,
+            k_field,
+            np.full((N, N), p["h_conv"]),
+            np.full((N, N), p["T_amb"]),
+            xx,
+            yy,
+            logL,
+        ],
+        0,
+    ).astype(np.float32)
+
+
+def gen_uniform(seed):
+    rng = np.random.default_rng(seed)
+    p = sample_params(rng)
+    mask, k, q, hg = build_fields(N, p)
+    T = solve_steady(N, hg, k, q, p["h_conv"], p["T_amb"])
+    return (build_X(p, mask, k, q), T.astype(np.float32))
+
+
+def run(fn, jobs, workers):
+    if workers <= 1:
+        out = [fn(j) for j in jobs]
+    else:
+        from multiprocessing import Pool
+
+        with Pool(workers) as pool:
+            out = list(pool.imap(fn, jobs, chunksize=8))
+    Xs, Ys = zip(*out)
+    return (np.stack(Xs), np.stack(Ys))
+
+
+def make_split(n_train, workers):
+    Xtr, Ytr = run(gen_uniform, [SEED_TRAIN + i for i in range(n_train)], workers)
+    n = Xtr.shape[0]
+    perm = np.random.default_rng(0).permutation(n)
+    ntr = int(0.8 * n)
+    nva = int(0.1 * n)
+    sp_idx = {
+        "train": perm[:ntr],
+        "val": perm[ntr : ntr + nva],
+        "test": perm[ntr + nva :],
+    }
+    return (Xtr, Ytr, sp_idx)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument(
+        "--data", default="/workspace/pde_surrogate/battery/battery_thermal_v3.h5"
+    )
+    ap.add_argument(
+        "--hot", default="/workspace/pde_surrogate/battery/hot_enrich_v3.h5"
+    )
+    ap.add_argument(
+        "--out", default="/workspace/pde_surrogate/battery/fno_ckpt_v3_final.pt"
+    )
+    ap.add_argument("--n_train", type=int, default=4000)
+    ap.add_argument("--n_hot", type=int, default=5000)
+    ap.add_argument("--workers", type=int, default=32)
+    ap.add_argument("--epochs", type=int, default=300)
+    ap.add_argument("--bs", type=int, default=128)
+    ap.add_argument("--lr", type=float, default=0.002)
+    ap.add_argument("--modes", type=int, default=32)
+    ap.add_argument("--width", type=int, default=80)
+    ap.add_argument("--layers", type=int, default=4)
+    ap.add_argument("--scale_floor", type=float, default=2.0)
+    ap.add_argument("--grad_w", type=float, default=3.0)
+    ap.add_argument("--rise_w", type=float, default=1.5)
+    ap.add_argument("--scale_w", type=float, default=3.0)
+    ap.add_argument("--smoke", action="store_true")
+    args = ap.parse_args()
+    if args.smoke:
+        Xtr, Ytr, sp_idx = make_split(args.n_train, args.workers)
+        n = Xtr.shape[0]
+        assert Xtr.shape[1] == 8 and Xtr.shape[2] == N and (Xtr.shape[3] == N)
+        assert (
+            len(sp_idx["train"]) == 3200
+            and len(sp_idx["val"]) == 400
+            and (len(sp_idx["test"]) == 400)
+        )
+        xu, yu = gen_uniform(SEED_HOLDOUT)
+        assert xu.shape == (8, N, N) and np.isfinite(yu).all() and (yu.max() > yu.min())
+        print(
+            f"[Smoke] n={n} train={len(sp_idx['train'])} val={len(sp_idx['val'])} test={len(sp_idx['test'])} ch={len(CH8)} holdoutT[{yu.min():.2f},{yu.max():.2f}]",
+            flush=True,
+        )
+        return
+    import h5py, torch, torch.nn as nn, torch.nn.functional as F
+
+    sys.path.insert(0, "/workspace/pde_surrogate/scripts")
+    from train_fno_v32 import FNO2dV32, phys_prior, spatial_grad_mag
+
+    AMBCH = 4
+
+    def load_h5(path, split):
+        with h5py.File(path, "r") as f:
+            return (
+                torch.from_numpy(f[split]["X"][:].astype(np.float32)),
+                torch.from_numpy(f[split]["Y"][:].astype(np.float32)),
+            )
+
+    dev = "cuda"
+    with h5py.File(args.data, "r") as f:
+        x_mean = np.array(f.attrs["x_mean"], np.float32)
+        x_std = np.array(f.attrs["x_std"], np.float32)
+        y_mean = float(f.attrs["y_mean"])
+        y_std = float(f.attrs["y_std"])
+        channels = json.loads(f.attrs["channels"])
+        base_in = f["train"]["X"].shape[1]
+    Xtr, Ytr = load_h5(args.data, "train")
+    Xva, Yva = load_h5(args.data, "val")
+    with h5py.File(args.hot, "r") as f:
+        Xh = torch.from_numpy(f["hot"]["X"][:].astype(np.float32))
+        Yh = torch.from_numpy(f["hot"]["Y"][:].astype(np.float32))
+    Xtr = torch.cat([Xtr, Xh], 0)
+    Ytr = torch.cat([Ytr, Yh], 0)
+    xm_ = Xtr.reshape(Xtr.shape[0], base_in, -1).mean((0, 2))
+    xs_ = Xtr.reshape(Xtr.shape[0], base_in, -1).std((0, 2)) + 1e-06
+    x_mean = xm_.numpy()
+    x_std = xs_.numpy()
+    Xtr = Xtr.to(dev)
+    Ytr = Ytr.to(dev)
+    Xva = Xva.to(dev)
+    Yva = Yva.to(dev)
+    ntr = Xtr.shape[0]
+    xm = torch.tensor(x_mean, device=dev)[None, :, None, None]
+    xs = torch.tensor(x_std, device=dev)[None, :, None, None]
+    model = FNO2dV32(
+        in_ch=base_in, modes=args.modes, width=args.width, L=args.layers
+    ).to(dev)
+    opt = torch.optim.AdamW(model.parameters(), lr=args.lr, weight_decay=1e-05)
+    sched = torch.optim.lr_scheduler.CosineAnnealingLR(opt, args.epochs)
+    print(
+        f"[V32] params={sum((p.numel() for p in model.parameters())) / 1000000.0:.2f}M ntr={ntr}",
+        flush=True,
+    )
+
+    def prep(Xb):
+        dTc, dTd = phys_prior(Xb)
+        return ((Xb - xm) / xs, dTc, dTd)
+
+    def val_binned():
+        model.eval()
+        rls = []
+        rises = []
+        mae = 0.0
+        vb = 0
+        with torch.no_grad():
+            for s in range(0, Xva.shape[0], args.bs):
+                Xb = Xva[s : s + args.bs]
+                Yb = Yva[s : s + args.bs][:, None]
+                Xin, dTc, dTd = prep(Xb)
+                field_ps, log_scale, _ = model(Xin, dTc, dTd)
+                amb = Xb[:, AMBCH].flatten(1).mean(1)
+                log_scale = log_scale.clamp(
+                    float(np.log(args.scale_floor)), float(np.log(2000.0))
+                )
+                pp = (
+                    amb[:, None, None, None]
+                    + torch.exp(log_scale)[:, None, None, None] * field_ps
+                )
+                num = torch.linalg.norm((pp - Yb).flatten(1), dim=1)
+                den = torch.linalg.norm(Yb.flatten(1), dim=1).clamp_min(1e-08)
+                rls.append((num / den).cpu())
+                rises.append((Yb.flatten(1).amax(1) - amb).cpu())
+                mae += torch.abs(pp - Yb).mean().item()
+                vb += 1
+        rls = torch.cat(rls)
+        rises = torch.cat(rises)
+        mae /= vb
+        hot = rls[rises > 10]
+        return (
+            float(rls.median()),
+            float(hot.median()) if hot.numel() else float("nan"),
+            mae,
+            int((rises > 10).sum()),
+        )
+
+    best = 1000000000.0
+    for ep in range(args.epochs):
+        model.train()
+        perm = torch.randperm(ntr, device=dev)
+        tl = 0.0
+        nb = 0
+        for s in range(0, ntr, args.bs):
+            idx = perm[s : s + args.bs]
+            Xb = Xtr[idx]
+            Yb = Ytr[idx][:, None]
+            amb = Xb[:, AMBCH].flatten(1).mean(1)
+            flat = Yb.flatten(1)
+            scale = torch.quantile(flat - amb[:, None], 0.95, dim=1).clamp_min(
+                args.scale_floor
+            )
+            Yps = (Yb - amb.view(-1, 1, 1, 1)) / scale.view(-1, 1, 1, 1)
+            Xin, dTc, dTd = prep(Xb)
+            opt.zero_grad()
+            field_ps, log_scale, prior = model(Xin, dTc, dTd)
+            gm = spatial_grad_mag(Yps)
+            gw = 1.0 + args.grad_w * gm / (
+                gm.flatten(1).mean(1)[:, None, None, None] + 1e-06
+            )
+            rise = (flat.amax(1) - amb).clamp_min(0.0)
+            sw = ((rise + 1.0) ** args.rise_w)[:, None, None, None]
+            sw = sw / sw.mean()
+            field_loss = (gw * sw * (field_ps - Yps) ** 2).mean()
+            scale_loss = F.smooth_l1_loss(log_scale, torch.log(scale), beta=0.1)
+            loss = field_loss + args.scale_w * scale_loss
+            loss.backward()
+            opt.step()
+            tl += loss.item()
+            nb += 1
+        sched.step()
+        overall, hotm, mae, nhot = val_binned()
+        score = hotm if hotm == hotm else overall
+        if score < best:
+            best = score
+            torch.save(
+                {
+                    "model": model.state_dict(),
+                    "args": vars(args),
+                    "x_mean": x_mean,
+                    "x_std": x_std,
+                    "y_mean": y_mean,
+                    "y_std": y_std,
+                    "channels": channels,
+                    "scale_floor": args.scale_floor,
+                    "amb_channel": AMBCH,
+                    "in_ch": base_in,
+                },
+                args.out,
+            )
+        if ep % 10 == 0 or ep == args.epochs - 1:
+            print(
+                f"Ep{ep:3d} loss={tl / nb:.4e} overall={overall:.4f} HOTSPOT(>10C,n={nhot})={hotm:.4f} MAE={mae:.3f}C (best {best:.4f})",
+                flush=True,
+            )
+    print(f"[V32] DONE best HOTSPOT {best:.4f} -> {args.out}", flush=True)
+
+
+if __name__ == "__main__":
+    main()

verify.py

@@ -0,0 +1,44 @@
+import argparse
+import os
+import sys
+import torch
+
+sys.path.insert(0, os.path.dirname(__file__))
+from modeling import load_model
+
+SHAPE = (1, 8, 96, 96)
+VERIFICATION = 0.566771
+TOL = 0.001
+
+
+def fixed_input():
+    torch.manual_seed(0)
+    return torch.randn(*SHAPE)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--weights", default=".")
+    args = ap.parse_args()
+    model = load_model(args.weights)
+    x = fixed_input()
+    with torch.no_grad():
+        out = model(x)
+    if tuple(out.shape) != (1, 1, 96, 96):
+        print(
+            f"Fail: unexpected output shape {tuple(out.shape)}, expected (1, 1, 96, 96)"
+        )
+        sys.exit(1)
+    center = out[0, 0, 48, 48].item()
+    print(f"Captured center value: {center:.6f}")
+    if abs(center - VERIFICATION) > TOL:
+        print(
+            f"Fail: center {center:.6f} differs from verification {VERIFICATION:.6f} by more than {TOL}"
+        )
+        sys.exit(1)
+    print(f"Verification check OK (center within {TOL} of {VERIFICATION:.6f})")
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()