Script language oriented earthquake batch job editing method and device

Abstract

The application provides a script language-oriented seismic batch processing job editing method and device, including obtaining seismic job requirements to be processed, determining seismic job items and database information; initializing each module object in a previously established seismic batch processing job framework, the framework being a script language framework including a preset core library, a module library and a tool chain; determining standard type parameters corresponding to each module object; initializing a job topology structure of the seismic batch processing job framework; based on the seismic job items and the database information, selecting target module objects and adding them to target jobs; outputting a topology graph of a module according to debugging needs, and generating target jobs corresponding to seismic job requirements by calling an XML format file. The application edits a seismic batch processing job framework by facing a script language, realizes seamless connection between job editing and code editing, is more flexible and efficient, and meets diversified needs of users in editing jobs by using a script programming language.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of scripting editing and execution framework of seismic batch processing operation in geophysical exploration, and particularly relates to a seismic batch processing operation editing method and device for a scripting language. BACKGROUND

[0002] For the development of geophysical exploration software based on a scripting language such as Python, the batch processing development technology and framework of GeoEast software specifically involves the Python scripting editing function of seismic batch processing operation. Specifically, GeoEast V2021 is based on a new iEco platform, integrates 961 function modules, and has more than 30 million lines of code, which can meet the needs of seismic processing and interpretation from land to sea, from P-wave to multi-wave, from surface to well, has the full-process integrated service capability from time domain to depth domain, from project level to basin level, from data processing to reservoir description, and has passed the qualification certification of multiple international oil companies, becoming one of the three major mainstream geophysical exploration software in the world.

[0003] In the prior art, the traditional editing of seismic batch processing operation completely depends on the editor based on interface interaction of the operation, please refer to Figure 1 This editor has the advantages of simple operation and easy to use, and guides the user to input the specified parameters through interaction, however, the editor has the disadvantages of poor flexibility and low efficiency, especially for users who understand the scripting programming language, and cannot reflect the advantages of professional technical personnel in operation batch processing. Specifically, the traditional editing of seismic batch processing operation has the following defects:

[0004] 1. Model coupling barrier, the traditional operation editor adopts an event-driven GUI architecture, and all parameter configurations are completed through interface components, resulting in: ① the model cannot directly parse the interface state to obtain parameter semantic information; ② it is difficult to realize AI-assisted operation generation and optimization.

[0005] 2. Logic expression limitation, the traditional operation editing only supports linear parameter configuration, and cannot realize: ① dynamic condition branching (such as automatically selecting a preprocessing process according to a work area type); ② loop iteration processing (such as batch processing of multi-line data); ③ complex data conversion logic (such as dynamic generation of trace header character mapping rules).

[0006] 3. Low-efficiency parameter reuse, module parameters are stored in a flattened manner in the operation file, resulting in: ① cross-operation parameter reuse needs to be imported and exported through a file, which is high in operation cost; ② parameter changes need to be manually synchronized to all related operations, which is difficult to maintain; ③ it is impossible to realize parameter version management and change tracking; ④ it is impossible to realize parameter or module level customization and sharing (derivation of custom parameter or module pool).

[0007] 4. Dynamic check missing, existing check only supports: ① numerical type check (such as floating point type parameter input string); ② simple dependency relationship (such as parameter A exists, parameter B must be non-empty); ③ cannot support dynamic business rules (for example: before the job starts to execute, dynamically check the validity of the seismic data, the validity of the parameter dependency, etc.), which can expose the problems of the job parameters before the job is executed, improve the quality of the job, and improve the work efficiency.

[0008] 5. Operation and maintenance expansion is insufficient, and job execution depends on job scheduling: ① cannot dynamically send jobs according to the resources required by the job; ② failed jobs need to be manually located to analyze the reasons, and cannot form a summary document; ③ cannot automatically complete job retry and timed sending.

[0009] In summary, in seismic processing, for complex situations, the traditional job editing method lacks flexibility and is low in efficiency, and it is difficult to develop a job editing method combined with the diversified needs of various users, which greatly limits the application of large language models in seismic batch job editing. Therefore, the present application provides a solution for seismic batch job editing to solve the problems in the prior art. SUMMARY

[0010] The present application shows a seismic batch job editing method and device for a scripting language.

[0011] In a first aspect, the present application shows a seismic batch job editing method for a scripting language, which comprises:

[0012] Obtaining the seismic job requirements to be processed, determining the seismic job project and database information according to the seismic job requirements;

[0013] Initializing each module object in the pre-established seismic batch job framework, the seismic batch job framework being a scripting language framework including a preset core library, a module library and a tool chain;

[0014] Determining the standard type parameters corresponding to each module object, the standard type parameters being standard types set in advance for each parameter;

[0015] Initializing the job topology structure of the seismic batch job framework;

[0016] Based on the seismic job project and the database information, selecting target module objects from the seismic batch job framework and adding them to the target job;

[0017] Outputting the topology graph of the module according to the debugging needs, and generating the target job corresponding to the seismic job requirements by calling the XML format file.

[0018] Preferably, before the step of obtaining the seismic operation requirements to be processed, determining the seismic operation project and database information according to the seismic operation requirements, the method further comprises:

[0019] Defining a standard header word class, reading all header words in a standard header word file into memory using a header word generation tool, and formatting and outputting a Python file; the attributes of the standard header word class at least include: name, number, attention, type, display, and description.

[0020] Preferably, before the step of obtaining the seismic operation requirements to be processed, determining the seismic operation project and database information according to the seismic operation requirements, the method further comprises:

[0021] Defining a PDL parameter constant class, converting a PDL file into a Python type PDL object using a PDL parsing tool, the parameter constant at least includes: a label and an attribute in the PDL file, and the PDL object at least includes module, parameter, parameter set, and parameter dependency information;

[0022] Using the Python type PDL object as input, generating a module class from a module base class using a PDL generation tool, writing all module information into a module object and a plurality of parameter classes, each parameter of the plurality of parameter classes being generated from a parameter base class, and writing parameter information according to parameter type and parameter value, to generate a target module file corresponding to the target module object.

[0023] Preferably, the core library comprises a parameter system unit, a dependency management unit, a module model unit, and a job management unit;

[0024] The parameter system unit defines a parameter base class and a module base class, supports type checking, value range constraint, and parameter value automatic conversion functions;

[0025] The dependency management unit establishes logical association between parameters through a GEDependency class, and supports dynamic dependency relationship analysis;

[0026] The module model unit encapsulates input and output channels, parameter sets, and job segment generation interfaces according to the module base class, and supports chain connection between modules;

[0027] The job management unit integrates job metadata management, topology generation, and XML output functions according to a GEJob class, and supports multi-module combination and arrangement.

[0028] Preferably, the module library comprises:

[0029] The batch module in the GeoEast environment comprises a module class derived from a module base class GEModule and a plurality of parameter classes derived from a parameter base class GEParameter in a Python file of each module, and initial value data of the module and the parameters are obtained from a module PDL file.

[0030] Preferably, the module library comprises:

[0031] The GeoEast module description file is automatically converted into a Python file module by a tool chain, parameter definitions are kept consistent with semantics of the original module, PDL parameter types are mapped to types of Python data structures, and a type hint function of an intelligent editor is supported, and each module is exported in the form of a Python module package.

[0032] Preferably, the tool chain comprises: a standard header generation tool, a batch module generation tool, and a PDL analysis tool.

[0033] The standard header generation tool inputs a standard header file, automatically generates a header module, and outputs the header module to a core library directory by default, thereby supporting quick query and reference of header properties.

[0034] The batch module generation tool inputs a batch module PDL file, automatically generates a Python version of the module file, and outputs the module file to a module library directory by default.

[0035] The PDL analysis tool analyzes a PDL file and outputs the PDL file as a Python object of PDL.

[0036] In a second aspect, the present application shows a script language-oriented seismic batch processing job editing device, which comprises:

[0037] A seismic job requirement determination unit is configured to obtain a seismic job requirement to be processed, and determine a seismic job item and database information according to the seismic job requirement.

[0038] A framework module initialization unit is configured to initialize each module object in a pre-established seismic batch processing job framework, wherein the seismic batch processing job framework is a script language framework comprising a preset core library, a module library, and a tool chain.

[0039] A module parameter determination unit is configured to determine a standard type parameter corresponding to each module object, wherein the standard type parameter is a standard type set in advance for each parameter.

[0040] A topological structure initialization unit is configured to initialize a job topological structure of the seismic batch processing job framework.

[0041] a target module selection unit, configured to select a target module object from the seismic batch processing job framework based on a seismic operation project and database information, and add the target module object to a target job;

[0042] a target job generation unit, configured to output a topology graph of a debugging required output module, and generate a target job corresponding to the seismic operation requirement by calling an XML format file.

[0043] In a third aspect, the present application shows an electronic device, comprising: a processor; a memory for storing processor-executable instructions; wherein the processor is configured to execute the method according to any one of the preceding aspects.

[0044] In a fourth aspect, the present application shows a non-transitory computer-readable storage medium, when the instructions in the storage medium are executed by a processor of an electronic device, the electronic device can execute the method according to any one of the preceding aspects.

[0045] In a fifth aspect, the present application shows a computer program product, when the instructions in the computer program product are executed by a processor of an electronic device, the electronic device can execute the method according to any one of the preceding aspects.

[0046] The technical scheme provided by the present application can include the following beneficial effects:

[0047] The present application realizes efficient editing of a seismic batch processing job framework for Python, replaces the traditional job editing mode based on an interface with a job editing mode based on a programming language, fills the gap in traditional batch job editing, supplements and enhances the function of existing batch job editing, can support editing of a Python script language, seamlessly connects job editing and code editing, makes job editing more flexible and efficient, meets the diversified needs of users who master the Python programming language for self-defined job editing, and lays a solid foundation for subsequent application of job editing in a large model. BRIEF DESCRIPTION OF DRAWINGS

[0048] Figure 1 FIG. 1 is a schematic diagram of a seismic batch processing job editing method based on traditional interactive software;

[0049] Figure 2 FIG. 4 is a flowchart of a seismic batch processing job editing method for a script language provided by the present application;

[0050] Figure 3 FIG. 6 is a schematic diagram of a principle of a tool chain provided by the present application for translating a GeoEast standard trace header word and a PDL file into a Python script module;

[0051] Figure 4 A flow chart of a seismic operation editing based on a Python language is provided in the present application;

[0052] Figure 5 A module parameter representation intention of a seismic batch operation editing method based on a traditional interactive software is provided;

[0053] Figure 6 An interactive interface schematic diagram of a seismic batch operation editing method based on a traditional interactive software is provided;

[0054] Figure 7 A script language schematic diagram of a seismic operation editing based on a Python language is provided in the present application;

[0055] Figure 8 A structure diagram of a seismic batch operation editing device facing a script language is provided in the present application;

[0056] Figure 9 A block diagram of an electronic device is provided in the present application;

[0057] Figure 10 A block diagram of another electronic device is provided in the present application. DETAILED DESCRIPTION

[0058] The technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the drawings in the embodiments of the present application. Obviously, the described embodiments are some of the embodiments of the present application, rather than all the embodiments of the present application. Based on the embodiments in the present application, all other embodiments obtained by those of ordinary skill in the art without creative labor fall within the scope of protection of the present application.

[0059] The Python framework is a framework that has encapsulated the basic code in advance and provided a corresponding API (Application Programming Interface). In this way, the developer can directly call the encapsulated API when using the framework, which can improve work efficiency and development speed. Generally, the correct selection of the Python framework mainly depends on the project size, communication requirements, whether it is a standalone application, the level of customization requirements, overhead and many other factors.

[0060] It should be noted that the following embodiments are described by taking the Python language as an example, but the script language mentioned in the present application is not limited to the Python language, but can also be other script programming languages, such as Lua / JavaScript / Json / Yaml, etc.

[0061] The seismic batch operation editing method facing the script language will be described below. Embodiments

[0062] Referring to Figure 2 A flowchart of a script language oriented seismic batch job editing method provided in the present application can be applied in an electronic device, wherein the method can specifically include the following steps:

[0063] Step S101: Obtain a seismic job requirement to be processed, and determine a seismic job item and database information according to the seismic job requirement.

[0064] Step S102: Initialize each module object in a pre-established seismic batch job framework, wherein the seismic batch job framework is a script language framework including a preset core library, a module library and a tool chain.

[0065] Step S103: Determine a standard type parameter corresponding to each module object, wherein the standard type parameter is a standard type set in advance for each parameter. Specifically, a corresponding parameter is specified for each module, and each parameter has a standard type, and if a smart editor such as VSCode is used, a type description will be prompted.

[0066] Step S104: Initialize a job topology structure of the seismic batch job framework. For example, A.preceed(B) indicates A->B, that is, the A module is followed by the B module.

[0067] Step S105: Select a target module object from the seismic batch job framework based on the seismic job item and the database information, and add the target module object to a target job.

[0068] Step S106: Output a topology graph of a module according to debugging needs, and generate a target job corresponding to the seismic job requirement by calling an XML format file.

[0069] Further, as shown in Figure 3 Before step S101, the method can further include: defining a standard header word class, using a header word generation tool (for example, genHeaderWords.py) to read all header words in a standard header word file (for example, geoeastSTD.header) into a memory, and formatting and outputting the header words into a Python file (for example, stdHeaderWords.py); and attributes of the standard header word class at least include: name, number, attention, type, display and description. In one case, all header words can be defined, and each header word corresponds to a HeaderWord type.

[0070] Further, as shown in Figure 3As shown, before step S101, it can also include: defining a PDL parameter constant class (for example, pdlConstants.py), converting a PDL file into a Python type PDL object using a PDL parsing tool (for example, pdlParser.py), the parameter constant at least including: a label and an attribute in the PDL file, the PDL object at least including module, parameter, parameter set and parameter dependency information; using the Python type PDL object as input, generating a module class from a module base class using a PDL generation tool (for example, pdlParser.py), writing all module information into a module object and a plurality of parameter classes, each parameter of the plurality of parameter classes being generated from a parameter base class, and writing parameter information according to parameter type and parameter value, generating a target module file corresponding to the target module object. For example, the original module file name is abset.pdl, and the output Python module file is abset.py.

[0071] In an implementation manner, the core library includes a parameter system unit, a dependency management unit, a module model unit and a job management unit; the parameter system unit defines a parameter base class (GEParameter) and a module base class (GEModule), supports type checking, value range constraint, parameter value automatic conversion and the like. Further, complex parameter types such as a selection type (GESelectType) and a matrix type (GEMatrixType) are extended and supported; the dependency management unit establishes logical association between parameters through a GEDependency class, and supports dynamic dependency relationship analysis; the module model unit encapsulates input and output channels, parameter sets and job segment generation interfaces according to the module base class (GEModule), and supports chain connection between modules; and the job management unit integrates job metadata management, topology graph generation and XML output functions according to a GEJob class, and supports multi-module combination arrangement.

[0072] In an implementation manner, the module library contains batch processing modules in a GeoEast environment, a module class derived from a module base class GEModule and a plurality of parameter classes derived from a parameter base class GEParameter are contained in a Python file of each module, and initial value data of the module and the parameters are obtained from a module PDL file.

[0073] Further, the module library automatically converts a GeoEast module description file (.pdl) into a Python file module through a tool chain, keeps parameter definition consistent with semantics of an original module, maps PDL parameter types to types of Python data structures, supports type hinting function of an intelligent editor, and each module is exported in a form of a Python module package.

[0074] In an implementation manner, the tool chain comprises: a standard header word generation tool, a batch module generation tool, and a PDL analysis tool; the standard header word generation tool inputs a standard header word file (geoeastSTD.header), automatically generates a header word module, and outputs to a core library directory by default, supports quick query and reference of header word attributes; the batch module generation tool inputs a batch module PDL file, automatically generates a module file in a Python version, and outputs to a module library directory by default; and the PDL analysis tool analyzes a PDL file and outputs the PDL file as a Python object of PDL.

[0075] The application realizes efficient editing of a seismic batch processing job framework for Python, replaces a traditional job editing mode based on an interface with a job editing mode based on a programming language, fills the gap in traditional batch job editing, supplements and enhances the function of existing batch job editing, can support editing of a Python script language, seamlessly connects job editing and code editing, makes job editing more flexible and efficient, meets the diversified needs of users who master the Python programming language for self-defined job editing, and lays a solid foundation for subsequent application of job editing in a large model.

[0076] The seismic batch processing job editing method for a script language provided by the application is described in detail below taking the Python script language as an example, please refer to Figure 3 and Figure 4 Compared with traditional job editing, the application eliminates frequent operations of a graphical interface, and first prepares a basic environment for job editing by using the tool set of the application.

[0077] The core idea of the framework is to use existing batch modules as data, convert and encapsulate existing module files such as a PDL (Program Design Language) format into Python classes by writing a series of Python classes and tool chains, and then use the Python programming language to code batch processing jobs.

[0078] Step (1), a standard header word class is defined, and the attributes include: name, number, attention, type, display, and description. A header word generation tool (genHeaderWords.py) is used to read all header words in a standard header word file (geoeastSTD.header) into memory and format output into a Python file (stdHeaderWords.py), and the file defines all header words, and each header word corresponds to a HeaderWord type.

[0079] Step (2), define PDL parameter constant class (pdlConstants.py), constants include: labels and attributes in PDL files, use PDL parsing tool (pdlParser.py) to convert PDL files into a Python object (PDL type), which includes module, parameter, parameter set and parameter dependency information.

[0080] Step (3), the Python type PDL object output in step (2) is used as input, and PDL generation tool (PDLGenerator) is used to generate a module class (derived from module base class), write all module information to module object and multiple parameter classes (each parameter is derived from parameter base class), and write parameter information according to parameter type and parameter value, and finally generate a module file, for example: the original module file name is abset.pdl, and the output Python module file is abset.py. The flowchart of steps (1)~(3) is shown in Figure 3 .

[0081] Step (4), user writes job based on Python version of batch module.

[0082] a. According to the job requirements, specify the project and database information of the job;

[0083] b. Initialize each module object, take two modules A and B as an example, where A module represents geodiskin and B module represents geodiskout;

[0084] c. Specify the corresponding parameters for each module, each parameter has a standard type, and the type description will be prompted if VSCode or other intelligent editors are used;

[0085] d. Initialize the job topology structure, which defines that A is the post-module of B, that is, A->B;

[0086] e. Add all modules used in the job to the job;

[0087] f. According to the needs, output the topology graph of the module;

[0088] g. Call genJobXML to generate the job.

[0089] h. User development flowchart, refer to Figure 3 .

[0090] Specifically, for the above step (1): use the head word parsing and generation tool of the tool chain to convert the standard head word file into Python class. Take legal_mark head word as an example, its original information is in XML format:

[0091] <?xml version="1.0" encoding="UTF-8"?>

[0092] <headerdef version="3.0">

[0093] <!--Definition of seismic trace headers, including number, category label, attention level, etc.-->

[0094] <headerword>

[0095] <no> 1< / no>

[0096] <classmark> M001< / classmark>

[0097] <attention> C< / attention>

[0098] <key>legal_mark< / key>

[0099] <macro>< / macro>

[0100] <type> c16< / type>

[0101] <factor> 0< / factor>

[0102] <display>Legal mark< / display>

[0103] <description>Legal mark (GeoEast)< / description>

[0104] <defaultinvalid>NULL< / defaultinvalid>

[0105] <code>< / code>

[0106] <commonid> 1< / commonid>

[0107] <statmethod> 0< / statmethod>

[0108] < / headerword>

[0109] After converting it into a Python module using the trace header tool, it is as follows:

[0110] # Represent a seismic data trace header in Python

[0111] class Headerword:

[0112] def __init__(self,

[0113] no :int = -1, # Number

[0114] classMark :str = '', # Category label

[0115] attention :str = '', # Attention level

[0116] key :str = '',

[0117] macro :str = '',

[0118] type :str = '',

[0119] factor :str = '',

[0120] display :str = '',

[0121] desc :str = '',

[0122] defaultInvalid :str = '',

[0123] code :str = '',

[0124] commonId :int = 0, # 0:TraceHeader 1:CommonHeader

[0125] statMethod :int = -1 ):

[0127] self.no :int = no

[0128] self.classMark :str = classMark

[0129] self.attention :str = attention

[0130] self.key :str = key

[0131] self.macro :str = macro

[0132] self.type :str = type

[0133] self.factor :str = factor

[0134] self.display :str = display

[0135] self.desc :str = desc

[0136] self.defaultInvalid :str = defaultInvalid

[0137] self.code :str = code

[0138] self.commonId :int = commonId # 0:TraceHeader 1:CommonHeader

[0139] self.statMethod :int = statMethod

[0140] It should be noted that the above program segment is a standard header word base class defined by the framework layer, which is used to describe the structure of the header word in the Python script language; and the tool chain is automatically parsed and generated according to the standard header word in the GeoEast system environment, which is used to cooperate with the batch processing module to complete the job editing operation.

[0141] Specifically, for steps (2) and (3) above: the module parsing and generation tool converts the batch processing module configuration file (PDL suffix, XML format) into the corresponding Python module. Taking the abset module as an example, its XML configuration file is as follows, and the following program segment is part of the XML format file with PDL suffix, which can be simply understood as a module (i.e., a description of the module):

[0142] <?xml version="1.0"?>

[0143] <!-- Module information, including: name, version, type, transmission way -->

[0144] <moudle name="absest" version="3.0" moduletype="NORMAL" datatransfer="SINGLE">

[0145] <!-- Parameter list -->

[0146] <parameters>

[0147] <!-- compid parameter, parameter name, display name -->

[0148] <parameter name="compid" class="1" display="Component for absorptionestimation" inmethod="DIRECT" uiname="component type" no="5">

[0149] <!-- Parameter value type, maximum, minimum value -->

[0150] <value col="1" vtype="Int" type="SINGLE" row="1" prec="0">

[0151] <max> 2147483647< / max>

[0152] <min> -1< / min>

[0153] <default> -1< / default>

[0154] < / value>

[0155] <!-- Parameter comment -->

[0156] <comment>

[0157] <ecomment>Absorption estimation should be performed for givencomponent identifier. If -1 is set then all components are used.< / ecomment>

[0158] < / comment>

[0159] < / parameter> < / parameters>

[0160] <!-- Detailed description information of the module, including: library name, description, development language, author, input and output channel, etc. -->

[0161] <description>

[0162] <libname>absest.so< / libname>

[0163] <func>The program estimates absorption by trace energy descent intime window along hodograph. Hodograph may be obtained from firstbreak orfrom VSP picking seismic trace header word. Estimation may be performed ingiven range of receiver depths.< / func> <author>Eliseev Vladimir< / author>

[0164] <language> C++< / language>

[0165] <interfacetype>GEOEAST< / interfacetype>

[0166] <anamod>absest.am< / anamod>

[0167] <exemod>absest.pm< / exemod>

[0168] <prodate>Thu Mar 17 2005< / prodate>

[0169] <inchannel num="1" format="1" type="Float" needed="YES">

[0170] <mecomment>Input GeoEast seismic traces with first break or VSPpicking hodograph defined.< / mecomment>

[0171] < / inchannel>

[0172] <outchannel num="1" format="1" type="Float" needed="YES">

[0173] <mecomment>GeoEast traces without any changes in headers and insamples.< / mecomment>

[0174] < / outchannel>

[0175] <checkpoint state="false">

[0176] <nodedep>false< / nodedep>

[0177] < / checkpoint>

[0178] < / description>

[0179] <assistant>

[0180] <applicationtype>Input< / applicationtype>

[0181] <funlevel> 0< / funlevel>

[0182] <frelevel> 0< / frelevel>

[0183] < / assistant>

[0184] < / moudle>

[0185] Take the abset module as an example, it is converted into abset.py (a module in Python language) by the module parser and generator of the tool chain, which completely includes all original information of the module, including the name, category, version, channel, and description of the module; and a module can be completely expressed in Python language.

[0186] Each parameter in the module corresponds to a Python class. Take the abset module as an example, the parameter class corresponding to the compid parameter is Compid; each parameter class retains all the information of the original XML file, including the parameter name, display name, interface name, category, parameter type, parameter value type, parameter value range, and parameter description, and a parameter can be completely expressed in Python language.

[0187] #encoding=utf-8

[0188] # The parsing is completed by the PDLParser of the tool chain, and the PDL -> Python module class generation is completed by the PDLGenerator.

[0189] #====================================

[0190] #- Auto Generated 20250521 15:50:51 -

[0191] #author:ds

[0192] #email:daisu@cnpc.com.cn

[0193] #====================================

[0194] import sys,os

[0195] from typing import List

[0196] sys.path.append(os.path.abspath('.. / ..'))

[0197] from pyjob.core.parameter import *

[0198] from pyjob.core.module import *

[0199] '''

[0200] Source: D:\mysvn\code\geoeast\pyjobeditor\res\pdl\absest.pdl

[0201] MD5: 840407ae9d5e9ab69c62914d917061c1

[0202] Modified Date:20250103 10:42:49

[0203] Description:

[0204] The program estimates absorption by trace energy descent in timewindow along hodograph. Hodograph may be obtained from firstbreak or from VSPpicking seismic trace header word. Estimation may be performed in given rangeof receiver depths.

[0205] '''

[0206] # The module class generated from the abset.pdl module configuration file retains all the description information of the original module.

[0207] class absest(GEModule):

[0208] def __init__(self):

[0209] super().__init__()

[0210] # Initialize module properties

[0211] attr :GEModuleAttr = self.attr

[0212] attr.name = 'absest' # Module name

[0213] attr.libName = 'absest.so' #Library name

[0214] attr.language = 'C++' # Programming language

[0215] attr.version = '3.0' # Module version

[0216] attr.type = '' # Module type

[0217] attr.dataTransfer = 'SINGLE' # Data transfer method

[0218] attr.author = 'Eliseev Vladimir' # Developer author

[0219] attr.createdDate = 'Thu Mar 17 2005' # Creation date

[0220] attr.interfaceType = 'GEOEAST' # Interface type

[0221] attr.moduleType = 'NORMAL' # Module type

[0222] attr.desc = '''The program estimates absorption by trace energydescent in time window along hodograph. Hodograph may be obtained from firstbreak or from VSP picking seismic trace header word. Estimation may beperformed in given range of receiver depths.'''

[0223] attr.amMod = 'absest.am'

[0224] attr.pmMod = 'absest.pm'

[0225] #Initialize input channel

[0226] inChan :GEChan = self.inputChan

[0227] inChan.count = 1

[0228] inChan.format = 1

[0229] inChan.type = 'Float'

[0230] inChan.required = 'YES'

[0231] inChan.comment = '''Input GeoEast seismic traces with first break or VSP picking hodograph defined.'''

[0232] # Initialize output channel

[0233] outChan :GEChan = self.outputChan

[0234] outChan.count = 1

[0235] outChan.format = 1

[0236] outChan.type = 'Float'

[0237] outChan.required = 'YES'

[0238] outChan.comment = '''GeoEast traces without any changes in headers and in samples.'''

[0239] # Initialize help information

[0240] assist :GEAssistAttr = self.assistAttr

[0241] assist.appType = 'Input'

[0242] assist.funLevel = '0'

[0243] assist.freLevel = '0'

[0244] # Input and output channels, iport and oport

[0245] self.iport1 :GEChanInputPort = GEChanInputPort(self,0)

[0246] self.oport1 :GEChanOutputPort = GEChanOutputPort(self,0)

[0247] # Parameter list

[0248] self.parasCount = 1

[0249] self.compid = Compid()

[0250] # Parameter set

[0251] self.paras.append(self.compid)

[0252] # Module parameter, if there are multiple modules, there will be multiple parameter classes here, each parameter corresponds to a parameter class, which contains all the information of the original module parameters

[0253] class Compid(GEParameter):

[0254] def __init__(self):

[0255] super().__init__()

[0256] self.name = 'compid'

[0257] self.uiName = 'component type'

[0258] self.disName = 'Component for absorption estimation'

[0259] self.no = 5

[0260] self.classLevel = 1

[0261] self.inMethod = 'DIRECT'

[0262] self.ptype = 'SINGLE'

[0263] self.vtype = 'Int'

[0264] self.vsize = GEVSize(1, 1)

[0265] self.vrange = GEVRange(-1, 2147483647, 0)

[0266] self.rowAutoExpand = True

[0267] self.prec = 0

[0268] # If not specified, None is automatically selected by default

[0269] self.value :int = None

[0270] self.valueTypeName :str = "NoneType"

[0271] self.eComment = ''

[0272] self.cComment = ''

[0273] # Value type, if it is a single value, None

[0274] self.valueType :any = None

[0275] # Parameter default value

[0276] self.default = -1

[0277] It should be noted that the content shown in the above program segment is to define the constants of the PDL file in the batch processing module, and use these constants to parse the existing batch PDL file through the tool chain; and for the mapping of the PDL file to the Python language structure, the PDL configuration file is described using the Python script language, which is used for subsequent PDL file parsing and module processing.

[0278] It should be noted that the content shown in the above program segment is to translate the existing batch PDL file into a Python language module by the tool chain, and the abset module is taken as an example for illustration; the core steps include parsing and generating, which are similar to decoding and encoding operations.

[0279] Specifically, for the above step (4): after completing the conversion of the batch processing module (PDL suffix configuration file) to the Python library, steps (1) and (2) above can be completed using the batch processing module job development library to write a Python version of the batch processing job.

[0280] As can be seen from the job editor shown in Figure 1 , each box in the left side is a module, a job is composed of multiple modules, each module has many parameters, and different parameters are configured. The input and output streams of the modules are connected by the ports of the modules to edit a job. Here, each module corresponds to a subclass derived from GEModule, for example, abset, see Figure 5 . Each parameter in the right side of the job corresponds to a Python class of GEParameter, and the modules in the job are connected in the form of channel connection lines. For information about specifying a job, including the database, project work area, and survey line, see Figure 6 .

[0281] Next, a job is constructed using the Python programming language, as shown in Figure 7 . For users who understand Python scripts, the job information described by the code can be understood at a glance. Specifically, the selection of modules is completed by module import in the Python language. The setting of module parameters is completed by the creation of module parameter objects. The topology between modules is described in the form of a tuple.

[0282] In summary, the scheme provided in the present application has the following advantages in editing a seismic batch processing job:

[0283] 1. Strong AI friendliness: ① It is conducive to better understanding of the job editing by a large model, and designing a job according to user needs, thereby reducing the difficulty of application of the large model in batch processing; ② It provides a structured code interface for the large model, and supports intelligent generation and optimization of future batch processing jobs.

[0284] 2. Flexible logic programming: ① It realizes flexible arrangement of complex business logic by using the characteristics of the Python language; ② It can use the advantages of the programming language to design more complex jobs.

[0285] 3. High parameter reuse rate: ① It can improve the parameter reuse rate by customizing parameter classes; ② It can customize modules to design and simplify the reuse rate of modules.

[0286] 4. More efficient operation and maintenance: ① It uses the operation and maintenance library of Python to determine the timing of sending a job; ② It uses the scheduling library of Python to realize timing and retry of a job, etc.

[0287] It should be noted that for the method embodiments, the series of acts performed are presented in sequential order for simplicity and clarity. However, it should be appreciated that some steps have been left out and that other steps can be added to the above described embodiments and the acts described can be performed in an order other than that described. Further, it should be noted that the embodiments described above are just exemplary embodiments and that many variations and modifications are possible. Embodiments

[0288] Referring to Figure 8 A structural diagram of a script language oriented seismic data batch processing job editing device provided by the present application is provided, and the device comprises:

[0289] A seismic job requirement determination unit 210 is configured to obtain a seismic job requirement to be processed, and determine a seismic job item and database information according to the seismic job requirement;

[0290] A framework module initialization unit 220 is configured to initialize each module object in a pre-established seismic batch processing job framework, and the seismic batch processing job framework is a script language framework comprising a preset core library, a module library and a tool chain;

[0291] A module parameter determination unit 230 is configured to determine a standard type parameter corresponding to each module object, and the standard type parameter is a standard type set in advance for each parameter;

[0292] A topology initialization unit 240 is configured to initialize a job topology of the seismic batch processing job framework;

[0293] A target module selection unit 250 is configured to select a target module object from the seismic batch processing job framework based on the seismic job item and the database information, and add the target module object to a target job;

[0294] A target job generation unit 260 is configured to output a topology graph of a module according to debugging needs, and generate a target job corresponding to the seismic job requirement by calling an XML format file.

[0295] The present application realizes efficient editing of a seismic batch processing job framework oriented to Python, replaces a traditional job editing mode based on an interface with a job editing mode based on a programming language, fills the gap in traditional batch processing job editing, supplements and enhances the function of existing batch processing job editing, can support editing of a Python script language, seamlessly connects job editing and code editing, makes job editing more flexible and efficient, meets the diversified needs of users who master the Python programming language for self-defined job editing, and lays a solid foundation for subsequent application of job editing in a large model.

[0296] For the apparatus embodiment, since it is basically similar to the method embodiment, the description is relatively simple, and the relevant part can be referred to the part of the method embodiment. Embodiment

[0297] Optionally, the embodiment of the present application further provides an electronic device, including: a processor, a memory, a computer program stored in the memory and executable in the processor, when the computer program is executed by the processor, each process of the above method embodiment is realized, and the same technical effects can be achieved, to avoid repetition, which will not be repeated here.

[0298] The embodiment of the present application further provides a computer readable storage medium, and the computer readable storage medium stores a computer program, when the computer program is executed by the processor, each process of the above method embodiment is realized, and the same technical effects can be achieved, to avoid repetition, which will not be repeated here. The computer readable storage medium includes a read-only memory (ROM), a random access memory (RAM), a magnetic disk or an optical disk, etc.

[0299] Figure 9 A block diagram of an electronic device 800 is provided. For example, the electronic device 800 can be a mobile phone, a computer, a digital broadcast terminal, a messaging device, a game console, a tablet device, a medical device, a fitness device, a personal digital assistant, or the like.

[0300] Reference Figure 9 The electronic device 800 can include one or more of the following components: a processing component 802, a memory component 804, a power supply component 806, a multimedia component 808, an audio component 810, an input / output (I / O) interface 812, a sensor component 814, and a communication component 816.

[0301] The processing component 802 usually controls overall operations of the electronic device 800, such as operations associated with displaying, making phone calls, data communications, camera operations and recording operations. The processing component 802 can include one or more processors 820 to execute instructions to complete all or part of steps of the above method. In addition, the processing component 802 can include one or more modules to facilitate the interaction between the processing component 802 and other components. For example, the processing component 802 can include a multimedia module to facilitate the interaction between the multimedia component 808 and the processing component 802.

[0302] The memory 804 is configured to store various types of data to support the operation of the electronic device 800. Examples of such data include instructions for any application or method operating on the electronic device 800, contact data, phonebook data, messages, images, videos, and the like. The memory 804 can be implemented by any type of volatile or nonvolatile memory, or a combination thereof, such as static random access memory (SRAM), electrically erasable programmable read-only memory (EEPROM), erasable programmable read-only memory (EPROM), programmable read-only memory (PROM), read-only memory (ROM), magnetic memory, flash memory, a magnetic disk or a compact disk.

[0303] The power supply component 806 supplies power for various components of the electronic device 800. The power supply component 806 can include a power management system, one or more power supplies, and other components associated with generating, managing, and distributing power for the electronic device 800.

[0304] The multimedia component 808 includes a screen providing an output interface between the electronic device 800 and a user. In some embodiments, the screen can include a liquid crystal display (LCD) and a touch panel (TP). If the screen includes a touch panel, the screen can be implemented as a touch screen to receive an input signal from a user. The touch panel includes one or more touch sensors to sense a touch, a slide, and a gesture on the touch panel. The touch sensor can not only sense a boundary of a touching or a sliding action, but also detect duration and pressure related to the touching or sliding action. In some embodiments, the multimedia component 808 includes a front camera and / or a back camera. The front camera and / or the back camera can receive external multimedia data when the device 800 is in an operating mode, such as a shooting mode or a video mode. Each of the front and back cameras can be a fixed optical lens system or have a focal length and optical zoom capability.

[0305] The audio component 810 is configured to output and / or input an audio signal. For example, the audio component 810 includes a microphone (MIC) configured to receive an external audio signal when the electronic device 800 is in an operating mode, such as a call mode, a recording mode, and a voice recognition mode. The received audio signal can be further stored in the memory 804 or transmitted via the communication component 816. In some embodiments, the audio component 810 also includes a speaker for outputting an audio signal.

[0306] The I / O interface 812 provides an interface between the processing component 802 and peripheral interface modules, which can be a keypad, a click wheel, buttons, and the like. The buttons can include, but are not limited to, a home button, a volume button, a start button, and a lock button.

[0307] The sensor component 814 includes one or more sensors for providing status assessments for various aspects of the electronic device 800. For example, the sensor component 814 can detect an open / closed position of the device 800, relative positioning of components, such as a display and a keypad of the electronic device 800, a change in position of the electronic device 800 or a component of the electronic device 800, the presence or absence of user contact with the electronic device 800, the orientation or acceleration / deceleration / g-force and a temperature change of the electronic device 800. The sensor component 814 can include a proximity sensor configured to detect presence of a nearby object without any physical touch. The sensor component 814 can also include a light sensor, such as a CMOS or CCD image sensor, for use in imaging applications. In some embodiments, the sensor component 814 can further include an acceleration sensor, a gyroscope sensor, a magnetic sensor, a pressure sensor, or a temperature sensor.

[0308] The communication component 816 is configured to facilitate wired or wireless communication between the electronic device 800 and other devices. The electronic device 800 can access a wireless network based on a communication standard, such as WiFi, a cellular network (e.g., 2G, 3G, 4G or 5G), or a combination thereof. In an example embodiment, the communication component 816 receives broadcast signals or broadcast operation information from an external broadcast management system via a broadcast channel. In an example embodiment, the communication component 816 can further include a Near Field Communication (NFC) module to facilitate short-range communication. For example, the NFC module can be implemented based on Radio Frequency Identification (RFID) techniques, infrared data association (IrDA) techniques, ultra-wideband (UWB) techniques, Bluetooth (BT) techniques, and other techniques.

[0309] In an example embodiment, the electronic device 800 can be implemented using one or more application-specific integrated circuits (ASICs), digital signal processors (DSPs), digital signal processing devices (DSPDs), programmable logic devices (PLDs), field programmable gate arrays (FPGAs), controllers, micro-controllers, microprocessors, or other electronic elements to perform the above-described methods.

[0310] In an example embodiment, a non-transitory computer-readable storage medium, such as the memory 804 including instructions, is also provided, which can be executed by the processor 820 of the electronic device 800 to implement the above-described methods. For example, the non-transitory computer-readable storage medium can be a ROM, a random access memory (RAM), a CD-ROM, a magnetic tape, a floppy disc, and an optical data storage device, etc. Embodiments

[0311] Figure 10 Another block diagram of an electronic device 1900 is provided. For example, the electronic device 1900 can be provided as a server.

[0312] Referring to Figure 10 The electronic device 1900 includes a processing component 1922, which further includes one or more processors, and a memory resource represented by a memory 1932, for storing instructions, such as an application, executable by the processing component 1922. The application stored in the memory 1932 can include one or more than one module each corresponding to a set of instructions. In addition, the processing component 1922 is configured to execute the instructions to perform the above method.

[0313] The electronic device 1900 can further include a power component 1926 configured to perform power management of the electronic device 1900, a wired or wireless network interface 1950 configured to connect the electronic device 1900 to a network, and an input / output (I / O) interface 1958. The electronic device 1900 can operate based on an operating system stored in the memory 1932, such as Windows ServerTM, Mac OS XTM, UnixTM, LinuxTM, FreeBSDTM, or the like. Embodiments

[0314] In a fifth aspect, the present application shows a computer program product, when instructions in the computer program product are executed by a processor of an electronic device, the electronic device is enabled to perform the method as claimed in any one of the above aspects.

[0315] It should be noted that, in this document, the terms "comprise", "contain" or any other variant thereof are intended to cover non-exclusive inclusion, so that processes, methods, articles or devices that include a series of elements not only include those elements, but also include other elements not explicitly listed, or include elements inherent to such processes, methods, articles or devices. Without more limitations, the element defined by the statement "comprises a" does not exclude the presence of another identical element in the process, method, article or device that includes the element.

[0316] Those skilled in the art can clearly understand that the above-mentioned embodiment method can be realized by means of software and necessary general hardware platform, of course, it can also be realized by hardware, but in many cases, the former is a better embodiment. Based on such understanding, the technical solutions of the present application can be embodied in the form of a software product, which is stored in a storage medium (such as ROM / RAM, magnetic disk, optical disk) and includes a plurality of instructions for causing a terminal (which can be a mobile phone, computer, server, air conditioner, or network device) to execute the methods described in the various embodiments of the present application.

[0317] The embodiments of the present application are described above in conjunction with the drawings, but the present application is not limited to the specific embodiments described above, which are merely illustrative rather than restrictive, and those of ordinary skill in the art can make many forms without departing from the purpose of the present application and the scope protected by the claims.

[0318] Those of ordinary skill in the art can realize that the units and algorithm steps of each example described in conjunction with the embodiments disclosed in the embodiments of the present application can be realized by electronic hardware or a combination of computer software and electronic hardware. Whether the functions are performed in hardware or software depends on the specific application and design constraints of the technical solutions. Those of ordinary skill in the art can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of the present application.

[0319] Those of ordinary skill in the art can clearly understand that, for the convenience and brevity of description, the specific working processes of the above-described system, device and unit can refer to the corresponding processes in the foregoing method embodiments, which will not be described here.

[0320] In the embodiments provided by the present application, it should be understood that the disclosed devices and methods can be implemented in other ways. For example, the device embodiments described above are merely illustrative, for example, the division of the units is only a logical function division, and actual implementation can have another division manner, for example, a plurality of units or components can be combined or integrated into another system, or some features can be ignored or not executed. In addition, the coupling or direct coupling or communication connection between the displayed or discussed ones can be indirect coupling or communication connection through some interfaces, devices or units, which can be electrical, mechanical or other forms.

[0321] The units described as separate components may or may not be physically separate, and the components displayed as units may or may not be physical units, that is, may be located in one place, or may be distributed to multiple network units. Part or all of the units can be selected according to actual needs to achieve the purpose of the embodiment scheme.

[0322] In addition, the functional units in each embodiment of the present application can be integrated in one processing unit, or each unit can be physically present separately, or two or more units can be integrated in one unit.

[0323] The functions, if realized in the form of software functional units and sold or used as independent products, can be stored in a computer readable storage medium. Based on such understanding, the technical solutions of the present application or the part of the present application that essentially contributes to the prior art or the part of the technical solutions can be embodied in the form of a software product. The computer software product is stored in a storage medium and includes a plurality of instructions for causing a computer device (which can be a personal computer, a server, or a network device, etc.) to execute all or part of the steps of the method described in each embodiment of the present application. The aforementioned storage medium includes: a U disk, a mobile hard disk, a ROM, a RAM, a magnetic disk or an optical disk, and various storage medium capable of storing program codes.

[0324] The above is only a specific embodiment of the present application, but the protection scope of the present application is not limited thereto. Any person skilled in the art can easily think of changes or replacements within the technical scope disclosed in the present application, which should be covered within the protection scope of the present application. Therefore, the protection scope of the present application should be subject to the protection scope of the claims.< / headerdef>

Claims

1. A method for editing earthquake batch processing jobs using a scripting language, characterized in that, The method includes: Define a standard keyword class, use a keyword generation tool to read all the keywords from the standard keyword file into memory, and output them in a formatted Python file; the attributes of the standard keyword class shall include at least: name, number, attention level, type, display, and description; Define a PDL parameter constant class, and use a PDL parsing tool to convert the PDL file into a PDL object of Python type. The parameter constants include at least the tags and attributes in the PDL file, and the PDL object includes at least the module, parameters, parameter set and parameter dependency information. The PDL object of type Python is taken as input. A PDL generation tool is used to derive a module class from the module base class. All module information is written into the module object and multiple parameter classes. Each parameter of the multiple parameter classes is derived from the parameter base class. Parameter information is written one by one according to the parameter type and parameter value to generate the target module file corresponding to the target module object. Obtain the earthquake operation requirements to be processed, and determine the earthquake operation projects and database information based on the earthquake operation requirements; Each module object in the pre-established earthquake batch processing job framework is initialized. The earthquake batch processing job framework is a scripting language framework that includes a pre-set core library, module library and toolchain. Determine the standard type parameters corresponding to each module object, wherein the standard type parameters are standard types that are pre-set for each parameter; The job topology of the earthquake batch processing job editing framework is initialized; Based on earthquake operation projects and database information, target module objects are selected from the earthquake batch processing operation framework and added to the target operation; Output the module topology diagram according to the debugging needs, and generate the target operation corresponding to the earthquake operation requirements by calling the XML format file.

2. The earthquake batch processing job editing method based on a scripting language according to claim 1, characterized in that, The core library includes a parameter system unit, a dependency management unit, a module model unit, and a job management unit; The parameter system unit defines a parameter base class and a module base class, and supports type validation, value range constraints, and automatic parameter value conversion. The dependency management unit establishes logical relationships between parameters through the GEDependency class, supporting dynamic dependency resolution; The module model unit encapsulates input / output channels, parameter sets, and job fragment generation interfaces based on the module base class, supporting chained connections between modules; The job management unit integrates job metadata management, topology map generation, and XML output functions based on the GEJob class, and supports multi-module combination and arrangement.

3. The earthquake batch processing job editing method based on a scripting language according to claim 1, characterized in that, The module library: It includes batch processing modules in the GeoEast environment. Each module's Python file contains a module class derived from the module base class GEModule and multiple parameter classes derived from the parameter base class GEParameter. The initial value data for the modules and parameters are obtained from the module's PDL file.

4. The earthquake batch processing job editing method based on a scripting language according to claim 3, characterized in that, The module library automatically converts GeoEast module description files into Python file modules through a toolchain, maintaining the semantic consistency of parameter definitions with the original modules, mapping PDL parameter types to Python data structure types, supporting type hints in a smart editor, and exporting each module as a Python module package.

5. The earthquake batch processing job editing method based on a scripting language according to claim 1, characterized in that, The toolchain includes: a standard header generation tool, a batch processing module generation tool, and a PDL parsing tool; The standard track header generation tool takes a standard track header file as input, automatically generates a track header module, and outputs it to the core library directory by default. It supports quick querying and referencing of track header attributes. The batch module generation tool takes a batch module PDL file as input, automatically generates a Python version of the module file, and outputs it to the module library directory by default. The PDL parsing tool parses the PDL file and outputs it as a Python object of PDL.

6. A scripting language-oriented earthquake batch processing job editing device, characterized in that, The device includes: The earthquake operation requirement determination unit is used to acquire earthquake operation requirements to be processed and determine earthquake operation items and database information based on the earthquake operation requirements. The framework module initialization unit is used to initialize each module object in the pre-established earthquake batch processing job framework, which is a scripting language framework including a preset core library, module library and toolchain. The module parameter determination unit is used to determine the standard type parameters corresponding to each module object, wherein the standard type parameters are standard types that are pre-set for each parameter; The topology initialization unit is used to initialize the job topology of the earthquake batch processing job editing framework; The target module selection unit is used to select target module objects from the earthquake batch processing operation framework and add them to the target operation based on the earthquake operation project and database information; The target job generation unit is used to output the topology diagram of the module according to the debugging needs, and to generate the target job corresponding to the earthquake operation requirements by calling the XML format file; Before the earthquake job processing editing device, which is based on a scripting language, obtains the earthquake job requirements to be processed by the earthquake job requirement determination unit and determines the earthquake job items and database information based on the earthquake job requirements, it is also used for: Define a standard keyword class, use a keyword generation tool to read all the keywords from the standard keyword file into memory, and output them in a formatted Python file; the attributes of the standard keyword class shall include at least: name, number, attention level, type, display, and description; Define a PDL parameter constant class, and use a PDL parsing tool to convert the PDL file into a PDL object of Python type. The parameter constants include at least the tags and attributes in the PDL file, and the PDL object includes at least the module, parameters, parameter set and parameter dependency information. Using the Python type PDL object as input, a PDL generation tool is used to derive a module class from the module base class. All module information is written into the module object and multiple parameter classes. Each parameter in the multiple parameter classes is derived from the parameter base class, and parameter information is written one by one according to the parameter type and parameter value to generate the target module file corresponding to the target module object.

7. An electronic device, characterized in that, include: A processor, a memory, and a computer program stored in the memory and executable on the processor, wherein the computer program, when executed by the processor, implements the method as described in any one of claims 1 to 5.

8. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores a computer program that, when executed by a processor, implements the method as described in any one of claims 1 to 5.

9. A computer program product, characterized in that, When the instructions in the computer program product are executed by the processor of the electronic device, the electronic device implements the method as described in any one of claims 1 to 5.

Images