geofwi 0.0.0.1__tar.gz

geofwi-0.0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 aaspip
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

geofwi-0.0.0.1/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.1
+Name: geofwi
+Version: 0.0.0.1
+Summary: GeoFWI: A lightweight velocity model dataset for benchmarking full waveform inversion using deep learning
+Home-page: https://github.com/aaspip/geofwi
+Author: geofwi developing team
+Author-email: chenyk2016@gmail.com
+License: MIT License
+Keywords: seismology,seismic imaging,computational seismology,AI for science
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: Unix
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: License :: OSI Approved :: MIT License
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: matplotlib
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: ipython; extra == "docs"
+Requires-Dist: runipy; extra == "docs"
+
+Source code: https://github.com/aaspip/geofwi

geofwi-0.0.0.1/README.md

@@ -0,0 +1,269 @@
+# GeoFWI
+
+## Description
+
+**GeoFWI** is a lightweight velocity model dataset for deep-learning-based FWI benchmarking. This project is inspired by the OpenFWI project (https://sites.google.com/site/youzuolin044/openfwi) but includes more realistic geological models (e.g., folding layers, faults, and salt bodies). 
+
+Currently, we call it lightweight because this is the first step toward an eventually "heavyweight," very realistic, highly generalizable 3D velocity model dataset for unprecedented high-efficacy deep-learning-empowered FWI studies. 
+
+-----------
+## Download GeoFWI.npy from
+https://utexas.box.com/s/scbh25utyy5jz3mq7b0hp3wyluka7gaq
+
+## Reference
+Li et al., 2025, GeoFWI: A lightweight velocity model dataset for benchmarking full waveform inversion using deep learning - upcoming, TBD. 
+
+BibTeX:
+
+	@Article{geofwi,
+  	author={Chao Li and Liuqing Yang and Sergey Fomel and Andrey Bakulin and Yiran Shen and Shuang Gao and Umair Bin Waheed and Alexandros Savvaidis and Yangkang Chen},
+  	title = {GeoFWI: A lightweight velocity model dataset for benchmarking full waveform inversion using deep learning},
+  	journal={TBD},
+  	year=2025,
+  	volume=TBD,
+  	number=TBD,
+  	issue=TBD,
+  	pages={TBD},
+  	doi={TBD},
+	}
+
+-----------
+## Copyright
+    GEOFWI developing team, 2024-present
+
+-----------
+## License
+    MIT License 
+
+-----------
+## Install
+Using the latest version
+
+    git clone https://github.com/aaspip/geofwi
+    cd geofwi
+    pip install -v -e .
+
+or using Pypi
+
+    pip install geofwi
+
+or (recommended, because we update very fast)
+
+	pip install git+https://github.com/aaspip/geofwi
+
+-----------
+## Verified runnable OS
+Mac OS, Linux, Windows (need Microsoft C++ Build Tools)
+
+-----------
+## Examples
+
+Here is a sneak peek of some of the structures and initial results of the GeoFWI project.
+
+<p align="center">
+<img src='https://github.com/aaspip/gallery/blob/main/geofwi/geofwi-seisinvnet.png' alt='comp' width=960/>
+</p>
+
+Figure below shows a few good/bad predictions using the data-driven DL-based method (SeisInvNet) detailed in Li et al., 2020, Deep learning Inversion of Seismic Data, IEEE TGRS.
+
+<p align="center">
+<img src='https://github.com/aaspip/gallery/blob/main/geofwi/geofwi-types.png' alt='comp' width=960/>
+</p>
+
+-----------
+## Play with GeoFWI
+
+Read the GeoFWI data and check its dimension
+
+	import numpy as np
+	sizes=np.load("data/geofwi-size-layer-fault-salt-1-10.npy")
+	GeoFWI_path='data/geofwi.npy' #suppose you put geofwi.npy in "./data/" directory
+	geofwi=np.load(GeoFWI_path)
+	print('geofwi.shape',geofwi.shape)
+	print('NO of samples in GeoFWI is ',geofwi.shape[0])
+	print('Each sample has a dimension of %d * %d '%(geofwi.shape[1],geofwi.shape[2]))
+	
+*The output will be like*
+
+> geofwi.shape (49476, 100, 100)
+
+> NO of samples in GeoFWI is  49476
+
+> Each sample has a dimension of 100 * 100 
+
+Get some statistics from GeoFWI
+
+	import numpy as np
+	sizes=np.load("data/geofwi-size-layer-fault-salt-1-10.npy")
+	print('length of sizes:',len(sizes))
+	
+	print('Two-layer folding model: %d samples'%sizes[0])
+	print('Two-layer fault model: %d samples'%sizes[1])
+	print('Two-layer salt model: %d samples'%sizes[2])
+	print('Three-layer folding model: %d samples'%sizes[3])
+	print('Three-layer fault model: %d samples'%sizes[4])
+	print('Three-layer salt model: %d samples'%sizes[5])
+	print('Four-layer folding model: %d samples'%sizes[6])
+	print('Four-layer fault model: %d samples'%sizes[7])
+	print('Four-layer salt model: %d samples'%sizes[8])
+	print('Five-layer folding model: %d samples'%sizes[9])
+	print('Five-layer fault model: %d samples'%sizes[10])
+	print('Five-layer salt model: %d samples'%sizes[11])
+	print('Six-layer folding model: %d samples'%sizes[12])
+	print('Six-layer fault model: %d samples'%sizes[13])
+	print('Six-layer salt model: %d samples'%sizes[14])
+	print('Seven-layer folding model: %d samples'%sizes[15])
+	print('Seven-layer fault model: %d samples'%sizes[16])
+	print('Seven-layer salt model: %d samples'%sizes[17])
+	print('Eight-layer folding model: %d samples'%sizes[18])
+	print('Eight-layer fault model: %d samples'%sizes[19])
+	print('Eight-layer salt model: %d samples'%sizes[20])
+	print('Nine-layer folding model: %d samples'%sizes[21])
+	print('Nine-layer fault model: %d samples'%sizes[22])
+	print('Nine-layer salt model: %d samples'%sizes[23])
+	print('Ten-layer folding model: %d samples'%sizes[24])
+	print('Ten-layer fault model: %d samples'%sizes[25])
+	print('Ten-layer salt model: %d samples'%sizes[26])
+	print('Eleven-layer folding model: %d samples'%sizes[27])
+	print('Eleven-layer fault model: %d samples'%sizes[28])
+	print('Eleven-layer salt model: %d samples'%sizes[29])
+	
+*The output will be like*
+
+> Two-layer folding model: 2826 samples 
+
+> Two-layer fault model: 2754 samples 
+
+> Two-layer salt model: 1888 samples
+
+> Three-layer folding model: 2649 samples
+
+> Three-layer fault model: 2473 samples
+
+> Three-layer salt model: 1758 samples
+
+> Four-layer folding model: 2491 samples
+
+> Four-layer fault model: 2161 samples
+
+> Four-layer salt model: 1674 samples
+
+> Five-layer folding model: 2245 samples
+
+> Five-layer fault model: 1948 samples
+
+> Five-layer salt model: 1508 samples
+
+> Six-layer folding model: 1974 samples
+
+> Six-layer fault model: 1653 samples
+
+> Six-layer salt model: 1340 samples
+
+> Seven-layer folding model: 1797 samples
+
+> Seven-layer fault model: 1478 samples
+
+> Seven-layer salt model: 1226 samples
+
+> Eight-layer folding model: 1635 samples
+
+> Eight-layer fault model: 1325 samples
+
+> Eight-layer salt model: 1076 samples
+
+> Nine-layer folding model: 1453 samples
+
+> Nine-layer fault model: 1117 samples
+
+> Nine-layer salt model: 976 samples
+
+> Ten-layer folding model: 1309 samples
+
+> Ten-layer fault model: 1000 samples
+
+> Ten-layer salt model: 881 samples
+
+> Eleven-layer folding model: 1200 samples
+
+> Eleven-layer fault model: 829 samples
+
+> Eleven-layer salt model: 832 samples
+
+
+Extract a few five-layer fault models from GeoFWI
+
+	import numpy as np
+	sizes=np.load("data/geofwi-size-layer-fault-salt-1-10.npy")
+	GeoFWI_path='data/geofwi.npy' #suppose you put geofwi.npy in "./data/" directory
+	geofwi=np.load(GeoFWI_path)
+	
+	#first index for five-layer fault models,
+	ind=sum(sizes[0:10])+1  #refer to last example for checking the index for each type of model
+	
+	no=8 #make it 4,8,16
+	import matplotlib.pyplot as plt
+	fig=plt.figure(figsize=(16, 8))
+	for ii in range(no):
+		plt.subplot(2,int(no/2),ii+1)
+		plt.imshow(geofwi[ind+ii,:,:],clim=[1500,4000]);
+	plt.colorbar(orientation='horizontal',cax=fig.add_axes([0.37,0.07,0.3,0.01]),shrink=1,label='Velocity (m/s)');
+	plt.show()
+
+*The output will be like*
+<img src='https://github.com/aaspip/gallery/blob/main/geofwi/hands-example-5layer-fault.png' alt='comp' width=960/>
+
+Extract a few five-layer salt models from GeoFWI
+
+	import numpy as np
+	sizes=np.load("data/geofwi-size-layer-fault-salt-1-10.npy")
+	GeoFWI_path='data/geofwi.npy' #suppose you put geofwi.npy in "./data/" directory
+	geofwi=np.load(GeoFWI_path)
+	
+	#first index for five-layer salt models,
+	ind=sum(sizes[0:11])+1  #refer to last example for checking the index for each type of model
+	
+	no=8 #make it 4,8,16
+	import matplotlib.pyplot as plt
+	fig=plt.figure(figsize=(16, 8))
+	for ii in range(no):
+		plt.subplot(2,int(no/2),ii+1)
+		plt.imshow(geofwi[ind+ii,:,:],clim=[1500,4000]);
+	plt.colorbar(orientation='horizontal',cax=fig.add_axes([0.37,0.07,0.3,0.01]),shrink=1,label='Velocity (m/s)');
+	plt.show()
+
+*The output will be like*
+<img src='https://github.com/aaspip/gallery/blob/main/geofwi/hands-example-5layer-salt.png' alt='comp' width=960/>
+
+-----------
+## Development
+    The development team welcomes voluntary contributions from any open-source enthusiast. 
+    If you want to make contribution to this project, feel free to contact the development team. 
+
+-----------
+## Contact
+    Regarding any questions, bugs, developments, collaborations, please contact  
+    Yangkang Chen
+    chenyk2016@gmail.com
+    
+
+-----------
+## Gallery
+The gallery figures of the geofwi project can be found at
+    https://github.com/aaspip/gallery/tree/main/geofwi
+All figures in the gallery directory can be reproduced by their corresponding DEMO scripts in the "demo" directory. These gallery figures are also presented below. 
+
+# Below is an example for quickly visualizing a few samples from GeoFWI.npy in different scenarios 
+Generated by [demos/test_quick_visualize.py](https://github.com/aaspip/geofwi/tree/main/demos/test_quick_visualize.py)
+
+First scenario: randomly chosen 25 samples from the whole GeoFWI dataset
+<img src='https://github.com/aaspip/gallery/blob/main/geofwi/geofwi-samples-random.png' alt='comp' width=960/>
+
+Second scenario: the first 25 samples from the whole GeoFWI dataset
+<img src='https://github.com/aaspip/gallery/blob/main/geofwi/geofwi-samples-increasing.png' alt='comp' width=960/>
+
+Third scenario: the last 25 samples from the whole GeoFWI dataset
+<img src='https://github.com/aaspip/gallery/blob/main/geofwi/geofwi-samples-increasing.png' alt='comp' width=960/>
+
+Fourth scenario: the last 25 samples in the "11-layer fault category" (e.g., sizes=np.load('data/geofwi-size-layer-fault-salt-1-10.npy'); index is chosen from 49476-sizes[-1]-1 to sizes[-1]-25) from the whole GeoFWI dataset
+<img src='https://github.com/aaspip/gallery/blob/main/geofwi/geofwi-samples-faults.png' alt='comp' width=960/>

geofwi-0.0.0.1/demos/test_quick_visualize.py

@@ -0,0 +1,54 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import os
+
+## Define GeoFWI datapath
+GeoFWI_path=os.getenv('HOME')+'/DATALIB/GeoFWI/geofwi.npy' #define your own path
+#GeoFWI_path = './geofwi.npy' #for example
+
+sizes=np.load('../data/geofwi-size-layer-fault-salt-1-10.npy') #if you run this script in demos/
+
+geofwi=np.load(GeoFWI_path)
+nsample=geofwi.shape[0]
+
+np.random.seed(20232425)
+inds=np.arange(49500)
+np.random.shuffle(inds)
+
+fig=plt.figure(figsize=(16, 16))
+for ii in range(25):
+	plt.subplot(5,5,ii+1)
+	plt.imshow(geofwi[inds[ii],:,:],clim=[1500,4000]);
+plt.colorbar(orientation='horizontal',cax=fig.add_axes([0.37,0.07,0.3,0.01]),shrink=1,label='Velocity (m/s)');
+plt.savefig('geofwi-samples-random.png',dpi=300)
+plt.show()
+
+fig=plt.figure(figsize=(16, 16))
+for ii in range(25):
+	plt.subplot(5,5,ii+1)
+	plt.imshow(geofwi[ii,:,:],clim=[1500,4000]);
+plt.colorbar(orientation='horizontal',cax=fig.add_axes([0.37,0.07,0.3,0.01]),shrink=1,label='Velocity (m/s)');
+plt.savefig('geofwi-samples-increasing.png',dpi=300)
+plt.show()
+
+
+
+fig=plt.figure(figsize=(16, 16))
+for ii in range(25):
+	plt.subplot(5,5,ii+1)
+	plt.imshow(geofwi[nsample-ii-1,:,:],clim=[1500,4000]);
+plt.colorbar(orientation='horizontal',cax=fig.add_axes([0.37,0.07,0.3,0.01]),shrink=1,label='Velocity (m/s)');
+plt.savefig('geofwi-samples-decreasing.png',dpi=300)
+plt.show()
+
+
+fig=plt.figure(figsize=(16, 16))
+for ii in range(25):
+	plt.subplot(5,5,ii+1)
+	plt.imshow(geofwi[nsample-sizes[-1]-1-ii,:,:],clim=[1500,4000]);
+plt.colorbar(orientation='horizontal',cax=fig.add_axes([0.37,0.07,0.3,0.01]),shrink=1,label='Velocity (m/s)');
+plt.savefig('geofwi-samples-faults.png',dpi=300)
+
+plt.show()
+
+

geofwi-0.0.0.1/geofwi/__init__.py

@@ -0,0 +1,3 @@
+from .plot import *
+from .utils import *
+from .acc import *

geofwi-0.0.0.1/geofwi/acc.py

@@ -0,0 +1,145 @@
+# import os
+
+def acc_occurence(yesno,geofwipath='./'):
+	'''
+	acc_occurence: calculate occurence accuracy
+	
+	EXAMPLE
+	
+	from pylib.io import asciiread
+	
+	yesnoall=asciiread('yesnoall_cyk_new.txt');
+	yesnoall=[float(ii) for ii in yesnoall]
+	
+	locall=asciiread('locall_cyk_new.txt')
+	magall=asciiread('magall_cyk_new.txt')
+
+	from geofwi import acc_occurence
+	import os
+	geofwipath=os.getenv('HOME')+"/DATALIB/geofwi.h5"
+	pre,rec,acc,f1=acc_occurence(yesnoall,geofwipath)
+	
+	'''
+
+	#one way to get label
+# 	import h5py
+# 	aetalab=[]
+# 	f = h5py.File(geofwipath, 'r')
+# 	for WKNO in range(1,31,1): 
+# 		idx='WK_%02d'%(WKNO)
+# 		g=f.get(idx)
+# 	
+# 		if g.get('Label_EV').attrs['yesno'] == 'yes':
+# 			aetalab.append(1)
+# 		else:
+# 			aetalab.append(0)
+
+	#an easier way to get label
+	from geofwi import get_testlabel
+	aetalab=get_testlabel(geofwipath,mode='occurence')
+	
+	print('aetalab size is',len(aetalab))
+	print('yesno size is',len(yesno))
+	
+	from sklearn.metrics import f1_score, precision_score, recall_score, accuracy_score
+
+	accuracy=accuracy_score(aetalab,yesno)
+	f1=f1_score(aetalab,yesno)
+	precision=precision_score(aetalab,yesno)
+	recall=recall_score(aetalab,yesno)
+
+	print("Precision=",precision)
+	print("Recall=",recall)
+	print("Accuracy=",accuracy)
+	print("F1-score=",f1)
+	
+	return precision,recall,accuracy,f1
+	
+	
+def acc_mag(mags,geofwipath='./'):
+	'''
+	acc_mag: calculate magnitude accuracy
+	
+	EXAMPLE
+	
+	from pylib.io import asciiread
+	import numpy as np
+	
+	yesnoall=asciiread('yesnoall_cyk_new.txt');
+	yesnoall=[float(ii) for ii in yesnoall]
+	
+	locall=asciiread('locall_cyk_new.txt')
+	magall=asciiread('magall_cyk_new.txt')
+	magall=[float(ii.split(" ")[0].split("]")[0].split("[")[-1]) for ii in magall] #choose the first one
+
+	from geofwi import acc_mag
+	import os
+	geofwipath=os.getenv('HOME')+"/DATALIB/geofwi.h5"
+	mae=acc_mag(magall,geofwipath)
+	
+	'''
+	import numpy as np
+	from geofwi import get_testlabel
+	aetalab=get_testlabel(geofwipath,mode='occurence')
+	aetalabmag=get_testlabel(geofwipath,mode='magnitude')
+	
+	print('aetalab size is',len(aetalab))
+	
+	ssum=[]
+	for ii in range(len(aetalab)):
+		if mags[ii]>0 and aetalab[ii]==1:
+			print(mags[ii],aetalabmag[ii])
+			ssum.append(np.abs(mags[ii]-aetalabmag[ii]))
+	MAE=np.mean(ssum)
+	
+	print('MAE of magnitude=',MAE)
+
+	return MAE
+	
+
+def acc_loc(locs,geofwipath='./'):
+	'''
+	acc_loc: calculate location accuracy
+	
+	EXAMPLE
+	
+	from pylib.io import asciiread
+	import numpy as np
+	
+	yesnoall=asciiread('yesnoall_cyk_new.txt');
+	yesnoall=[float(ii) for ii in yesnoall]
+	
+	locall=asciiread('locall_cyk_new.txt')
+	locall=[ii.split("]")[0].split("[")[-1] for ii in locall]
+	
+	magall=asciiread('magall_cyk_new.txt')
+	magall=[float(ii.split(" ")[0].split("]")[0].split("[")[-1]) for ii in magall] #choose the first one
+
+	from geofwi import acc_loc
+	import os
+	geofwipath=os.getenv('HOME')+"/DATALIB/geofwi.h5"
+	mde=acc_loc(locall,geofwipath)
+	
+	'''
+	import numpy as np
+	from geofwi import get_testlabel
+	aetalab=get_testlabel(geofwipath,mode='occurence')
+	aetalabmag=get_testlabel(geofwipath,mode='magnitude')
+	aetalabloc=get_testlabel(geofwipath,mode='location')
+	
+	print('aetalab size is',len(aetalab))
+	
+	ssum=[]
+	for ii in range(len(aetalab)):
+		if locs[ii]!='0' and aetalab[ii]==1:
+			print(locs[ii],aetalabloc[ii])
+			loc=locs[ii].split()
+			loc=[float(ii) for ii in loc]
+			ssum.append(np.hypot(loc[0]-aetalabloc[ii][0],loc[1]-aetalabloc[ii][1])*111.0) 
+	MDE=np.mean(ssum)
+	
+	print('MDE of location=',MDE)
+
+	return MDE
+	
+

geofwi-0.0.0.1/geofwi/plot.py

@@ -0,0 +1,127 @@
+import matplotlib.pyplot as plt
+import numpy as np
+
+def plot_traces(st,axoff=1,ayoff=1,titleoff=1,picks=None,eid=None,mag=None,ifmap=0,staloc=None,evloc=None,staname=None,ptime=None,stime=None,figname=None,showf=True,**kwargs):
+	"""
+	plot_traces: plot all traces in a stream quickly side-by-side from top to bottom
+	
+	INPUT
+	st: Stream
+	axoff: axes X off
+	ayoff: axes Y off
+	title: title off
+	picks: P/S picks object
+		in this subroutine, picks is a list of two-entries Dict 
+		initialized by {'P':None,'S':None}
+		(compared with obspy pick object obspy.core.event.origin.Pick)
+	showf: if show figure interatively
+	
+	EXAMPLES
+	from geofwi import plot_traces
+	plot_traces(st);
+	
+	from geofwi import plot_traces
+	plot_traces(st,axoff=0,ayoff=0,titleoff=0);
+	
+	from geofwi plot_traces; 
+	plot_traces(obspy.read("newwaveforms/texnet2022ugad.mseed")[0:10]);
+	
+	demos/test_event.py
+	"""
+	ntr=len(st)
+	if ifmap == 0:
+		fig = plt.figure(figsize=(6, 8))
+	else:
+		fig = plt.figure(figsize=(12, 8))
+	
+	for ii in range(ntr):
+		if ifmap==0:
+			ax = plt.subplot(ntr,1,ii+1)
+		else:
+			ax = plt.subplot(ntr,2,2*ii+1)
+		nt=len(st[ii].data);
+		twin=(nt-1)*1.0/st[ii].stats.sampling_rate;
+# 		print('twin=',twin,'nt=',nt,'dt',1.0/st[ii].stats.sampling_rate)
+# 		staname=st[ii].stats.network+'.'+st[ii].stats.station
+		t=np.linspace(0,twin,nt)
+		plt.plot(t,st[ii].data,color='k',label = st[ii].stats.station, linewidth = 1, markersize=1)
+		
+		if ii==0 and titleoff != 1:
+			if eid is None and mag is None:
+				plt.title(st[ii].stats.starttime,fontsize='large', fontweight='normal')
+			else:
+				plt.title(eid+' (M=%.3g)'%(mag)+' '+str(st[ii].stats.starttime),fontsize=10, fontweight='normal')
+
+		ax.legend(loc='lower right', fontsize = 10/(ntr/4))
+		if ii==ntr-1:
+			if axoff == 1:
+				plt.setp(ax.get_xticklabels(), visible=False)
+			else:
+				plt.setp(ax.get_xticklabels(), visible=True)
+				ax.set_xlabel("Time (s)",fontsize='large', fontweight='normal')
+		else:
+			plt.setp(ax.get_xticklabels(), visible=False)
+		ax.set_xlim(xmin=0)
+		ax.set_xlim(xmax=t[-1])
+		ymin, ymax = ax.get_ylim()
+		
+		if ayoff:
+			plt.setp(ax.get_yticklabels(), visible=False)
+			
+		if picks is not None:
+			if picks[ii]['P'] is not None:
+				tp=picks[ii]['P']-st[ii].stats.starttime
+				plt.vlines(tp, ymin, ymax, color = 'r', linewidth = 1) #for P
+			
+			if picks[ii]['S'] is not None:
+				ts=picks[ii]['S']-st[ii].stats.starttime
+				plt.vlines(ts, ymin, ymax, color = 'g', linewidth = 1) #for S
+# 		plt.text(2.5,(ymin+ymax)/2,staname)
+				
+		if ptime is not None:
+			tp=ptime[ii]-st[ii].stats.starttime
+			plt.vlines(tp, ymin, ymax, color = 'r', linewidth = 1) #for P
+			
+		if stime is not None:
+			ts=stime[ii]-st[ii].stats.starttime
+			plt.vlines(ts, ymin, ymax, color = 'g', linewidth = 1) #for P
+			
+	if ifmap==1:	
+		ax = plt.subplot(2,2,2)
+		plt.plot(staloc[:,0],staloc[:,1],'v',color='b')
+		plt.plot(evloc[0],evloc[1],'*',color='r')
+		addcounty_tx();
+		
+		plt.ylabel('Latitude (deg)')
+		plt.gca().set_xlim(evloc[0]-3,evloc[0]+3)
+		plt.gca().set_ylim(evloc[1]-3,evloc[1]+3)
+		[x1,x2]=plt.gca().get_xlim()
+		
+		if len(staname) == staloc.shape[0]:
+			for ii in range(len(staname)):
+				plt.text(staloc[ii,0],staloc[ii,1],staname[ii][:],color='k',fontsize=6)
+		
+		ax = plt.subplot(2,2,4)
+		plt.plot(evloc[0],evloc[2],'*',color='r',label='TexNet event')
+			
+		plt.gca().set_ylim(-2, 25);plt.gca().set_xlim(x1, x2)
+		plt.gca().invert_yaxis()
+		plt.xlabel('Longitude (deg)');plt.ylabel('Depth (km)')
+		
+		plt.plot(staloc[:,0],-staloc[:,2]/1000.0,'v',color='b',label='Station')
+		plt.plot(0, 0, color = 'k', linestyle='solid', linewidth = 1, label="Waveform") #for S
+		
+		## add picks legend
+		plt.vlines(0, 100, 120, color = 'r', linestyle='solid', linewidth = 1, label="TexNet P") #for P
+		plt.vlines(0, 100, 120, color = 'g', linestyle='solid', linewidth = 1, label="TexNet S") #for S
+		
+		ax.legend(loc='lower right', fontsize = 8)
+		
+		
+	if figname is not None:
+		plt.savefig(figname,**kwargs)
+	
+	if showf:
+		plt.show()
+	else:
+		plt.close() #or plt.clear() ?

geofwi-0.0.0.1/geofwi/utils.py

@@ -0,0 +1,572 @@
+import numpy as np
+def shift3c(data,tshift):
+	'''
+	shift3c: shift a 3C numpy array according to the tshift (scalar)
+	
+	INPUT
+	data: nsample x 3 array
+	tshift: shift in samples (>0 -> right shift; <0 -> left shift)
+	
+	OUTPUT
+	data2: shifted array
+	'''
+	
+# 	return np.roll(data, tshift, axis=0) #not best
+	data2=np.zeros(data.shape)
+	if tshift>0:
+		data2[tshift:,:] = data[0:-tshift,:]
+	else:
+		data2[0:tshift,:]=data[-tshift:,:]
+	
+	return data2
+	
+def asciiread(fname):
+	'''
+	fname: file name
+	din:   a list of lines
+	withnewline: if with the newline symbol '\n': True: with; False: without
+	
+	EXAMPLE
+	
+	from geofwi import asciiread
+	import os
+	
+	lines=asciiread(os.getenv('HOME')+'/chenyk.data2/various/cyksmall/texnet_stations_2022_1019.csv');
+	'''
+	
+	f=open(fname,'r')
+	lines=f.readlines()
+	lines=[ii.strip() for ii in lines]
+	
+	return lines
+
+def asciiwrite(fname,din,withnewline=False):
+	'''
+	fname: file name
+	din:   a list of lines
+	withnewline: if with the newline symbol '\n': True: with; False: without
+	
+	EXAMPLE
+	
+	from geofwi import asciiwrite
+	import os
+	
+	f=open(os.getenv('HOME')+'/chenyk.data2/various/cyksmall/texnet_stations_2022_1019.csv')
+	lines=f.readlines();
+	
+	asciiwrite('stations.txt',lines,withnewline=True);
+	'''
+	
+	f=open(fname,'w')
+	if withnewline:
+		for ii in range(len(din)):
+			f.write(str(din[ii]))
+	else:
+		for ii in range(len(din)):
+			f.write(str(din[ii])+"\n")
+
+def get_week():
+	'''
+	get_week: get week interval
+	
+	three columns in each list entry are weekNO,starting time (local),ending time (local)
+	
+	EXAMPLE
+	from geofwi import get_week
+	import os
+	weeks=get_week()
+	
+	'''
+	from obspy.core.utcdatetime import UTCDateTime
+	import h5py
+	import numpy as np
+
+	##########################################################################################
+	contime= 8 * 60 *60
+	t0 = UTCDateTime(1483200000+contime) 	#begin time: 2017-01-01T00:00:00.000000Z
+	tend = UTCDateTime(1606751400+contime) 	#end time: 2020-11-30T23:50:00.000000Z
+	print('Starting and Ending time of testing data are', t0, tend)
+	
+	v = int(tend-t0)/(7*24*60*60) #number of weeks
+	tweek=[]
+	c=0
+	for cv in range(0,int(v)):
+		c =t0 + (cv*7*24*60*60)
+		tweek.append(c)
+	tweek.append(c+7*24*60*60) #making it 205 weeks (actually there are only 204 complete weeks)
+
+	weeks=[str(ii+1)+" "+str(tweek[ii])+" "+str(tweek[ii+1]) for ii in range(len(tweek)-1)]
+	return weeks
+
+def get_week_test():
+	'''
+	get_week_test: get week interval in the testing data
+	
+	three columns in each list entry are weekNO,starting time (local),ending time (local)
+	
+	EXAMPLE
+	from geofwi import get_week_test
+	import os
+	weeks=get_week_test()
+	
+	'''
+	from obspy.core.utcdatetime import UTCDateTime
+	import h5py
+	import numpy as np
+
+	##########################################################################################
+	t0 = UTCDateTime(2021,3,28) 	#begin time: 2021-03-28T00:00:00.000000Z
+	tend = UTCDateTime(2021,10,24) 	#end time: 2021-10-23T23:50:00.000000Z
+	print('Starting and Ending time of testing data are', t0, tend)
+	
+	v = int(tend-t0)/(7*24*60*60) #number of weeks
+	tweek=[]
+	c=0
+	for cv in range(0,int(v)):
+		c =t0 + (cv*7*24*60*60)
+		tweek.append(c)
+	tweek.append(c+7*24*60*60) #making it 205 weeks (actually there are only 204 complete weeks)
+
+	weeks=[str(ii+1)+" "+str(tweek[ii])+" "+str(tweek[ii+1]) for ii in range(len(tweek)-1)]
+	return weeks
+	
+def get_traindata(station='EM_101',geofwipath='./'):
+	'''
+	get_traindata: get station-wise training data (for 203 weeks, no first week)
+	
+	EXAMPLE
+	from geofwi import get_traindata
+	import os
+	data=get_traindata('EM_101',os.getenv('HOME')+"/DATALIB/geofwi.h5")
+	
+	'''
+	from obspy.core.utcdatetime import UTCDateTime
+	import h5py
+	import numpy as np
+
+	##########################################################################################
+	contime= 8 * 60 *60
+	t0 = UTCDateTime(1483200000+contime) 	#begin time: 2017-01-01T00:00:00.000000Z
+	tend = UTCDateTime(1606751400+contime) 	#end time: 2020-11-30T23:50:00.000000Z
+	t0, tend
+
+	v = int(tend-t0)/(10*60)
+	t10min=[]
+	c=0
+	for cv in range(0,int(v)):
+		c =t0 + (cv*10*60)
+		t10min.append(c)
+	
+	v = int(tend-t0)/(7*24*60*60)
+	tweek=[]
+	c=0
+	for cv in range(0,int(v)):
+		c =t0 + (cv*7*24*60*60)
+		tweek.append(c)
+	tweek.append(c+7*24*60*60) #making it 205 weeks (actually there are only 204 complete weeks)
+	f = h5py.File(geofwipath, 'r')
+
+# 	keys=list(f.keys())
+# 	# id=2 #event NO
+# 	keys=[ii for ii in keys if ii[0:2]=='EV']
+# 
+# 	#sort
+# 	def myFunc(e):
+#   		return int(e[3:])
+# 	keys.sort(key=myFunc)
+# 
+# ##########################################################################################
+# ##extract event info (longitude,latitude,magnitude)
+# ##########################################################################################
+# 	tweek_lab=np.zeros_like(tweek)
+# 	Longall=[]
+# 	Latall=[]
+# 	magall=[]
+# 	for s in range(3,len(keys)):
+# 		dataset = f.get(keys[s])
+# 		mag=[]
+# 		Lat=[]
+# 		Long=[]
+# 		b = 0
+# 		ind=[]
+# 		for q in tweek:
+# 			d = UTCDateTime(q)-UTCDateTime(dataset.attrs['ev_time'])
+# 			if d>=0:
+# 				ind=b-1
+# 				tweek_lab[ind]=tweek_lab[ind]+1
+	
+	dataset = f.get('%s'%station)
+	data=np.array(dataset['data'])
+	data19=[]
+	for i in range(1,205):
+
+		a = int(tweek[i-1]-t0)/(10*60)
+		b = int(tweek[i]-t0)/(10*60)
+
+		dataE = data[int(a):int(b)]
+		dataE = np.reshape(dataE,(dataE.shape[0]*dataE.shape[1]))
+
+		data19.append(dataE)
+	data19=np.array(data19)
+	if True in np.isnan(np.isnan(data19)):
+		print('Running nan check')
+		data19=np.nan_to_num(data19, nan=0, posinf=33333333, neginf=33333333)
+	data19=np.nan_to_num(data19, nan=0, posinf=33333333, neginf=33333333)
+	
+	return data19
+	
+def get_label(geofwipath='./',mode='occurence',ifmag='True'):
+	'''
+	get_label: get earthquake occurence label of geofwi
+	
+	NOTE: 
+	Actual EQ label week is one week after the ML label in a forecasting-classification problem
+	
+	For instance
+	If the data from Week2-203 is selected for training
+	Correspondingly, the label for EQ occurence is Week3-204 
+	
+	The first EQ earthquake in the 204-week training data occurred in the third week
+	but for forecasting it, the label in the second week should be set as 1 (one week before)
+	
+	EXAMPLE 1
+	from geofwi import get_label
+	import os
+	label=get_label(os.getenv('HOME')+"/DATALIB/geofwi.h5")
+
+	EXAMPLE 2
+	from geofwi import get_label
+	import os
+	geofwipath=os.getenv('HOME')+"/DATALIB/geofwi.h5"
+	labelmag=get_label(geofwipath,mode='magnitude')
+
+	EXAMPLE 3
+	from geofwi import get_label
+	import os
+	geofwipath=os.getenv('HOME')+"/DATALIB/geofwi.h5"
+	labelloc=get_label(geofwipath,mode='location')
+	'''
+	
+	if ifmag==True:
+		mode='magnitude' #for compatible with old version
+	
+	from obspy.core.utcdatetime import UTCDateTime
+	
+	##########################################################################################
+	## Set up week
+	##########################################################################################
+	contime= 8 * 60 *60
+	t0 = UTCDateTime(1483200000+contime) 	#begin time: 2017-01-01T00:00:00.000000Z
+	tend = UTCDateTime(1606751400+contime) 	#end time: 2020-11-30T23:50:00.000000Z
+	t0, tend
+
+	v = int(tend-t0)/(10*60)
+	t10min=[]
+	c=0
+	for cv in range(0,int(v)):
+		c =t0 + (cv*10*60)
+		t10min.append(c)
+	
+	v = int(tend-t0)/(7*24*60*60)
+	tweek=[]
+	c=0
+	for cv in range(0,int(v)):
+		c =t0 + (cv*7*24*60*60)
+		tweek.append(c)
+	
+	import h5py
+	f = h5py.File(geofwipath, 'r')
+	keys=list(f.keys())
+	# id=2 #event NO
+	keys=[ii for ii in keys if ii[0:2]=='EV']
+
+	#sort
+	def myFunc(e):
+  		return int(e[3:])
+	keys.sort(key=myFunc)
+
+##########################################################################################
+##extract event info (longitude,latitude,magnitude)
+##########################################################################################
+	tweek_lab=np.zeros_like(tweek)
+	Longall=[]
+	Latall=[]
+	magall=[]
+	for s in range(0,len(keys)):
+		dataset = f.get(keys[s])
+		mag=[]
+		Lat=[]
+		Long=[]
+		b = 0
+		ind=[]
+		for q in tweek:
+			d = UTCDateTime(q)-UTCDateTime(dataset.attrs['ev_time'])
+			if d>=0:
+				ind=b-1
+				tweek_lab[ind]=tweek_lab[ind]+1 #This is the actual EQ week (one week after the label week)
+				mag.append(dataset.attrs['ev_magnitude'])
+				Lat.append(dataset.attrs['ev_latitude'])
+				Long.append(dataset.attrs['ev_longitude'])
+				break
+			b = b+1
+		magall.append(mag)
+		Longall.append(Long)
+		Latall.append(Lat)
+	
+		magweek = np.zeros_like(tweek_lab)
+		latweek = np.zeros_like(tweek_lab)
+		lonweek = np.zeros_like(tweek_lab)
+
+	v = 0
+	c = 0
+	for i in tweek_lab:
+		if i>0:
+			magweek[v] = magall[c:c+i]
+			latweek[v] = Latall[c:c+i]
+			lonweek[v] = Longall[c:c+i]
+			c = c +i
+		else:
+			magweek[v]=0
+			latweek[v]=[[0]]
+			lonweek[v]=[[0]]
+		v = v+1
+	
+	len(tweek_lab), int(tweek[2]-t0)/(10*60), int(tweek[3]-t0)/(10*60)
+
+	lab=tweek_lab
+	labclass = np.zeros((len(lab)))
+	cc=0
+	for i in lab:
+		if i>0:
+			labclass[cc]=1
+		cc = cc+1
+	labclass = np.array(labclass)	
+
+	if mode=='occurence':
+		return labclass
+	elif mode=='magnitude':
+		mags = np.array([np.round(np.array(ii).max()) for ii in magweek])
+		return mags
+	elif mode=='location':
+		inds=np.array([np.array(ii).argmax() for ii in magweek],dtype='int')
+		lons=np.array([lonweek[ii][inds[ii]] for ii in range(len(lonweek))]).flatten()
+		lats=np.array([latweek[ii][inds[ii]] for ii in range(len(latweek))]).flatten()
+		return [(lons[ii],lats[ii]) for ii in range(len(inds))]
+	else:
+		return labclass
+		
+		
+		
+def get_time():
+	'''
+	get_time: get the time axis for geofwi
+	
+	The length of the time vector is 205920
+	The format of time is UTC time format but in local time (CST = UTC + 8 hours)
+	
+	Written by Yangkang Chen
+	Aug, 21, 2024
+	
+	EXAMPLE
+	from geofwi import get_time
+	times=get_time()
+	print(times[0],times[-1])
+	
+	'''
+	from obspy.core.utcdatetime import UTCDateTime
+	import numpy as np
+	
+	##########################################################################################
+	## Set up week
+	##########################################################################################
+	contime= 8 * 60 *60
+	t0 = UTCDateTime(1483200000+contime) 	#begin time: 2017-01-01T00:00:00.000000Z
+	tend = UTCDateTime(1606751400+contime) 	#end time: 2020-11-30T23:50:00.000000Z
+	t0, tend
+	
+	nsample=204*7*24*6+2*24*6; #205920
+	
+	timestamps=np.linspace(1483200000+contime,1606751400+contime,nsample);
+	
+	times=[UTCDateTime(ii) for ii in timestamps]
+	
+	return times
+	
+	
+def get_testdata(week=1,station='EM_101',geofwipath='./'):
+	'''
+	get_testdata: get station-wise training data (for 203 weeks, no first week)
+	
+	EXAMPLE:
+	
+	exe1
+	from geofwi import get_testdata
+	import os
+	data=get_testdata(1,'EM_101',os.getenv('HOME')+"/DATALIB/geofwi.h5")
+
+	exe2
+	from geofwi import get_testdata
+	import os
+	data=get_testdata(1,'GA_101',os.getenv('HOME')+"/DATALIB/geofwi.h5")
+	
+	'''
+	import h5py
+	f = h5py.File(geofwipath, 'r')
+	idx="WK_%02d"%week
+	dataset = f.get(idx)
+	print('idx:',idx)
+	
+	keywords=list(f.get(idx).keys())
+
+	ems=[ii for ii in keywords if ii[0:2]=='EM']
+	gas=[ii for ii in keywords if ii[0:2]=='GA']
+	
+	ems=ems+gas
+
+	# wkno='WK_01'
+	allstas=[station]
+	for ista in range(len(allstas)):
+		print(idx,ista,len(allstas))
+	
+		emname=[ii for ii in ems if ii.split("_")[0]+'_'+ii.split("_")[-1]==allstas[ista] ]
+		
+		if len(emname) > 0:
+			print(idx,emname)
+			data_em=np.array(f.get(idx).get(emname[0])['data'])
+			data_em=np.nan_to_num(data_em, nan=0, posinf=33333333, neginf=33333333)
+			
+# 		ganame=[ii for ii in gas if ii.split("_")[-1]==allstas[ista] ]
+# 	
+# 		if len(ganame) > 0:
+# 			data_ga=np.array(f.get(idx).get(ganame[0])['data'])
+# 			print('Max/Min GA values: ',data_ga.max(),data_ga.min())
+			
+	return data_em
+
+
+def get_testlabel(geofwipath='./',mode='occurence'):
+	'''
+	get_testlabel: get earthquake occurence label of geofwi for the testing data (30 weeks)
+	
+	
+	mode: occurence, magnitude, location
+	
+	EXAMPLE:
+	from geofwi import get_testlabel
+	import os
+	label=get_testlabel(os.getenv('HOME')+"/DATALIB/geofwi.h5")
+	labelmag=get_testlabel(os.getenv('HOME')+"/DATALIB/geofwi.h5",mode='magnitude')
+	labelloc=get_testlabel(os.getenv('HOME')+"/DATALIB/geofwi.h5",mode='location')
+	
+	'''
+	import os,h5py
+	
+	geofwipath=os.getenv('HOME')+'/DATALIB/geofwi.h5'
+
+	f = h5py.File(geofwipath, 'r')
+	keys=list(f.keys())
+	keys=[ii for ii in keys if ii[0:2]=='WK']
+
+	
+	labclass=[]
+	mags=[]
+	lons=[]
+	lats=[]
+	for ii in range(len(keys)):
+		idx=keys[ii]
+		keywords=list(f.get(idx).keys())
+# 		print(keywords[-1])
+		yesno=f.get(idx).get('Label_EV').attrs['yesno']
+		
+		if yesno=='yes':
+			labclass.append(1)
+			mags.append(f.get(idx).get('Label_EV').attrs['ev_magnitude'])
+			lons.append(f.get(idx).get('Label_EV').attrs['ev_longitude'])
+			lats.append(f.get(idx).get('Label_EV').attrs['ev_latitude'])
+		else:
+			labclass.append(0)
+			mags.append(0)
+			lons.append(0)
+			lats.append(0)
+
+	
+	if mode=='occurence':
+		return labclass
+	elif mode=='magnitude':
+		return mags
+	elif mode=='location':
+		return [(lons[ii],lats[ii]) for ii in range(len(lons))]
+	else:
+		return labclass
+	
+	
+def get_testlabelaeta(geofwipath='./',mode='occurence'):
+	'''
+	get_testlabelaeta: get earthquake occurence label of geofwi for the testing data (30 weeks)
+	
+	NOTE: The difference between get_testlabel and get_testlabelaeta is that the latter
+	removes the events that are far away from AETA stations. The AETA competition is
+	based on the labels from the latter (get_testlabelaeta). 
+	
+	For keep a record of all event information, we preserve both label functions.
+	
+	mode: occurence, magnitude, location
+	
+	EXAMPLE:
+	from geofwi import get_testlabelaeta
+	import os
+	label=get_testlabelaeta(os.getenv('HOME')+"/DATALIB/geofwi.h5")
+	labelmag=get_testlabelaeta(os.getenv('HOME')+"/DATALIB/geofwi.h5",mode='magnitude')
+	labelloc=get_testlabelaeta(os.getenv('HOME')+"/DATALIB/geofwi.h5",mode='location')
+	
+	'''
+	import os,h5py
+	
+	geofwipath=os.getenv('HOME')+'/DATALIB/geofwi.h5'
+
+	f = h5py.File(geofwipath, 'r')
+	keys=list(f.keys())
+	keys=[ii for ii in keys if ii[0:2]=='WK']
+
+	
+	labclass=[]
+	mags=[]
+	lons=[]
+	lats=[]
+	for ii in range(len(keys)):
+		idx=keys[ii]
+		keywords=list(f.get(idx).keys())
+# 		print(keywords[-1])
+		yesno=f.get(idx).get('Label_EV').attrs['yesno']
+		
+		if yesno=='yes':
+			labclass.append(1)
+			mags.append(f.get(idx).get('Label_EV').attrs['ev_magnitude'])
+			lons.append(f.get(idx).get('Label_EV').attrs['ev_longitude'])
+			lats.append(f.get(idx).get('Label_EV').attrs['ev_latitude'])
+		else:
+			labclass.append(0)
+			mags.append(0)
+			lons.append(0)
+			lats.append(0)
+
+	weeks=[17,18,20,23] 
+	#In these weeks, event from China's catalog is removed due to the remoteness from nearest AETA stations
+	for iweek in weeks:
+		labclass[iweek-1]=0
+		mags[iweek-1]=0
+		lons[iweek-1]=0
+		lats[iweek-1]=0
+	
+	if mode=='occurence':
+		return labclass
+	elif mode=='magnitude':
+		return mags
+	elif mode=='location':
+		return [(lons[ii],lats[ii]) for ii in range(len(lons))]
+	else:
+		return labclass
+		
+		
+
+	

geofwi-0.0.0.1/geofwi.egg-info/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.1
+Name: geofwi
+Version: 0.0.0.1
+Summary: GeoFWI: A lightweight velocity model dataset for benchmarking full waveform inversion using deep learning
+Home-page: https://github.com/aaspip/geofwi
+Author: geofwi developing team
+Author-email: chenyk2016@gmail.com
+License: MIT License
+Keywords: seismology,seismic imaging,computational seismology,AI for science
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: Unix
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: License :: OSI Approved :: MIT License
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: matplotlib
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: ipython; extra == "docs"
+Requires-Dist: runipy; extra == "docs"
+
+Source code: https://github.com/aaspip/geofwi

geofwi-0.0.0.1/geofwi.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+setup.py
+data/data.jsonl
+data/geofwi-size-layer-fault-salt-1-10.npy
+demos/test_quick_visualize.py
+geofwi/__init__.py
+geofwi/acc.py
+geofwi/plot.py
+geofwi/utils.py
+geofwi.egg-info/PKG-INFO
+geofwi.egg-info/SOURCES.txt
+geofwi.egg-info/dependency_links.txt
+geofwi.egg-info/not-zip-safe
+geofwi.egg-info/requires.txt
+geofwi.egg-info/top_level.txt
+notebooks/README.md

geofwi-0.0.0.1/geofwi.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

geofwi-0.0.0.1/geofwi.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

geofwi-0.0.0.1/geofwi.egg-info/requires.txt

@@ -0,0 +1,8 @@
+numpy
+scipy
+matplotlib
+
+[docs]
+sphinx
+ipython
+runipy

geofwi-0.0.0.1/geofwi.egg-info/top_level.txt

@@ -0,0 +1 @@
+geofwi

geofwi-0.0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

geofwi-0.0.0.1/setup.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python
+# -*- encoding: utf8 -*-
+# import glob
+# import inspect
+# import io
+# import os
+
+from setuptools import setup
+import numpy
+long_description = """
+Source code: https://github.com/aaspip/geofwi""".strip() 
+
+
+def read(*names, **kwargs):
+    return io.open(
+        os.path.join(os.path.dirname(__file__), *names),
+        encoding=kwargs.get("encoding", "utf8")).read()
+
+# from numpy.distutils.core import setup 
+setup(
+    name="geofwi",
+    version="0.0.0.1",
+    license='MIT License',
+    description="GeoFWI: A lightweight velocity model dataset for benchmarking full waveform inversion using deep learning",
+    long_description=long_description,
+    author="geofwi developing team",
+    author_email="chenyk2016@gmail.com",
+    url="https://github.com/aaspip/geofwi",
+    packages=['geofwi'],
+    include_package_data=True,
+    zip_safe=False,
+    classifiers=[
+        # complete classifier list:
+        # http://pypi.python.org/pypi?%3Aaction=list_classifiers
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "Intended Audience :: Science/Research",
+        "Operating System :: Unix",
+        "Operating System :: POSIX",
+        "Operating System :: Microsoft :: Windows",
+        "Programming Language :: Python",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: Implementation :: CPython",
+        "Topic :: Scientific/Engineering",
+        "Topic :: Scientific/Engineering :: Physics",
+        "License :: OSI Approved :: MIT License"
+    ],
+    keywords=[
+        "seismology", "seismic imaging", "computational seismology", "AI for science"
+    ],
+    install_requires=[
+        "numpy", "scipy", "matplotlib"
+    ],
+    extras_require={
+        "docs": ["sphinx", "ipython", "runipy"]
+    }
+)