segyio
# Version 1.9.12
La documentación oficial está alojada en readthedocs.
Segyio es una pequeña biblioteca C con licencia LGPL para una fácil interacción con datos sísmicos formateados SEG-Y y Seismic Unix, con enlaces de lenguaje para Python y Matlab. Segyio es un intento de crear una biblioteca fácil de usar, integrable y orientada a la comunidad para aplicaciones sísmicas. Las funciones se agregan a medida que se necesitan; Se aceptan sugerencias y aportaciones de todo tipo.
Para ponerse al día con los últimos desarrollos y funciones, consulte el registro de cambios. Para escribir código a prueba de futuro, consulte los cambios importantes planificados.
Cuando segyio esté construido e instalado, ¡estará listo para comenzar a programar! Consulte el tutorial, los ejemplos, los programas de ejemplo y los cuadernos de ejemplo. Para obtener una referencia técnica con ejemplos y pequeñas recetas, lea los documentos. Los documentos API también están disponibles con pydoc: inicie su intérprete de Python favorito y escriba help(segyio) , que debería integrarse bien con IDLE, pycharm y otras herramientas de Python.
import segyio
import numpy as np
with segyio . open ( 'file.sgy' ) as f :
for trace in f . trace :
filtered = trace [ np . where ( trace < 1e-2 )]Vea los ejemplos para más.
Una copia de segyio está disponible como binarios prediseñados y como código fuente:
apt install python3-segyiopip install segyiogit clone https://github.com/statoil/segyioPara construir segyio necesitas:
Para construir la documentación, también necesitas Sphinx.
Para compilar e instalar segyio, realice las siguientes acciones en su consola:
git clone https://github.com/equinor/segyio
mkdir segyio/build
cd segyio/build
cmake .. -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=ON
make
make install make install debe realizarse como root para una instalación del sistema; si desea instalar en su directorio de inicio, agregue -DCMAKE_INSTALL_PREFIX=~/ o algún otro directorio apropiado, o make DESTDIR=~/ install . Asegúrese de que su entorno admita ubicaciones de instalación no estándar (PYTHONPATH, LD_LIBRARY_PATH y PATH).
Si tiene varias instalaciones de Python o desea utilizar algún intérprete alternativo, puede ayudar a cmake a encontrar el correcto pasando -DPYTHON_EXECUTABLE=/opt/python/binary junto con el prefijo de instalación y el tipo de compilación.
Para crear los enlaces de Matlab, invoque CMake con la opción -DBUILD_MEX=ON . En algunos entornos, los binarios de Matlab se encuentran en una ubicación no estándar, en cuyo caso debe ayudar a CMake a encontrar los binarios de Matlab pasando -DMATLAB_ROOT=/path/to/matlab .
Se recomienda compilar en modo de depuración para obtener más advertencias e incrustar símbolos de depuración en los objetos. Sustituir Debug por Release en CMAKE_BUILD_TYPE es suficiente.
Las pruebas se encuentran en los directorios de idioma/pruebas, y se recomienda encarecidamente que se demuestre la corrección y el contrato de las nuevas características agregadas agregando una prueba. Todas las pruebas se pueden ejecutar invocando ctest . No dude en utilizar las pruebas ya escritas como guía.
Después de compilar segyio, puedes ejecutar las pruebas con ctest , ejecutado desde el directorio de compilación.
Tenga en cuenta que para ejecutar los ejemplos de Python debe informar a su entorno dónde encontrar la biblioteca de Python. Se puede instalar como usuario o agregando la biblioteca segyio/build/python a su pythonpath.
Todo el código de este tutorial supone que segyio se importa y que numpy está disponible como np.
import segyio
import numpy as npEste tutorial asume que estás familiarizado con Python y numpy. Para actualizar, consulte el tutorial de Python y el inicio rápido de numpy.
La apertura de un archivo para lectura se realiza con la función segyio.open y se usa idiomáticamente con administradores de contexto. Al utilizar la instrucción with , los archivos se cierran correctamente incluso en el caso de excepciones. De forma predeterminada, los archivos se abren en modo de sólo lectura.
with segyio . open ( filename ) as f :
... Open acepta varias opciones (para obtener una referencia más completa, consulte la cadena de documentación de la función open con help(segyio.open) . La opción más importante es el segundo argumento posicional (opcional). Para abrir un archivo para escribir, haga segyio.open(filename, 'r+') , de la función fopen de C.
Los archivos se pueden abrir en modo no estructurado , ya sea pasando segyio.open los argumentos opcionales strict=False , en cuyo caso no establecer la estructura (números en línea, números entre líneas, etc.) no es un error, e ignore_geometry=True , en cuyo caso segyio Ni siquiera intentará establecer estos atributos internos.
El objeto de archivo segy tiene varios atributos públicos que describen esta estructura:
f.ilines Números en línea inferidosf.xlines Números de líneas cruzadas inferidosf.offsets Números de compensaciones inferidasf.samples Compensaciones de muestra inferidas (frecuencia y retardo de tiempo de grabación)f.unstructured Verdadero si no está estructurado, Falso si está estructuradof.ext_headers El número de encabezados textuales extendidos Si el archivo se abre sin estructura , todas las propiedades de la línea serán None .
En segyio, los datos se recuperan y escriben mediante los llamados modos . Los modos son matrices abstractas o esquemas de direccionamiento y cambian el significado de los nombres e índices. Todos los modos son propiedades en el objeto de identificador de archivos, admiten la función len y las lecturas y escrituras se realizan a través de f.mode[] . Las escrituras se realizan con la tarea. Los modos admiten la división de matrices inspirada en numpy. Están disponibles los siguientes modos:
trace
El modo de seguimiento ofrece direccionamiento sin formato de los seguimientos tal como están dispuestos en el archivo. Este, junto con header , es el único modo disponible para archivos no estructurados. Las trazas se enumeran 0..len(f.trace) .
Leer un rastro produce un ndarray numpy y leer múltiples rastros produce un generador de ndarray s. Se utiliza la semántica del generador y se reutiliza el mismo objeto, por lo que si desea almacenar en caché o abordar los datos de seguimiento más adelante, debe copiarlos explícitamente.
> >> f . trace [ 10 ]
> >> f . trace [ - 2 ]
> >> f . trace [ 15 : 45 ]
> >> f . trace [: 45 : 3 ] header
Con un comportamiento de direccionamiento similar al trace , el acceso a elementos genera objetos de encabezado en lugar de numerosos ndarray . Los encabezados son objetos tipo dict, donde las claves son números enteros, claves sísmicas de estilo Unix (en el módulo segyio.su) y enumeraciones segyio (segyio.TraceField).
Los valores del encabezado se pueden actualizar asignándole un dict similar, y las claves que no están presentes en el lado derecho de la asignación no se modifican .
> >> f . header [ 5 ] = { segyio . su . tracl : 10 }
> >> f . header [ 5 ]. items ()
> >> f . header [ 5 ][ 25 , 37 ] # read multiple values at once iline , xline
Estos modos generarán un error si el archivo no está estructurado. Consideran los argumentos de [] como las claves de las líneas respectivas. Los números de línea siempre aumentan, pero pueden tener espacios arbitrarios y desiguales. Los nombres válidos se pueden encontrar en las propiedades ilines y xlines .
Al igual que con las trazas, obtener una línea produce un ndarray y un segmento de líneas produce un generador de ndarray s. Cuando se utilizan sectores con un paso, es posible que se omitan algunos elementos intermedios si el paso no coincide, es decir, al hacer f.line[1:10:3] en un archivo con líneas [1,2,3,4,5] es equivalente a buscar 1, 4, 7 y encontrar [1,4] .
Cuando se trabaja con un archivo preapilado 4D, el primer desplazamiento se lee implícitamente. Para acceder a compensaciones diferentes o a un rango de ellas, utilice índices o rangos separados por comas, como por ejemplo: f.iline[120, 4] .
fast , slow
Estos son alias para iline y xline , determinados por cómo se distribuyen las trazas. Para archivos ordenados en línea, fast produciría iline .
depth_slice
El corte de profundidad es un corte horizontal de toda la lima y en profundidad. Los valores obtenidos son ndarray sy generadores de matrices.
gather
La gather es la intersección de una línea en línea y una línea cruzada, una columna vertical de la encuesta y, a menos que se especifique un único desplazamiento, devuelve un desplazamiento x muestras ndarray . En presencia de rangos, devuelve un generador de dichos ndarray .
text
El modo text es una matriz de encabezados textuales, donde text[0] es el encabezado textual obligatorio estándar y 1..n son los encabezados extendidos opcionales.
Los encabezados de texto se devuelven como blobs similares a bytes de 3200 bytes tal como están en el archivo. La función segyio.tools.wrap puede crear una versión orientada a líneas de esta cadena.
bin
Los valores del encabezado binario de todo el archivo con una interfaz tipo dict. Se comporta como el modo header , pero sin indexación.
> >> for line in f . iline [: 2430 ]:
... print ( np . average ( line ))
> >> for line in f . xline [ 2 : 10 ]:
... print ( line )
> >> for line in f . fast [:: 2 ]:
... print ( np . min ( line ))
> >> for factor , offset in enumerate ( f . iline [ 10 , :]):
... offset *= factor
print ( offset )
> >> f . gather [ 200 , 241 , :]. shape
> >> text = f . text [ 0 ]
> >> type( text )
< type 'bytes' >
> >> f . trace [ 10 ] = np . zeros ( len ( f . samples )) Se pueden encontrar más ejemplos y recetas en la help(segyio) y en la sección de ejemplos.
Segyio no necesariamente intenta ser el fin de todas las interacciones SEG-Y; más bien, nuestro objetivo es reducir la barrera para interactuar con archivos SEG-Y para incrustarlos, nuevas aplicaciones o programas independientes.
Además, el objetivo no es admitir todos los archivos formateados estándar o exóticos (pero compatibles con el estándar) que existen. Se hacen algunas suposiciones, tales como:
Actualmente, segyio admite:
La funcionalidad de escritura en segyio está destinada principalmente a modificar o adaptar archivos. Un archivo creado desde cero no es necesariamente un archivo SEG-Y según las especificaciones, ya que solo escribimos necesariamente los campos de encabezado que Segyio necesita para entender la geometría. Todavía se recomienda encarecidamente que los archivos SEG-Y se mantengan y escriban de acuerdo con las especificaciones, pero segyio no exige esto.
Segyio puede manejar muchos archivos similares a SEG-Y, es decir, segyio maneja archivos que no se ajustan estrictamente al estándar SEG-Y. Segyio tampoco discrimina entre las revisiones, sino que intenta utilizar la información disponible en el archivo. Para una referencia actual de la norma, consulte las publicaciones de la SEG:
Damos la bienvenida a todo tipo de contribuciones; por favor consulte CONTRIBUTING.md.
xarrayAlan Richardson ha escrito una pequeña herramienta excelente para usar xarray con archivos segy, que muestra en este cuaderno.
Se incluyen pequeños archivos con formato SEG-Y en el repositorio para fines de prueba. Los datos no tienen sentido y están hechos para ser predecibles, y son reproducibles mediante el uso de segyio. El archivo de pruebas se encuentra en el directorio de datos de prueba. Para reproducir el archivo de datos, compila segyio y ejecuta el programa de prueba make-file.py , make-ps-file.py y make-rotated-copies.py como tales:
python examples / make - file . py small . sgy 50 1 6 20 25
python examples / make - ps - file . py small - ps . sgy 10 1 5 1 4 1 3
python examples / make - rotated - copies . py small . sgyEl archivo small-lsb.sgy se creó ejecutando el programa flip-endianness. Este programa está incluido en el árbol fuente de segyio, pero no forma parte del paquete y no está diseñado para distribución e instalación, solo para reproducir archivos de prueba.
Los archivos sísmicos de Unix Small.su y Small-lsb.su fueron creados mediante los siguientes comandos:
segyread tape=small.sgy ns=50 remap=tracr,cdp byte=189l,193l conv=1 format=1
> small-lsb.su
suswapbytes < small.su > small-lsb.suSi tiene archivos de datos pequeños con una licencia gratuita, ¡no dude en enviarlos al proyecto!
Importar bibliotecas útiles:
import segyio
import numpy as np
from shutil import copyfileAbra el archivo segy e inspecciónelo:
filename = 'name_of_your_file.sgy'
with segyio . open ( filename ) as segyfile :
# Memory map file for faster reading (especially if file is big...)
segyfile . mmap ()
# Print binary header info
print ( segyfile . bin )
print ( segyfile . bin [ segyio . BinField . Traces ])
# Read headerword inline for trace 10
print ( segyfile . header [ 10 ][ segyio . TraceField . INLINE_3D ])
# Print inline and crossline axis
print ( segyfile . xlines )
print ( segyfile . ilines )Lea el cubo de datos posterior a la pila contenido en el archivo segy:
# Read data along first xline
data = segyfile . xline [ segyfile . xlines [ 1 ]]
# Read data along last iline
data = segyfile . iline [ segyfile . ilines [ - 1 ]]
# Read data along 100th time slice
data = segyfile . depth_slice [ 100 ]
# Read data cube
data = segyio . tools . cube ( filename )Lea el cubo de datos previo a la pila contenido en el archivo segy:
filename = 'name_of_your_prestack_file.sgy'
with segyio . open ( filename ) as segyfile :
# Print offsets
print ( segyfile . offset )
# Read data along first iline and offset 100: data [nxl x nt]
data = segyfile . iline [ 0 , 100 ]
# Read data along first iline and all offsets gath: data [noff x nxl x nt]
data = np . asarray ([ np . copy ( x ) for x in segyfile . iline [ 0 : 1 , :]])
# Read data along first 5 ilines and all offsets gath: data [noff nil x nxl x nt]
data = np . asarray ([ np . copy ( x ) for x in segyfile . iline [ 0 : 5 , :]])
# Read data along first xline and all offsets gath: data [noff x nil x nt]
data = np . asarray ([ np . copy ( x ) for x in segyfile . xline [ 0 : 1 , :]])Leer y comprender datos bastante "no estructurados" (por ejemplo, datos ordenados en tomas comunes):
filename = 'name_of_your_prestack_file.sgy'
with segyio . open ( filename , ignore_geometry = True ) as segyfile :
segyfile . mmap ()
# Extract header word for all traces
sourceX = segyfile . attributes ( segyio . TraceField . SourceX )[:]
# Scatter plot sources and receivers color-coded on their number
plt . figure ()
sourceY = segyfile . attributes ( segyio . TraceField . SourceY )[:]
nsum = segyfile . attributes ( segyio . TraceField . NSummedTraces )[:]
plt . scatter ( sourceX , sourceY , c = nsum , edgecolor = 'none' )
groupX = segyfile . attributes ( segyio . TraceField . GroupX )[:]
groupY = segyfile . attributes ( segyio . TraceField . GroupY )[:]
nstack = segyfile . attributes ( segyio . TraceField . NStackedTraces )[:]
plt . scatter ( groupX , groupY , c = nstack , edgecolor = 'none' )Escriba un archivo segy usando el mismo encabezado de otro archivo pero multiplique los datos por *2
input_file = 'name_of_your_input_file.sgy'
output_file = 'name_of_your_output_file.sgy'
copyfile ( input_file , output_file )
with segyio . open ( output_file , "r+" ) as src :
# multiply data by 2
for i in src . ilines :
src . iline [ i ] = 2 * src . iline [ i ]Crear archivo segy desde sctrach
filename='name_of_your_file.sgy'
% Inspect segy
Segy_struct=SegySpec(filename,189,193,1);
% Read headerword inline for each trace
Segy.get_header(filename,'Inline3D')
%Read data along first xline
data= Segy.readCrossLine(Segy_struct,Segy_struct.crossline_indexes(1));
%Read cube
data=Segy.get_cube(Segy_struct);
%Write segy, use same header but multiply data by *2
input_file='input_file.sgy';
output_file='output_file.sgy';
copyfile(input_file,output_file)
data = Segy.get_traces(input_file);
data1 = 2*data;
Segy.put_traces(output_file, data1);
Muy a menudo surgen problemas en los que alguien tiene problemas con el rendimiento de segyio, en particular al crear nuevos archivos. El culpable suele ser este código:
with segyio.create('new.sgy', spec) as dst:
dst.header = headers
El código en sí está perfectamente bien, pero tiene un comportamiento sutil en algunos sistemas cuando el archivo se crea recientemente: realiza muchas escrituras dispersas en un archivo disperso. Esto puede ser rápido o lento, dependiendo en gran medida del sistema de archivos.
Vuelva a escribir el bucle para escribir en el archivo de forma contigua:
with segyio.create('new.sgy', spec) as dst:
for i in range(spec.tracecount):
dst.header[i] = headers[i]
dst.trace[i] = traces[i]
Si el archivo es una copia modificada de otro archivo, sin cambiar la longitud del seguimiento, a menudo es más rápido (¡y más fácil!) copiar primero el archivo sin segyio y luego usar segyio para modificar la copia in situ:
shutil.copyfile(srcfile, dstfile)
with segyio.open(dstfile) as f:
f.header = headers
Este error aparece cuando el cargador no puede encontrar la biblioteca principal de Segyio. Si ha configurado explícitamente el prefijo de instalación (con -DCMAKE_INSTALL_PREFIX ), debe configurar su cargador para que también busque este prefijo, ya sea con un archivo ld.conf.d o la variable LD_LIBRARY_PATH .
Si no ha configurado CMAKE_INSTALL_PREFIX , cmake se instalará de forma predeterminada en /usr/local , que su cargador generalmente conoce. En los sistemas basados en Debian, la biblioteca a menudo se instala en /usr/local/lib , lo que es posible que el cargador no conozca. Consulte el número 239.
sudo ldconfig a menudo funciona)-DCMAKE_INSTALL_LIBDIR=lib64Esta excepción se genera cuando segyio intenta abrir el en modo estricto, bajo el supuesto de que el archivo es un volumen 3D ordenado y normal. Si el archivo es sólo una colección de rastros en orden arbitrario, esto fallaría.
Compruebe si los parámetros de entrada segyio.open iline y xline son correctos para el archivo actual. Segyio también admite archivos que son solo una colección de rastros, pero se le debe informar que está bien hacerlo. Pase strict = False o ignore_geometry = True a segyio.open para permitir o forzar el modo no estructurado respectivamente. Tenga en cuenta que f.iline y funciones similares ahora están deshabilitadas y generarán errores.
Segyio fue escrito inicialmente y es mantenido por Equinor ASA como una forma gratuita, simple y fácil de usar de interactuar con datos sísmicos que se pueden adaptar a nuestras necesidades y como contribución a la comunidad de software libre.
