def _copyPreviousSolution(self):
if self._curTStep == 0:
return
# Function for finding closest timestep to current time
def closest_floor(arr):
tstep = arr.index.get_level_values('tstep')
t = self._curTStep - tstep > 0
# print(t)
return (tstep[t].min())
# Find closest time and copy fields to current time
g = self.fields.groupby(level='fieldID').apply(closest_floor)
for fID in g.index:
key = (fID, g[fID])
newKey = (fID, self._curTStep)
f = self.fields[key]
newField = Field.Field(f.getMesh(),
f.getFieldID(),
f.getValueType(),
units=f.getUnits(),
values=f.values,
time=self._curTStep,
fieldType=f.fieldType)
self.fields.set_value(newKey, newField)
# Find closest time and copy properties to current time
g = self.properties.groupby(level=('propertyID',
'objectID')).apply(closest_floor)
for pID in g.index:
key = (pID[0], pID[1], g[pID])
newKey = (pID[0], pID[1], self._curTStep)
p = self.properties[key]
newProp = Property.Property(value=p.getValue(),
propID=p.getPropertyID(),
valueType=p.valueType,
time=self._curTStep,
units=p.getUnits(),
objectID=p.getObjectID())
self.properties.set_value(newKey, newProp)
def initialProps(props, jsondata, pID=PropertyID):
# Number of rays
nr = Property.Property(value=jsondata['sources'][0]['rays'],
propID=pID.PID_NumberOfRays,
valueType=ValueType.Scalar,
time=0.0,
units=None,
objectID=objID.OBJ_CHIP_ACTIVE_AREA)
key = (pID.PID_NumberOfRays, objID.OBJ_CHIP_ACTIVE_AREA, 0)
props.set_value(key, nr)
# Refractive index of silicone cone
v = jsondata['materials'][3]['refractiveIndex']
nr = Property.Property(value=v,
propID=pID.PID_RefractiveIndex,
valueType=ValueType.Scalar,
time=0.0,
units=None,
objectID=objID.OBJ_CONE)
key = (pID.PID_RefractiveIndex, objID.OBJ_CONE, 0)
props.set_value(key, nr)
# LED spectrum
nr = Property.Property(value={
"wavelengths": np.array([450]),
"intensities": np.array([0])
},
propID=pID.PID_LEDSpectrum,
valueType="dict",
time=0.0,
units=None,
objectID=objID.OBJ_LED)
key = (pID.PID_LEDSpectrum, objID.OBJ_LED, 0)
props.set_value(key, nr)
# Chip spectrum
v1 = jsondata['sources'][0]['wavelengths']
v2 = jsondata['sources'][0]['intensities']
nr = Property.Property(value={
"wavelengths": np.array(v1),
"intensities": np.array(v2)
},
propID=pID.PID_ChipSpectrum,
valueType="dict",
time=0.0,
units=None,
objectID=objID.OBJ_CHIP_ACTIVE_AREA)
key = (pID.PID_ChipSpectrum, objID.OBJ_CHIP_ACTIVE_AREA, 0)
props.set_value(key, nr)
# Color X
nr = Property.Property(value=0,
propID=pID.PID_LEDColor_x,
valueType=ValueType.Scalar,
time=0.0,
units=None,
objectID=objID.OBJ_LED)
key = (pID.PID_LEDColor_x, objID.OBJ_LED, 0)
props.set_value(key, nr)
# Color Y
nr = Property.Property(value=0,
propID=pID.PID_LEDColor_y,
valueType=ValueType.Scalar,
time=0.0,
units=None,
objectID=objID.OBJ_LED)
key = (pID.PID_LEDColor_y, objID.OBJ_LED, 0)
props.set_value(key, nr)
# CCT
nr = Property.Property(value=0,
propID=pID.PID_LEDCCT,
valueType=ValueType.Scalar,
time=0.0,
units=None,
objectID=objID.OBJ_LED)
key = (pID.PID_LEDCCT, objID.OBJ_LED, 0)
props.set_value(key, nr)
# RadiantPower
nr = Property.Property(value=0,
propID=pID.PID_LEDRadiantPower,
valueType=ValueType.Scalar,
time=0.0,
units=None,
objectID=objID.OBJ_LED)
key = (pID.PID_LEDRadiantPower, objID.OBJ_LED, 0)
props.set_value(key, nr)
# Number of fluorescent particles:
nr = Property.Property(
value=jsondata['materials'][3]['numberOfFluorescentParticles'],
valueType=ValueType.Scalar,
propID=pID.PID_NumberOfFluorescentParticles,
time=0.0,
units=None,
objectID=objID.OBJ_CONE)
key = (pID.PID_NumberOfFluorescentParticles, objID.OBJ_CONE, 0)
props.set_value(key, nr)
# Phosphor efficiency for PARTICLE_TYPE_1:
p_eff = Property.Property(
value=jsondata['materials'][3]['phosphorEfficiencies'][0],
valueType=ValueType.Scalar,
propID=pID.PID_PhosphorEfficiency,
time=0.0,
units=None,
objectID=objID.OBJ_PARTICLE_TYPE_1)
key = (pID.PID_PhosphorEfficiency, objID.OBJ_PARTICLE_TYPE_1, 0)
props.set_value(key, p_eff)
tracerApp.setProperty(pScat)
tracerApp.setProperty(pPhase)
# Connect fields
fTemp = comsolApp.getField(FieldID.FID_Temperature, 0)
fHeat = comsolApp.getField(FieldID.FID_Thermal_absorption_volume, 0)
tracerApp.setField(fTemp)
tracerApp.setField(fHeat)
# Connect properties
# Particle density
vDens = 0.00003400
pDens = Property.Property(value=vDens,
propID=PropertyID.PID_ParticleNumberDensity,
valueType=ValueType.Scalar,
time=0.0,
units=None,
objectID=objID.OBJ_CONE)
tracerApp.setProperty(pDens)
# Number of rays to trace
pRays = Property.Property(value=100000,
propID=PropertyID.PID_NumberOfRays,
valueType=ValueType.Scalar,
time=0.0,
units=None,
objectID=objID.OBJ_CONE)
tracerApp.setProperty(pRays)
# Emission spectrum
em = Property.Property(value=ex_em_import.getEm(),
propID=PropertyID.PID_EmissionSpectrum,
tracerApp.setProperty(pPhase, objID.OBJ_PARTICLE_TYPE_1)
logger.info('Props connected')
# Connect fields
fTemp = comsolApp.getField(FieldID.FID_Temperature, 0)
fHeat = comsolApp.getField(FieldID.FID_Thermal_absorption_volume, 0)
tracerApp.setField(fTemp)
tracerApp.setField(fHeat)
# Connect properties
# Particle density
vDens = 0.00000003400
pDens = Property.Property(value=vDens,
propID=PropertyID.PID_ParticleNumberDensity,
valueType=ValueType.Scalar,
time=0.0,
units=None,
objectID=objID.OBJ_CONE)
tracerApp.setProperty(pDens)
# Number of rays to trace
pRays = Property.Property(value=100,
propID=PropertyID.PID_NumberOfRays,
valueType=ValueType.Scalar,
time=0.0,
units=None,
objectID=objID.OBJ_CONE)
tracerApp.setProperty(pRays)
# Emission spectrum
import numpy as np
def interpolateProperty(properties,
time,
propertyID,
objectID,
method='linear'):
"""
Function to interpolate fields in between solved timesteps.
Parameters
----------
properties : pandas.Series of Property.Property
Series of properties for consecutive timesteps.
time : float
Time to interpolate data
propetyID : PropertyID
Type of the property to interpolate
objectID : float
Object id the porperty is attached to.
method : string, optional
Method to be used in the interpolation. Only linear is currently
supported
Returns
-------
interPorp : Property.Property
Interpolated property
"""
if not isinstance(properties, pd.Series):
raise TypeError("Properties should be in pandas Series -object")
# Find closest timesteps
idx_tstep = properties.loc[propertyID, objectID, :].index
value_to_find = time
Min = idx_tstep <= value_to_find
Max = idx_tstep >= value_to_find
p_min = properties[(propertyID, objectID, idx_tstep[Min].max())]
p_max = properties[(propertyID, objectID, idx_tstep[Max].min())]
# Dictinary not supported
if type(p_max.getValue()) == dict:
logger.warning('Interpolation of (dict) not supported! Returning max.')
return (p_max)
# Interpolate property getValue().
if method == 'linear':
newValue = p_min.getValue() + (p_max.getValue() -
p_min.getValue()) / 2.0
else:
logger.warning(
'Interpolation method (%s) not supported! Using linear.' % method)
newValue = p_min.getValue() + (p_max.getValue() -
p_min.getValue()) / 2.0
# Create new property.
newProp = Property.Property(value=newValue,
propID=propertyID,
valueType=p_min.getValueType(),
time=time,
units=p_min.getUnits(),
objectID=objectID)
return (newProp)