def createLASolver():
lasolver = superlu.daeCreateSuperLUSolver()
options = lasolver.Options
if lasolver.Name == 'SuperLU':
# SuperLU options:
options.ColPerm = superlu.COLAMD # {NATURAL, MMD_ATA, MMD_AT_PLUS_A, COLAMD}
#options.RowPerm = superlu.NOROWPERM # {NOROWPERM, LargeDiag}
#options.PrintStat = superlu.YES # {YES, NO}
#options.DiagPivotThresh = 1.0 # Between 0.0 and 1.0
#options.Equil = superlu.NO # {YES, NO}
#options.PivotGrowth = superlu.NO # {YES, NO}
#options.ConditionNumber = superlu.NO # {YES, NO}
elif lasolver.Name == 'SuperLU_MT':
# SuperLU_MT options:
# Leave nprocs to default (specified in daetools.cfg) or specify it manually
#options.nprocs = 4 # No. of threads (= no. of CPUs/Cores)
print('SuperLU_MT numThreads = %d' % options.nprocs)
#options.PrintStat = superlu.YES # {YES, NO}
#options.ColPerm = superlu.COLAMD # {NATURAL, MMD_ATA, MMD_AT_PLUS_A, COLAMD}
#options.diag_pivot_thresh = 1.0 # Between 0.0 and 1.0
#options.panel_size = 8 # Integer value
#options.relax = 6 # Integer value
#options.drop_tol = 0.0 # Floating point value
return lasolver
def run(**kwargs):
guiRun = kwargs.get('guiRun', False)
simulation = simTutorial()
# Create SuperLU LA solver
lasolver = pySuperLU.daeCreateSuperLUSolver()
# Create and setup two data reporters:
datareporter = daeDelegateDataReporter()
simName = simulation.m.Name + strftime(" [%d.%m.%Y %H:%M:%S]", localtime())
if guiRun:
results_folder = tempfile.mkdtemp(suffix = '-results', prefix = 'tutorial_deal_II_2-')
daeQtMessage("deal.II", "The simulation results will be located in: %s" % results_folder)
else:
results_folder = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'tutorial_deal_II_2-results')
print("The simulation results will be located in: %s" % results_folder)
# 1. deal.II (exports only FE DOFs in .vtk format to the specified directory)
feDataReporter = simulation.m.fe_system.CreateDataReporter()
datareporter.AddDataReporter(feDataReporter)
if not feDataReporter.Connect(results_folder, simName):
sys.exit()
# 2. TCP/IP
tcpipDataReporter = daeTCPIPDataReporter()
datareporter.AddDataReporter(tcpipDataReporter)
if not tcpipDataReporter.Connect("", simName):
sys.exit()
return daeActivity.simulate(simulation, reportingInterval = 2,
timeHorizon = 200,
lasolver = lasolver,
datareporter = datareporter,
**kwargs)
def run(**kwargs):
simulation = simTutorial()
relativeTolerance = 1e-07
from daetools.solvers.superlu import pySuperLU as superlu
lasolver = superlu.daeCreateSuperLUSolver()
return daeActivity.simulate(simulation,
reportingInterval=60,
timeHorizon=3000,
lasolver=lasolver,
relativeTolerance=relativeTolerance,
**kwargs)
def run(**kwargs):
guiRun = kwargs.get('guiRun', False)
simulation = simTutorial()
# Create SuperLU LA solver
lasolver = pySuperLU.daeCreateSuperLUSolver()
# Create and setup two data reporters:
datareporter = daeDelegateDataReporter()
simName = simulation.m.Name + strftime(" [%d.%m.%Y %H:%M:%S]", localtime())
if guiRun:
results_folder_c = tempfile.mkdtemp(suffix='-results_c',
prefix='tutorial_deal_II_8-')
results_folder_cs = tempfile.mkdtemp(suffix='-results_cs',
prefix='tutorial_deal_II_8-')
daeQtMessage(
"deal.II", "The simulation results will be located in: %s and %s" %
(results_folder_c, results_folder_cs))
else:
results_folder_c = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'tutorial_deal_II_8-results-c')
results_folder_cs = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'tutorial_deal_II_8-results-cs')
print("The simulation results will be located in: %s and %s" %
(results_folder_c, results_folder_cs))
# 1. deal.II for c
feDataReporter_c = simulation.m.fe_system_c.CreateDataReporter()
datareporter.AddDataReporter(feDataReporter_c)
if not feDataReporter_c.Connect(results_folder_c, simName):
sys.exit()
# 2. deal.II for cs
feDataReporter_cs = simulation.m.fe_system_cs.CreateDataReporter()
datareporter.AddDataReporter(feDataReporter_cs)
if not feDataReporter_cs.Connect(results_folder_cs, simName):
sys.exit()
# 3. TCP/IP
tcpipDataReporter = daeTCPIPDataReporter()
datareporter.AddDataReporter(tcpipDataReporter)
if not tcpipDataReporter.Connect("", simName):
sys.exit()
return daeActivity.simulate(simulation,
reportingInterval=0.05,
timeHorizon=2,
lasolver=lasolver,
datareporter=datareporter,
**kwargs)
def run_simulation(ndD_s, ndD_e, tScale, outdir):
# Create Log, Solver, DataReporter and Simulation object
log = dae.daePythonStdOutLog()
daesolver = dae.daeIDAS()
simulation = sim.SimMPET(ndD_s, ndD_e, tScale)
datareporter = data_reporting.setup_data_reporters(simulation, outdir)
# Use SuperLU direct sparse LA solver
lasolver = pySuperLU.daeCreateSuperLUSolver()
# lasolver = pyTrilinos.daeCreateTrilinosSolver("Amesos_Umfpack", "")
daesolver.SetLASolver(lasolver)
# Enable reporting of all variables
simulation.m.SetReportingOn(True)
# Set relative tolerances
daesolver.RelativeTolerance = ndD_s["relTol"]
# Set the time horizon and the reporting interval
simulation.TimeHorizon = ndD_s["tend"]
# The list of reporting times excludes the first index (zero, which is implied)
simulation.ReportingTimes = list(np.linspace(0, ndD_s["tend"], ndD_s["tsteps"] + 1))[1:]
# Example logspacing for output times:
# simulation.ReportingTimes = list(
# np.logspace(-4, np.log10(simulation.TimeHorizon), ndD_s['tsteps']))
# Connect data reporter
simName = simulation.m.Name + time.strftime(
" [%d.%m.%Y %H:%M:%S]", time.localtime())
if not datareporter.Connect("", simName):
sys.exit()
# Initialize the simulation
simulation.Initialize(daesolver, datareporter, log)
# Solve at time=0 (initialization)
simulation.SolveInitial()
# Run
try:
simulation.Run()
except Exception as e:
print(str(e))
simulation.ReportData(simulation.CurrentTime)
raise
except KeyboardInterrupt:
print("\nphi_applied at ctrl-C:",
simulation.m.phi_applied.GetValue(), "\n")
simulation.ReportData(simulation.CurrentTime)
simulation.Finalize()
def run(**kwargs):
simulation = simTutorial()
# Equation EvaluationMode can be one of:
# - eEvaluationTree_OpenMP
# - eComputeStack_OpenMP
#simulation.EvaluationMode = eComputeStack_External
# External compute stack evaluators can be set using SetComputeStackEvaluator function.
# Here, the evaluation mode is set to eComputeStack_External.
# Evaluators can be also set using the computeStackEvaluator argument of daeActivity.simulate function.
# Available OpenCL platforms/devices can be obtained using the following functions:
openclPlatforms = pyEvaluator_OpenCL.AvailableOpenCLPlatforms()
openclDevices = pyEvaluator_OpenCL.AvailableOpenCLDevices()
print('Available OpenCL platforms:')
for platform in openclPlatforms:
print(' Platform: %s' % platform.Name)
print(' PlatformID: %d' % platform.PlatformID)
print(' Vendor: %s' % platform.Vendor)
print(' Version: %s' % platform.Version)
#print(' Profile: %s' % platform.Profile)
#print(' Extensions: %s' % platform.Extensions)
print('')
print('Available OpenCL devices:')
for device in openclDevices:
print(' Device: %s' % device.Name)
print(' PlatformID: %d' % device.PlatformID)
print(' DeviceID: %d' % device.DeviceID)
print(' DeviceVersion: %s' % device.DeviceVersion)
print(' DriverVersion: %s' % device.DriverVersion)
print(' OpenCLVersion: %s' % device.OpenCLVersion)
print(' MaxComputeUnits: %d' % device.MaxComputeUnits)
print('')
# OpenCL evaluators can use a single or multiple OpenCL devices.
# a) Single OpenCL device:
computeStackEvaluator = pyEvaluator_OpenCL.CreateComputeStackEvaluator(
platformID=0, deviceID=0)
# b) Multiple OpenCL devices (for heterogenous computing):
#computeStackEvaluator = pyEvaluator_OpenCL.CreateComputeStackEvaluator( [(0, 0, 0.6), (1, 1, 0.4)] )
simulation.SetComputeStackEvaluator(computeStackEvaluator)
# Create LA solver
lasolver = pySuperLU.daeCreateSuperLUSolver()
return daeActivity.simulate(simulation,
reportingInterval=5,
timeHorizon=500,
lasolver=lasolver,
**kwargs)
def simulate(Nx, Ny, **kwargs):
# Create Log, Solver, DataReporter and Simulation object
log = daePythonStdOutLog()
daesolver = daeIDAS()
datareporter = daeDelegateDataReporter()
simulation = simTutorial(Nx, Ny)
# Do no print progress
log.PrintProgress = False
lasolver = pySuperLU.daeCreateSuperLUSolver()
# Enable reporting of time derivatives for all reported variables
simulation.ReportTimeDerivatives = True
# 1. TCP/IP
tcpipDataReporter = daeTCPIPDataReporter()
datareporter.AddDataReporter(tcpipDataReporter)
simName = simulation.m.Name + strftime(" [%d.%m.%Y %H:%M:%S]", localtime())
if not tcpipDataReporter.Connect("", simName):
sys.exit()
# 2. Data
dr = daeNoOpDataReporter()
datareporter.AddDataReporter(dr)
daeActivity.simulate(simulation,
reportingInterval=2.0,
timeHorizon=90.0,
log=log,
lasolver=lasolver,
datareporter=datareporter,
**kwargs)
###########################################
# Data #
###########################################
results = dr.Process.dictVariables
uvar = results[simulation.m.Name + '.u']
vvar = results[simulation.m.Name + '.v']
umvar = results[simulation.m.Name + '.um']
vmvar = results[simulation.m.Name + '.vm']
times = uvar.TimeValues
u = uvar.Values[-1, :, :] # 3D array [t,x,y]
v = vvar.Values[-1, :, :] # 3D array [t,x,y]
um = umvar.Values[-1, :, :] # 3D array [t,x,y]
vm = vmvar.Values[-1, :, :] # 3D array [t,x,y]
return times, u, v, um, vm, simulation
def simulate(Nx, **kwargs):
# Create Log, Solver, DataReporter and Simulation object
log = daePythonStdOutLog()
daesolver = daeIDAS()
datareporter = daeDelegateDataReporter()
simulation = simTutorial(Nx)
# Do no print progress
log.PrintProgress = False
lasolver = pySuperLU.daeCreateSuperLUSolver()
daesolver.RelativeTolerance = 1e-7
# 1. TCP/IP
tcpipDataReporter = daeTCPIPDataReporter()
datareporter.AddDataReporter(tcpipDataReporter)
simName = simulation.m.Name + strftime(" [%d.%m.%Y %H:%M:%S]", localtime())
if not tcpipDataReporter.Connect("", simName):
sys.exit()
# 2. Data
dr = daeNoOpDataReporter()
datareporter.AddDataReporter(dr)
daeActivity.simulate(simulation,
reportingInterval=0.02,
timeHorizon=dt,
log=log,
lasolver=lasolver,
datareporter=datareporter,
**kwargs)
###########################################
# Data #
###########################################
results = dr.Process.dictVariables
cvar = results[simulation.m.Name + '.c']
c = cvar.Values[-1, :] # 2D array [t,x]
return simulation.m.x.Points, c, simulation
def simulate(mesh, quadratureFormulaOrder):
# Create Log, Solver, DataReporter and Simulation object
log = daePythonStdOutLog()
daesolver = daeIDAS()
datareporter = daeDelegateDataReporter()
simulation = simTutorial(mesh, quadratureFormulaOrder)
# Do no print progress
log.PrintProgress = False
lasolver = pySuperLU.daeCreateSuperLUSolver()
daesolver.SetLASolver(lasolver)
simName = simulation.m.Name + strftime(" [%d.%m.%Y %H:%M:%S]", localtime())
results_folder = os.path.join(os.path.dirname(os.path.abspath(__file__)),
'tutorial_cv_5-results')
# Create three data reporters:
# 1. DealII
feDataReporter = simulation.m.fe_system.CreateDataReporter()
datareporter.AddDataReporter(feDataReporter)
if not feDataReporter.Connect(results_folder, simName):
sys.exit()
# 2. TCP/IP
tcpipDataReporter = daeTCPIPDataReporter()
datareporter.AddDataReporter(tcpipDataReporter)
if not tcpipDataReporter.Connect("", simName):
sys.exit()
# 3. Data
dr = daeNoOpDataReporter()
datareporter.AddDataReporter(dr)
# Enable reporting of all variables
simulation.m.SetReportingOn(True)
# Set the time horizon and the reporting interval
simulation.ReportingInterval = 3600
simulation.TimeHorizon = 20 * 3600
# Initialize the simulation
simulation.Initialize(daesolver, datareporter, log)
# Save the model report and the runtime model report
simulation.m.fe_model.SaveModelReport(simulation.m.Name + ".xml")
#simulation.m.fe_model.SaveRuntimeModelReport(simulation.m.Name + "-rt.xml")
# Solve at time=0 (initialization)
simulation.SolveInitial()
# Run
simulation.Run()
simulation.Finalize()
###########################################
# Plots and data #
###########################################
results = dr.Process.dictVariables
Tvar = results[simulation.m.Name + '.HeatConduction.T']
uvar = results[simulation.m.Name + '.u']
Nx = simulation.m.x.NumberOfPoints
L = simulation.m.L
times = numpy.linspace(0, L, Nx)
T = Tvar.Values[-1, :] # 2D array [t,x]
u = uvar.Values[-1, :] # 2D array [t,x]
return times, T, u
def simulate(Nx):
# Create Log, Solver, DataReporter and Simulation object
log = daePythonStdOutLog()
daesolver = daeIDAS()
datareporter = daeDelegateDataReporter()
simulation = simTutorial(Nx)
daesolver.RelativeTolerance = 1E-6
# Do no print progress
log.PrintProgress = False
lasolver = pySuperLU.daeCreateSuperLUSolver()
daesolver.SetLASolver(lasolver)
simName = simulation.m.Name + 'Nx=%d'%Nx + strftime(" [%d.%m.%Y %H:%M:%S]", localtime())
results_folder = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'tutorial_cv_9-results(Nx=%d)' % Nx)
# Create three data reporters:
# 1. DealII
feDataReporter = simulation.m.fe_system.CreateDataReporter()
datareporter.AddDataReporter(feDataReporter)
if not feDataReporter.Connect(results_folder, simName):
sys.exit()
# 2. TCP/IP
tcpipDataReporter = daeTCPIPDataReporter()
datareporter.AddDataReporter(tcpipDataReporter)
if not tcpipDataReporter.Connect("", simName):
sys.exit()
# 3. Data
dr = daeNoOpDataReporter()
datareporter.AddDataReporter(dr)
# Enable reporting of all variables
simulation.m.SetReportingOn(True)
# Set the time horizon and the reporting interval
simulation.ReportingInterval = 2*numpy.pi / 100
simulation.TimeHorizon = 2*numpy.pi
# Initialize the simulation
simulation.Initialize(daesolver, datareporter, log)
# Save the model report and the runtime model report
#simulation.m.fe_model.SaveModelReport(simulation.m.Name + ".xml")
#simulation.m.fe_model.SaveRuntimeModelReport(simulation.m.Name + "-rt.xml")
# Solve at time=0 (initialization)
simulation.SolveInitial()
# Run
simulation.Run()
simulation.Finalize()
###########################################
# Plots and data #
###########################################
results = dr.Process.dictVariables
cvar = results[simulation.m.Name + '.SolidBodyRotation.c']
points = cvar.Domains[0].Points
c = cvar.Values[-1,:] # 2D array [t,omega]
# After t = 2pi system returned to the initial position
c_exact = cvar.Values[0,:] # 2D array [t,omega]
return points, c, c_exact
def createLASolver(lasolverIndex):
lasolver = None
if lasolverIndex == laSundialsLU:
pass
elif lasolverIndex == laSuperLU:
from daetools.solvers.superlu import pySuperLU
lasolver = pySuperLU.daeCreateSuperLUSolver()
elif lasolverIndex == laSuperLU_MT:
from daetools.solvers.superlu_mt import pySuperLU_MT
lasolver = pySuperLU_MT.daeCreateSuperLUSolver()
elif lasolverIndex == laAmesos_Klu:
from daetools.solvers.trilinos import pyTrilinos
lasolver = pyTrilinos.daeCreateTrilinosSolver("Amesos_Klu", "")
elif lasolverIndex == laAmesos_Superlu:
from daetools.solvers.trilinos import pyTrilinos
lasolver = pyTrilinos.daeCreateTrilinosSolver("Amesos_Superlu", "")
elif lasolverIndex == laAmesos_Umfpack:
from daetools.solvers.trilinos import pyTrilinos
lasolver = pyTrilinos.daeCreateTrilinosSolver("Amesos_Umfpack", "")
elif lasolverIndex == laAmesos_Lapack:
from daetools.solvers.trilinos import pyTrilinos
lasolver = pyTrilinos.daeCreateTrilinosSolver("Amesos_Lapack", "")
elif lasolverIndex == laAztecOO:
from daetools.solvers.trilinos import pyTrilinos
lasolver = pyTrilinos.daeCreateTrilinosSolver("AztecOO", "ILUT")
elif lasolverIndex == laPardiso:
from daetools.solvers.pardiso import pyPardiso
lasolver = pyPardiso.daeCreatePardisoSolver()
elif lasolverIndex == laIntelPardiso:
from daetools.solvers.intel_pardiso import pyIntelPardiso
lasolver = pyIntelPardiso.daeCreateIntelPardisoSolver()
elif lasolverIndex == laIntelMKL:
from daetools.solvers import pyIntelMKL
lasolver = pyIntelMKL.daeCreateLapackSolver()
elif lasolverIndex == laAmdACML:
from daetools.solvers import pyAmdACML
lasolver = pyAmdACML.daeCreateLapackSolver()
elif lasolverIndex == laLapack:
from daetools.solvers import pyLapack
lasolver = pyLapack.daeCreateLapackSolver()
elif lasolverIndex == laMagmaLapack:
from daetools.solvers import pyMagma
lasolver = pyMagma.daeCreateLapackSolver()
elif lasolverIndex == laSuperLU_CUDA:
from daetools.solvers.superlu_cuda import pySuperLU_CUDA
lasolver = pySuperLU_CUDA.daeCreateSuperLUSolver()
elif lasolverIndex == laCUSP:
from daetools.solvers import pyCUSP
lasolver = pyCUSP.daeCreateCUSPSolver()
else:
raise RuntimeError("Unsupported LA Solver selected")
return lasolver
