Exemple #1
0
def setup_map_generator(database, aircrafts, lengthScales, variance,
                        noiseVariance, wind):

    # Object which is in charge of giving the wind to the gpr kernel.
    windServer = WindMapConstant('WindServer', wind)

    # Kernel to use in the gpr
    params = {}
    params['lengthScales'] = lengthScales
    params['variance'] = variance
    params['noiseVariance'] = noiseVariance

    shallowParams = {}  # this is because of sklean clone function
    shallowParams['windMap'] = windServer
    params['shallowParameters'] = DeepcopyGuard(**shallowParams)
    kernel = WindKernel(**params)

    # Objects in charge of fetch cloud sensor data and voltage data from the
    # database and giving to the gpr calibrated sensor data.
    cloudViews = []
    for aircraft, params in aircrafts.items():
        cloudViews.append(
            CloudSensorProcessing("Cloud data " + aircraft, database,
                                  [aircraft, "cloud_channel_0"],
                                  [aircraft, "energy"], params['alpha'],
                                  params['beta'], params['scaling']))
    # Aggregating the output of these view to a single one for the gpr
    cloudView = DataView("Cloud data", parents=cloudViews)

    # The object in charge of all gpr calculations.
    gpr = GprPredictor("Cloud Map estimator", cloudView, kernel)
    gpr.computeStd = True

    return gpr
Exemple #2
0
#########################################################################

mesonhPath = '/home/pnarvor/work/nephelae/data/MesoNH-2019-02/REFHR.1.ARMCu.4D.nc'
rct = MesonhVariable(MFDataset(mesonhPath), 'RCT')
ut = MesonhVariable(MFDataset(mesonhPath), 'UT')
vt = MesonhVariable(MFDataset(mesonhPath), 'VT')

t, p0, p, b, xyLocations, v0, mapShape, tStart, tEnd = parameters(rct)

# Kernel
processVariance = 1.0e-8
noiseStddev = 0.1 * np.sqrt(processVariance)
# kernel0 = WindKernel(lengthScales, processVariance, noiseStddev**2, v0)
# lengthScales = [70.0, 60.0, 60.0, 60.0]
lengthScales = [70.0, 80.0, 80.0, 60.0]
kernel0 = WindKernel(lengthScales, processVariance, noiseStddev**2,
                     WindMapConstant('Wind', v0))

noise = noiseStddev * np.random.randn(p.shape[0])
dtfile = 'output/wind_data03.neph'
print("Getting mesonh values... ", end='')
# dtbase = NephelaeDataServer()
# sys.stdout.flush()
# for pos,n in zip(p,noise):
#     dtbase.add_gps(Gps("100", Position(pos[0],pos[1],pos[2],pos[3])))
#     dtbase.add_sample(SensorSample('RCT', '100', pos[0],
#         Position(pos[0],pos[1],pos[2],pos[3]),
#         [rct[pos[0],pos[1],pos[2],pos[3] + n]]))
#     dtbase.add_sample(SensorSample('Wind', '100', pos[0],
#         Position(pos[0],pos[1],pos[2],pos[3]),
#         [ut[pos[0],pos[1],pos[2],pos[3]], vt[pos[0],pos[1],pos[2],pos[3]]]))
# dtbase.save(dtfile, force=True)
database = NephelaeDataServer.load(databasePath)

mesonhDataset = MesonhDataset(mesonhPath)
rct = MesonhMap('Liquid water', mesonhDataset, 'RCT', interpolation='linear')

# Have to define wind by hand for now.
wind = np.array([8.5, 0.9])
windMap = WindMapConstant('Wind', wind)

# Kernel for liquid water content
processVariance = 1.0e-8
noiseStddev = 0.1 * np.sqrt(processVariance)
lengthScales = [70.0, 80.0, 80.0, 60.0]

rctKernel0 = WindKernel(lengthScales, processVariance, noiseStddev**2, windMap)
rctGpr = GprPredictor('RCT', database, ['RCT'], rctKernel0)

# coordinates of the map you want to generate/extract
t = 160.0
x = [12.5, 6387.5]
y = [1837.5, 2712.5]
z = 1100.0

# getting some mesonh data
mesonhSlice = rct[t, x[0]:x[1], y[0]:y[1], z].data
# predicting with gpr
gprSlice = rctGpr[t, x[0]:x[1], y[0]:y[1], z][0].data[:, :, 0]

# the GPR prediction resolution depends on the kernel length scale so it is not
# necessarily the same as the mesonh. Although they represent the same region