| """Select candidate MP tasks for the rows under review and extract their full outputs from S3.""" |
| import sys, json, re, gzip, time, numpy as np, pandas as pd, requests |
| from pathlib import Path |
| from concurrent.futures import ProcessPoolExecutor, as_completed |
| W=Path(sys.argv[1]); OUT=W/"s3"; OUT.mkdir(exist_ok=True) |
| MAN=Path("/home/kna/.local/share/wyformer/cache/mp_forces_recovery") |
| S3="https://materialsproject-parsed.s3.amazonaws.com/" |
| TASK_ID_RE=re.compile(rb'"task_id":\s*"([a-z]+-\d+)"') |
| def legacy(i): |
| p,_,b=i.rpartition("-") |
| if not re.fullmatch(r"[a-z]+",b): return i |
| n=0 |
| for c in b: n=n*26+ord(c)-97 |
| return f"{p or 'mp'}-{n}" |
|
|
| def select(): |
| f=pd.read_parquet(W/"identify.parquet") |
| core={d["material_id"]:d for d in json.load(open(W/"core_lemat.json"))} |
| alias=json.load(open(W/"core_alias.json")) if (W/"core_alias.json").exists() else {} |
| for i,parent in alias.items(): core.setdefault(i,core[parent]) |
| tasks={t["task_id"]:t for t in json.load(open(W/"tasks_meta.json"))} |
| stale=f.grp.isin(["deprecated","dep_runmismatch","unidentified","runmismatch"]) |
| livebig=(f.grp=="live_other_task")&(f.dE_mp.abs()>0.05) |
| ctrl1=f[f.grp=="same_task"].sample(300,random_state=0).index |
| ctrl2=f[(f.grp=="live_other_task")&(f.dE_mp.abs()<=0.05)].sample(300,random_state=0).index |
| f["review"]=np.where(stale,"stale",np.where(livebig,"live_big","")) |
| f.loc[ctrl1,"review"]="control_same"; f.loc[ctrl2,"review"]="control_live" |
| r=f[f.review!=""] |
| pairs=[] |
| for row in r.itertuples(): |
| d=core.get(row.immutable_id) |
| if d is None: continue |
| dep={legacy(t) for t in d.get("deprecated_tasks") or []} |
| for k,ct in (d.get("calc_types") or {}).items(): |
| tid=legacy(k); t=tasks.get(tid) |
| if t is None: continue |
| run,_,typ=ct.partition(" ") |
| if run not in ("GGA","GGA+U") or typ not in ("Static","Structure Optimization"): continue |
| is_lemat = tid==row.lemat_task |
| is_mp = tid==row.mp_task |
| if is_lemat or is_mp or (tid not in dep and t.get("nsites")==row.nsites and (not isinstance(row.mp_run,str) or run==row.mp_run)): |
| pairs.append((row.immutable_id,tid,tid in dep,is_lemat,is_mp,ct)) |
| p=pd.DataFrame(pairs,columns=["immutable_id","task_id","task_deprecated","is_lemat_task","is_mp_task","calc_type"]) |
| f.to_parquet(W/"identify.parquet"); p.to_parquet(W/"candidates.parquet") |
| print(f.review.value_counts().to_dict(), "pairs",len(p),"tasks",p.task_id.nunique(), flush=True) |
| return p |
|
|
| def extract(doc): |
| o=doc.get("output") or {}; s=o.get("structure") or {} |
| c=(doc.get("calcs_reversed") or [{}])[0]; co=c.get("output") or {}; oc=co.get("outcar") or {} |
| inp=doc.get("input") or {} |
| lat=s["lattice"]["matrix"] |
| return {"task_id":doc["task_id"],"energy":o.get("energy"),"lattice":lat, |
| "species":[x["species"][0]["element"] for x in s["sites"]], |
| "xyz":[x["xyz"] if "xyz" in x else list(np.dot(x["abc"],lat)) for x in s["sites"]], |
| "magmom":[(x.get("properties") or {}).get("magmom") for x in s["sites"]], |
| "forces":o.get("forces"),"stress":o.get("stress"), |
| "total_magnetization":oc.get("total_magnetization"),"efermi":co.get("efermi"), |
| "potcars":[p.get("titel") for p in (inp.get("potcar_spec") or [])], |
| "hubbards":inp.get("hubbards"),"last_updated":str(doc.get("last_updated")), |
| "calc_type":doc.get("calc_type"),"nions_steps":len(co.get("ionic_steps") or [])} |
|
|
| def scan(key, needed): |
| wanted=set(needed); got={} |
| for a in range(4): |
| try: |
| with requests.get(S3+key,stream=True,timeout=900) as resp: |
| resp.raise_for_status() |
| with gzip.GzipFile(fileobj=resp.raw) as fh: |
| for line in fh: |
| ids={m.decode() for m in TASK_ID_RE.findall(line[:4000])} or {m.decode() for m in TASK_ID_RE.findall(line)} |
| if not ids & wanted: continue |
| d=json.loads(line); t=d.get("task_id") |
| if t in wanted: |
| try: got[t]=extract(d) |
| except Exception as e: got[t]={"task_id":t,"error":repr(e)} |
| wanted.discard(t) |
| if not wanted: break |
| return key, got, sorted(wanted), True |
| except Exception as e: |
| time.sleep(5*(a+1)) |
| return key, got, sorted(wanted), False |
|
|
| def fetch(p, workers): |
| need=set(p.task_id) |
| done=set() |
| for fn in OUT.glob("*.jsonl"): |
| for line in open(fn): done.add(json.loads(line)["task_id"]) |
| need-=done |
| a2=pd.read_parquet(MAN/"manifest_atomate2.parquet",columns=["task_id","sourced_from_path"]) |
| a2=a2[a2.task_id.isin(need)] |
| leg=pd.read_parquet(MAN/"manifest_legacy.parquet",columns=["task_id","nelements","spacegroup","dt"]) |
| leg=leg[leg.task_id.isin(need-set(a2.task_id))] |
| keys={} |
| for t,k in zip(a2.task_id,a2.sourced_from_path.str.replace("s3://materialsproject-parsed/","",regex=False)): keys.setdefault(k,[]).append(t) |
| for r in leg.itertuples(): keys.setdefault(f"tasks-legacy/tasks/nelements={r.nelements}/output_spacegroup_number={r.spacegroup}/dt={r.dt}.jsonl.gz",[]).append(r.task_id) |
| nowhere=need-set(a2.task_id)-set(leg.task_id) |
| print("to fetch",len(need),"files",len(keys),"in no manifest",len(nowhere),flush=True) |
| out=open(OUT/f"part_{int(time.time())}.jsonl","w"); miss=open(OUT/"missing.txt","a") |
| with ProcessPoolExecutor(workers) as ex: |
| futs=[ex.submit(scan,k,v) for k,v in keys.items()] |
| for i,fu in enumerate(as_completed(futs),1): |
| k,got,left,ok=fu.result() |
| for d in got.values(): out.write(json.dumps(d)+"\n") |
| for t in left: miss.write(f"{t}\t{k}\t{ok}\n") |
| if i%100==0 or i==len(futs): out.flush(); print(f"files {i}/{len(futs)}",flush=True) |
| for t in nowhere: miss.write(f"{t}\tNO_MANIFEST\tTrue\n") |
| out.close(); miss.close() |
|
|
| if __name__=="__main__": |
| p=select() if not (W/"candidates.parquet").exists() else pd.read_parquet(W/"candidates.parquet") |
| fetch(p, int(sys.argv[2]) if len(sys.argv)>2 else 12) |
| print("DONE",flush=True) |
|
|
