Coverage for /usr/local/lib/python3.7/dist-packages/pyrocko/fomosto/psgrn_pscmp.py : 88%

# http://pyrocko.org - GPLv3 

# 

# The Pyrocko Developers, 21st Century 

# ---|P------/S----------~Lg---------- 

from __future__ import absolute_import, division 

import logging 

import os 

from os.path import join as pjoin 

import signal 

import shutil 

import copy 

import math 

import numpy as num 

from tempfile import mkdtemp 

from subprocess import Popen, PIPE 

from pyrocko.guts import Float, Int, Tuple, List, Object, String 

from pyrocko.model import Location 

from pyrocko import gf, util, trace, cake 

# how to call the programs 

program_bins = { 

'pscmp.2008a': 'fomosto_pscmp2008a', 

'psgrn.2008a': 'fomosto_psgrn2008a' 

} 

psgrn_displ_names = ('uz', 'ur', 'ut') 

psgrn_stress_names = ('szz', 'srr', 'stt', 'szr', 'srt', 'stz') 

psgrn_tilt_names = ('tr', 'tt', 'rot') 

psgrn_gravity_names = ('gd', 'gr') 

psgrn_components = 'ep ss ds cl'.split() 

km = 1000. 

guts_prefix = 'pf' 

logger = logging.getLogger('pyrocko.fomosto.psgrn_pscmp') 

def have_backend(): 

for cmd in [[exe] for exe in program_bins.values()]: 

try: 

p = Popen(cmd, stdout=PIPE, stderr=PIPE, stdin=PIPE) 

(stdout, stderr) = p.communicate() 

except OSError: 

return False 

return True 

def nextpow2(i): 

return 2 ** int(math.ceil(math.log(i) / math.log(2.))) 

def str_float_vals(vals): 

return ' '.join('%e' % val for val in vals) 

def str_int_vals(vals): 

return ' '.join('%i' % val for val in vals) 

def str_str_vals(vals): 

return ' '.join("'%s'" % val for val in vals) 

def cake_model_to_config(mod): 

srows = [] 

for ir, row in enumerate(mod.to_scanlines(get_burgers=True)): 

depth, vp, vs, rho, qp, qs, eta1, eta2, alpha = row 

# replace qs with etas = 0. 

row = [depth / km, vp / km, vs / km, rho, eta1, eta2, alpha] 

srows.append('%i %15s' % (ir + 1, str_float_vals(row))) 

return '\n'.join(srows), len(srows) 

class PsGrnSpatialSampling(Object): 

n_steps = Int.T(default=10) 

start_distance = Float.T(default=0.) # start sampling [km] from source 

end_distance = Float.T(default=100.) # end 

def string_for_config(self): 

return '%i %15e %15e' % (self.n_steps, self.start_distance, 

self.end_distance) 

class PsGrnConfig(Object): 

version = String.T(default='2008a') 

sampling_interval = Float.T( 

default=1.0, 

help='exponential sampling 1.- equidistant, > 1. decreasing sampling' 

' with distance') 

n_time_samples = Int.T( 

default=1, 

help='Number of temporal GF samples up to max_time. Has to be equal' 

' to a power of 2! If not, next power of 2 is taken.') 

max_time = Float.T( 

default=1., 

help='Maximum time [days] after seismic event.') 

gf_depth_spacing = Float.T( 

default=1., 

help='spatial depth spacing [km] for the medium properties.') 

gf_distance_spacing = Float.T( 

default=10., 

help='spatial distance spacing [km] for the medium properties.') 

observation_depth = Float.T(default=0.) 

def items(self): 

return dict(self.T.inamevals(self)) 

class PsGrnConfigFull(PsGrnConfig): 

earthmodel_1d = gf.meta.Earthmodel1D.T(optional=True) 

psgrn_outdir = String.T(default='psgrn_green/') 

distance_grid = PsGrnSpatialSampling.T(PsGrnSpatialSampling.D()) 

depth_grid = PsGrnSpatialSampling.T(PsGrnSpatialSampling.D()) 

sw_source_regime = Int.T(default=1) # 1-continental, 0-ocean 

sw_gravity = Int.T(default=0) 

accuracy_wavenumber_integration = Float.T(default=0.025) 

displ_filenames = Tuple.T(3, String.T(), default=psgrn_displ_names) 

stress_filenames = Tuple.T(6, String.T(), default=psgrn_stress_names) 

tilt_filenames = Tuple.T(3, String.T(), psgrn_tilt_names) 

gravity_filenames = Tuple.T(2, String.T(), psgrn_gravity_names) 

@staticmethod 

def example(): 

conf = PsGrnConfigFull() 

conf.earthmodel_1d = cake.load_model().extract(depth_max=100*km) 

conf.psgrn_outdir = 'TEST_psgrn_functions/' 

return conf 

def string_for_config(self): 

assert self.earthmodel_1d is not None 

d = self.__dict__.copy() 

model_str, nlines = cake_model_to_config(self.earthmodel_1d) 

d['n_t2'] = nextpow2(self.n_time_samples) 

d['n_model_lines'] = nlines 

d['model_lines'] = model_str 

d['str_psgrn_outdir'] = "'%s'" % './' 

d['str_displ_filenames'] = str_str_vals(self.displ_filenames) 

d['str_stress_filenames'] = str_str_vals(self.stress_filenames) 

d['str_tilt_filenames'] = str_str_vals(self.tilt_filenames) 

d['str_gravity_filenames'] = str_str_vals(self.gravity_filenames) 

d['str_distance_grid'] = self.distance_grid.string_for_config() 

d['str_depth_grid'] = self.depth_grid.string_for_config() 

template = '''# autogenerated PSGRN input by psgrn.py 

#============================================================================= 

# This is input file of FORTRAN77 program "psgrn08a" for computing responses 

# (Green's functions) of a multi-layered viscoelastic halfspace to point 

# dislocation sources buried at different depths. All results will be stored in 

# the given directory and provide the necessary data base for the program 

# "pscmp07a" for computing time-dependent deformation, geoid and gravity changes 

# induced by an earthquake with extended fault planes via linear superposition. 

# For more details, please read the accompanying READ.ME file. 

# 

# written by Rongjiang Wang 

# GeoForschungsZentrum Potsdam 

# e-mail: wang@gfz-potsdam.de 

# phone +49 331 2881209 

# fax +49 331 2881204 

# 

# Last modified: Potsdam, Jan, 2008 

# 

################################################################# 

## ## 

## Cylindrical coordinates (Z positive downwards!) are used. ## 

## ## 

## If not specified otherwise, SI Unit System is used overall! ## 

## ## 

################################################################# 

# 

#------------------------------------------------------------------------------ 

# 

# PARAMETERS FOR SOURCE-OBSERVATION CONFIGURATIONS 

# ================================================ 

# 1. the uniform depth of the observation points [km], switch for oceanic (0) 

# or continental(1) earthquakes; 

# 2. number of (horizontal) observation distances (> 1 and <= nrmax defined in 

# psgglob.h), start and end distances [km], ratio (>= 1.0) between max. and 

# min. sampling interval (1.0 for equidistant sampling); 

# 3. number of equidistant source depths (>= 1 and <= nzsmax defined in 

# psgglob.h), start and end source depths [km]; 

# 

# r1,r2 = minimum and maximum horizontal source-observation 

# distances (r2 > r1). 

# zs1,zs2 = minimum and maximum source depths (zs2 >= zs1 > 0). 

# 

# Note that the same sampling rates dr_min and dzs will be used later by the 

# program "pscmp07a" for discretizing the finite source planes to a 2D grid 

# of point sources. 

#------------------------------------------------------------------------------ 

%(observation_depth)e %(sw_source_regime)i 

%(str_distance_grid)s %(sampling_interval)e 

%(str_depth_grid)s 

#------------------------------------------------------------------------------ 

# 

# PARAMETERS FOR TIME SAMPLING 

# ============================ 

# 1. number of time samples (<= ntmax def. in psgglob.h) and time window [days]. 

# 

# Note that nt (> 0) should be power of 2 (the fft-rule). If nt = 1, the 

# coseismic (t = 0) changes will be computed; If nt = 2, the coseismic 

# (t = 0) and steady-state (t -> infinity) changes will be computed; 

# Otherwise, time series for the given time samples will be computed. 

# 

#------------------------------------------------------------------------------ 

%(n_t2)i %(max_time)f 

#------------------------------------------------------------------------------ 

# 

# PARAMETERS FOR WAVENUMBER INTEGRATION 

# ===================================== 

# 1. relative accuracy of the wave-number integration (suggested: 0.1 - 0.01) 

# 2. factor (> 0 and < 1) for including influence of earth's gravity on the 

# deformation field (e.g. 0/1 = without / with 100percent gravity effect). 

#------------------------------------------------------------------------------ 

%(accuracy_wavenumber_integration)e 

%(sw_gravity)i 

#------------------------------------------------------------------------------ 

# 

# PARAMETERS FOR OUTPUT FILES 

# =========================== 

# 

# 1. output directory 

# 2. file names for 3 displacement components (uz, ur, ut) 

# 3. file names for 6 stress components (szz, srr, stt, szr, srt, stz) 

# 4. file names for radial and tangential tilt components (as measured by a 

# borehole tiltmeter), rigid rotation of horizontal plane, geoid and gravity 

# changes (tr, tt, rot, gd, gr) 

# 

# Note that all file or directory names should not be longer than 80 

# characters. Directory and subdirectoy names must be separated and ended 

# by / (unix) or \ (dos)! All file names should be given without extensions 

# that will be appended automatically by ".ep" for the explosion (inflation) 

# source, ".ss" for the strike-slip source, ".ds" for the dip-slip source, 

# and ".cl" for the compensated linear vector dipole source) 

# 

#------------------------------------------------------------------------------ 

%(str_psgrn_outdir)s 

%(str_displ_filenames)s 

%(str_stress_filenames)s 

%(str_tilt_filenames)s %(str_gravity_filenames)s 

#------------------------------------------------------------------------------ 

# 

# GLOBAL MODEL PARAMETERS 

# ======================= 

# 1. number of data lines of the layered model (<= lmax as defined in psgglob.h) 

# 

# The surface and the upper boundary of the half-space as well as the 

# interfaces at which the viscoelastic parameters are continuous, are all 

# defined by a single data line; All other interfaces, at which the 

# viscoelastic parameters are discontinuous, are all defined by two data 

# lines (upper-side and lower-side values). This input format could also be 

# used for a graphic plot of the layered model. Layers which have different 

# parameter values at top and bottom, will be treated as layers with a 

# constant gradient, and will be discretised to a number of homogeneous 

# sublayers. Errors due to the discretisation are limited within about 

# 5percent (changeable, see psgglob.h). 

# 

# 2.... parameters of the multilayered model 

# 

# Burgers rheology (a Kelvin-Voigt body and a Maxwell body in series 

# connection) for relaxation of shear modulus is implemented. No relaxation 

# of compressional modulus is considered. 

# 

# eta1 = transient viscosity (dashpot of the Kelvin-Voigt body; <= 0 means 

# infinity value) 

# eta2 = steady-state viscosity (dashpot of the Maxwell body; <= 0 means 

# infinity value) 

# alpha = ratio between the effective and the unrelaxed shear modulus 

# = mu1/(mu1+mu2) (> 0 and <= 1) 

# 

# Special cases: 

# (1) Elastic: eta1 and eta2 <= 0 (i.e. infinity); alpha meaningless 

# (2) Maxwell body: eta1 <= 0 (i.e. eta1 = infinity) 

# or alpha = 1 (i.e. mu1 = infinity) 

# (3) Standard-Linear-Solid: eta2 <= 0 (i.e. infinity) 

#------------------------------------------------------------------------------ 

%(n_model_lines)i |int: no_model_lines; 

#------------------------------------------------------------------------------ 

# no depth[km] vp[km/s] vs[km/s] rho[kg/m^3] eta1[Pa*s] eta2[Pa*s] alpha 

#------------------------------------------------------------------------------ 

%(model_lines)s 

#=======================end of input=========================================== 

''' # noqa 

return (template % d).encode('ascii') 

class PsGrnError(gf.store.StoreError): 

pass 

def remove_if_exists(fn, force=False): 

if os.path.exists(fn): 

if force: 

os.remove(fn) 

else: 

raise gf.CannotCreate('file %s already exists' % fn) 

class PsGrnRunner(object): 

''' 

Wrapper object to execute the program fomosto_psgrn. 

''' 

def __init__(self, outdir): 

outdir = os.path.abspath(outdir) 

if not os.path.exists(outdir): 

os.mkdir(outdir) 

self.outdir = outdir 

self.config = None 

def run(self, config, force=False): 

''' 

Run the program with the specified configuration. 

:param config: :py:class:`PsGrnConfigFull` 

:param force: boolean, set true to overwrite existing output 

''' 

self.config = config 

input_fn = pjoin(self.outdir, 'input') 

remove_if_exists(input_fn, force=force) 

with open(input_fn, 'wb') as f: 

input_str = config.string_for_config() 

logger.debug('===== begin psgrn input =====\n' 

'%s===== end psgrn input =====' % input_str.decode()) 

f.write(input_str) 

program = program_bins['psgrn.%s' % config.version] 

old_wd = os.getcwd() 

os.chdir(self.outdir) 

interrupted = [] 

def signal_handler(signum, frame): 

os.kill(proc.pid, signal.SIGTERM) 

interrupted.append(True) 

original = signal.signal(signal.SIGINT, signal_handler) 

try: 

try: 

proc = Popen(program, stdin=PIPE, stdout=PIPE, stderr=PIPE) 

except OSError: 

os.chdir(old_wd) 

raise PsGrnError( 

'''could not start psgrn executable: "%s" 

Available fomosto backends and download links to the modelling codes are listed 

on 

https://pyrocko.org/docs/current/apps/fomosto/backends.html 

''' % program) 

(output_str, error_str) = proc.communicate(b'input\n') 

finally: 

signal.signal(signal.SIGINT, original) 

if interrupted: 

raise KeyboardInterrupt() 

logger.debug('===== begin psgrn output =====\n' 

'%s===== end psgrn output =====' % output_str.decode()) 

errmess = [] 

if proc.returncode != 0: 

errmess.append( 

'psgrn had a non-zero exit state: %i' % proc.returncode) 

if error_str: 

logger.warn( 

'psgrn emitted something via stderr: \n\n%s' 

% error_str.decode()) 

# errmess.append('psgrn emitted something via stderr') 

if output_str.lower().find(b'error') != -1: 

errmess.append("the string 'error' appeared in psgrn output") 

if errmess: 

os.chdir(old_wd) 

raise PsGrnError(''' 

===== begin psgrn input ===== 

%s===== end psgrn input ===== 

===== begin psgrn output ===== 

%s===== end psgrn output ===== 

===== begin psgrn error ===== 

%s===== end psgrn error ===== 

%s 

psgrn has been invoked as "%s" 

in the directory %s'''.lstrip() % ( 

input_str.decode(), output_str.decode(), error_str.decode(), 

'\n'.join(errmess), program, self.outdir)) 

self.psgrn_output = output_str 

self.psgrn_error = error_str 

os.chdir(old_wd) 

pscmp_displ_names = ('un', 'ue', 'ud') 

pscmp_stress_names = ('snn', 'see', 'sdd', 'sne', 'snd', 'sed') 

pscmp_tilt_names = ('tn', 'te', 'rot') 

pscmp_gravity_names = ('gd', 'gr') 

pscmp_all_names = pscmp_displ_names + pscmp_stress_names + pscmp_tilt_names + \ 

pscmp_gravity_names 

pscmp_component_mapping = { 

'displ': (pscmp_displ_names, (2, 5)), 

'stress': (pscmp_stress_names, (5, 11)), 

'tilt': (pscmp_tilt_names, (11, 14)), 

'gravity': (pscmp_gravity_names, (14, 16)), 

'all': (pscmp_all_names, (2, 16)), 

} 

def dsin(value): 

return num.sin(value * num.pi / 180.) 

def dcos(value): 

return num.cos(value * num.pi / 180.) 

def distributed_fault_patches_to_config(patches): 

''' 

Input: List of PsCmpRectangularSource(s) 

''' 

srows = [] 

for i, patch in enumerate(patches): 

srows.append('%i %s' % (i + 1, patch.string_for_config())) 

return '\n'.join(srows), len(srows) 

class PsCmpObservation(Object): 

pass 

class PsCmpScatter(PsCmpObservation): 

''' 

Scattered observation points. 

''' 

lats = List.T(Float.T(), optional=True, default=[10.4, 10.5]) 

lons = List.T(Float.T(), optional=True, default=[12.3, 13.4]) 

def string_for_config(self): 

srows = [] 

for lat, lon in zip(self.lats, self.lons): 

srows.append('(%15f, %15f)' % (lat, lon)) 

self.sw = 0 

return ' %i' % (len(srows)), '\n'.join(srows) 

class PsCmpProfile(PsCmpObservation): 

''' 

Calculation along observation profile. 

''' 

n_steps = Int.T(default=10) 

slat = Float.T( 

default=0., 

help='Profile start latitude') 

slon = Float.T( 

default=0., 

help='Profile start longitude') 

elat = Float.T( 

default=0., 

help='Profile end latitude') 

elon = Float.T( 

default=0., 

help='Profile end longitude') 

distances = List.T( 

Float.T(), 

optional=True, 

help='Distances [m] for each point on profile from start to end.') 

def string_for_config(self): 

self.sw = 1 

return ' %i' % (self.n_steps), \ 

' ( %15f, %15f ), ( %15f, %15f )' % ( 

self.slat, self.slon, self.elat, self.elon) 

class PsCmpArray(PsCmpObservation): 

''' 

Calculation on a grid. 

''' 

n_steps_lat = Int.T(default=10) 

n_steps_lon = Int.T(default=10) 

slat = Float.T( 

default=0., 

help='Array start latitude') 

slon = Float.T( 

default=0., 

help='Array start longitude') 

elat = Float.T( 

default=0., 

help='Array end latitude') 

elon = Float.T( 

default=0., 

help='Array end longitude') 

def string_for_config(self): 

self.sw = 2 

return ' %i %15f %15f ' % ( 

self.n_steps_lat, self.slat, self.elat), \ 

' %i %15f %15f ' % ( 

self.n_steps_lon, self.slon, self.elon) 

class PsCmpRectangularSource(Location, gf.seismosizer.Cloneable): 

''' 

Rectangular Source for the input geometry of the active fault. 

Input parameters have to be in: 

[deg] for reference point (lat, lon) and angles (rake, strike, dip) 

[m] shifting with respect to reference position 

[m] for fault dimensions and source depth. The default shift of the 

origin (:py:attr`pos_s`, :py:attr:`pos_d`) with respect to the reference 

coordinates 

(lat, lon) is zero, which implies that the reference is the center of 

the fault plane! 

The calculation point is always the center of the fault-plane! 

Setting :py:attr`pos_s` or :py:attr`pos_d` moves the fault point with 

respect to the origin along strike and dip direction, respectively! 

''' 

length = Float.T(default=6.0 * km) 

width = Float.T(default=5.0 * km) 

strike = Float.T(default=0.0) 

dip = Float.T(default=90.0) 

rake = Float.T(default=0.0) 

torigin = Float.T(default=0.0) 

slip = Float.T(optional=True, default=1.0) 

pos_s = Float.T(optional=True, default=None) 

pos_d = Float.T(optional=True, default=None) 

opening = Float.T(default=0.0) 

def update(self, **kwargs): 

'''Change some of the source models parameters. 

Example:: 

>>> from pyrocko import gf 

>>> s = gf.DCSource() 

>>> s.update(strike=66., dip=33.) 

>>> print(s) 

--- !pf.DCSource 

depth: 0.0 

time: 1970-01-01 00:00:00 

magnitude: 6.0 

strike: 66.0 

dip: 33.0 

rake: 0.0 

''' 

for (k, v) in kwargs.items(): 

self[k] = v 

@property 

def dip_slip(self): 

return float(self.slip * dsin(self.rake) * (-1)) 

@property 

def strike_slip(self): 

return float(self.slip * dcos(self.rake)) 

def string_for_config(self): 

if self.pos_s or self.pos_d is None: 

self.pos_s = 0. 

self.pos_d = 0. 

tempd = copy.deepcopy(self.__dict__) 

tempd['dip_slip'] = self.dip_slip 

tempd['strike_slip'] = self.strike_slip 

tempd['effective_lat'] = self.effective_lat 

tempd['effective_lon'] = self.effective_lon 

tempd['depth'] /= km 

tempd['length'] /= km 

tempd['width'] /= km 

return '%(effective_lat)15f %(effective_lon)15f %(depth)15f' \ 

'%(length)15f %(width)15f %(strike)15f' \ 

'%(dip)15f 1 1 %(torigin)15f \n %(pos_s)15f %(pos_d)15f ' \ 

'%(strike_slip)15f %(dip_slip)15f %(opening)15f' % tempd 

MTIso = { 

'nn': dict(strike=90., dip=90., rake=0., slip=0., opening=1.), 

'ee': dict(strike=0., dip=90., rake=0., slip=0., opening=1.), 

'dd': dict(strike=0., dip=0., rake=-90., slip=0., opening=1.), 

} 

MTDev = { 

'ne': dict(strike=90., dip=90., rake=180., slip=1., opening=0.), 

'nd': dict(strike=180., dip=0., rake=0., slip=1., opening=0.), 

'ed': dict(strike=270., dip=0., rake=0., slip=1., opening=0.), 

} 

class PsCmpTensileSF(Location, gf.seismosizer.Cloneable): 

''' 

Compound dislocation of 3 perpendicular, rectangular sources to approximate 

an opening single force couple. NED coordinate system! 

''' 

length = Float.T(default=1.0 * km) 

width = Float.T(default=1.0 * km) 

torigin = Float.T(default=0.0) 

idx = String.T(default='nn', 

help='Axis Index for opening direction; "nn, ee, dd"') 

def to_rfs(self): 

rf = -0.25 

cmpd = [] 

for comp, mt in MTIso.items(): 

params = copy.deepcopy(mt) 

if comp != self.idx: 

params = copy.deepcopy(mt) 

params['opening'] *= rf 

kwargs = copy.deepcopy(self.__dict__) 

kwargs.update(params) 

kwargs.pop('idx') 

kwargs.pop('_latlon') 

cmpd.append(PsCmpRectangularSource(**kwargs)) 

return cmpd 

class PsCmpShearSF(Location, gf.seismosizer.Cloneable): 

length = Float.T(default=1.0 * km) 

width = Float.T(default=1.0 * km) 

torigin = Float.T(default=0.0) 

idx = String.T(default='ne', 

help='Axis Index for shear direction; "ne, nd, ed"') 

def to_rfs(self): 

kwargs = copy.deepcopy(self.__dict__) 

kwargs.pop('idx') 

kwargs.pop('_latlon') 

kwargs.update(MTDev[self.idx]) 

return [PsCmpRectangularSource(**kwargs)] 

class PsCmpMomentTensor(Location, gf.seismosizer.Cloneable): 

''' 

Mapping of Moment Tensor components to rectangular faults. 

Only one component at a time valid! NED coordinate system! 

''' 

length = Float.T(default=1.0 * km) 

width = Float.T(default=1.0 * km) 

torigin = Float.T(default=0.0) 

idx = String.T(default='nn', 

help='Axis Index for MT component;' 

'"nn, ee, dd, ne, nd, ed"') 

def to_rfs(self): 

kwargs = copy.deepcopy(self.__dict__) 

kwargs.pop('_latlon') 

if self.idx in MTIso: 

tsf = PsCmpTensileSF(**kwargs) 

return tsf.to_rfs() 

elif self.idx in MTDev: 

ssf = PsCmpShearSF(**kwargs) 

return ssf.to_rfs() 

else: 

raise Exception('MT component not supported!') 

class PsCmpCoulombStress(Object): 

pass 

class PsCmpCoulombStressMasterFault(PsCmpCoulombStress): 

friction = Float.T(default=0.7) 

skempton_ratio = Float.T(default=0.0) 

master_fault_strike = Float.T(default=300.) 

master_fault_dip = Float.T(default=15.) 

master_fault_rake = Float.T(default=90.) 

sigma1 = Float.T(default=1.e6) 

sigma2 = Float.T(default=-1.e6) 

sigma3 = Float.T(default=0.0) 

def string_for_config(self): 

return '%(friction)15e %(skempton_ratio)15e %(master_fault_strike)15f'\ 

'%(master_fault_dip)15f %(master_fault_rake)15f'\ 

'%(sigma1)15e %(sigma2)15e %(sigma3)15e' % self.__dict__ 

class PsCmpSnapshots(Object): 

''' 

Snapshot time series definition. 

''' 

tmin = Float.T( 

default=0.0, 

help='Time [days] after source time to start temporal sample' 

' snapshots.') 

tmax = Float.T( 

default=1.0, 

help='Time [days] after source time to end temporal sample f.') 

deltatdays = Float.T( 

default=1.0, 

help='Sample period [days].') 

@property 

def times(self): 

nt = int(num.ceil((self.tmax - self.tmin) / self.deltatdays)) 

return num.linspace(self.tmin, self.tmax, nt).tolist() 

@property 

def deltat(self): 

return self.deltatdays * 24 * 3600 

class PsCmpConfig(Object): 

version = String.T(default='2008a') 

# scatter, profile or array 

observation = PsCmpObservation.T(default=PsCmpScatter.D()) 

rectangular_fault_size_factor = Float.T( 

default=1., 

help='The size of the rectangular faults in the compound MT' 

' :py:class:`PsCmpMomentTensor` is dependend on the horizontal' 

' spacing of the GF database. This factor is applied to the' 

' relationship in i.e. fault length & width = f * dx.') 

snapshots = PsCmpSnapshots.T(PsCmpSnapshots.D()) 

rectangular_source_patches = List.T(PsCmpRectangularSource.T()) 

def items(self): 

return dict(self.T.inamevals(self)) 

class PsCmpConfigFull(PsCmpConfig):