def __init__(self, conf, pmtx=None, prhs=None, comm=None, **kwargs):
if comm is None:
try:
import petsc4py
petsc4py.init([])
except ImportError:
msg = 'cannot import petsc4py!'
raise ImportError(msg)
from petsc4py import PETSc as petsc
converged_reasons = {}
for key, val in six.iteritems(petsc.SNES.ConvergedReason.__dict__):
if isinstance(val, int):
converged_reasons[val] = key
ksp_converged_reasons = {}
for key, val in six.iteritems(petsc.KSP.ConvergedReason.__dict__):
if isinstance(val, int):
ksp_converged_reasons[val] = key
NonlinearSolver.__init__(self, conf, petsc=petsc,
pmtx=pmtx, prhs=prhs, comm=comm,
converged_reasons=converged_reasons,
ksp_converged_reasons=ksp_converged_reasons,
**kwargs)
def __init__( self, conf, **kwargs ):
try:
import petsc4py
petsc4py.init([])
from petsc4py import PETSc
except ImportError:
msg = 'cannot import petsc4py!'
raise ImportError( msg )
LinearSolver.__init__(self, conf, eps_a=conf.eps_a, eps_r=conf.eps_r,
petsc=PETSc, pmtx=None, **kwargs)
ksp = PETSc.KSP().create()
ksp.setType( self.conf.method )
ksp.getPC().setType( self.conf.precond )
side = self._precond_sides[self.conf.precond_side]
if side is not None:
ksp.setPCSide(side)
self.ksp = ksp
self.converged_reasons = {}
for key, val in ksp.ConvergedReason.__dict__.iteritems():
if isinstance(val, int):
self.converged_reasons[val] = key
def updatesolution(self,state):
r"""
Compute slution at the new time level for the implicit 1D
Lax-Wendroff scheme, i.e.
q^(n+1) = q^(n) + R(q^(n+1)),
where q^(n) = solution at the current time level
q^(n+1) = solution at the new time level (solution of the nonlinear system)
R(q^(n+1)) = nonlinear function arising from the spatial/time discretization
"""
import numpy as np
import sys, petsc4py
petsc4py.init(sys.argv)
from petsc4py import PETSc
# Define aux array
maux = state.maux
mx = state.grid.ng[0]
mwaves,mbc = self.mwaves,self.mbc
if maux>0:
aux = self.auxbc(state)
else:
aux=np.empty((maux,mx+2*mbc))
# Create application context (appc) and PETSc nonlinear solver
appc = ImplicitLW1D(state,mwaves,mbc,self.method,self.mthlim,self.dt,aux,self.kernel_language)
snes = PETSc.SNES().create()
# Define the vector in charge of containing the solution of the
# nonlinear system. The initial guess is qnew = q^n, i.e. solution at
# the current time level t^n.
qnew = state.qbc.copy()
# Define the function in charge of computing the nonlinear residual.
f = PETSc.Vec().createSeq(qnew.size)
# Define the constant part of the equation.
# For the implicit LW scheme this could either zero or the solution at
# the current time level (q^n). In this case we set it equal to the
# solution at the current time level.
b = qnew.copy()
# Register the function in charge of computing the nonlinear residual
snes.setFunction(appc.evalNonLinearFunction, f)
# Configure the nonlinear solver to use a matrix-free Jacobian
snes.setUseMF(True)
snes.getKSP().setType('cg')
snes.setFromOptions()
# Solve the nonlinear problem
snes.solve(b, qnew)
# Assign to q the new value qnew.
state.qbc = qnew
def run_app_from_main(application,setplot=None):
r"""
Runs an application from pyclaw/examples/, automatically parsing command line keyword
arguments (key=value) as parameters to the application, with positional
arguments being passed to PETSc (if it is enabled).
Perhaps we should take the PETSc approach of having a database of PyClaw
options that can be queried for options on specific objects within the
PyClaw runtime instead of front-loading everything through the application
main...
"""
# Arguments to the PyClaw should be keyword based, positional arguments
# will be passed to PETSc
petsc_args, pyclaw_kwargs = _info_from_argv(sys.argv)
if 'use_petsc' in pyclaw_kwargs and pyclaw_kwargs['use_petsc']:
import petsc4py
petsc_args = [arg.replace('--','-') for arg in sys.argv[1:] if '=' not in arg]
petsc4py.init(petsc_args)
from clawpack import petclaw as pyclaw
else:
from clawpack import pyclaw
if sys.version_info >= (2, 7):
app_kwargs = {key: value for key, value in pyclaw_kwargs.items()
if not key in ('htmlplot','iplot')}
else:
# the above fails with Python < 2.7, so write it out...
app_kwargs = {}
for key,value in pyclaw_kwargs.items():
if key not in ('htmlplot','iplot'):
app_kwargs[key] = value
claw=application(**app_kwargs)
# Solve
status = claw.run()
# Plot results
htmlplot = pyclaw_kwargs.get('htmlplot',False)
iplot = pyclaw_kwargs.get('iplot',False)
outdir = pyclaw_kwargs.get('outdir','./_output')
if htmlplot:
if setplot is not None:
pyclaw.plot.html_plot(outdir=outdir,setplot=setplot)
else:
pyclaw.plot.html_plot(outdir=outdir)
if iplot:
if setplot is not None:
pyclaw.plot.interactive_plot(outdir=outdir,setplot=setplot)
else:
pyclaw.plot.interactive_plot(outdir=outdir)
return claw
def __init__(self, conf, **kwargs):
try:
import petsc4py
petsc4py.init([])
from petsc4py import PETSc
except ImportError:
msg = 'cannot import petsc4py!'
raise ImportError(msg)
LinearSolver.__init__(self, conf, petsc=PETSc, pmtx=None,
converged_reasons=None, **kwargs)
def generate_commandline(filename):
infile = open(filename, 'r')
args = [line[:-1] for line in infile if not line.strip().startswith('#')]
infile.close()
if any('use_old_options_style' in line for line in args):
raise NotImplementedError("Old style options can't be used here... generate a PETSc-style options file and try again")
else:
import petsc4py
petsc4py.init(' '.join(args))
from petsc4py import PETSc
return
def __init__(self, conf, pmtx=None, prhs=None, comm=None, **kwargs):
if comm is None:
try:
import petsc4py
petsc4py.init([])
except ImportError:
msg = 'cannot import petsc4py!'
raise ImportError(msg)
from petsc4py import PETSc as petsc
NonlinearSolver.__init__(self, conf, petsc=petsc,
pmtx=pmtx, prhs=prhs, comm=comm, **kwargs)
def solve_petsc(self, solver_data_list, rhs_list, nu, *args, **kwargs ):
#try catch for the petsc4py use in multiple rhs solve
try:
import petsc4py
petsc4py.init(sys.argv)
from petsc4py import PETSc
from pysit.util.wrappers.petsc import PetscWrapper
except ImportError:
raise ImportError('petsc4py is not installed, please install it and try again')
petsc = kwargs['petsc']
if petsc is not None:
if len(solver_data_list) != len(rhs_list):
raise ValueError('solver and right hand side list must be the same size')
else:
#Building the Helmholtz operator for petsc
H = self._build_helmholtz_operator(nu)
ndof = H.shape[1]
nshot = len(rhs_list)
# creating the B rhs Matrix
B = PETSc.Mat().createDense([ndof, nshot])
B.setUp()
for i in range(nshot):
# added by zhilong [0:ndof]
B.setValues(list(range(0, ndof)), [i], rhs_list[i][0:ndof])
B.assemblyBegin()
B.assemblyEnd()
# call the wrapper to solve the system
wrapper = PetscWrapper()
try:
linear_solver = wrapper.factorize(H, petsc, PETSc.COMM_WORLD)
Uhat = linear_solver(B.getDenseArray())
except:
raise SyntaxError('petsc = '+str(petsc)+' is not a correct solver you can only use \'superlu_dist\', \'mumps\' or \'mkl_pardiso\' ')
numb = 0
for solver_data in solver_data_list:
u = Uhat[:,numb]
u = np.append(u, np.zeros(2*ndof)) # added by zhilong, assume that we do not need the auxiliary wavefields
u.shape = solver_data.k.data.shape
solver_data.k.data = u
numb += 1
def help(args=None):
import sys, shlex
# program name
try:
prog = sys.argv[0]
except Exception:
prog = getattr(sys, 'executable', 'python')
if args is None:
args = sys.argv[1:]
elif isinstance(args, str):
args = shlex.split(args)
else:
args = [str(a) for a in args]
import petsc4py
petsc4py.init([prog, '-help'] + args)
from petsc4py import PETSc
COMM = PETSc.COMM_SELF
if 'vec' in args:
vec = PETSc.Vec().create(comm=COMM)
vec.setSizes(0)
vec.setFromOptions()
del vec
if 'mat' in args:
mat = PETSc.Mat().create(comm=COMM)
mat.setSizes([0, 0])
mat.setFromOptions()
del mat
if 'ksp' in args:
ksp = PETSc.KSP().create(comm=COMM)
ksp.setFromOptions()
del ksp
if 'pc' in args:
pc = PETSc.PC().create(comm=COMM)
pc.setFromOptions()
del pc
if 'snes' in args:
snes = PETSc.SNES().create(comm=COMM)
snes.setFromOptions()
del snes
if 'ts' in args:
ts = PETSc.TS().create(comm=COMM)
ts.setFromOptions()
del ts
if 'da' in args:
da = PETSc.DA().create(comm=COMM)
da.setFromOptions()
del da
def main(args):
try:
import mpi4py
from mpi4py import MPI
except:
raise mpi4pyError('mpi4py must be installed and in PYTHONPATH')
try:
import petsc4py
comm = MPI.COMM_WORLD
petsc4py.init([],comm=comm)
from petsc4py import PETSc
except:
raise petsc4pyError('petsc4py must be installed and in PYTHONPATH')
p = _reconparser.Parser(args[0])
solve = _reconsolver.Solver(p)
comm.Barrier()
solve.PPS(p,comm)
def __init__(self, conf, comm=None, **kwargs):
if comm is None:
try:
import petsc4py
petsc4py.init([])
except ImportError:
msg = 'cannot import petsc4py!'
raise ImportError(msg)
from petsc4py import PETSc as petsc
converged_reasons = {}
for key, val in petsc.KSP.ConvergedReason.__dict__.iteritems():
if isinstance(val, int):
converged_reasons[val] = key
LinearSolver.__init__(self, conf, petsc=petsc, comm=comm,
converged_reasons=converged_reasons, **kwargs)
def solve_petsc_uhat(self, solver, rhs_list, frequency, petsc='mumps', *args, **kwargs):
#try catch for the petsc4py use in multiple rhs solve
#use only in the data generation where we do not need to compute
#the system for the whole auxiliary fields
try:
import petsc4py
petsc4py.init(sys.argv)
from petsc4py import PETSc
from pysit.util.wrappers.petsc import PetscWrapper
except ImportError:
raise ImportError('petsc4py is not installed, please install it and try again')
#Building the Helmholtz operator for petsc
H = self._build_helmholtz_operator(frequency)
ndof = H.shape[1]
nshot = len(rhs_list)
# if the compact operator is used we do not need to slice the solution
if self.compact:
usize = ndof
else:
nwfield = len(self.WavefieldVector.aux_names) + 1
usize = ndof/nwfield
# creating the B rhs Matrix
B = PETSc.Mat().createDense([ndof, nshot])
B.setUp()
for i in range(nshot):
B.setValues(range(0, ndof), [i], rhs_list[i])
B.assemblyBegin()
B.assemblyEnd()
# call the wrapper to solve the system
wrapper = PetscWrapper()
try:
linear_solver = wrapper.factorize(H, petsc, PETSc.COMM_WORLD)
Uhat = linear_solver(B.getDenseArray())
except:
raise SyntaxError('petsc = '+str(petsc)+' is not a correct solver you can only use \'superlu_dist\', \'mumps\' or \'mkl_pardiso\' ')
Uhat = Uhat[xrange(usize),:]
return Uhat
def init():
global comm, petscInitialized
if not petscInitialized:
petsc4py.init(argv)
petscInitialized = True
else:
from petsc4py import PETSc
OptDB=PETSc.Options()
narg = len(argv)
for i,s in enumerate(argv):
if len(s) > 0 and s[0] is '-':
name = s
if i+1 < narg and argv[i+1][0] is not '-':
value = argv[i+1]
OptDB.setValue(name,value)
new_comm = Comm()
if not comm:
comm = new_comm
return new_comm
def init(petscDatabaseFilename=None,argv=sys.argv):
global initial_communicator,isInitialized
if isInitialized is 0:
petsc4py.init(argv)
isInitialized=1
else:
from petsc4py import PETSc
narg = len(argv)
for i,s in enumerate(argv):
if len(s) > 0 and s[0] is '-':
name = s
if i+1 < narg and argv[i+1][0] is not '-':
value = argv[i+1]
PETSc.Options.SetValue(name,value)
if isinstance(petscDatabaseFilename,str):
comm = flcbdfWrappers.DaetkPetscSys(isInitialized,argv,petscDatabaseFilename)
else:
comm = flcbdfWrappers.DaetkPetscSys(isInitialized,argv)
if initial_communicator == None:
initial_communicator = comm
return comm
def init():
global comm, petscInitialized
if not petscInitialized:
petsc4py.init(argv)
petscInitialized = True
else:
from petsc4py import PETSc
OptDB=PETSc.Options()
narg = len(argv)
for i,s in enumerate(argv):
if len(s) > 0 and s[0] is '-':
name = s
if i+1 < narg and argv[i+1][0] is not '-':
value = argv[i+1]
OptDB.setValue(name,value)
if not OptDB.hasName("options_left"):
OptDB.setValue("options_left",False)
petsc4py.PETSc.Log.Stage('proteus').push()
new_comm = Comm()
if not comm:
comm = new_comm
return new_comm
def run_app_from_main(application):
r"""
Runs an application from apps/, automatically parsing command line keyword
arguments (key=value) as parameters to the application, with positional
arguments being passed to PETSc (if it is enabled).
Perhaps we should take the PETSc approach of having a database of PyClaw
options that can be queried for options on specific objects within the
PyClaw runtime instead of front-loading everything through the application
main...
"""
# Arguments to the PyClaw should be keyword based, positional arguments
# will be passed to PETSc
petsc_args, app_kwargs = _info_from_argv(sys.argv)
if 'use_petsc' in app_kwargs and app_kwargs['use_petsc']:
import petsc4py
petsc_args = [arg.replace('--','-') for arg in sys.argv[1:] if '=' not in arg]
petsc4py.init(petsc_args)
output=application(**app_kwargs)
return output
def __init__( self, conf, **kwargs ):
try:
import petsc4py
petsc4py.init([])
from petsc4py import PETSc
except ImportError:
msg = 'cannot import petsc4py!'
raise ImportError( msg )
LinearSolver.__init__( self, conf, petsc = PETSc, pmtx = None, **kwargs )
ksp = PETSc.KSP().create()
ksp.setType( self.conf.method )
ksp.getPC().setType( self.conf.precond )
if hasattr( self, 'mtx' ):
if self.mtx is not None:
self.pmtx, self.sol, self.rhs = self.set_matrix( self.mtx )
ksp.setOperators( self.pmtx ) # set the matrix
ksp.setFromOptions()
self.ksp = ksp
def main(*args):
if args:
args = list(args)
else:
args = sys.argv
commandlineArguments = parse_commandline(args[1:])
petsc4py.init(args=(args[0:1] + commandlineArguments.petsc))
logMAIN('commandlineArguments.petsc', commandlineArguments.petsc)
#
# The following must not be done until petsc4py.init has been
# called.
#
from petsc4py import PETSc
catch_signals()
comm = MPI.COMM_WORLD
periodic = not commandlineArguments.noperiodic
if not periodic:
raise KSFDException(
'--periodic=false not implements'
)
ps = SolutionParameters(commandlineArguments)
logMAIN('list(ps.groups.ligands())',
list(ps.groups.ligands()))
kgen = Generator(seed=commandlineArguments.seed, comm=comm)
if (commandlineArguments.showparams):
for n,p,d,h in ps.params0.params():
print(
'{n}={val} -- {h}'.format(n=n, val=p(), h=h)
)
if not in_notebook():
sys.exit()
grid = Grid(
dim=ps.dim,
dof=ps.nligands+1, # rho, ligands
width=ps.width, height=ps.height, depth=ps.depth,
nx=ps.nwidth, ny=ps.nheight, nz=ps.ndepth
)
sources = decode_sources(commandlineArguments.source, ps, grid)
logMAIN('sources', sources)
vec0, t = initial_values(commandlineArguments, grid, ps)
logMAIN('ps.params0', ps.params0)
logMAIN('ps.values0', ps.values0)
if commandlineArguments.save:
tseries = TimeSeries(
basename=commandlineArguments.save,
grid=grid,
mode='w',
mpiok=commandlineArguments.mpiok,
retries=commandlineArguments.series_retries,
retry_interval=commandlineArguments.series_retry_interval,
)
tseries.info['commandlineArguments'] = dillnp(commandlineArguments)
tseries.info['SolutionParameters'] = dillnp(ps, recurse=True)
tseries.info['sources'] = dillnp(sources)
tseries.info['dt'] = float(ps.params0['dt'])
if 'lastvart' in ps.params0:
tseries.info['lastvart'] = float(ps.params0['lastvart'])
tseries.flush()
else:
tseries = None
vec0.assemble()
v0a = vec0.array.reshape(grid.Vlshape, order='F')
lvec0 = grid.Vdmda.createLocalVec()
derivs = Derivatives(ps, grid, sources=sources, u0=vec0)
# UJacobian_arrays = derivs.UJacobian_arrays(t=ps.t0)
grid.Vdmda.globalToLocal(vec0, lvec0)
lv0a = lvec0.array.reshape(grid.Vashape, order='F')
logMAIN('lv0a[:]', lv0a[:])
options = PETSc.Options()
# options.setValue('ts_max_snes_failures', 100)
resuming = commandlineArguments.resume or commandlineArguments.restart
if commandlineArguments.onestep:
truemaxsteps = 1
else:
truemaxsteps = ps.params0['maxsteps']
ts = implicitTS(derivs,
t0 = t,
restart = not bool(resuming),
rtol = ps.params0['rtol'],
atol = ps.params0['atol'],
dt = ps.params0['dt'],
tmax = ps.params0['tmax'],
maxsteps = truemaxsteps)
logMAIN('ts', str(ts))
ts.setMonitor(ts.printMonitor)
logMAIN('printMonitor set')
if commandlineArguments.save:
saveMonitor, closeMonitor = ts.makeSaveMonitor(
timeseries=tseries
)
ts.setMonitor(saveMonitor)
logMAIN('saveMonitor set')
if commandlineArguments.check:
ts.setMonitor(
ts.checkpointMonitor,
(),
{
'prefix': commandlineArguments.check,
'mpiok': commandlineArguments.mpiok
}
)
logMAIN('checkpointMonitor set')
try:
logMAIN('calling ts.solve', ts.solve)
ts.solve()
except KeyboardInterrupt as e:
print('KeyboardInterrupt:', str(e))
except Exception as e:
print('Exception:', str(e))
einfo = sys.exc_info()
sys.excepthook(*einfo)
if commandlineArguments.save:
closeMonitor()
tseries.close()
logMAIN('saveMonitor closed')
ts.cleanup()
grid.cleanup()
try:
vec0.destroy()
except:
pass
try:
lvec0.destroy()
except:
pass
if MPI.COMM_WORLD.rank == 0:
print("SNES failures = ", ts.getSNESFailures())
# try:
# PETSc._finalize()
# except PETSc.Error:
# pass
logMAIN('returning 0 from main')
return 0
def KalmanFilterMRTI(**kwargs):
"""
kalman filtered MRTI
"""
# import needed modules
import petsc4py, numpy
PetscOptions = sys.argv
PetscOptions.append("-ksp_monitor")
PetscOptions.append("-ksp_rtol")
PetscOptions.append("1.0e-15")
PetscOptions.append("-solver")
#PetscOptions.append("petsc")
PetscOptions.append("superlu_dist")
PetscOptions.append("-log_summary")
PetscOptions.append("-override_max")
PetscOptions.append("-modelcov")
PetscOptions.append( kwargs['cv']['modelcov'] )
#PetscOptions.append("-verify_inverse")
#PetscOptions.append("-write_system_matrix")
#PetscOptions.append("-ksp_inverse_pc")
#PetscOptions.append("ilu")
#PetscOptions.append("lu")
# ROI info
#PetscOptions.append("-nx")
#PetscOptions.append("-35")
#PetscOptions.append("-ny")
#PetscOptions.append("-35")
#PetscOptions.append("-ix")
#PetscOptions.append("-125")
#PetscOptions.append("-iy")
#PetscOptions.append("-115")
#PetscOptions.append("-help")
petsc4py.init(PetscOptions)
from petsc4py import PETSc
# create stages for logging
PredictionStage = PETSc.Log.Stage("Prediction")
CorrectionStage = PETSc.Log.Stage("Correction")
# break processors into separate communicators
petscRank = PETSc.COMM_WORLD.getRank()
petscSize = PETSc.COMM_WORLD.Get_size()
sys.stdout.write("petsc rank %d petsc nproc %d\n" % (petscRank, petscSize))
# set shell context
# TODO import vtk should be called after femLibrary ????
# FIXME WHY IS THIS????
import femLibrary
# initialize libMesh data structures
libMeshInit = femLibrary.PyLibMeshInit(PetscOptions,PETSc.COMM_WORLD)
# store control variables
getpot = femLibrary.PylibMeshGetPot(PetscOptions)
#getpot.SetIniValue( "thermal_conductivity/k_0_probe","1.0e8")
#getpot.SetIniValue( "thermal_conductivity/k_0_tumor","1.0e8")
getpot.SetIniValue( "thermal_conductivity/k_0_healthy","0.45" )
#getpot.SetIniValue( "perfusion/w_0_healthy", "9.0" )
getpot.SetIniValue( "perfusion/w_0_healthy", "4.0" )
# tumor = applicator
getpot.SetIniValue( "perfusion/w_0_tumor", "0.0" )
#getpot.SetIniValue( "optical/mu_a_healthy", "5.0e2")
getpot.SetIniValue( "optical/mu_a_healthy", "3.2e2")
#getpot.SetIniValue( "optical/mu_s_healthy","140.0e2")
getpot.SetIniValue( "optical/mu_s_healthy","4.69e4")
getpot.SetIniValue( "optical/anfact" , "0.88" )
# from Duck table 2.15
getpot.SetIniValue( "material/specific_heat","3840.0" )
# set ambient temperature
u_init = 37.0
probe_init = 21.0
probe_init = u_init
getpot.SetIniValue( "initial_condition/u_init","%f" % u_init )
getpot.SetIniValue( "initial_condition/probe_init","%f" % probe_init )
getpot.SetIniValue( "bc/u_dirichletid","1" ) #apply dirichlet data on applicator domain
# set probe domain for heating
getpot.SetIniValue( "probe/domain" , "2" )
# root directory of data
# FIXME Josh update with your data directory
workDir = "/share/work/fuentes/data/biotex/090318_751642_treat/"
workDir = "/work/00131/jyung/data/biotex/KalmanLocalization/"
workDir = "/work/00131/fuentes/data/biotex/090318_751642_treat/"
workDir = "/data/fuentes/biotex/090318_751642_treat/"
workDir = "/work/01642/jyung/data/biotex/090318_751642_treat/KalmanLocalization/SDATemp/"
dataRoot = "%s/Processed/s1%03d%03d" % ( workDir, kwargs['cv']['uniform'] , kwargs['cv']['roi'] )
tmapRoot = "%s/Processed/s1%03d%03d" % ( workDir, 0 , 0 )
# load vtk modules to read imaging
import vtk
import vtk.util.numpy_support as vtkNumPy
# read imaging data geometry that will be used to project FEM data onto
#vtkReader = vtk.vtkXMLImageDataReader()
vtkReader = vtk.vtkDataSetReader()
vtkReader.SetFileName('%s/tmap.fem_data.0001.e.0000.vtk' % tmapRoot )
vtkReader.Update()
templateImage = vtkReader.GetOutput()
dimensions = templateImage.GetDimensions()
# dimensions should already be in meters
spacing = [ dx * 1.000 for dx in templateImage.GetSpacing() ]
origin = [ x0 * 1.000 for x0 in templateImage.GetOrigin() ]
origin = [-0.095223505, -0.058349645000000006, 0.049946399000000002]
print spacing, origin, dimensions
femImaging = femLibrary.PytttkImaging(getpot, dimensions ,origin,spacing)
#image_roi = [[130,155],[123,148],[0,0]]
image_roi = [[120,145],[123,148],[0,0]]
size_roi = [ image_roi[0][1]-image_roi[0][0]+1,
image_roi[1][1]-image_roi[1][0]+1,
image_roi[2][1]-image_roi[2][0]+1]
roiOrigin = [ origin[0] + image_roi[0][0] * spacing[0],
origin[1] + image_roi[1][0] * spacing[1],
origin[2] + image_roi[2][0] * spacing[2]]
# create ROI template
roi_array = numpy.zeros(dimensions,dtype=numpy.double,order='C')
#roi_array[118:153,125:160] = 1.e4
# TODO row/column major ordering never seems to work...
# FIXME notice the indices are reversed to account to the transpose
roi_array[image_roi[1][0]:image_roi[1][1]+1,
image_roi[0][0]:image_roi[0][1]+1] = 1.e4
roi_vec = PETSc.Vec().createWithArray( roi_array, comm=PETSc.COMM_SELF)
# initialize FEM Mesh
femMesh = femLibrary.PylibMeshMesh()
RotationMatrix = [[1.,0.,0.],
[0.,1.,0.],
[0.,0.,1.]]
Translation = [0.,0.,0.]
#Setup Affine Transformation for registration
AffineTransform = vtk.vtkTransform()
#AffineTransform.Translate( [0.050,0.080, origin[2]] )
#AffineTransform.Translate( [0.051,0.080, 0.0509] )
AffineTransform.Translate( [0.038,0.075, 0.050] )
#AffineTransform.RotateZ( 29.0 )
AffineTransform.RotateZ( 0.0 )
#AffineTransform.RotateY( 86.0 )
AffineTransform.RotateY( 270.0 )
#AffineTransform.RotateY( 90.0 )
AffineTransform.RotateX( 0.0 )
AffineTransform.Scale([1.,1.,1.])
matrix = AffineTransform.GetConcatenatedTransform(0).GetMatrix()
RotationMatrix = [[matrix.GetElement(0,0),matrix.GetElement(0,1),matrix.GetElement(0,2)],
[matrix.GetElement(1,0),matrix.GetElement(1,1),matrix.GetElement(1,2)],
[matrix.GetElement(2,0),matrix.GetElement(2,1),matrix.GetElement(2,2)]]
Translation = [matrix.GetElement(0,3),matrix.GetElement(1,3),matrix.GetElement(2,3)]
# set intial mesh
#femMesh.SetupUnStructuredGrid( "%s/meshTemplate1.e" % workDir ,0,RotationMatrix, Translation )
femMesh.SetupUnStructuredGrid( "%s/meshTemplate2.NoAppBoundary.e" % ".." ,0,RotationMatrix, Translation )
#femMesh.SetupUnStructuredGrid( "%s/meshTemplate2.WithAppBoundary.e" % ".." ,0,RotationMatrix, Translation )
#femMesh.SetupStructuredGrid( (60,60,2),
# [.0216,.0825],[.0432,.104],[-.001,.001],[2,2,2,2,3,2])
#femMesh.ReadFile("magnitudeROI.e")
# add the data structures for the Background System Solve
# set deltat, number of time steps, power profile, and add system
#acquisitionTime = 5.00
acquisitionTime = 1.00
deltat = acquisitionTime
#ntime = 128
ntime = 596
eqnSystems = femLibrary.PylibMeshEquationSystems(femMesh,getpot)
#getpot.SetIniPower(1, [ [17,27,39,69,ntime],[0.0,4.05,0.0,10.05,0.0] ])
getpot.SetIniPower(1, [ [35,135,195,ntime],[0.0,4.05,0.0,10.05,0.0] ])
# instantiate Kalman class
kalmanFilter = None
if ( kwargs['cv']['algebra'] == 0 ):
kalmanFilter = femLibrary.PytttkDenseKalmanFilterMRTI(eqnSystems, deltat)
elif ( kwargs['cv']['algebra'] == 1 ):
kalmanFilter = femLibrary.PytttkUncorrelatedKalmanFilterMRTI(eqnSystems, deltat)
elif ( kwargs['cv']['algebra'] == 2 ):
kalmanFilter = femLibrary.PytttkSparseKalmanFilterMRTI(eqnSystems, deltat)
else:
raise RuntimeError("\n\n unknown linear algebra... ")
kalmanFilter.systems["StateSystem"].AddStorageVectors(ntime)
# add systems to plot covariance
CovCol = [0,1,4,5,8,10,100,101,104,150,151,154,200,201,204,250,251,254,300,301,304,350,351,354,400,401,404,450,451,454,504,505,510,900,901,904,905,908,910,1000,1001,1004,1050,1051,1054,1100,1101,1104,1150,1151,1154,1200,1201,1204,1250,1251,1254,1300,1301,1304,1350,1351,1354,1400,1401,1404,1450,1451,1454,1500,1501,1504,1550,1551,1554,1600,1601,1604,1650,1651,1654,1700,1701,1704,1750,1751,1754,1802,1803,1805,1807,1832,1835,1836,1839,1908,1911,1946,1949,1984,1987,2022,2025,2060,2063,2098,2101,2136,2139,2174,2177,2216,2219,2516,2519,2520,2523,2592,2595,2630,2633,2668,2671,2706,2709,2744,2747,2782,2785,2820,2823,2858,2861,2896,2899,2934,2937,2972,2975,3010,3013,3048,3051,3086,3089,3124,3127,3162,3165,3201,3203,3217,3219,3221,3223,3303,3305,3346,3348,3389,3391,3432,3434,3475,3477,3518]
CovCol = [3520,3561,3563,3604,3606,3649,3653,3991,3993,3995,3997,4077,4079,4120,4122,4163,4165,4206,4208,4248,4250,4291,4293,4334,4336,4377,4379,4420,4422,4463,4465,4506,4508,4549,4551,4592,4594,4635,4637,4678,4680,4721,4723,4766,4767,4780,4782,4842,4873,4904,4935,4966,4997,5028,5059,5092,5338,5340,5400,5431,5462,5493,5524,5555,5586,5617,5648,5679,5710,5741,5772,5803,5834,5865,5897,5904,5905,5906,5907,5908,5909,5910,5911,5912,5913,5914,5915,5916,5917,5918,5919,5920,5921,5922,5923,5924,5925,5926,5927,5928,5929,5930,5931,5932,5933,5934,5935,5936,5937,5938,5939,5940,5941,5942,5943,5944,5945,5946,5947,5948,5949,5950,5951,5952,5953,5954,5955,5956,5957,5958,5959,5960,5961,5962,5963,5964,5965,5966,5967,5968,5969,5970,5971,5972,5973,5974,5975,5976,5977,5978,5979,5980,5981,5982,5983,5984,5985,5986,5987,5988,5989,5990,5991,5992,5993,5994,5995,5996,5997,5998,5999,6000]
CovCol = [6001,6002,6003,6004,6005,6006,6007,6008,6009,6010,6011,6012,6013,6014,6015,6016,6017,6018,6019,6020,6021,6022,6023,6024,6025,6026,6027,6028,6029,6030,6031,6032,6033,6034,6035,6036,6037,6038,6039,6040,6041,6042,6043,6044,6045,6046,6047,6048,6049,6050,6051,6052,6053,6054,6055,6056,6057,6058,6059,6060,6061,6062,6063,6064,6065,6066,6067,6068,6069,6070,6071,6072,6073,6074,6075,6076,6077,6078,6079,6080,6081,6082,6083,6084,6085,6086,6087,6088,6089,6090,6091,6092,6093,6094,6095,6096,6097,6098,6099,6100,6101,6102,6103,6104,6105,6106,6107,6108,6109,6110,6111,6112,6113,6114,6115,6116,6117,6118,6119,6120,6121,6122,6123,6124,6125,6126,6127,6128,6129,6130,6131,6132,6133,6134,6135,6136,6137,6138,6139,6140,6141,6142,6143,6144,6145,6146,6147,6148,6149,6150,6151,6152,6153,6154,6155]
CovCol = [33,187,3469]
CovCol = CovCol + [40,69,111,222,555,654,807,911,987,5454]
for column in CovCol:
tmpCovSystem = eqnSystems.AddExplicitSystem( "Cov%04d" % column )
tmpCovSystem.AddFirstLagrangeVariable( "col%04d" % column )
preUpdateSystem = eqnSystems.AddExplicitSystem( "preUpdate" )
preUpdateSystem.AddFirstLagrangeVariable( "predict" )
preUpdateSystem.AddFirstLagrangeVariable( "damage" )
preUpdateSystem.AddFirstLagrangeVariable( "damderiv" )
roiSystem = eqnSystems.AddExplicitSystem( "ROISystem" )
roiSystem.AddFirstLagrangeVariable( "roi" )
# initialize libMesh data structures
eqnSystems.init( )
# print info
eqnSystems.PrintSelf()
# project ROI
femImaging.ProjectImagingToFEMMesh("ROISystem",0.0,roi_vec,eqnSystems)
# show interpolations range
roi_vec.set(1.e4)
femImaging.ProjectImagingToFEMMesh("MRTIMean",0.0,roi_vec,eqnSystems)
# choose system to create measurement from
#numMeasurement = kalmanFilter.CreateMeasurementMapFromImaging("MRTIMean", 8 )
#numMeasurement = kalmanFilter.CreateMeasurementMapFromImaging("ROISystem", 8 )
MeasurementMapNodeSet = 7
MeasurementMapNodeSet = 8
FEMMeshIsImagingMesh = False
if ( FEMMeshIsImagingMesh ):
# create identity map if needed
MeasurementMapNodeSet = 9
numMeasurement = kalmanFilter.CreateIdentityMeasurementMap( MeasurementMapNodeSet )
kalmanFilter.Setup( numMeasurement )
kalmanFilter.CreateROINodeSetMeasurementMap( MeasurementMapNodeSet )
else : # default is unstructured FEM Mesh
# initialize petsc data structures
MeasurementMapNodeSet = 5 # use node set ID as the averaging number
numMeasurement = size_roi[0]* size_roi[1]* size_roi[2]
kalmanFilter.Setup( numMeasurement )
kalmanFilter.CreateROIAverageMeasurementMap(image_roi, MeasurementMapNodeSet ,
[origin[0], origin[1], 0.0469], spacing )
# get covariance diagonal and and covariance entries for plotting
for column in CovCol:
kalmanFilter.ExtractCoVarianceForPlotting("Cov%04d" % column,column)
kalmanFilter.ExtractVarianceForPlotting("StateStdDev")
# set output file
MeshOutputFile = "fem_data%s%d.%04d.e" % (kalmanFilter.LinAlgebra,
MeasurementMapNodeSet , kwargs['fileID'] )
# write IC
exodusII_IO = femLibrary.PylibMeshExodusII_IO(femMesh)
exodusII_IO.WriteTimeStep(MeshOutputFile,eqnSystems, 1, 0.0 )
# NOTE This is after IC write
# error check that can recover a constant field
roiVec = roiSystem.GetSolutionVector()
roiVec.set(1000.0)
imagetest = kalmanFilter.ProjectMeasurementMatrix(roiVec)
# show transpose measurement matrix map
kalmanFilter.MeasurementMatrixTranspose("ROISystem",1.e3)
# loop over time steps and solve
#for timeID in range(35,70):
for timeID in range(1,ntime):
print "time step = " ,timeID
eqnSystems.UpdatePetscFEMSystemTimeStep("StateSystem",timeID )
PredictionStage.push() # log prediction stage
# use model to predict the state and covariance
kalmanFilter.StatePredict(timeID)
kalmanFilter.CovariancePredict()
PredictionStage.pop() # log prediction stage
# copy from state system
preUpdateSystem.CopySolutionVector( kalmanFilter.systems["StateSystem"] )
CorrectionStage.push() # log correction stage
# read MRTI Data
vtkTmapReader = vtk.vtkDataSetReader()
vtkTmapReader.SetFileName('%s/tmap.fem_data.0001.e.%04d.vtk' % (tmapRoot,timeID) )
vtkTmapReader.Update()
tmap_cells = vtkTmapReader.GetOutput().GetPointData()
#tmap_array = u_init + vtkNumPy.vtk_to_numpy( tmap_cells.GetArray('scalars') )
tmap_array = vtkNumPy.vtk_to_numpy( tmap_cells.GetArray('scalars') )
tmap_vec = PETSc.Vec().createWithArray( tmap_array, comm=PETSc.COMM_SELF)
femImaging.ProjectImagingToFEMMesh("MRTIMean",u_init,tmap_vec,eqnSystems)
# read in SNR base uncertainty measurement
measurementCov = 2.0 * 2.0 ;
vtkSTDReader = vtk.vtkDataSetReader()
vtkSTDReader.SetFileName('%s/snruncert.fem_data.0001.e.%04d.vtk' % (dataRoot,timeID) )
vtkSTDReader.Update()
std_cells = vtkSTDReader.GetOutput().GetPointData()
snr_array = vtkNumPy.vtk_to_numpy(std_cells.GetArray('scalars'))
snr_vec = PETSc.Vec().createWithArray( snr_array, comm=PETSc.COMM_SELF )
femImaging.ProjectImagingToFEMMesh("MRTIStdDev",measurementCov,snr_vec,eqnSystems)
# extract data to kalman data structures
#mrtiSoln = kalmanFilter.systems["MRTIMean"].GetSolutionVector( )
#mrtiROI = kalmanFilter.ProjectMeasurementMatrix("MRTIMean")
mrtiROI = PETSc.Vec().createWithArray(
tmap_array.reshape(dimensions)[image_roi[1][0]:image_roi[1][1]+1,
image_roi[0][0]:image_roi[0][1]+1],comm=PETSc.COMM_SELF)
kalmanFilter.ExtractMeasurementData(mrtiROI,"MRTIStdDev")
#kalmanFilter.systems["MRTIMean"].ApplyDirichletData()
#kalmanFilter.systems["MRTIStdDev"].ApplyDirichletData()
# save prefem to disk for dbg
PreFEMsoln = eqnSystems.GetPetscFEMSystemSolnSubVector( "StateSystem", 0)
predictFEM = kalmanFilter.ProjectMeasurementMatrix(PreFEMsoln)
vtkPreFEMImage = ConvertNumpyVTKImage(predictFEM[...],"prefem",size_roi,spacing,roiOrigin)
vtkPreFEMWriter = vtk.vtkXMLImageDataWriter()
vtkPreFEMWriter.SetFileName( "prefemROI%d.%04d.%04d.vti" % (MeasurementMapNodeSet, kwargs['fileID'],timeID) )
vtkPreFEMWriter.SetInput( vtkPreFEMImage )
vtkPreFEMWriter.Update()
# save mrti to disk for compare
vtkMRTImage = ConvertNumpyVTKImage(mrtiROI[...],"mrti",size_roi,spacing,roiOrigin)
vtkMRTIWriter = vtk.vtkXMLImageDataWriter()
vtkMRTIWriter.SetFileName( "mrtiROI%d.%04d.%04d.vti" % (MeasurementMapNodeSet, kwargs['fileID'],timeID) )
vtkMRTIWriter.SetInput( vtkMRTImage )
vtkMRTIWriter.Update()
# save stddev to disk for rms
stddevROI = PETSc.Vec().createWithArray(
snr_array.reshape(dimensions)[image_roi[1][0]:image_roi[1][1]+1,
image_roi[0][0]:image_roi[0][1]+1],comm=PETSc.COMM_SELF)
vtkstdDevImage = ConvertNumpyVTKImage(stddevROI[...],"stddev",size_roi,spacing,roiOrigin)
vtkstdDevWriter = vtk.vtkXMLImageDataWriter()
vtkstdDevWriter.SetFileName( "stddevROI%d.%04d.%04d.vti" % (MeasurementMapNodeSet, kwargs['fileID'],timeID) )
vtkstdDevWriter.SetInput( vtkstdDevImage )
vtkstdDevWriter.Update()
# set UpdatePrediction = False to study model propagation only
UpdatePrediction = False
UpdatePrediction = True
if( UpdatePrediction ):
# update the state vector and covariance
kalmanGainSolver = "petsc"
kalmanGainSolver = "superlu_dist"
kalmanFilter.StateUpdate( kalmanGainSolver )
kalmanFilter.CovarianceUpdate()
CorrectionStage.pop() # log correction stage
# save prefem to disk for dbg
UpdateFEMsoln = eqnSystems.GetPetscFEMSystemSolnSubVector( "StateSystem", 0)
updateFEM = kalmanFilter.ProjectMeasurementMatrix(UpdateFEMsoln)
vtkUpdateFEMImage = ConvertNumpyVTKImage(updateFEM[...],"updatefem",size_roi,spacing,roiOrigin)
vtkUpdateFEMWriter = vtk.vtkXMLImageDataWriter()
vtkUpdateFEMWriter.SetFileName( "updatefemROI%d.%04d.%04d.vti" % (MeasurementMapNodeSet, kwargs['fileID'],timeID) )
vtkUpdateFEMWriter.SetInput( vtkUpdateFEMImage )
vtkUpdateFEMWriter.Update()
# get covariance diagonal and and covariance entries for plotting
for column in CovCol:
kalmanFilter.ExtractCoVarianceForPlotting("Cov%04d" % column,column)
kalmanFilter.ExtractVarianceForPlotting("StateStdDev")
# compute l2 norm of difference
print femLibrary.WeightedL2Norm(
kalmanFilter.systems["StateSystem"], "u0",
kalmanFilter.systems["MRTIMean"], "u0*",
kalmanFilter.systems["MRTIStdDev"],"du0*")
print femLibrary.WeightedL2Norm(
kalmanFilter.systems["StateSystem"], "u0",
kalmanFilter.systems["MRTIMean"], "u0*",
kalmanFilter.systems["StateStdDev"], "du0")
#eqnSystems.StoreTransientSystemTimeStep("StateSystem",timeID )
exodusII_IO.WriteTimeStep(MeshOutputFile,eqnSystems, timeID+1, timeID*deltat )
retval = dict([])
retval['fns'] = [0.0]
retval['rank'] = petscRank
return(retval)
"""
background correction model
"""
# import needed modules
import petsc4py, numpy, sys
import scipy.io as scipyio
PetscOptions = sys.argv
PetscOptions.append("-ksp_monitor")
PetscOptions.append("-ksp_rtol")
PetscOptions.append("1.e-10")
# need to solve w/ constant null space for Neumann problem
#PetscOptions.append("-ksp_constant_null_space")
#PetscOptions.append("-help")
petsc4py.init(PetscOptions)
# get rank
from petsc4py import PETSc
petscRank = PETSc.COMM_WORLD.getRank()
petscSize = PETSc.COMM_WORLD.Get_size()
sys.stdout.write("petsc rank %d petsc nproc %d\n" % (petscRank, petscSize))
# set shell context
# TODO import vtk should be called after femLibrary ????
# FIXME WHY IS THIS????
import femLibrary
# initialize libMesh data structures
libMeshInit = femLibrary.PyLibMeshInit(PetscOptions, PETSc.COMM_WORLD)
# load vtk modules to read imaging
import vtk
def help(args=None):
import sys, shlex
# program name
try:
prog = sys.argv[0]
except Exception:
prog = getattr(sys, 'executable', 'python')
# arguments
if args is None:
args = sys.argv[1:]
elif isinstance(args, str):
args = shlex.split(args)
else:
args = [str(a) for a in args]
# import and initialize
import petsc4py
petsc4py.init([prog, '-help'] + args)
from petsc4py import PETSc
# help dispatcher
COMM = PETSc.COMM_SELF
if 'vec' in args:
vec = PETSc.Vec().create(comm=COMM)
vec.setSizes(0)
vec.setFromOptions()
vec.destroy()
if 'mat' in args:
mat = PETSc.Mat().create(comm=COMM)
mat.setSizes([0, 0])
mat.setFromOptions()
mat.destroy()
if 'pc' in args:
pc = PETSc.PC().create(comm=COMM)
pc.setFromOptions()
pc.destroy()
if 'ksp' in args:
ksp = PETSc.KSP().create(comm=COMM)
ksp.setFromOptions()
ksp.destroy()
if 'snes' in args:
snes = PETSc.SNES().create(comm=COMM)
snes.setFromOptions()
snes.destroy()
if 'ts' in args:
ts = PETSc.TS().create(comm=COMM)
ts.setFromOptions()
ts.destroy()
if 'tao' in args:
tao = PETSc.TAO().create(comm=COMM)
tao.setFromOptions()
tao.destroy()
#if 'dm' in args:
# dm = PETSc.DM().create(comm=COMM)
# dm.setFromOptions()
# dm.destroy()
if 'dmda' in args:
dmda = PETSc.DMDA().create(comm=COMM)
dmda.setFromOptions()
dmda.destroy()
if 'dmplex' in args:
dmplex = PETSc.DMPlex().create(comm=COMM)
dmplex.setFromOptions()
dmplex.destroy()
import os, petsc4py
petsc4py.init(os.sys.argv)
from petsc4py import PETSc
import scipy as sp
import scipy.sparse
def pol2car(r,tho):
return r*sp.cos(tho),r*sp.sin(tho)
def car2pol(x,y):
return sp.sqrt(x**2+y**2),sp.arctan2(y,x)
def ComputeCP(x):
'''Compute CP for circle'''
tho = car2pol(x[:,0],x[:,1])[1]
xx,yy = pol2car(1.0,tho)
rslt = sp.zeros((x.shape))
rslt[:,0] = xx
rslt[:,1] = yy
return rslt
def GenerateDiffMatNP(k,m,n):
mat = scipy.sparse.lil_matrix((m*n,(m+2)*(n+2)))
def helper_base(i,j,base,value,rm=m,rn=n,m=mat):
m[i*rm+j,(i+1)*(rm+2)+j+1+base]=value
def helper_1((i,j)):
helper_base(i,j,0,-4*k)
def helper_2((i,j)):
# --------------------------------------------------------------------
if __name__ == "__main__":
import sys, petsc4py
petsc4py.init(sys.argv + ["-log_summary"])
# --------------------------------------------------------------------
from petsc4py import PETSc
import unittest
# --------------------------------------------------------------------
class TestLog(unittest.TestCase):
def setUp(self):
# PETSc.Log.begin()
# register stages
self.stage1 = PETSc.Log.Stage("Stage 1")
self.stage2 = PETSc.Log.Stage("Stage 2")
# register classes
self.klassA = PETSc.Log.Class("Class A")
self.klassB = PETSc.Log.Class("Class B")
# register events
self.event1 = PETSc.Log.Event("Event 1") # no class
self.event2 = PETSc.Log.Event("Event 2") # no class
self.eventA = PETSc.Log.Event("Event A", self.klassA)
self.eventB = PETSc.Log.Event("Event B", self.klassB)
def testGetName(self):
"""
default LU Facto
"""
import sys, petsc4py
PetscOptions = sys.argv
PetscOptions.append("-log_summary")
petsc4py.init(PetscOptions)
from petsc4py import PETSc
import numpy
import scipy.io as scipyio
# create stages for logging
LogSetup = PETSc.Log.Stage("Setup")
LogFactor= PETSc.Log.Stage("Factor")
LogSolve = PETSc.Log.Stage("Solve")
LogSetup.push()
# read in matrix
#sumcov = scipyio.loadmat("/home/fuentes/DDDAS/trunk/dddas/SumCov.mat" )
#n = len(sumcov['Mat_0'])
#AMat = PETSc.Mat().createDense([n, n], array=sumcov['Mat_0'],comm=PETSc.COMM_WORLD)
n = 7000
AMat = PETSc.Mat().createDense([n, n], array=numpy.random.rand(n,n), comm=PETSc.COMM_WORLD)
AMat.assemblyBegin();AMat.assemblyEnd()
# storage space for solution
AInv = PETSc.Mat().createDense([n, n], array=numpy.zeros((n,n)), comm=PETSc.COMM_WORLD)
AInv.assemblyBegin();AInv.assemblyEnd()
from scipy.signal import correlate
import glob
import os
import sys
import h5py
import matplotlib
import matplotlib.gridspec as gridspec
import matplotlib.patches as patches
from matplotlib.collections import LineCollection
from matplotlib import transforms, colors
matplotlib.use('agg')
import pylab as pl
#import yt
#yt.enable_parallelism()
import petsc4py, sys; petsc4py.init(sys.argv)
from petsc4py import PETSc
import PetscBinaryIO
import domain
#import boundary_conditions
#import params
#import initialize
#import coords
def line(x, m, c):
return (m*x+c)
# Optimized plot parameters to make beautiful plots:
parser.add_argument('--implicit')
parser.add_argument('--imex')
parser.add_argument('--explicit')
parser.add_argument('--solver', default='gmres')
parser.add_argument('--seed', type=int, default=793817931)
commandlineArguments = parser.parse_args(namespace=commandlineArguments)
parse_commandline()
import petsc4py, sys
from KSDG import *
import fenics as fe
import numpy as np
#
# this needs to be done before importing PETSc
#
petsc4py.init(sys.argv[0:1] + commandlineArguments.petsc)
from petsc4py import PETSc
fe.parameters.parse(sys.argv[0:1] + commandlineArguments.fenics)
fe.parameters['ghost_mode'] = 'shared_facet'
def main():
nelements = 8
dim = 1
degree = 2
params = {
'alpha': 1,
'beta': 1,
'mu': 0.4,
'Umax': 1,
'Ufac': 4,
'sU': 1,
def main():
comm = MPI.COMM_WORLD
if comm.size > 1:
raise KSFDException('tsmerge must be run sequentially.')
petsc4py.init()
parser = ArgumentParser(description='Merge time series', allow_abbrev=True)
parser.add_argument('-o', '--outfile', help='merged file basename')
parser.add_argument('-s',
'--start',
type=float,
default=0.0,
help='start time')
parser.add_argument('-e', '--end', type=float, help='end time')
parser.add_argument('infiles', nargs='+', help='files to merge')
parser.add_argument('-v', '--verbose', action='count')
clargs = parser.parse_args()
times = np.empty((0), dtype=float)
steps = np.empty((0), dtype=int)
files = np.empty((0), dtype=int)
grid = None
for f, name in enumerate(clargs.infiles):
if clargs.verbose > 0:
print('collecting times from {name}'.format(name=name), flush=True)
g = Gatherer(name)
if grid is None:
grid = g.grid
st = g.sorted_times()
if clargs.verbose > 1:
print('times:', st, flush=True)
steps = np.append(steps, g.steps())
times = np.append(times, st)
files = np.append(files, np.full_like(st, f, dtype=int))
g.close()
out = TimeSeries(clargs.outfile, grid, comm=MPI.COMM_SELF, mode='w')
# order = times.argsort()
# files = files[order]
# steps = steps[order]
# times = times[order]
k = 0
del out.tsf['/info']
for f, name in enumerate(clargs.infiles):
if clargs.verbose > 0:
print('collecting data from {name}'.format(name=name), flush=True)
fmatch = files == f
# forder = order[fmatch]
fsteps = steps[fmatch]
ftimes = times[fmatch]
g = Gatherer(name)
if '/info' not in out.tsf:
g.tsf.copy(source='/info',
dest=out.tsf,
name='/info',
shallow=False)
for s in g:
if clargs.verbose > 0:
print(str(s.tsf), flush=True)
for k, t in zip(fsteps, ftimes):
if t < clargs.start or (clargs.end and t > clargs.end):
continue
vals = s.retrieve_by_number(k)
if clargs.verbose > 1:
print('point {k}, time {t}'.format(k=k, t=t), flush=True)
out.store_slice(s.ranges, vals, t)
g.close()
out.close()
def pennesModeling(**kwargs):
"""
treatment planning model
"""
# import petsc and numpy
import petsc4py, numpy
# init petsc
PetscOptions = sys.argv
PetscOptions.append("-snes_monitor")
PetscOptions.append("-snes_converged_reason")
PetscOptions.append("-ksp_monitor")
PetscOptions.append("-ksp_converged_reason")
PetscOptions.append("-ksp_rtol")
PetscOptions.append("1.0e-15")
#PetscOptions.append("-help")
#PetscOptions.append("-idb")
petsc4py.init(PetscOptions)
# break processors into separate communicators
from petsc4py import PETSc
petscRank = PETSc.COMM_WORLD.getRank()
petscSize = PETSc.COMM_WORLD.Get_size()
sys.stdout.write("petsc rank %d petsc nproc %d\n" % (petscRank, petscSize))
# the original configuration ini file should be stored
config = kwargs['config_parser']
# set shell context
# TODO import vtk should be called after femLibrary ????
# FIXME WHY IS THIS????
import femLibrary
# initialize libMesh data structures
libMeshInit = femLibrary.PyLibMeshInit(PetscOptions,PETSc.COMM_WORLD)
# store control variables
getpot = femLibrary.PylibMeshGetPot(PetscOptions)
# copy all values from the input file
for section in config.sections():
for name,value in config.items(section):
#print "%s/%s" % (section,name) , value
getpot.SetIniValue( "%s/%s" % (section,name) , value )
#####################################################
# update values from dakota
#####################################################
# thermal conductivity from Duck/CRC Handbook
try:
getpot.SetIniValue( "thermal_conductivity/k_0_healthy",
kwargs['cv']['k_0_healthy'] )
except KeyError:
pass #use default value
# nonlinear conductivity
try:
getpot.SetIniValue( "thermal_conductivity/k_1",
kwargs['cv']['k_1'] )
except KeyError:
pass #use default value
# tumor conductivity
try:
getpot.SetIniValue( "thermal_conductivity/k_0_tumor",
kwargs['cv']['k_0_tumor'] )
except KeyError:
pass #use default value
# perfusion from Duck/CRC Handbook
try:
getpot.SetIniValue( "perfusion/w_0_healthy",
kwargs['cv']['w_0_healthy'] )
except KeyError:
pass #use default value
try:
getpot.SetIniValue( "perfusion/w_1",
kwargs['cv']['w_1_coag'] )
except KeyError:
pass #use default value
try:
getpot.SetIniValue( "perfusion/w_0_tumor",
kwargs['cv']['w_0_tumor'] )
except KeyError:
pass #use default value
# water properties from Duck
# Adult white mater
# 3.2 1/cm
# Beek et al., 1993a
# Adult grey mater
# 5.0 1/cm
try:
getpot.SetIniValue( "optical/mu_a_healthy",
kwargs['cv']['mu_a_healthy'] )
except KeyError:
pass #use default value
try:
getpot.SetIniValue( "optical/mu_a_1",
kwargs['cv']['mu_a_coag'] )
except KeyError:
pass #use default value
# 1-300
try:
getpot.SetIniValue( "optical/mu_a_tumor",
kwargs['cv']['mu_a_tumor'] )
except KeyError:
pass #use default value
# FIXME large mu_s (> 30) in agar causing negative fluence to satisfy BC
try:
getpot.SetIniValue( "optical/mu_s_healthy",
kwargs['cv']['mu_s_healthy'] )
except KeyError:
pass #use default value
try:
getpot.SetIniValue( "optical/mu_s_1",
kwargs['cv']['mu_s_coag'] )
except KeyError:
pass #use default value
# 1-300
try:
getpot.SetIniValue( "optical/mu_s_tumor",
kwargs['cv']['mu_s_tumor'] )
except KeyError:
pass #use default value
# from AE paper
#http://scitation.aip.org/journals/doc/MPHYA6-ft/vol_36/iss_4/1351_1.html#F3
# .9 - .99
try:
getpot.SetIniValue( "optical/anfact",
kwargs['cv']['anfact'] )
except KeyError:
pass #use default value
#
# given the original orientation as two points along the centerline z = x2 -x1
# the transformed orienteation would be \hat{z} = A x2 + b - A x1 - b = A z
# ie transformation w/o translation which is exactly w/ vtk has implemented w/ TransformVector
# TransformVector = TransformPoint - the transation
#Setup Affine Transformation for registration
RotationMatrix = [[1.,0.,0.],
[0.,1.,0.],
[0.,0.,1.]]
Translation = [0.,0.,0.]
# initialize FEM Mesh
femMesh = femLibrary.PylibMeshMesh()
#femMesh.SetupUnStructuredGrid(kwargs['mesh_file'],0,RotationMatrix, Translation )
femMesh.ReadFile(kwargs['mesh_file'])
MeshOutputFile = MeshOutputTemplate % kwargs['fileID']
#fem.SetupStructuredGrid( (10,10,4) ,[0.0,1.0],[0.0,1.0],[0.0,1.0])
# add the data structures for the Background System Solve
# set deltat, number of time steps, power profile, and add system
eqnSystems = femLibrary.PylibMeshEquationSystems(femMesh,getpot)
#getpot.SetIniPower(1,[[19,119],[90.0,100.0]] )
getpot.SetIniPower(1,kwargs['powerHistory'] )
# AddPennesSDASystem
# AddPennesRFSystem
# AddPennesDeltaPSystem
pennesSystem = eval("eqnSystems.%s('StateSystem',kwargs['deltat'])" % kwargs['physics'])
pennesSystem.AddStorageVectors( kwargs['ntime']+1 )
# initialize libMesh data structures
eqnSystems.init( )
# quick error check
#errCheckSoln = fem.GetSolutionVector( "StateSystem" )[...]
#if ( errCheckSoln.size + 1 != kwargs['functions'] ):
# print "ERROR!! number of response functions incorrect!!"
# raise RuntimeError("soln vec + 1 = %d .NE. num_response = %d"%(errCheckSoln.size+1,kwargs['functions']) )
# print info
eqnSystems.PrintSelf()
# setup IC
pennesSystem.PetscFEMSystemSetupInitialConditions( )
# get responses for list of variable
responseLevelVarList = kwargs['responseLevelVarList']
# write IC
exodusII_IO = femLibrary.PylibMeshExodusII_IO(femMesh)
exodusII_IO.WriteTimeStep(MeshOutputFile,eqnSystems, 1, 0.0 )
ObjectiveFunction = 0.0
# loop over time steps and solve
print "deltat = ",kwargs['deltat']
#for timeID in range(1,2):
for timeID in range(1,kwargs['ntime']+1):
print "time step = " ,timeID
#for subTimeID in range(1):
for subTimeID in range(kwargs['nsubstep']):
pennesSystem.PetscFEMSystemUpdateTimeStep( timeID )
pennesSystem.SystemSolve( )
#fem.StoreTransientSystemTimeStep("StateSystem",timeID )
exodusII_IO.WriteTimeStep(MeshOutputFile ,eqnSystems, timeID+1, timeID*kwargs['acquisitionTime'])
retval = dict([])
retval['fns'] = [ObjectiveFunction]
retval['rank'] = petscRank
return(retval)
#!/usr/bin/env python
# provides an easy interface with petsc
import numpy as np
import scipy.sparse
import logging
import modest
import matplotlib.pyplot as plt
try:
import petsc4py
petsc4py.init()
from petsc4py import PETSc
except ImportError:
print(
'could not import PETSc. '
'PETSc can be installed by following the instructions at '
'https://www.mcs.anl.gov/petsc. Interfacing with PETSc requires '
'petsc4py which can be found at https://bitbucket.org/petsc/petsc4py. '
'Installing the latest version of petsc4py can be done with the command\n\n'
' pip install https://bitbucket.org/petsc/petsc4py/get/master.tar.gz\n')
raise
logger = logging.getLogger(__name__)
def _monitor(solver, its, fgnorm):
'''
this function is called for each iteration of a KSP solver
'''
logger.info('preconditioned residual norm at iteration %s: %.5e' % (its,fgnorm))
# Stiff 3-variable ODE system from chemical reactions,
# due to Robertson (1966),
# problem ROBER in Hairer&Wanner, ODE 2, 1996
import sys, petsc4py
petsc4py.init(sys.argv)
from petsc4py import PETSc
class Rober(object):
n = 3
comm = PETSc.COMM_SELF
def evalSolution(self, t, x):
assert t == 0.0, "only for t=0.0"
x[:] = [1, 0, 0]
x.assemble()
def evalFunction(self, ts, t, x, xdot, f):
f[:] = [
xdot[0] + 0.04 * x[0] - 1e4 * x[1] * x[2],
xdot[1] - 0.04 * x[0] + 1e4 * x[1] * x[2] + 3e7 * x[1]**2,
xdot[2] - 3e7 * x[1]**2
]
f.assemble()
def evalJacobian(self, ts, t, x, xdot, a, A, B):
J = B
J[:, :] = [[a + 0.04, -1e4 * x[2], -1e4 * x[1]],
[-0.04, a + 1e4 * x[2] + 3e7 * 2 * x[1], 1e4 * x[1]],
if True:
import numpy as np
import sys
from numpy import pi
from math import floor
import json
from sympy.physics.wigner import gaunt, wigner_3j
import Module as Mod
import Potential as Pot
if True:
import petsc4py
from petsc4py import PETSc
petsc4py.init(sys.argv)
petsc4py.init(comm=PETSc.COMM_WORLD)
from mpi4py import MPI
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
def Dipole_Z_Matrix(input_par):
index_map_l_m, index_map_box = Mod.Index_Map_M_Block(input_par)
grid = Mod.Make_Grid(input_par["grid_spacing"], input_par["grid_size"], input_par["grid_spacing"])
matrix_size = grid.size * len(index_map_l_m)
h = abs(grid[1] - grid[0])
Dipole_Matrix = PETSc.Mat().createAIJ([matrix_size, matrix_size], nnz=2, comm=PETSc.COMM_WORLD)
istart, iend = Dipole_Matrix.getOwnershipRange()
for i in range(istart, iend):
l_block = index_map_l_m[floor(i/grid.size)][1]
# Mostafa Mollaali
# Vahid
from fenics import *
from dolfin import *
from mshr import *
from dolfin_utils.meshconvert import meshconvert
from scipy.interpolate import UnivariateSpline
from scipy.interpolate import LinearNDInterpolator
import matplotlib.pyplot as plt
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
import sympy, sys, math, os, subprocess, shutil
import petsc4py
petsc4py.init()
from petsc4py import PETSc
from math import hypot, atan2, erfc
#=======================================================================================
def vec(z):
if isinstance(z, dolfin.cpp.Function):
return dolfin.as_backend_type(z.vector()).vec()
else:
return dolfin.as_backend_type(z).vec()
def mat(A):
return dolfin.as_backend_type(A).mat()
"""
Functions for a high-level PETSc-based parallelization.
"""
from __future__ import absolute_import
import time
import numpy as nm
import sys, petsc4py
from six.moves import range
argv = [arg for arg in sys.argv if arg not in ['-h', '--help']]
petsc4py.init(argv)
from petsc4py import PETSc
from mpi4py import MPI
from sfepy.base.base import assert_, output, ordered_iteritems, Struct
from sfepy.discrete.common.region import Region
from sfepy.discrete.fem.fe_surface import FESurface
def partition_mesh(mesh, n_parts, use_metis=True, verbose=False):
"""
Partition the mesh cells into `n_parts` subdomains, using metis, if
available.
"""
output('partitioning mesh into %d subdomains...' % n_parts,
verbose=verbose)
tt = time.clock()
if use_metis:
def PPS(self,p):
"""
Parallel solver implementing a PETSc KSP linear routine over the entire scene as a
single patch (PPS = Parallel PETSc Single)
"""
from _reconutils import get_gcd_vals, laplace_builder
try:
import mpi4py
from mpi4py import MPI
except:
print 'PPS requires that mpi4py be installed and in the Python path'
sys.exit()
try:
import petsc4py
petsc4py.init([],comm=MPI.COMM_WORLD)
from petsc4py import PETSc
except:
print 'PPS requires that petsc4py be installed and in the Python path'
sys.exit()
PETSc.Sys.Print('Running PPS: Parallel PETSc (linear) Solver on a single patch')
comm=PETSc.COMM_WORLD
size, rank = comm.Get_size(), comm.Get_rank()
cols = p.gen.cols
try:
p.gen.gmat_rows
except:
fid = open('.gmat_rows','r')
p.gen.gmat_rows = np.int32(''.join(fid.readlines()))
fid.close()
if rank == 0:
address = self._read_address(p)
metfile, modlen = p.gen.metfile, 3*len(address)
PETSc.Sys.Print('retrieving gmat, cdi, and dvec vals')
### get gmat, Cd and d values and send segments to other processors
gmatvals, gmatij, cdiv_temp, dvec_temp = get_gcd_vals(metfile,len(p.scenes),
p.gen.doline,p.gen.cols,address,p.gen.gmat_rows)
gmatij = gmatij.reshape(-1,3*p.gen.gmat_rows)
if gmatij.dtype != np.int32: gmatij = gmatij.astype(np.int32)
if p.gen.cmlambda < 1.e-12: del address
### initialize arrays to store start and end row indices for all procs
rowblocks_gmat = np.empty([2,size],dtype=np.int32)
rowblocks_cdiv = np.empty([2,size],dtype=np.int32)
rowblocks_dvec = np.empty([2,size],dtype=np.int32)
modlen = comm.bcast(modlen,root=0)
PETSc.Sys.Print('building sparse matrices')
### initialize
gmat = PETSc.Mat().createAIJ([p.gen.gmat_rows,modlen],nnz=p.gen.gmat_rows*3,comm=comm)
cdiv = PETSc.Mat().createAIJ([p.gen.gmat_rows,p.gen.gmat_rows],nnz=p.gen.gmat_rows,comm=comm)
dvec = PETSc.Vec().createMPI(p.gen.gmat_rows,comm=comm)
### get the block of rows owned by this processor
sr_gmat, er_gmat = gmat.getOwnershipRange()
sr_cdiv, er_cdiv = cdiv.getOwnershipRange()
sr_dvec, er_dvec = dvec.getOwnershipRange()
### send start/end rows to root proc and receive gmat, cdiv, and dvec entries
base_tag, base_stag = 777, 999
if rank == 0:
rowblocks_gmat[0,0], rowblocks_gmat[1,0] = sr_gmat, er_gmat
rowblocks_cdiv[0,0], rowblocks_cdiv[1,0] = sr_cdiv, er_cdiv
rowblocks_dvec[0,0], rowblocks_dvec[1,0] = sr_dvec, er_dvec
tag,stag = base_tag, base_stag
for i in np.arange(1,size):
comm.Recv([rowblocks_gmat[:,i],2,MPI.INT],source=i,tag=tag); tag += 1
comm.Recv([rowblocks_cdiv[:,i],2,MPI.INT],source=i,tag=tag); tag += 1
comm.Recv([rowblocks_dvec[:,i],2,MPI.INT],source=i,tag=tag); tag += 1
svec = gmatvals[3*rowblocks_gmat[0,i]:3*(rowblocks_gmat[1,i])]
comm.Send([svec,len(svec), MPI.FLOAT], dest=i, tag=stag); stag += 1
svec = gmatij[:,3*rowblocks_gmat[0,i]:3*(rowblocks_gmat[1,i])].flatten()
comm.Send([svec,len(svec), MPI.INT], dest=i, tag=stag); stag += 1
svec = cdiv_temp[rowblocks_cdiv[0,i]:rowblocks_cdiv[1,i]]
comm.Send([svec,len(svec), MPI.FLOAT], dest=i, tag=stag); stag += 1
svec = dvec_temp[rowblocks_dvec[0,i]:rowblocks_dvec[1,i]]
comm.Send([svec,len(svec), MPI.FLOAT], dest=i, tag=stag); stag += 1
del svec
gmatvals = gmatvals[3*rowblocks_gmat[0,0]:3*(rowblocks_gmat[1,0])]
gmatij = gmatij[:,3*rowblocks_gmat[0,0]:3*(rowblocks_gmat[1,0])]
cdiv_temp = cdiv_temp[rowblocks_cdiv[0,0]:rowblocks_cdiv[1,0]]
dvec_temp = dvec_temp[rowblocks_dvec[0,0]:rowblocks_dvec[1,0]]
else:
tag = base_tag + (rank-1)*3
comm.Send([np.array([sr_gmat, er_gmat]),2,MPI.INT], dest=0, tag=tag); tag += 1
comm.Send([np.array([sr_cdiv, er_cdiv]),2,MPI.INT], dest=0, tag=tag); tag += 1
comm.Send([np.array([sr_dvec, er_dvec]),2,MPI.INT], dest=0, tag=tag); tag += 1
stag = base_stag + (rank-1)*3
gmatvals = np.empty(3*(er_gmat-sr_gmat), dtype=np.float32)
gmatij = np.empty(2*3*(er_gmat-sr_gmat), dtype=np.int32)
cdiv_temp = np.empty((er_gmat-sr_gmat), dtype=np.float32)
dvec_temp = np.empty((er_gmat-sr_gmat), dtype=np.float32)
comm.Recv([gmatvals,len(gmatvals),MPI.FLOAT],source=0, tag=stag); stag += 1
comm.Recv([gmatij,len(gmatij),MPI.INT],source=0, tag=stag); stag += 1
comm.Recv([cdiv_temp,len(cdiv_temp),MPI.FLOAT],source=0, tag=stag); stag += 1
comm.Recv([dvec_temp,len(dvec_temp),MPI.FLOAT],source=0, tag=stag); stag += 1
gmatij = gmatij.reshape(2,-1)
### load and assemble gmat, cdiv, and dvec
for i in np.arange(len(dvec_temp)):
threei = 3*i
gmat.setValue(gmatij[0,threei],gmatij[1,threei],gmatvals[threei])
gmat.setValue(gmatij[0,threei],gmatij[1,threei+1],gmatvals[threei+1])
gmat.setValue(gmatij[0,threei],gmatij[1,threei+2],gmatvals[threei+2])
cdiv.setValue(gmatij[0,threei],gmatij[0,threei],cdiv_temp[i])
dvec.setValue(gmatij[0,threei],dvec_temp[i])
comm.Barrier()
dvec.assemblyBegin(); dvec.assemblyEnd()
gmat.assemblyBegin(assembly=FINAL); gmat.assemblyEnd(assembly=FINAL)
cdiv.assemblyBegin(assembly=FINAL); cdiv.assemblyEnd(assembly=FINAL)
comm.Barrier()
del gmatvals, gmatij, cdiv_temp, dvec_temp
### build A and gtilde (=dtilde)
omega = PETSc.Mat().createAIJ([modlen,p.gen.gmat_rows],comm=comm)
omega = gmat.matTransposeMult(cdiv,omega)
cdiv.destroy()
gtg = PETSc.Mat().createAIJ([modlen,modlen],comm=comm)
mtilde,gtilde = gtg.getVecs()
omega.mult(dvec,gtilde)
gtg = omega.matMult(gmat,gtg)
dvec.destroy(); omega.destroy(); gmat.destroy()
mtilde.set(0)
if p.gen.cmlambda > 1.e-12:
PETSc.Sys.Print('building fmat')
if rank == 0:
try:
aa = len(address)
if 3*aa != modlen:
address = self._read_address(p)
except:
address = self._read_address(p)
fmatval, fmatij = laplace_builder(p.gen.cols,address)
fmatval = fmatval[:np.argmin(fmatval)]
fmatij = fmatij.reshape(2,-1)[:,:len(fmatval)]
if fmatij.dtype != np.int32: fmatij = fmatij.astype(np.int32)
del address
rowblocks_fmat = np.empty([2,size],dtype=np.int32)
fmat = gtg.duplicate(copy=False)
fmat.setPreallocationNNZ(nnz=len(fmatval))
### get the row addresses for this processor
sr_fmat, er_fmat = fmat.getOwnershipRange()
base_tag, base_stag = 77, 444
if rank == 0:
rowblocks_fmat[0,0], rowblocks_fmat[1,0] = sr_fmat, er_fmat
tag, stag = base_tag, base_stag
for i in np.arange(1,size):
comm.Recv([rowblocks_fmat[:,i],2,MPI.INT],source=i,tag=tag); tag += 1
# get indexes for fmatval and fmatij
left = np.argmin(np.abs(fmatij[0,:]-rowblocks_fmat[0,i]))
right = np.argmin(np.abs(fmatij[0,:]-rowblocks_fmat[1,i]))
svec = fmatval[left:right]
comm.Send([len(svec),1,MPI.INT], dest=i, tag=stag); stag += 1
comm.Send([svec,len(svec),MPI.FLOAT], dest=i, tag=stag); stag += 1
svec = fmatij[:,left:right].flatten()
comm.Send([svec,len(svec),MPI.INT], dest=i, tag=stag); stag += 1
fmatval = fmatval[sr_fmat:er_fmat]
fmatij = fmatij[:,sr_fmat:er_fmat]
else:
tag, stag = base_tag + (rank-1), base_stag + (rank-1)*3
comm.Send([np.array([sr_fmat, er_fmat]),2,MPI.INT], dest=0, tag=tag); tag += 1
comm.Recv([lenrec,1,MPI.INT], source=0, tag=stag); stag += 1
fmatval = np.empty(lenrec,dtype=np.float32)
fmatij = np.empty(2*lenrec,dtype=np.int32)
comm.Recv([fmatval,lenrec,MPI.FLOAT], source=0, tag=stag); stag += 1
comm.Recv([fmatij,2*lenrec,MPI.INT], source=0, tag=stag); stag += 1
fmatij = fmatij.reshape(2,-1)
PETSc.Sys.Print('loading sparse fmat...')
for i in np.arange(len(fmatval)):
fmat.setValue(fmatij[0,i],fmatij[1,i],fmatval[i])
comm.Barrier()
fmat.assemblyBegin(assembly=FINAL); fmat.assemblyEnd(assembly=FINAL)
comm.Barrier()
del fmatval, fmatij
PETSc.Sys.Print('loading cli...')
cliv = PETSc.Vec().createMPI(modlen,comm=comm)
gtg.getDiagonal(cliv)
cli = gtg.duplicate(copy=False)
cli.setDiagonal(cliv)
cliv.destroy()
PETSc.Sys.Print('building C_m...')
rhs = gtg.duplicate(copy=False)
rhs = fmat.matTransposeMult(cli,rhs)
rhs = rhs.matMult(fmat)
cli.destroy(); fmat.destroy()
PETSc.Sys.Print('building A...\n')
gtg.axpy(p.gen.cmlambda,rhs)
rhs.destroy()
PETSc.Sys.Print('inverting using PETSc lsqr...')
ksp = PETSc.KSP().create(comm)
ksp.setType('lsqr')
ksp.pc.setType('none')
ksp.setOperators(gtg)
ksp.setFromOptions()
t0 = time.time()
ksp.solve(gtilde,mtilde)
gtg.destroy(); gtilde.destroy(); ksp.destroy()
PETSc.Sys.Print('lsqr took %10f seconds'%(time.time()-t0))
PETSc.Sys.Print(' Converged in %d iterations '%(ksp.getIterationNumber()))
PETSc.Sys.Print(' Tolerance Asked: %e %e %d %d'%(ksp.getTolerances()))
PETSc.Sys.Print(' Converged Reason: %d'%(ksp.getConvergedReason()))
PETSc.Sys.Print(' ')
comm.Barrier()
if rank == 0:
mtildenump = mtilde[...]; mtilde.destroy()
self._write_post_model(model=mtildenump,p=p)
comm.Barrier()
PETSc._finalize
MPI.Finalize
def pennesModeling(**kwargs):
"""
treatment planning model
"""
# import needed modules
import petsc4py, numpy, sys
PetscOptions = sys.argv
PetscOptions.append("-ksp_monitor")
PetscOptions.append("-ksp_rtol")
PetscOptions.append("1.0e-15")
#PetscOptions.append("-idb")
petsc4py.init(PetscOptions)
from petsc4py import PETSc
# break processors into separate communicators
petscRank = PETSc.COMM_WORLD.getRank()
petscSize = PETSc.COMM_WORLD.Get_size()
sys.stdout.write("petsc rank %d petsc nproc %d\n" % (petscRank, petscSize))
# set shell context
import femLibrary
# initialize libMesh data structures
libMeshInit = femLibrary.PyLibMeshInit(PetscOptions,PETSc.COMM_WORLD)
# the original configuration ini file should be stored
config = kwargs['config_parser']
# store control variables
getpot = femLibrary.PylibMeshGetPot(PetscOptions)
# copy all values from the input file
for section in config.sections():
for name,value in config.items(section):
#print "%s/%s" % (section,name) , value
getpot.SetIniValue( "%s/%s" % (section,name) , value )
# nodeset 1 will be treated as dirichlet
dirichletID = 1
getpot.SetIniValue( "bc/u_dirichlet" , '%d' % dirichletID )
# set tissue lookup tables
k_0Table = {"default":config.getfloat("thermal_conductivity","k_0_healthy") ,
"vessel" :config.getfloat("thermal_conductivity","k_0_healthy") ,
"grey" :config.getfloat("thermal_conductivity","k_0_grey" ) ,
"white" :config.getfloat("thermal_conductivity","k_0_white" ) ,
"csf" :config.getfloat("thermal_conductivity","k_0_csf" ) ,
"tumor" :config.getfloat("thermal_conductivity","k_0_tumor" ) }
w_0Table = {"default":config.getfloat("perfusion","w_0_healthy") ,
"vessel" :config.getfloat("perfusion","w_0_healthy") ,
"grey" :config.getfloat("perfusion","w_0_grey" ) ,
"white" :config.getfloat("perfusion","w_0_white" ) ,
"csf" :config.getfloat("perfusion","w_0_csf" ) ,
"tumor" :config.getfloat("perfusion","w_0_tumor" ) }
mu_aTable = {"default":config.getfloat("optical","mu_a_healthy") ,
"vessel" :config.getfloat("optical","mu_a_healthy") ,
"grey" :config.getfloat("optical","mu_a_grey" ) ,
"white" :config.getfloat("optical","mu_a_white" ) ,
"csf" :config.getfloat("optical","mu_a_csf" ) ,
"tumor" :config.getfloat("optical","mu_a_tumor" ) }
mu_sTable = {"default":config.getfloat("optical","mu_s_healthy") ,
"vessel" :config.getfloat("optical","mu_s_healthy") ,
"grey" :config.getfloat("optical","mu_s_grey" ) ,
"white" :config.getfloat("optical","mu_s_white" ) ,
"csf" :config.getfloat("optical","mu_s_csf" ) ,
"tumor" :config.getfloat("optical","mu_s_tumor" ) }
labelTable= {config.get("labels","greymatter" ):"grey" ,
config.get("labels","whitematter"):"white",
config.get("labels","csf" ):"csf" ,
config.get("labels","tumor" ):"tumor",
config.get("labels","vessel" ):"vessel"}
labelCount= {"default":0,
"grey" :0,
"white" :0,
"csf" :0,
"tumor" :0,
"vessel" :0}
# imaging params
import vtk
import vtk.util.numpy_support as vtkNumPy
SegmentFile=config.get("exec","segment_file")
# set the default reader based on extension
if( SegmentFile.split(".").pop() == "vtk"):
vtkImageReader = vtk.vtkDataSetReader
elif( SegmentFile.split(".").pop() == "vti"):
vtkImageReader = vtk.vtkXMLImageDataReader
else:
raise RuntimeError("uknown file")
# get dimension info from header
vtkSetupReader = vtkImageReader()
vtkSetupReader.SetFileName(SegmentFile )
vtkSetupReader.Update()
vtkImageMask = vtkSetupReader.GetOutput()
dimensions = vtkSetupReader.GetOutput().GetDimensions()
numberPointsImage = vtkSetupReader.GetOutput().GetNumberOfPoints()
spacing_mm = vtkSetupReader.GetOutput().GetSpacing()
origin_mm = vtkSetupReader.GetOutput().GetOrigin()
# convert to meters
spacing = [dx*.001 for dx in spacing_mm]
origin = [x0*.001 for x0 in origin_mm]
# pass pointer to c++
image_cells = vtkImageMask.GetPointData()
data_array = vtkNumPy.vtk_to_numpy( image_cells.GetArray(0) )
# need to pass numpy array's w/ Fortran storage... ie painful to debug
imageDataVec = PETSc.Vec().createWithArray(numpy.ravel(data_array,order='F'), comm=PETSc.COMM_SELF)
# FIXME - center around quadrature in out-of-plane direction
# FIXME - need better out of plane cooling model
quadratureOffset = 1./numpy.sqrt(3.0) * spacing[2]/2.0
# expecting roi and subsample of the form:
# roi = [(40,210),(30,220),(6,78)]
# subsample = [3,3,2]
ROI = eval(config.get('exec','roi'))
subsample = eval(config.get('exec','subsample'))
nelemROI = [ (pixel[1] - pixel[0] - 1 )/sub for pixel,sub in zip(ROI,subsample)]
xbounds = [ origin[0]+spacing[0]*(ROI[0][0]+0.5),origin[0]+spacing[0]*(ROI[0][1]+0.5) ]
ybounds = [ origin[1]+spacing[1]*(ROI[1][0]+0.5),origin[1]+spacing[1]*(ROI[1][1]+0.5) ]
zbounds = [ origin[2]+spacing[2]*(ROI[2][0]+0.5),origin[2]+spacing[2]*(ROI[2][1]+0.5) ]
if( petscRank ==0 ):
print "#points",numberPointsImage , "dimensions ",dimensions , "spacing ",spacing , "origin ",origin
print "ROI",ROI , "nelemROI ",nelemROI , "bounds", xbounds, ybounds, zbounds
#set to steady state solve
getpot.SetIniValue("steadystate/domain_0","true")
# initialize FEM Mesh
femMesh = femLibrary.PylibMeshMesh()
#femMesh.SetupUnStructuredGrid(kwargs['mesh_file'],0,RotationMatrix, Translation )
#femMesh.ReadFile(kwargs['mesh_file'])
femMesh.SetupStructuredGrid(nelemROI,xbounds,ybounds,zbounds,
[2,2,2,2,2,2])
# get output file name else set default name
try:
MeshOutputFile = config.get("exec","exodus_file" )
except ConfigParser.NoOptionError:
MeshOutputFile = "fem.e"
# add the data structures for the Background System Solve
# set deltat, number of time steps, power profile, and add system
eqnSystems = femLibrary.PylibMeshEquationSystems(femMesh,getpot)
#getpot.SetIniPower(1,[[19,119],[90.0,100.0]] )
getpot.SetIniPower(1,kwargs['powerHistory'] )
# AddPennesSDASystem
# AddPennesRFSystem
# AddPennesDeltaPSystem
pennesSystem = eval("eqnSystems.%s('StateSystem',kwargs['deltat'])" % kwargs['physics'])
pennesSystem.AddStorageVectors( kwargs['ntime']+1 )
# add system for labels
# FIXME: need both nodal, for dirichlet bc, and element version, for parameter masks
maskElemSystem = eqnSystems.AddExplicitSystem( "ElemImageMask" )
maskElemSystem.AddConstantMonomialVariable( "maskElem" )
# initialize libMesh data structures
eqnSystems.init( )
# print info
eqnSystems.PrintSelf()
# setup imaging to interpolate onto FEM mesh
femImaging = femLibrary.PytttkImaging(getpot, dimensions ,origin,spacing)
# Project imaging onto libMesh data structures
femImaging.ProjectImagingToFEMMesh("ElemImageMask" ,0.0,imageDataVec,eqnSystems)
femImaging.ProjectImagingToFEMMesh("StateSystem" ,0.0,imageDataVec,eqnSystems)
# create dirichlet nodes from this mask
numNodes = pennesSystem.PetscFEMSystemCreateNodeSetFromMask(config.getfloat("labels","vessel"),dirichletID)
print "# of dirichlet nodes %d" %numNodes
# get image label as numpy array
imageLabel = maskElemSystem.GetSolutionVector()[...]
#imageLabel = numpy.floor(10.0*imageLabel.copy())+1
k_0Label = imageLabel.copy()
w_0Label = imageLabel.copy()
mu_aLabel = imageLabel.copy()
mu_sLabel = imageLabel.copy()
for (idpos,label) in enumerate(imageLabel):
try:
tissueType = labelTable["%d"%int(label)]
except KeyError:
tissueType = "default"
labelCount[tissueType] = labelCount[tissueType] + 1
k_0Label[ idpos] = k_0Table[ tissueType]
w_0Label[ idpos] = w_0Table[ tissueType]
mu_aLabel[idpos] = mu_aTable[tissueType]
mu_sLabel[idpos] = mu_sTable[tissueType]
# create array of imaging data as petsc vec
k_0Vec = PETSc.Vec().createWithArray(k_0Label , comm=PETSc.COMM_SELF)
w_0Vec = PETSc.Vec().createWithArray(w_0Label , comm=PETSc.COMM_SELF)
mu_aVec = PETSc.Vec().createWithArray(mu_aLabel, comm=PETSc.COMM_SELF)
mu_sVec = PETSc.Vec().createWithArray(mu_sLabel, comm=PETSc.COMM_SELF)
# copy material properties to the system
eqnSystems.GetSystem("k_0").SetSolutionVector( k_0Vec )
eqnSystems.GetSystem("w_0").SetSolutionVector( w_0Vec )
eqnSystems.GetSystem("mu_a").SetSolutionVector(mu_aVec)
eqnSystems.GetSystem("mu_s").SetSolutionVector(mu_sVec)
# write IC
exodusII_IO = femLibrary.PylibMeshExodusII_IO(femMesh)
exodusII_IO.WriteTimeStep(MeshOutputFile,eqnSystems, 1, 0.0 )
exodusII_IO.WriteParameterSystems(eqnSystems)
# setup IC
pennesSystem.PetscFEMSystemSetupInitialConditions( )
# create list of laser positions
laserPositionList = [ ((.015,.015,2*spacing[2]+quadratureOffset),
(.018,.018,2*spacing[2]+quadratureOffset) ),
((.015,.015,2*spacing[2]+quadratureOffset),
(.016,.018,2*spacing[2]+quadratureOffset) ),
((.015,.015,1*spacing[2]+quadratureOffset),
(.014,.014,1*spacing[2]+quadratureOffset) ),
((.015,.015,1*spacing[2]+quadratureOffset),
(.015,.018,3*spacing[2]+quadratureOffset) )]
# time stamp
import pickle,time
timeStamp =0
# set power id to turn laser on
pennesSystem.PetscFEMSystemUpdateTimeStep( 1 )
# loop over laser position and solve steady state equations for each position
#for (idpos,(pos0,pos1)) in enumerate(laserPositionList):
# loop and read new laser parameters
while(True):
if(os.path.getmtime(fem_params['ini_filename']) > timeStamp):
timeStamp = os.path.getmtime(fem_params['ini_filename'] )
newIni = ConfigParser.SafeConfigParser({})
newIni.read(fem_params['ini_filename'])
laserParams = {}
laserParams['position1'] = [newIni.getfloat("probe",varID ) for varID in ["x_0","y_0","z_0"] ]
laserParams['position2'] = [newIni.getfloat("probe",varID ) for varID in ["x_1","y_1","z_1"] ]
print "laser position = ", newIni.getfloat("timestep","power") , laserParams
pennesSystem.PennesSDASystemUpdateLaserPower(newIni.getfloat("timestep","power"),1)
pennesSystem.PennesSDASystemUpdateLaserPosition(laserParams['position1'],laserParams['position2'])
pennesSystem.SystemSolve( )
#fem.StoreTransientSystemTimeStep("StateSystem",timeID )
#exodusII_IO.WriteTimeStep(MeshOutputFile ,eqnSystems, idpos+2, idpos*kwargs['deltat'])
exodusII_IO.WriteTimeStep(MeshOutputFile ,eqnSystems, 2, 1.0)
exodusII_IO.WriteParameterSystems(eqnSystems)
# write to txt file
if( petscRank ==0 ):
time.sleep(1)
vtkExodusIIReader = vtk.vtkExodusIIReader()
print "opening %s " % MeshOutputFile
vtkExodusIIReader.SetFileName( MeshOutputFile )
vtkExodusIIReader.Update()
ntime = vtkExodusIIReader.GetNumberOfTimeSteps()
variableID = "u0"
print "ntime %d %s " % (ntime,variableID)
vtkExodusIIReader.SetTimeStep(1)
vtkExodusIIReader.SetPointResultArrayStatus(variableID,1)
vtkExodusIIReader.Update()
curInput = None
# multi block
if vtkExodusIIReader.GetOutput().IsA("vtkMultiBlockDataSet"):
iter = vtkExodusIIReader.GetOutput().NewIterator()
iter.UnRegister(None)
iter.InitTraversal()
curInput = iter.GetCurrentDataObject()
else:
curInput = vtkExodusIIReader.GetOutput()
#fem_point_data= curInput.GetPointData().GetArray('u0')
#Soln=vtkNumPy.vtk_to_numpy(fem_point_data)
#numpy.savetxt( "temperature.txt" ,Soln)
# FIXME notice that order of operations is IMPORTANT
# FIXME translation followed by rotation will give different results
# FIXME than rotation followed by translation
# FIXME Translate -> RotateZ -> RotateY -> RotateX -> Scale seems to be the order of paraview
# scale back to millimeter
# TODO verify that the data sets are registered in the native slicer coordinate system
# TODO segmented data MUST be read in with:
# TODO add data -> volume -> show options -> ignore orientation
# TODO add data -> volume -> show options -> ignore orientation
# TODO add data -> volume -> show options -> ignore orientation
AffineTransform = vtk.vtkTransform()
AffineTransform.Translate([ 0.0,0.0,0.0])
AffineTransform.RotateZ( 0.0 )
AffineTransform.RotateY( 0.0 )
AffineTransform.RotateX( 0.0 )
AffineTransform.Scale([1000.,1000.,1000.])
# scale to millimeter
transformFilter = vtk.vtkTransformFilter()
transformFilter.SetInput(curInput)
transformFilter.SetTransform(AffineTransform)
transformFilter.Update()
# setup contour filter
vtkContour = vtk.vtkContourFilter()
vtkContour.SetInput( transformFilter.GetOutput() )
# TODO: not sure why this works...
# set the array to process at the temperature == u0
vtkContour.SetInputArrayToProcess(0,0,0,0,'u0')
contourValuesList = eval(newIni.get('exec','contours'))
vtkContour.SetNumberOfContours( len(contourValuesList ) )
print "plotting array:", vtkContour.GetArrayComponent( )
for idContour,contourValue in enumerate(contourValuesList):
print "plotting contour:",idContour,contourValue
vtkContour.SetValue( idContour,contourValue )
vtkContour.Update( )
# setup threshold filter
vtkThreshold = vtk.vtkThreshold()
vtkThreshold.SetInput( transformFilter.GetOutput() )
vtkThreshold.ThresholdByLower( contourValuesList[0] )
#vtkThreshold.SetSelectedComponent( 0 )
vtkThreshold.SetComponentModeToUseAny( )
vtkThreshold.Update()
# resample onto image
vtkResample = vtk.vtkCompositeDataProbeFilter()
vtkResample.SetInput( vtkImageMask )
vtkResample.SetSource( vtkThreshold.GetOutput() )
vtkResample.Update()
# write output
print "writing fem.vtk "
vtkImageWriter = vtk.vtkDataSetWriter()
vtkImageWriter.SetFileTypeToBinary()
vtkImageWriter.SetFileName("fem.vtk")
vtkImageWriter.SetInput(vtkResample.GetOutput())
vtkImageWriter.Update()
# write stl file
stlWriter = vtk.vtkSTLWriter()
stlWriter.SetInput(vtkContour.GetOutput( ))
stlWriter.SetFileName("fem.stl")
stlWriter.SetFileTypeToBinary()
stlWriter.Write()
# write support file to signal full stl file is written
# Slicer module will wait for this file to be written
# before trying to open stl file to avoid incomplete reads
with open('./fem.finish', 'w') as signalFile:
signalFile.write("the stl file has been written\n")
else:
print "waiting on user input.."
# echo lookup table
if( petscRank ==0 ):
print "lookup tables"
print "labeled %d voxels" % len(imageLabel)
print "labels" , labelTable
print "counts" , labelCount
print "conductivity", k_0Table
print "perfusion" , w_0Table
print "absorption" , mu_aTable
print "scattering" , mu_sTable
time.sleep(2)
def solve_for_combo(c):
import time
time_start = -time.time()
import FVF_loglib as flog
import FVF_plotlib as fplt
from . import analyze as fana
from . import utilities as util
import petsc4py
petsc4py.init()
import slepc4py
slepc4py.init()
import dill
print('working on combination {0}/{1}'.format(c['iter_num'], c['total_iter']))
data_dir = c['data_dir']
T = c['T_list']
# Set up directory to store solution data
try:
out_dir = futil.get_out_dir(out_dir_base, data_dir, len(cfg.data_dir), T, len(cfg.T_list))
futil.ensure_dir(out_dir)
except:
print('problem setting out directory')
return
# Set up logger
try:
logger = flog.setup_custom_logger(dir_name=out_dir, filename='run.log', verbose=cfg.verbose)
except:
print('problem creating logger')
return
try:
# Store config file for later reference
logger.info('used config file {0}.py'.format(config_file))
futil.store_config_file(config_file, out_dir_base)
logger.info('Main output directory set to {0}'.format(out_dir_base))
logger.info('Output subdirectory set to {0}'.format(out_dir))
# Convert Time in years to model frequency
t_star = (23.9345*3600)/(2*np.pi)
Target_j = 2*np.pi/(T*365.25*24*3600/t_star)*1j
Target = Target_j + Target_j*1j/(2*cfg.target_Q)
# Find which CC matrix to use
dCyr_list = futil.find_available_skin_depths(data_dir)
dCyr_use = futil.find_closest_CC(T, dCyr_list)
logger.info('{0} dCyr used'.format(dCyr_use))
except:
problem = "problem storing config file or finding correct magnetic skin depth"
logger.error(problem, exc_info=1)
print('combination {0}/{1} broke, {2}'.format(c['iter_num'], c['total_iter'], problem))
return
# %% Load Matrices and model from files
#==============================================================================
try:
viewer = petsc4py.PETSc.Viewer().createBinary(data_dir+fileA+str(dCyr_use)+'.dat', 'r')
A = petsc4py.PETSc.Mat().load(viewer)
viewer = petsc4py.PETSc.Viewer().createBinary(data_dir+fileB+'.dat', 'r')
B = petsc4py.PETSc.Mat().load(viewer)
try:
model = dill.load(open(data_dir+filemodel,'rb'))
except:
model = dill.load(open(data_dir+filemodel,'rb'),encoding='latin1')
logger.info('A'+str(dCyr_use)+' matrix used')
logger.info('matrices and model loaded into memory from ' + data_dir)
except:
problem = "Problem loading matrices from file."
logger.error(problem, exc_info=1)
print('combination {0}/{1} broke, {2}'.format(c['iter_num'], c['total_iter'], problem))
return
# %% Set up SLEPc Solver
#==============================================================================
try:
EPS = slepc4py.SLEPc.EPS().create()
EPS.setDimensions(num_solutions_to_calculate, petsc4py.PETSc.DECIDE)
EPS.setOperators(A, B)
EPS.setType(EPS.Type.KRYLOVSCHUR)
EPS.setProblemType(slepc4py.SLEPc.EPS.ProblemType.PGNHEP)
EPS.setTarget(Target)
EPS.setWhichEigenpairs(EPS.Which.TARGET_MAGNITUDE)
EPS.setTolerances(tol)
EPS.setFromOptions()
ST = EPS.getST()
ST.setType(slepc4py.SLEPc.ST.Type.SINVERT)
logger.info('Solver set up, Target Period = {0:.1f}, Number of solutions to calculate = {1}'.format(T, num_solutions_to_calculate))
except:
problem = "Problem setting up SLEPc Solver."
logger.error(problem, exc_info=1)
print('combination {0}/{1} broke, {2}'.format(c['iter_num'], c['total_iter'], problem))
return
# %% Solve Problem
#==============================================================================
try:
EPS.solve()
logger.info('problem solved')
except:
problem = "Problem Solving Eigenvalues."
logger.error(problem, exc_info=1)
print('combination {0}/{1} broke, {2}'.format(c['iter_num'], c['total_iter'], problem))
return
try:
# Save Computed Solutions
conv = EPS.getConverged()
logger.info('{0} eigenvalues converged'.format(conv))
vals = []
vecs = []
for ind in range(conv):
vs, ws = petsc4py.PETSc.Mat.getVecs(A)
v = EPS.getEigenpair(ind, ws)
vals.append(v)
vecs.append(ws.getArray())
Periods = (2*np.pi/np.array([x.imag for x in vals]))*model.t_star/(24.*3600.*365.25)
Period_max = Periods.max()
Period_min = Periods.min()
logger.info('min Period = {0:.1f}yrs, max Period = {1:.1f}yrs'.format(Period_min, Period_max))
except:
problem = "Problem Computing Eigenvalues."
logger.error(problem, exc_info=1)
print('combination {0}/{1} broke, {2}'.format(c['iter_num'], c['total_iter'], problem))
return
#%% Filter Solutions
#==============================================================================
try:
logger.info('Filtering Eigenvalues:')
# filter results to keep only those that satisfy requirements specified in filter_dict
fvals, fvecs = fana.filter_results(model, vals, vecs, cfg.filter_dict)
# Sort by fit to given parameter choices
svals, svecs = fana.sort_by_total_misfit(model, fvals, fvecs, cfg.sort_dict)
except:
try:
problem = "Problem Saving Eigenvalues."
logger.error(problem, exc_info=1)
print('combination {0}/{1} broke, {2}'.format(c['iter_num'], c['total_iter'], problem))
svals = vals
svecs = vecs
except:
svals = []
svecs = []
problem = "Problem Saving Eigenvalues."
logger.error(problem, exc_info=1)
print('combination {0}/{1} broke, {2}'.format(c['iter_num'], c['total_iter'], problem))
# %% Save Filtered Eigenvectors
#==============================================================================
try:
if savefile:
dill.dump({'vals': svals, 'vecs': svecs, 'model':model},open(out_dir + savefile, 'wb'))
logger.info('saved {0:d} vals and vecs saved to '.format(len(svals)) + out_dir + savefile)
except:
problem = "Problem Saving Eigenvalues."
logger.error(problem, exc_info=1)
print('combination {0}/{1} broke, {2}'.format(c['iter_num'], c['total_iter'], problem))
return
# %% Plot Filtered Eigenvectors
#==============================================================================
try:
logger.info('Plotting:')
for ind in range(min(cfg.num_solutions_to_plot,len(svals))):
val = svals[ind]
vec = fana.shift_vec_real(model, svecs[ind], var='vth')
vec = fana.normalize_vec(vec, 10)
Period = fana.get_period(model, val)
Q = fana.get_Q(val)
r_ord = fana.get_order_r(model, vec)
th_ord = fana.get_order_th(model, vec)
if abs(Period) < 1.0:
title = ('{0:03d} k={3}, l={4}, m={5}, T={1:.2f}dys, Q={2:.2f}'.format(ind, Period*365.25, Q, r_ord, th_ord, model.m)
+ '\nH={:.0f}km, B={:.2f}mT, N={:.2f} pvbc'.format(model.h/1e3, np.mean(model.Br)*model.B_star*1e3, np.mean(model.N)))
else:
title = ('{0:03d} k={3}, l={4}, m={5}, T={1:.2f}yrs, Q={2:.2f}'.format(ind, Period, Q, r_ord, th_ord, model.m)
+ '\nH={:.0f}km, B={:.2f}mT, N={:.2f} pvbc'.format(model.h/1e3, np.mean(model.Br)*model.B_star*1e3, np.mean(model.N)))
if (model.Nk > 1):
# fplt.plot_fast_solution(model, vec, title=title, dir_name=out_dir)
fplt.plot_full_solution(model, val, vec, title=title, dir_name=out_dir, layer_boundary=3380)
else:
if('br' in model.model_variables):
fplt.plot_1D(model, vec, val, ind, dir_name=out_dir, title=title)
else:
fplt.plot_1D_noB(model, vec, val, ind, dir_name=out_dir, title=title)
logger.info('\t plotted ind={0}, T={1:.2f}yrs (eig={2:.2e})'.format(ind, Period, val))
logger.info('run complete')
except:
problem = "Problem Plotting Eigenvalues."
logger.error(problem, exc_info=1)
print('combination {0}/{1} broke, {2}'.format(c['iter_num'], c['total_iter'], problem))
return
dtime = (time_start + time.time())/60.
print('done with combination {0}/{1} in {2:.2f}min'.format(c['iter_num'], c['total_iter'], dtime))
"""
Functions for a high-level PETSc-based parallelization.
"""
from __future__ import absolute_import
import time
import os
import numpy as nm
import sys, petsc4py
from six.moves import range
argv = [arg for arg in sys.argv if arg not in ['-h', '--help']]
petsc4py.init(argv)
from petsc4py import PETSc
from mpi4py import MPI
from sfepy.base.base import assert_, output, ordered_iteritems, Struct
from sfepy.discrete.common.region import Region
from sfepy.discrete.fem.fe_surface import FESurface
def partition_mesh(mesh, n_parts, use_metis=True, verbose=False):
"""
Partition the mesh cells into `n_parts` subdomains, using metis, if
available.
"""
output('partitioning mesh into %d subdomains...' % n_parts, verbose=verbose)
tt = time.clock()
if use_metis:
try:
# --------------------------------------------------------------------
if __name__ == "__main__":
import sys, petsc4py
petsc4py.init(sys.argv+['-log_summary'])
# --------------------------------------------------------------------
from petsc4py import PETSc
import unittest
# --------------------------------------------------------------------
class TestLog(unittest.TestCase):
def setUp(self):
#PETSc.Log.begin()
# register stages
self.stage1 = PETSc.Log.Stage('Stage 1')
self.stage2 = PETSc.Log.Stage('Stage 2')
# register classes
self.klassA = PETSc.Log.Class('Class A')
self.klassB = PETSc.Log.Class('Class B')
# register events
self.event1 = PETSc.Log.Event('Event 1') # no class
self.event2 = PETSc.Log.Event('Event 2') # no class
self.eventA = PETSc.Log.Event('Event A', self.klassA)
self.eventB = PETSc.Log.Event('Event B', self.klassB)
def testGetName(self):
self.assertEqual(self.klassA.name, 'Class A')
# Kjoring: python2.6 backward_wave_solver.py # Import and initialize import petsc4py, sys, numpy petsc4py.init(sys.argv) # kan man legge til input her for aa velge mellom mpich og OpenMPI? from petsc4py import PETSc if (len(sys.argv) > 1): n = int(sys.argv[1]) else: n = 100 # Make temporary spacing under warning print '\n\n\n' Nt = 100 # Number of timesteps C2 = (2/1)**2 # C = dt/dx ### These are big matrices and vectors, so we must eventually use sparse types. ### Using dense for now. Use small n # Need our two matrices. One tridiag and one diag of size n-by-n tridiag = PETSc.Mat().createDense(n) tridiag.setDiagonal(PETSc.Vec().createWithArray([1+2*C2]*n)) for i in range(n-1): # filling the off-diagonal entries tridiag.setValue(i+1,i,-C2) tridiag.setValue(i,i+1,-C2) diagm1 = PETSc.Mat().createDense(n)
# FENaPack is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# FENaPack is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with FENaPack. If not, see <http://www.gnu.org/licenses/>.
# Let PETSc print memory usage at the end
import petsc4py
petsc4py.init(("python", "-malloc_info"))
from defcon import *
from dolfin import *
from matplotlib import pyplot
from fenapack import PCDKSP
from fenapack import PCDAssembler
from fenapack import StabilizationParameterSD
import sys
import argparse
class NavierStokesProblem(BifurcationProblem):
def __init__(self):
def PPS(self,p,comm):
"""
Parallel solver implementing a PETSc KSP linear routine over the entire scene as a
single patch (PPS = Parallel PETSc Single)
"""
from _reconutils import get_gcd_vals, laplace_builder, pixelxpixelsolver
try:
import mpi4py
from mpi4py import MPI
except:
sys.stdout.write('mpi4py must be installed and in PYTHONPATH\n')
sys.exit()
try:
import petsc4py
petsc4py.init([],comm=MPI.COMM_WORLD)
from petsc4py import PETSc
except:
sys.stdout.write('petsc4py must be installed and in PYTHONPATH\n')
sys.exit()
PETSc.Sys.Print('Running PPS: Parallel PETSc (linear) Solver')
size, rank = comm.Get_size(), comm.Get_rank()
cols = p.gen.cols
if rank == 0:
self.define_solution_space(p)
address = self._read_address(p)
metfile, modlen = p.gen.metfile, 3*len(address)
### get gmat, Cd and d values and send segments to other processors
PETSc.Sys.Print('retrieving gmat, cdi, and dvec vals...')
gmatvals, gmatij, cdiv_temp, dvec_temp = get_gcd_vals(metfile,len(p.scenes),
p.gen.doline,p.gen.cols,address,p.gen.gmat_rows)
### estimate posterior model pixel x pixel (for PETSc initial guess)
PETSc.Sys.Print('estimating posterior model...')
mtilde_temp = pixelxpixelsolver(metfile,len(p.scenes),
p.gen.doline,p.gen.cols,address)
gmatij = gmatij.reshape(-1,3*p.gen.gmat_rows)
if gmatij.dtype != np.int32: gmatij = gmatij.astype(np.int32)
if p.gen.cmlambda < 1.e-12: del address
### initialize arrays to store start and end row indices for all procs
rowblocks_gmat = np.empty([2,size],dtype=np.int32)
rowblocks_cdiv = np.empty([2,size],dtype=np.int32)
rowblocks_dvec = np.empty([2,size],dtype=np.int32)
rowblocks_mtil = np.empty([2,size],dtype=np.int32)
tag = 1234
for i in np.arange(1,size):
comm.Send([np.array([modlen,p.gen.gmat_rows]),MPI.INT], dest=i, tag=tag); tag += 1
else:
tag, pararray = 1234 + (rank-1), np.array([-1,-1])
comm.Recv([pararray,MPI.INT], source=0, tag=tag)
modlen, p.gen.gmat_rows = pararray[0], pararray[1]
if modlen < 0 or p.gen.gmat_rows < 0:
print('\npararray receive command failed in rank '+str(rank))
PETSc._finalize; MPI.Finalize; sys.exit()
PETSc.Sys.Print('building gmat, cdiv, and dvec arrays...')
### initialize...nnz --> [DIAGONAL,OFF-DIAGONAL] (see PETSc documentation)
gmat = PETSc.Mat().createAIJ([p.gen.gmat_rows,modlen],nnz=[3,3],comm=comm)
cdiv = PETSc.Mat().createAIJ([p.gen.gmat_rows,p.gen.gmat_rows],nnz=[1,1],comm=comm)
dvec = PETSc.Vec().createMPI(p.gen.gmat_rows,comm=comm)
mtilde_pre = PETSc.Vec().createMPI(modlen,comm=comm)
### get the block of rows owned by this processor
sr_gmat, er_gmat = gmat.getOwnershipRange()
sr_cdiv, er_cdiv = cdiv.getOwnershipRange()
sr_dvec, er_dvec = dvec.getOwnershipRange()
sr_mtil, er_mtil = mtilde_pre.getOwnershipRange()
### send start/end rows to root proc and receive gmat, cdiv, and dvec entries
base_tag, base_stag = 777, 999
if rank == 0:
rowblocks_gmat[0,0], rowblocks_gmat[1,0] = sr_gmat, er_gmat
rowblocks_cdiv[0,0], rowblocks_cdiv[1,0] = sr_cdiv, er_cdiv
rowblocks_dvec[0,0], rowblocks_dvec[1,0] = sr_dvec, er_dvec
rowblocks_mtil[0.0], rowblocks_mtil[1,0] = sr_mtil, er_mtil
tag,stag = base_tag, base_stag
recsimple = np.array([-1,-1])
for i in np.arange(1,size):
comm.Recv([recsimple,MPI.INT],source=i,tag=tag); tag += 1
rowblocks_gmat[0,i], rowblocks_gmat[1,i] = recsimple[0], recsimple[1]
comm.Recv([recsimple,MPI.INT],source=i,tag=tag); tag += 1
rowblocks_cdiv[0,i], rowblocks_cdiv[1,i] = recsimple[0], recsimple[1]
comm.Recv([recsimple,MPI.INT],source=i,tag=tag); tag += 1
rowblocks_dvec[0,i], rowblocks_dvec[1,i] = recsimple[0], recsimple[1]
comm.Recv([recsimple,MPI.INT],source=i,tag=tag); tag += 1
rowblocks_mtil[0,i], rowblocks_mtil[1,i] = recsimple[0], recsimple[1]
svec = gmatvals[3*rowblocks_gmat[0,i]:3*rowblocks_gmat[1,i]]
comm.Send([svec, MPI.FLOAT], dest=i, tag=stag); stag += 1
svec = gmatij[:,3*rowblocks_gmat[0,i]:3*rowblocks_gmat[1,i]].flatten()
comm.Send([svec, MPI.INT], dest=i, tag=stag); stag += 1
svec = cdiv_temp[rowblocks_cdiv[0,i]:rowblocks_cdiv[1,i]]
comm.Send([svec, MPI.FLOAT], dest=i, tag=stag); stag += 1
svec = dvec_temp[rowblocks_dvec[0,i]:rowblocks_dvec[1,i]]
comm.Send([svec, MPI.FLOAT], dest=i, tag=stag); stag += 1
svec = mtilde_temp[rowblocks_mtil[0,i]:rowblocks_mtil[1,i]]
comm.Send([svec, MPI.FLOAT], dest=i, tag=stag); stag += 1
if size > 1: del svec
gmatvals = gmatvals[3*rowblocks_gmat[0,0]:3*(rowblocks_gmat[1,0])]
gmatij = gmatij[:,3*rowblocks_gmat[0,0]:3*(rowblocks_gmat[1,0])]
cdiv_temp = cdiv_temp[rowblocks_cdiv[0,0]:rowblocks_cdiv[1,0]]
dvec_temp = dvec_temp[rowblocks_dvec[0,0]:rowblocks_dvec[1,0]]
mtilde_temp = mtilde_temp[rowblocks_mtil[0,0]:rowblocks_mtil[1,0]]
else:
tag = base_tag + (rank-1)*4
comm.Send([np.array([sr_gmat, er_gmat]),MPI.INT], dest=0, tag=tag); tag += 1
comm.Send([np.array([sr_cdiv, er_cdiv]),MPI.INT], dest=0, tag=tag); tag += 1
comm.Send([np.array([sr_dvec, er_dvec]),MPI.INT], dest=0, tag=tag); tag += 1
comm.Send([np.array([sr_mtil, er_mtil]),MPI.INT], dest=0, tag=tag); tag += 1
stag = base_stag + (rank-1)*5
gmatvals = np.empty(3*(er_gmat-sr_gmat), dtype=np.float32)
gmatij = np.empty(2*3*(er_gmat-sr_gmat), dtype=np.int32)
cdiv_temp = np.empty((er_cdiv-sr_cdiv), dtype=np.float32)
dvec_temp = np.empty((er_dvec-sr_dvec), dtype=np.float32)
mtilde_temp = np.empty((er_mtil-sr_mtil), dtype=np.float32)
comm.Recv([gmatvals,MPI.FLOAT],source=0, tag=stag); stag += 1
comm.Recv([gmatij,MPI.INT],source=0, tag=stag); stag += 1
comm.Recv([cdiv_temp,MPI.FLOAT],source=0, tag=stag); stag += 1
comm.Recv([dvec_temp,MPI.FLOAT],source=0, tag=stag); stag += 1
comm.Recv([mtilde_temp,MPI.FLOAT],source=0, tag=stag); stag += 1
gmatij = gmatij.reshape(2,-1)
PETSc.Sys.Print('loading gmat, cdiv, and dvec sparse matrices...')
for i in np.arange(len(dvec_temp)):
threei = 3*i
gmat.setValue(gmatij[0,threei], gmatij[1,threei], gmatvals[threei])
gmat.setValue(gmatij[0,threei], gmatij[1,threei+1], gmatvals[threei+1])
gmat.setValue(gmatij[0,threei], gmatij[1,threei+2], gmatvals[threei+2])
cdiv.setValue(gmatij[0,threei], gmatij[0,threei], cdiv_temp[i])
dvec.setValue(gmatij[0,threei], dvec_temp[i])
comm.Barrier()
dvec.assemblyBegin(); dvec.assemblyEnd() # MAT_FINAL_ASSEMBLY is implied
gmat.assemblyBegin(); gmat.assemblyEnd()
cdiv.assemblyBegin(); cdiv.assemblyEnd()
comm.Barrier()
for i in np.arange(len(mtilde_temp)):
mtilde_pre.setValue(i+sr_mtil, mtilde_temp[i])
comm.Barrier()
mtilde_pre.assemblyBegin(); mtilde_pre.assemblyEnd()
comm.Barrier()
del gmatvals, gmatij, cdiv_temp, dvec_temp, mtilde_temp
### build A and gtilde (=dtilde)
omega = gmat.transposeMatMult(cdiv)
cdiv.destroy()
gtg = omega.matMult(gmat)
mtilde,gtilde = gtg.getVecs()
omega.mult(dvec,gtilde)
mtilde_pre.copy(mtilde)
dvec.destroy(); omega.destroy(); gmat.destroy(); mtilde_pre.destroy()
if p.gen.cmlambda > 1.e-12:
PETSc.Sys.Print('building Laplacian...')
if rank == 0:
try:
aa = len(address)
if 3*aa != modlen:
address = self._read_address(p)
except:
address = self._read_address(p)
fmatval, fmatij = laplace_builder(p.gen.cols,address)
fmatval = fmatval[:np.argmin(fmatval)]
fmatij = fmatij.reshape(2,-1)[:,:len(fmatval)]
if fmatij.dtype != np.int32: fmatij = fmatij.astype(np.int32)
del address
rowblocks_fmat = np.empty([2,size],dtype=np.int32)
fmat = PETSc.Mat().createAIJ([modlen, modlen],nnz=[5,5],comm=comm)
### get the row addresses for this processor
sr_gtg, er_gtg = gtg.getOwnershipRange()
sr_fmat, er_fmat = fmat.getOwnershipRange()
base_tag, base_stag = 77, 444
if rank == 0:
rowblocks_fmat[0,0], rowblocks_fmat[1,0] = sr_fmat, er_fmat
tag, stag = base_tag, base_stag
recarray = np.array([-1,-1])
for i in np.arange(1,size):
comm.Recv([recarray,MPI.INT],source=i,tag=tag); tag += 1
rowblocks_fmat[:,i] = recarray
# get indexes for fmatval and fmatij
left = np.argmin(np.abs(fmatij[0,:]-rowblocks_fmat[0,i]))
right = np.argmin(np.abs(fmatij[0,:]-rowblocks_fmat[1,i]))
svec = fmatval[left:right]
lensvec = np.array([len(svec)],dtype=np.int32)
comm.Send([lensvec,MPI.INT], dest=i, tag=stag); stag += 1
comm.Send([svec,MPI.FLOAT], dest=i, tag=stag); stag += 1
svec = fmatij[:,left:right].flatten()
comm.Send([svec,MPI.INT], dest=i, tag=stag); stag += 1
if size > 1: del svec
left = np.argmin(np.abs(fmatij[0,:]-rowblocks_fmat[0,0]))
right = np.argmin(np.abs(fmatij[0,:]-rowblocks_fmat[1,0]))
fmatval = fmatval[left:right]
fmatij = fmatij[:,left:right]
else:
tag, stag = base_tag + (rank-1), base_stag + (rank-1)*3
lenrec = np.array([-1],dtype=np.int32)
comm.Send([np.array([sr_fmat, er_fmat]),MPI.INT], dest=0, tag=tag); tag += 1
comm.Recv([lenrec,MPI.INT], source=0, tag=stag); stag += 1
lenrec = lenrec[0]
fmatval = np.empty(lenrec,dtype=np.float32)
fmatij = np.empty(2*lenrec,dtype=np.int32)
comm.Recv([fmatval,MPI.FLOAT], source=0, tag=stag); stag += 1
comm.Recv([fmatij,MPI.INT], source=0, tag=stag); stag += 1
fmatij = fmatij.reshape(2,-1)
PETSc.Sys.Print('loading sparse Laplacian...')
for i in np.arange(len(fmatval)):
fmat.setValue(fmatij[0,i],fmatij[1,i],fmatval[i])
comm.Barrier()
fmat.assemblyBegin(); fmat.assemblyEnd()
comm.Barrier()
del fmatval, fmatij
PETSc.Sys.Print('loading cli...')
cliv = PETSc.Vec().createMPI(modlen,comm=comm)
gtg.getDiagonal(cliv)
cli = gtg.duplicate(copy=False)
cli.setDiagonal(cliv)
cliv.destroy()
PETSc.Sys.Print('building C_m...')
rhs = fmat.transposeMatMult(cli)
rhs = rhs.matMult(fmat)
cli.destroy(); fmat.destroy()
PETSc.Sys.Print('building A...')
gtg.axpy(p.gen.cmlambda,rhs)
rhs.destroy()
#if p.gen.outputs['Output diag(G^T*W*G)^-1)']:
#PETSc.Sys.Print('Output diag(G^T*W*G)^-1) option not implemented...run vector_disp for estimate')
'''
### this part of the code works, but the inverse operator is not implemented due to expense
PETSc.Sys.Print('writing diagonal of posterior model covariance matrix')
cliv = PETSc.Vec().createMPI(modlen,comm=comm)
gtg.getDiagonal(cliv)
base_tag, base_stag = 2222, 3333
sr_mt, er_mt = cliv.getOwnershipRange()
if rank == 0:
clivnump = np.empty(modlen, dtype=np.float32)
clivnump[sr_mt:er_mt] = cliv[...]; cliv.destroy()
rowarr = np.array([-1,-1], dtype=np.int32)
tag = base_tag
for i in np.arange(1,size):
comm.Recv([rowarr,MPI.INT], source=i, tag=tag); tag += 1
comm.Recv([clivnump[rowarr[0]:rowarr[1]], MPI.FLOAT], source=i, tag=tag); tag += 1
self._write_post_model(model=clivnump,p=p,form=1)
else:
rowarr, tag = np.array([sr_mt, er_mt], dtype=np.int32), base_tag + (rank-1)*2
clivnump = cliv[...]; cliv.destroy()
if clivnump.dtype != np.float32: clivnump = clivnump.astype(np.float32)
comm.Send([rowarr,MPI.INT], dest=0, tag=tag); tag += 1
comm.Send([clivnump, MPI.FLOAT], dest=0, tag=tag); tag += 1
'''
PETSc.Sys.Print('inverting using PETSc lsqr...')
ksp = PETSc.KSP().create(comm)
ksp.setType('lsqr')
ksp.pc.setType('none')
ksp.setOperators(gtg)
self._get_ksp_tols(ksp=ksp,p=p)
ksp.setTolerances(rtol=self.rtol,atol=self.atol,divtol=self.dtol,max_it=self.max_it)
t0 = time.time()
ksp.solve(gtilde,mtilde)
tf = time.time()
gtg.destroy(); gtilde.destroy()
PETSc.Sys.Print(' lsqr took %10.2f seconds' % (tf-t0))
PETSc.Sys.Print(' Converged in %d iterations ' % (ksp.getIterationNumber()))
PETSc.Sys.Print(' Tolerances: %e %e %d %d' % (ksp.getTolerances()))
PETSc.Sys.Print(' Convergance code (< 0 --> diverged): %d\n' % (ksp.getConvergedReason()))
ksp.destroy()
base_tag, base_stag = 2222, 3333
sr_mt, er_mt = mtilde.getOwnershipRange()
if rank == 0:
mtildenump = np.empty(modlen, dtype=np.float32)
mtildenump[sr_mt:er_mt] = mtilde[...]; mtilde.destroy()
mtildenump *= p.gen.timefac * p.gen.distfac * p.gen.r2dsp
rowarr = np.array([-1,-1], dtype=np.int32)
tag = base_tag
for i in np.arange(1,size):
comm.Recv([rowarr,MPI.INT], source=i, tag=tag); tag += 1
comm.Recv([mtildenump[rowarr[0]:rowarr[1]], MPI.FLOAT], source=i, tag=tag); tag += 1
self._write_post_model(model=mtildenump,p=p)
self._cleanup(p=p)
else:
rowarr, tag = np.array([sr_mt, er_mt], dtype=np.int32), base_tag + (rank-1)*2
mtildenump = mtilde[...]; mtilde.destroy()
mtildenump *= p.gen.timefac * p.gen.distfac * p.gen.r2dsp
if mtildenump.dtype != np.float32: mtildenump = mtildenump.astype(np.float32)
comm.Send([rowarr,MPI.INT], dest=0, tag=tag); tag += 1
comm.Send([mtildenump, MPI.FLOAT], dest=0, tag=tag); tag += 1
PETSc._finalize
MPI.Finalize
def deltapModeling(**kwargs):
"""
treatment planning model
"""
# import petsc and numpy
import petsc4py, numpy
# init petsc
PetscOptions = sys.argv
PetscOptions.append("-ksp_monitor")
PetscOptions.append("-ksp_rtol")
PetscOptions.append("1.0e-15")
#PetscOptions.append("-help")
#PetscOptions.append("-idb")
petsc4py.init(PetscOptions)
#
# break processors into separate communicators
from petsc4py import PETSc
petscRank = PETSc.COMM_WORLD.getRank()
petscSize = PETSc.COMM_WORLD.Get_size()
sys.stdout.write("petsc rank %d petsc nproc %d\n" % (petscRank, petscSize))
# set shell context
# TODO import vtk should be called after femLibrary ????
# FIXME WHY IS THIS????
import femLibrary
# initialize libMesh data structures
libMeshInit = femLibrary.PyLibMeshInit(PetscOptions,PETSc.COMM_WORLD)
# store control variables
getpot = femLibrary.PylibMeshGetPot(PetscOptions)
# from Duck table 2.11 pig dermis
getpot.SetIniValue( "material/specific_heat","3280.0" )
# set ambient temperature
getpot.SetIniValue( "initial_condition/u_init","0.0" )
# from Duck 2.7 Rat tumor measured in vivo
getpot.SetIniValue( "thermal_conductivity/k_0_tumor","0.32" )
getpot.SetIniValue( "thermal_conductivity/k_0_healthy",kwargs['cv']['k_0_healthy'] )
# water properties at http://www.d-a-instruments.com/light_absorption.html
getpot.SetIniValue( "optical/mu_a_healthy", kwargs['cv']['mu_a_healthy'] )
# FIXME large mu_s (> 30) in agar causing negative fluence to satisfy BC
getpot.SetIniValue( "optical/mu_s_healthy",
kwargs['cv']['mu_s_healthy'] )
# from AE paper
#http://scitation.aip.org/journals/doc/MPHYA6-ft/vol_36/iss_4/1351_1.html#F3
#For SPIOs
#getpot.SetIniValue( "optical/guass_radius","0.0035" )
#For NR/NS
getpot.SetIniValue( "optical/guass_radius",".003" )
# cauchy BC
getpot.SetIniValue( "bc/u_infty","0.0" )
getpot.SetIniValue( "bc/newton_coeff","1.0e5" )
# 1-300
getpot.SetIniValue( "optical/mu_a_tumor",
kwargs['cv']['mu_a_tumor'] )
# 1-300
getpot.SetIniValue( "optical/mu_s_tumor",
kwargs['cv']['mu_s_tumor'] )
#getpot.SetIniValue( "optical/mu_a_tumor","71.0" )
#getpot.SetIniValue( "optical/mu_s_tumor","89.0" )
# .9 - .99
getpot.SetIniValue( "optical/anfact",kwargs['cv']['anfact'] )
#agar length
#for SPIOs
#getpot.SetIniValue( "optical/agar_length","0.0206" )
#for NR/NS
getpot.SetIniValue( "optical/agar_length","0.023" )
getpot.SetIniValue("optical/refractive_index","1.0")
#
# given the original orientation as two points along the centerline z = x2 -x1
# the transformed orienteation would be \hat{z} = A x2 + b - A x1 - b = A z
# ie transformation w/o translation which is exactly w/ vtk has implemented w/ TransformVector
# TransformVector = TransformPoint - the transation
#Setup Affine Transformation for registration
RotationMatrix = [[1.,0.,0.],
[0.,1.,0.],
[0.,0.,1.]]
Translation = [0.,0.,0.]
# original coordinate system laser input
# For SPIOs 67_11
#laserTip = [0.,-.000625,.035]
# For SPIOs 67_10
#laserTip = [0.,-.0001562,.035]
# For SPIOs 335_11
#laserTip = [0.,-.0014062,.035]
# For NR
#laserTip = [0.,.0002,.035]
# For NS
laserTip = [0.00001,.000001,.000001]
laserOrientation = [0.0,0.,-1.0]
import vtk
import vtk.util.numpy_support as vtkNumPy
# echo vtk version info
print "using vtk version", vtk.vtkVersion.GetVTKVersion()
# FIXME notice that order of operations is IMPORTANT
# FIXME translation followed by rotation will give different results
# FIXME than rotation followed by translation
# FIXME Translate -> RotateZ -> RotateY -> RotateX -> Scale seems to be the order of paraview
AffineTransform = vtk.vtkTransform()
# should be in meters
# For NS
#AffineTransform.Translate([ .01320,-.0037,0.00000010])
#AffineTransform.Translate([ .005,-.0035,0.0])
AffineTransform.Translate([-.006,-.0022,0.0])
AffineTransform.RotateZ( 0.0 )
AffineTransform.RotateY( -90.0 )
AffineTransform.RotateX( 0.0 )
AffineTransform.Scale([1.,1.,1.])
# get homogenius 4x4 matrix of the form
# A | b
# matrix = -----
# 0 | 1
#
matrix = AffineTransform.GetConcatenatedTransform(0).GetMatrix()
#print matrix
RotationMatrix = [[matrix.GetElement(0,0),matrix.GetElement(0,1),matrix.GetElement(0,2)],
[matrix.GetElement(1,0),matrix.GetElement(1,1),matrix.GetElement(1,2)],
[matrix.GetElement(2,0),matrix.GetElement(2,1),matrix.GetElement(2,2)]]
Translation = [matrix.GetElement(0,3),matrix.GetElement(1,3),matrix.GetElement(2,3)]
#print RotationMatrix ,Translation
laserTip = AffineTransform.TransformPoint( laserTip )
laserOrientation = AffineTransform.TransformVector( laserOrientation )
# set laser orientation values
getpot.SetIniValue( "probe/x_0","%f" % laserTip[0])
getpot.SetIniValue( "probe/y_0","%f" % laserTip[1])
getpot.SetIniValue( "probe/z_0","%f" % laserTip[2])
getpot.SetIniValue( "probe/x_orientation","%f" % laserOrientation[0] )
getpot.SetIniValue( "probe/y_orientation","%f" % laserOrientation[1] )
getpot.SetIniValue( "probe/z_orientation","%f" % laserOrientation[2] )
# initialize FEM Mesh
femMesh = femLibrary.PylibMeshMesh()
# must setup Ini File first
#For SPIOs
#femMesh.SetupUnStructuredGrid( "/work/01741/cmaclell/data/mdacc/deltap_phantom_oct10/phantomMeshFullTess.e",0,RotationMatrix, Translation )
#For NS/NR
RotationMatrix = [[1,0,0],
[0,1,0],
[0,0,1]]
Translation = [.0000001,.00000001,.000001]
#
femMesh.SetupUnStructuredGrid( "./sphereMesh.e",0,RotationMatrix, Translation )
#femMesh.SetupUnStructuredGrid( "phantomMesh.e",0,RotationMatrix, Translation )
MeshOutputFile = "fem_data.%04d.e" % kwargs['fileID']
#femMes.SetupStructuredGrid( (10,10,4) ,[0.0,1.0],[0.0,2.0],[0.0,1.0])
# add the data structures for the background system solve
# set deltat, number of time steps, power profile, and add system
nsubstep = 1
#for SPIOs
#acquisitionTime = 4.9305
#for NS/NR
acquisitionTime = 5.09
deltat = acquisitionTime / nsubstep
ntime = 60
eqnSystems = femLibrary.PylibMeshEquationSystems(femMesh,getpot)
#For SPIOs
#getpot.SetIniPower(nsubstep, [ [1,6,30,ntime],[1.0,0.0,4.5,0.0] ])
#For NS/NR
getpot.SetIniPower(nsubstep, [ [1,6,42,ntime],[1.0,0.0,1.13,0.0] ])
deltapSystem = eqnSystems.AddPennesDeltaPSystem("StateSystem",deltat)
deltapSystem.AddStorageVectors(ntime)
# hold imaging
mrtiSystem = eqnSystems.AddExplicitSystem( "MRTI" )
mrtiSystem.AddFirstLagrangeVariable( "u0*" )
mrtiSystem.AddStorageVectors(ntime)
maskSystem = eqnSystems.AddExplicitSystem( "ImageMask" )
maskSystem.AddFirstLagrangeVariable( "mask" )
# initialize libMesh data structures
eqnSystems.init( )
# print info
eqnSystems.PrintSelf()
# write IC
exodusII_IO = femLibrary.PylibMeshExodusII_IO(femMesh)
exodusII_IO.WriteTimeStep(MeshOutputFile,eqnSystems, 1, 0.0 )
# read imaging data geometry that will be used to project FEM data onto
#For 67_11
#vtkReader.SetFileName('/work/01741/cmaclell/data/mdacc/deltap_phantom_oct10/spio/spioVTK/67_11/tmap_67_11.0000.vtk')
#For 67_10
#vtkReader.SetFileName('/work/01741/cmaclell/data/mdacc/deltap_phantom_oct10/spio/spioVTK/67_10/tmap_67_10.0000.vtk')
#For 335_11
#vtkReader.SetFileName('/work/01741/cmaclell/data/mdacc/deltap_phantom_oct10/spio/spioVTK/335_11/tmap_335_11.0000.vtk')
#For NS
#vtkReader.SetFileName('/work/01741/cmaclell/data/mdacc/deltap_phantom_oct10/nrtmapsVTK/S695/S695.0000.vtk')
#For NR
imageFileNameTemplate = '/work/01741/cmaclell/data/mdacc/NanoMouseJune12/matlab_VTK/control_1_tmap.%04d.vtk'
imageFileNameTemplate = '/FUS4/data2/CJM/SPIO_mice/matlab_VTK/control_1_tmap.%04d.vtk'
#imageFileNameTemplate = "/share/work/fuentes/deltap_phantom_oct10/nrtmapsVTK/R695/R695.%04d.vtk"
#imageFileNameTemplate = "/data/fuentes/mdacc/deltap_phantom_oct10/nrtmapsVTK/R695/R695.%04d.vtk"
#vtkReader = vtk.vtkXMLImageDataReader()
vtkReader = vtk.vtkDataSetReader()
vtkReader.SetFileName( imageFileNameTemplate % 0 )
vtkReader.Update()
templateImage = vtkReader.GetOutput()
dimensions = templateImage.GetDimensions()
spacing = templateImage.GetSpacing()
origin = templateImage.GetOrigin()
print spacing, origin, dimensions
femImaging = femLibrary.PytttkImaging(getpot, dimensions ,origin,spacing)
ObjectiveFunction = 0.0
# loop over time steps and solve
for timeID in range(1,ntime*nsubstep):
#for timeID in range(1,10):
# project imaging onto fem mesh
vtkImageReader = vtk.vtkDataSetReader()
vtkImageReader.SetFileName( imageFileNameTemplate % timeID )
vtkImageReader.Update()
image_cells = vtkImageReader.GetOutput().GetPointData()
data_array = vtkNumPy.vtk_to_numpy(image_cells.GetArray('scalars'))
v1 = PETSc.Vec().createWithArray(data_array, comm=PETSc.COMM_SELF)
femImaging.ProjectImagingToFEMMesh("MRTI",0.0,v1,eqnSystems)
mrtiSystem.StoreSystemTimeStep(timeID )
# create image mask
# The = operator for numpy arrays just copies by reference
# .copy() provides a deep copy (ie physical memory copy)
image_mask = data_array.copy().reshape(dimensions,order='F')
# Set all image pixels to large value
largeValue = 1.e6
image_mask[:,:] = 1
# RMS error will be computed within this ROI/VOI imagemask[xcoords/column,ycoords/row]
#image_mask[93:153,52:112] = 1.0
#image_mask[98:158,46:106] = 1.0
v2 = PETSc.Vec().createWithArray(image_mask, comm=PETSc.COMM_SELF)
femImaging.ProjectImagingToFEMMesh("ImageMask",largeValue,v2,eqnSystems)
#print mrti_array
#print type(mrti_array)
print "time step = " ,timeID
eqnSystems.UpdatePetscFEMSystemTimeStep("StateSystem",timeID )
deltapSystem.SystemSolve()
#eqnSystems.StoreTransientSystemTimeStep("StateSystem",timeID )
# accumulate objective function
#
# qoi = ( (FEM - MRTI) / ImageMask)^2
#
qoi = femLibrary.WeightedL2Norm( deltapSystem,"u0",
mrtiSystem,"u0*",
maskSystem,"mask" )
ObjectiveFunction =( ObjectiveFunction + qoi)
# control write output
writeControl = True
if ( timeID%nsubstep == 0 and writeControl ):
# write exodus file
exodusII_IO.WriteTimeStep(MeshOutputFile,eqnSystems, timeID+1, timeID*deltat )
# Interpolate FEM onto imaging data structures
if (vtk != None):
vtkExodusIIReader = vtk.vtkExodusIIReader()
vtkExodusIIReader.SetFileName(MeshOutputFile )
vtkExodusIIReader.SetPointResultArrayStatus("u0",1)
vtkExodusIIReader.SetTimeStep(timeID-1)
vtkExodusIIReader.Update()
# reflect
vtkReflect = vtk.vtkReflectionFilter()
vtkReflect.SetPlaneToYMax()
vtkReflect.SetInput( vtkExodusIIReader.GetOutput() )
vtkReflect.Update()
# reuse ShiftScale Geometry
vtkResample = vtk.vtkCompositeDataProbeFilter()
vtkResample.SetInput( vtkImageReader.GetOutput() )
vtkResample.SetSource( vtkReflect.GetOutput() )
vtkResample.Update()
fem_point_data= vtkResample.GetOutput().GetPointData()
fem_array = vtkNumPy.vtk_to_numpy(fem_point_data.GetArray('u0'))
#print fem_array
#print type(fem_array )
# only rank 0 should write
#if ( petscRank == 0 ):
# print "writing ", timeID
# vtkTemperatureWriter = vtk.vtkDataSetWriter()
# vtkTemperatureWriter.SetFileTypeToBinary()
# vtkTemperatureWriter.SetFileName("invspio_67_11.%04d.vtk" % timeID )
# vtkTemperatureWriter.SetInput(vtkResample.GetOutput())
# vtkTemperatureWriter.Update()
print 'Objective Fn'
print ObjectiveFunction
retval = dict([])
retval['fns'] = [ObjectiveFunction *10000000.]
retval['rank'] = petscRank
return(retval)
def test_petgem():
# ---------------------------------------------------------------
# PETSc init
# ---------------------------------------------------------------
petsc4py.init(sys.argv)
# ---------------------------------------------------------------
# Load python modules
# ---------------------------------------------------------------
# ---------------------------------------------------------------
# Load petgem modules (BSC)
# ---------------------------------------------------------------
from petgem.common import Print, InputParameters, Timers
from petgem.parallel import MPIEnvironment
from petgem.preprocessing import Preprocessing
from petgem.solver import Solver
# ---------------------------------------------------------------
# Load system setup (both parameters and dataset configuration)
# ---------------------------------------------------------------
# Obtain the MPI environment
parEnv = MPIEnvironment()
# Import parameters file
inputSetup = InputParameters('tests/data/params.yaml', parEnv)
# Initialize timers
Timers(inputSetup.output.directory)
# ---------------------------------------------------------------
# Print header
# ---------------------------------------------------------------
Print.header()
# ---------------------------------------------------------------
# Initialize preprocessing and timers
# ---------------------------------------------------------------
Print.master(' ')
Print.master(' Data preprocessing')
# Create a preprocessing instance and output directory
preprocessing = Preprocessing()
# Run preprocessing
preprocessing.run(inputSetup)
# ---------------------------------------------------------------
# Initialize and execute the solver
# ---------------------------------------------------------------
Print.master(' ')
Print.master(' Run modelling')
# Create a solver instance
csem_solver = Solver()
# Setup solver (import files from preprocessing stage)
csem_solver.setup(inputSetup)
# Assembly linear system
csem_solver.assembly(inputSetup)
# Set dirichlet boundary conditions
csem_solver.solve()
# Compute electromagnetic responses
csem_solver.postprocess(inputSetup)
# Remove output directory
shutil.rmtree(inputSetup.output.directory)
#!/usr/bin/python # interpolate scalar gradient onto nedelec space from dolfin import * import petsc4py import sys petsc4py.init(sys.argv) from petsc4py import PETSc Print = PETSc.Sys.Print # from MatrixOperations import * import numpy as np #import matplotlib.pylab as plt import PETScIO as IO import common import scipy import scipy.io import time import BiLinear as forms import IterOperations as Iter import MatrixOperations as MO import CheckPetsc4py as CP import ExactSol import Solver as S import MHDmatrixPrecondSetup as PrecondSetup import NSprecondSetup import MHDallatonce as MHDpreconditioner m = 7
else:
namespace[name] = getattr(module, name)
if not imported_from_sphinx:
import petsc4py
try:
# Look if petsc4py has already been initialized
PETSc = petsc4py.__getattribute__('PETSc')
except AttributeError:
# If not, initialize petsc4py with the PETSc that PISM was compiled against.
import sys
import PISM.version_info
try:
petsc4py.init(sys.argv, arch=PISM.version_info.PETSC_ARCH)
except TypeError:
# petsc4py on Debian 9 does not recognize the PETSC_ARCH of PETSc in the .deb package
petsc4py.init(sys.argv)
from petsc4py import PETSc
import PISM.cpp
import_symbols(PISM.cpp, globals())
else: # pragma: no cover
# The following constants will be imported from 'cpp' if we are not
# running inside sphinx. But if we are inside sphinx, then we'll
# need them to be able to import submodules.
WITH_GHOSTS = True
WITHOUT_GHOSTS = False