From 9e103beefc5bb13b10c13903c7d625b93ffe4ff6 Mon Sep 17 00:00:00 2001 From: Pierre Aumond Date: Thu, 25 Apr 2024 11:18:20 +0200 Subject: [PATCH 1/3] New Dynamic Tools --- .../noisemodelling/jdbc/JdbcNoiseMap.java | 92 +- .../noisemodelling/jdbc/LTComputeRaysOut.java | 317 ++++++ .../noisemodelling/jdbc/LTConfig.java | 259 +++++ .../jdbc/LTPointNoiseMapFactory.java | 527 ++++++++++ .../jdbc/LTPropagationProcessData.java | 140 +++ .../noisemodelling/jdbc/PointNoiseMap.java | 44 +- .../jdbc/LTPointNoiseMapFactoryTest.java | 108 ++ .../Acoustic_Tools/DynamicIndicators.groovy | 121 +++ .../Noise_From_Attenuation_Matrix.groovy | 287 ------ ...oise_From_Attenuation_Matrix_MatSim.groovy | 205 ++++ .../Dynamic_Road_Emission_from_Traffic.groovy | 881 +++++++++++++++++ .../Noise_From_Attenuation_Matrix.groovy | 204 ++++ .../Traffic_Probabilistic_Modelling.groovy | 935 ------------------ .../noisemodelling/wps/JdbcTestCase.groovy | 3 +- .../wps/TestNoiseModelling.groovy | 110 ++- .../noisemodelling/wps/ROADS2.dbf | Bin 421596 -> 421596 bytes 16 files changed, 2999 insertions(+), 1234 deletions(-) create mode 100644 noisemodelling-jdbc/src/main/java/org/noise_planet/noisemodelling/jdbc/LTComputeRaysOut.java create mode 100644 noisemodelling-jdbc/src/main/java/org/noise_planet/noisemodelling/jdbc/LTConfig.java create mode 100644 noisemodelling-jdbc/src/main/java/org/noise_planet/noisemodelling/jdbc/LTPointNoiseMapFactory.java create mode 100644 noisemodelling-jdbc/src/main/java/org/noise_planet/noisemodelling/jdbc/LTPropagationProcessData.java create mode 100644 noisemodelling-jdbc/src/test/java/org/noise_planet/noisemodelling/jdbc/LTPointNoiseMapFactoryTest.java create mode 100644 wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/Acoustic_Tools/DynamicIndicators.groovy delete mode 100644 wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/Experimental_Matsim/Noise_From_Attenuation_Matrix.groovy create mode 100644 wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/Experimental_Matsim/Noise_From_Attenuation_Matrix_MatSim.groovy create mode 100644 wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/NoiseModelling/Dynamic_Road_Emission_from_Traffic.groovy create mode 100644 wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/NoiseModelling/Noise_From_Attenuation_Matrix.groovy delete mode 100644 wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/NoiseModelling/Traffic_Probabilistic_Modelling.groovy diff --git a/noisemodelling-jdbc/src/main/java/org/noise_planet/noisemodelling/jdbc/JdbcNoiseMap.java b/noisemodelling-jdbc/src/main/java/org/noise_planet/noisemodelling/jdbc/JdbcNoiseMap.java index aa5f1a8e3..9f95bc7ee 100644 --- a/noisemodelling-jdbc/src/main/java/org/noise_planet/noisemodelling/jdbc/JdbcNoiseMap.java +++ b/noisemodelling-jdbc/src/main/java/org/noise_planet/noisemodelling/jdbc/JdbcNoiseMap.java @@ -16,11 +16,9 @@ import org.slf4j.LoggerFactory; import java.io.IOException; -import java.sql.Connection; -import java.sql.PreparedStatement; -import java.sql.ResultSet; -import java.sql.SQLException; +import java.sql.*; import java.util.ArrayList; +import java.util.HashMap; import java.util.List; import static org.h2gis.utilities.GeometryTableUtilities.getGeometryColumnNames; @@ -35,6 +33,8 @@ public abstract class JdbcNoiseMap { // When computing cell size, try to keep propagation distance away from the cell // inferior to this ratio (in comparison with cell width) PropagationProcessPathData propagationProcessPathDataDay = new PropagationProcessPathData(); + + HashMap propagationProcessPathDataT= new HashMap(); PropagationProcessPathData propagationProcessPathDataEvening = new PropagationProcessPathData(); PropagationProcessPathData propagationProcessPathDataNight = new PropagationProcessPathData(); Logger logger = LoggerFactory.getLogger(JdbcNoiseMap.class); @@ -43,7 +43,7 @@ public abstract class JdbcNoiseMap { protected static final double MINIMAL_BUFFER_RATIO = 0.3; private String alphaFieldName = "G"; protected final String buildingsTableName; - protected final String sourcesTableName; + protected String sourcesTableName; protected String soilTableName = ""; // Digital elevation model table. (Contains points or triangles) protected String demTable = ""; @@ -96,6 +96,10 @@ public PropagationProcessPathData getPropagationProcessPathData(LDENConfig.TIME_ } } + public PropagationProcessPathData getPropagationProcessPathData(String time_period) { + return propagationProcessPathDataT.get(time_period); + } + public void setPropagationProcessPathData(LDENConfig.TIME_PERIOD time_period, PropagationProcessPathData propagationProcessPathData) { switch (time_period) { case DAY: @@ -106,6 +110,10 @@ public void setPropagationProcessPathData(LDENConfig.TIME_PERIOD time_period, Pr propagationProcessPathDataNight = propagationProcessPathData; } } + + public void setPropagationProcessPathData(String time_period, PropagationProcessPathData propagationProcessPathData) { + propagationProcessPathDataT.put(time_period, propagationProcessPathData); + } public PropagationProcessPathData getPropagationProcessPathDataDay() { return propagationProcessPathDataDay; } @@ -401,6 +409,76 @@ public void fetchCellSource(Connection connection,Envelope fetchEnvelope, Cnosso } } + + /** + * Fetch source geometries and power + * @param connection Active connection + * @throws SQLException + */ + public List fetchSourceNumber(Connection connection) + throws SQLException, IOException { + TableLocation sourceTableIdentifier = TableLocation.parse(sourcesTableName); + Statement st = connection.createStatement(); + ResultSet rs = st.executeQuery("SELECT DISTINCT(PK) PK FROM " + sourcesTableName +";"); + // Create a List to store the values + List distinctSources = new ArrayList<>(); + + + // Iterate through the ResultSet and add values to the List + while (rs.next()) { + Integer value = rs.getInt("PK"); // Change "IT" to the actual column name + distinctSources.add(value); + } + + List distinctTimesteps = new ArrayList<>(); + + rs = st.executeQuery("SELECT DISTINCT(IT) IT FROM " + sourcesTableName +";"); + + // Iterate through the ResultSet and add values to the List + while (rs.next()) { + Integer value = rs.getInt("IT"); // Change "IT" to the actual column name + distinctTimesteps.add(value); + } + + return distinctSources; + } + + public void createSourcesTable(Connection connection, List frequencyValues) + throws SQLException, IOException { + TableLocation sourceTableIdentifier = TableLocation.parse(sourcesTableName); + Statement st = connection.createStatement(); + + st.execute("CREATE TABLE LW_SOURCES_130DB AS SELECT DISTINCT PK, THE_GEOM FROM " + sourcesTableName +";"); + + for (int freq : frequencyValues) { + st.execute("ALTER TABLE LW_SOURCES_130DB ADD HZ"+ freq +" DOUBLE NOT NULL DEFAULT 130.0;"); + } + + st.execute("ALTER TABLE LW_SOURCES_130DB ALTER COLUMN PK INTEGER NOT NULL;"); + st.execute("ALTER TABLE LW_SOURCES_130DB ADD CONSTRAINT PK PRIMARY KEY (PK);"); + + + + } + + public List fetchTimeSteps(Connection connection) + throws SQLException, IOException { + TableLocation sourceTableIdentifier = TableLocation.parse(sourcesTableName); + Statement st = connection.createStatement(); + + List distinctTimesteps = new ArrayList<>(); + + ResultSet rs = st.executeQuery("SELECT DISTINCT(IT) IT FROM " + sourcesTableName +";"); + + // Iterate through the ResultSet and add values to the List + while (rs.next()) { + String value = rs.getString("IT"); // Change "IT" to the actual column name + distinctTimesteps.add(value); + } + + return distinctTimesteps; + } + /** * true if train propagation is computed (multiple reflection between the train and a screen) * @param bodyBarrier @@ -498,6 +576,10 @@ public String getSourcesTableName() { return sourcesTableName; } + public void setSourcesTableName(String sourcesTableName) { + this.sourcesTableName = sourcesTableName; + } + /** * Extracted from NMPB 2008-2 7.3.2 * Soil areas POLYGON, with a dimensionless coefficient G: diff --git a/noisemodelling-jdbc/src/main/java/org/noise_planet/noisemodelling/jdbc/LTComputeRaysOut.java b/noisemodelling-jdbc/src/main/java/org/noise_planet/noisemodelling/jdbc/LTComputeRaysOut.java new file mode 100644 index 000000000..2de7aaf90 --- /dev/null +++ b/noisemodelling-jdbc/src/main/java/org/noise_planet/noisemodelling/jdbc/LTComputeRaysOut.java @@ -0,0 +1,317 @@ +package org.noise_planet.noisemodelling.jdbc; + +import org.noise_planet.noisemodelling.pathfinder.IComputeRaysOut; +import org.noise_planet.noisemodelling.pathfinder.PropagationPath; +import org.noise_planet.noisemodelling.pathfinder.utils.PowerUtils; +import org.noise_planet.noisemodelling.propagation.ComputeRaysOutAttenuation; +import org.noise_planet.noisemodelling.propagation.PropagationProcessPathData; + +import java.util.*; +import java.util.concurrent.ConcurrentLinkedDeque; +import java.util.concurrent.atomic.AtomicLong; + +import static org.noise_planet.noisemodelling.pathfinder.utils.PowerUtils.*; + +public class LTComputeRaysOut extends ComputeRaysOutAttenuation { + LtData ltData; + LTPropagationProcessData ltPropagationProcessData; + public PropagationProcessPathData PathData; + public LTConfig ltConfig; + + public LTComputeRaysOut(PropagationProcessPathData PathData, LTPropagationProcessData inputData, + LtData ltData, LTConfig ltConfig) { + super(inputData.ltConfig.exportRaysMethod != LTConfig.ExportRaysMethods.NONE, null, inputData); + this.keepAbsorption = inputData.ltConfig.keepAbsorption; + this.ltData = ltData; + this.ltPropagationProcessData = inputData; + this.PathData = PathData; + this.ltConfig = ltConfig; + } + + public LtData getLtData() { + return ltData; + } + + @Override + public IComputeRaysOut subProcess() { + return new ThreadComputeRaysOut(this); + } + + public static class Attenuation { + public HashMap Levels = null; + public double[] getTimePeriodLevel(String timestep) { + return Levels.get(timestep); + } + public void setTimePeriodLevel(String timestep, double [] levels) { + Levels.put(timestep, levels); + } + } + + public static class ThreadComputeRaysOut implements IComputeRaysOut { + LTComputeRaysOut ltComputeRaysOut; + LTConfig ltConfig; + + ThreadRaysOut[] lTThreadRaysOut = new ThreadRaysOut[1]; + public List propagationPaths = new ArrayList(); + + public ThreadComputeRaysOut(LTComputeRaysOut multiThreadParent) { + this.ltComputeRaysOut = multiThreadParent; + this.ltConfig = multiThreadParent.ltPropagationProcessData.ltConfig; + lTThreadRaysOut[0] = new ThreadRaysOut(multiThreadParent, multiThreadParent.PathData); + for (ThreadRaysOut threadRaysOut : lTThreadRaysOut) { + threadRaysOut.keepRays = false; + } + + } + + + /** + * Energetic sum of VerticeSL attenuation with WJ sources + * @param wjSources + * @param receiverAttenuationLevels + * @return + */ + double[] sumLevels(List wjSources,List receiverAttenuationLevels) { + double[] levels = new double[ltComputeRaysOut.PathData.freq_lvl.size()]; + for (VerticeSL lvl : receiverAttenuationLevels) { + levels = sumArray(levels, + dbaToW(sumArray(wToDba(wjSources.get((int) lvl.sourceId)), lvl.value))); + } + return levels; + } + + double[] processAndPushResult(long receiverPK, List wjSources,List receiverAttenuationLevels, ConcurrentLinkedDeque result, boolean feedStack) { + double[] levels = sumLevels(wjSources, receiverAttenuationLevels); + if(feedStack) { + pushInStack(result, new VerticeSL(receiverPK, -1, wToDba(levels))); + } + return levels; + } + + + @Override + public double[] addPropagationPaths(long sourceId, double sourceLi, long receiverId, List propagationPathsParameter) { + ltComputeRaysOut.rayCount.addAndGet(propagationPathsParameter.size()); + if(ltComputeRaysOut.keepRays && !ltComputeRaysOut.keepAbsorption) { + for(PropagationPath propagationPath : propagationPathsParameter) { + // Use only one ray as the ray is the same if we not keep absorption values + if (ltComputeRaysOut.inputData != null && sourceId < ltComputeRaysOut.inputData.sourcesPk.size() && receiverId < ltComputeRaysOut.inputData.receiversPk.size()) { + // Copy path content in order to keep original ids for other method calls + PropagationPath pathPk = new PropagationPath(propagationPath); + pathPk.setIdReceiver(ltComputeRaysOut.inputData.receiversPk.get((int) receiverId).intValue()); + pathPk.setIdSource(ltComputeRaysOut.inputData.sourcesPk.get((int) sourceId).intValue()); + this.propagationPaths.add(pathPk); + } else { + this.propagationPaths.add(propagationPath); + } + } + } + double[] globalLevel = null; + for(String timestep : ltConfig.timesteps) { + for(PropagationPath propagationPath : propagationPathsParameter) { + if (globalLevel == null) { + + + globalLevel = lTThreadRaysOut[0].addPropagationPaths(sourceId, sourceLi, + receiverId, Collections.singletonList(propagationPath)); + } else { + globalLevel = PowerUtils.sumDbArray(globalLevel, lTThreadRaysOut[0].addPropagationPaths(sourceId, sourceLi, + receiverId, Collections.singletonList(propagationPath))); + } + propagationPath.setTimePeriod(timestep); + if(ltComputeRaysOut.keepRays && ltComputeRaysOut.keepAbsorption) { + // copy ray for each time period because absorption is different for each period + if (ltComputeRaysOut.inputData != null && sourceId < ltComputeRaysOut.inputData.sourcesPk.size() && receiverId < ltComputeRaysOut.inputData.receiversPk.size()) { + // Copy path content in order to keep original ids for other method calls + PropagationPath pathPk = new PropagationPath(propagationPath); + pathPk.setIdReceiver(ltComputeRaysOut.inputData.receiversPk.get((int) receiverId).intValue()); + pathPk.setIdSource(ltComputeRaysOut.inputData.sourcesPk.get((int) sourceId).intValue()); + this.propagationPaths.add(pathPk); + } else { + this.propagationPaths.add(propagationPath); + } + } + } + } + return globalLevel; + } + + /** + * @param stack Stack to feed + * @param data receiver noise level in dB + */ + public void pushInStack(ConcurrentLinkedDeque stack, VerticeSL data) { + while(ltComputeRaysOut.ltData.queueSize.get() > ltConfig.outputMaximumQueue) { + try { + Thread.sleep(10); + } catch (InterruptedException ex) { + ltConfig.aborted = true; + break; + } + if(ltConfig.aborted) { + if(ltComputeRaysOut != null && this.ltComputeRaysOut.inputData != null && + this.ltComputeRaysOut.inputData.cellProg != null) { + this.ltComputeRaysOut.inputData.cellProg.cancel(); + } + return; + } + } + stack.add(data); + ltComputeRaysOut.ltData.queueSize.incrementAndGet(); + } + + @Override + public IComputeRaysOut subProcess() { + return null; + } + + /** + * @param stack Stack to feed + * @param data rays + */ + public void pushInStack(ConcurrentLinkedDeque stack, Collection data) { + while(ltComputeRaysOut.ltData.queueSize.get() > ltConfig.outputMaximumQueue) { + try { + Thread.sleep(10); + } catch (InterruptedException ex) { + ltConfig.aborted = true; + break; + } + if(ltConfig.aborted) { + if(ltComputeRaysOut != null && this.ltComputeRaysOut.inputData != null && + this.ltComputeRaysOut.inputData.cellProg != null) { + this.ltComputeRaysOut.inputData.cellProg.cancel(); + } + return; + } + } + if(ltConfig.getMaximumRaysOutputCount() == 0 || ltComputeRaysOut.ltData.totalRaysInserted.get() < ltConfig.getMaximumRaysOutputCount()) { + long newTotalRays = ltComputeRaysOut.ltData.totalRaysInserted.addAndGet(data.size()); + if(ltConfig.getMaximumRaysOutputCount() > 0 && newTotalRays > ltConfig.getMaximumRaysOutputCount()) { + // too many rays, remove unwanted rays + int newListSize = data.size() - (int)(newTotalRays - ltConfig.getMaximumRaysOutputCount()); + List subList = new ArrayList(newListSize); + for(PropagationPath propagationPath : data) { + subList.add(propagationPath); + if(subList.size() >= newListSize) { + break; + } + } + data = subList; + } + stack.addAll(data); + ltComputeRaysOut.ltData.queueSize.addAndGet(data.size()); + } + } + + @Override + public void finalizeReceiver(final long receiverId) { + if(!propagationPaths.isEmpty()) { + if(ltConfig.getExportRaysMethod() == LTConfig.ExportRaysMethods.TO_RAYS_TABLE) { + // Push propagation rays + pushInStack(ltComputeRaysOut.ltData.rays, propagationPaths); + } else if(ltConfig.getExportRaysMethod() == LTConfig.ExportRaysMethods.TO_MEMORY + && (ltConfig.getMaximumRaysOutputCount() == 0 || + ltComputeRaysOut.propagationPathsSize.get() < ltConfig.getMaximumRaysOutputCount())){ + int newRaysSize = ltComputeRaysOut.propagationPathsSize.addAndGet(propagationPaths.size()); + if(ltConfig.getMaximumRaysOutputCount() > 0 && newRaysSize > ltConfig.getMaximumRaysOutputCount()) { + // remove exceeded elements of the array + propagationPaths = propagationPaths.subList(0, + propagationPaths.size() - Math.min( propagationPaths.size(), + newRaysSize - ltConfig.getMaximumRaysOutputCount())); + } + ltComputeRaysOut.propagationPaths.addAll(propagationPaths); + } + propagationPaths.clear(); + } + long receiverPK = receiverId; + if(ltComputeRaysOut.inputData != null) { + if(receiverId < ltComputeRaysOut.inputData.receiversPk.size()) { + receiverPK = ltComputeRaysOut.inputData.receiversPk.get((int)receiverId); + } + } + double[] tLevels = new double[0]; + if (!ltConfig.mergeSources) { + // Aggregate by source id + Map levelsPerSourceLines = new HashMap<>(); + for (String timestep : ltConfig.timesteps) { + ThreadRaysOut threadRaysOut = lTThreadRaysOut[0]; + for (VerticeSL lvl : threadRaysOut.receiverAttenuationLevels) { + Attenuation attenuation; + if (!levelsPerSourceLines.containsKey(lvl.sourceId)) { + attenuation = new Attenuation(); + levelsPerSourceLines.put(lvl.sourceId, attenuation); + } else { + attenuation = levelsPerSourceLines.get(lvl.sourceId); + } + if (attenuation.getTimePeriodLevel(timestep) == null) { + attenuation.setTimePeriodLevel(timestep, lvl.value); + } else { + // same receiver, same source already exists, merge attenuation + attenuation.setTimePeriodLevel(timestep, sumDbArray( + attenuation.getTimePeriodLevel(timestep), lvl.value)); + } + } + } + long sourcePK; + for (Map.Entry entry : levelsPerSourceLines.entrySet()) { + final long sourceId = entry.getKey(); + sourcePK = sourceId; + if (ltComputeRaysOut.inputData != null) { + // Retrieve original source identifier + if (entry.getKey() < ltComputeRaysOut.inputData.sourcesPk.size()) { + sourcePK = ltComputeRaysOut.inputData.sourcesPk.get((int) sourceId); + } + } + + for (String timestep : ltConfig.timesteps) { + List srcLvls = ltComputeRaysOut.ltPropagationProcessData.wjSourcesT.get(timestep); + // tLevels = sumArray(wToDba(srcLvls.get(int sourceId)), entry.getValue().Levels); + } + pushInStack(ltComputeRaysOut.ltData.lTLevels, new VerticeSL(receiverPK, sourcePK, tLevels)); + + + + + + double[] levels = new double[tLevels.length]; + for(int idFrequency = 0; idFrequency < levels.length; idFrequency++) { + levels[idFrequency] = (12 * tLevels[idFrequency] + + 4 * dbaToW(wToDba(tLevels[idFrequency]) + 5) + + 8 * dbaToW(wToDba(tLevels[idFrequency]) + 10)) / 24.0; + } + pushInStack(ltComputeRaysOut.ltData.lTLevels, new VerticeSL(receiverPK, sourcePK, levels)); + + } + } else { + // Merge all results + + /* tLevels = processAndPushResult(receiverPK, + ltComputeRaysOut.ltPropagationProcessData.wjSources, + lTThreadRaysOut[0].receiverAttenuationLevels, ltComputeRaysOut.ltData.lTLevels); + + +*/ + double[] levels = new double[tLevels.length]; + for(int idFrequency = 0; idFrequency < levels.length; idFrequency++) { + levels[idFrequency] = (12 * tLevels[idFrequency] + + 4 * dbaToW(wToDba(tLevels[idFrequency]) + 5) + + 8 * dbaToW(wToDba(tLevels[idFrequency]) + 10)) / 24.0; + } + pushInStack(ltComputeRaysOut.ltData.lTLevels, new VerticeSL(receiverPK, -1, wToDba(levels))); + + } + for (ThreadRaysOut threadRaysOut : lTThreadRaysOut) { + threadRaysOut.receiverAttenuationLevels.clear(); + } + } + } + + public static class LtData { + public final AtomicLong queueSize = new AtomicLong(0); + public final AtomicLong totalRaysInserted = new AtomicLong(0); + public final ConcurrentLinkedDeque lTLevels = new ConcurrentLinkedDeque<>(); + + public final ConcurrentLinkedDeque rays = new ConcurrentLinkedDeque<>(); + } +} diff --git a/noisemodelling-jdbc/src/main/java/org/noise_planet/noisemodelling/jdbc/LTConfig.java b/noisemodelling-jdbc/src/main/java/org/noise_planet/noisemodelling/jdbc/LTConfig.java new file mode 100644 index 000000000..ef3d7e19b --- /dev/null +++ b/noisemodelling-jdbc/src/main/java/org/noise_planet/noisemodelling/jdbc/LTConfig.java @@ -0,0 +1,259 @@ +/** + * NoiseModelling is a free and open-source tool designed to produce environmental noise maps on very large urban areas. It can be used as a Java library or be controlled through a user friendly web interface. + * + * This version is developed by Université Gustave Eiffel and CNRS + * + * as part of: + * the Eval-PDU project (ANR-08-VILL-0005) 2008-2011, funded by the Agence Nationale de la Recherche (French) + * the CENSE project (ANR-16-CE22-0012) 2017-2021, funded by the Agence Nationale de la Recherche (French) + * the Nature4cities (N4C) project, funded by European Union’s Horizon 2020 research and innovation programme under grant agreement No 730468 + * + * Noisemap is distributed under GPL 3 license. + * + * Contact: contact@noise-planet.org + * + * Copyright (C) 2011-2012 IRSTV (FR CNRS 2488) and Ifsttar + * Copyright (C) 2013-2019 Ifsttar and CNRS + * Copyright (C) 2020 Université Gustave Eiffel and CNRS + * + * @Author Pierre Aumond, Université Gustave Eiffel + * @Author Nicolas Fortin, Université Gustave Eiffel + */ +package org.noise_planet.noisemodelling.jdbc; + +import org.noise_planet.noisemodelling.propagation.PropagationProcessPathData; + +import java.io.File; +import java.util.HashMap; +import java.util.List; + +/** + * Configuration of NoiseModelling computation based on database data using standard Lden outputs + */ +public class LTConfig { + public String timestep; + public List timesteps; + + + + public enum INPUT_MODE {INPUT_MODE_LWT} + final INPUT_MODE input_mode; + + // This field is initialised when {@link PointNoiseMap#initialize} is called + + + HashMap propagationProcessPathDataT= new HashMap(); + + + // Cnossos revisions have multiple coefficients for road emission formulae + // this parameter will be removed when the final version of Cnossos will be published + int coefficientVersion = 2; + + boolean fixAttenuation = true; + + // Process status + boolean exitWhenDone = false; + boolean aborted = false; + + // Output config + public int geojsonColumnSizeLimit = 1000000; // sql column size limitation for geojson + + public boolean isComputeLAEQOnly() { + return computeLAEQOnly; + } + + public void setComputeLAEQOnly(boolean computeLAEQOnly) { + this.computeLAEQOnly = computeLAEQOnly; + } + + boolean computeLAEQOnly = false; + + public enum ExportRaysMethods {TO_RAYS_TABLE, TO_MEMORY, NONE} + ExportRaysMethods exportRaysMethod = ExportRaysMethods.NONE; + + boolean exportProfileInRays = false; + boolean keepAbsorption = false; // in rays, keep store detailed absorption data + int maximumRaysOutputCount = 0; // if export rays, do not keep more than this number of rays (0 infinite) + // Maximum result stack to be inserted in database + // if the stack is full, the computation core is waiting + int outputMaximumQueue = 50000; + + boolean mergeSources = true; + + String lTTable = "LT_RESULT"; + + String raysTable = "RAYS"; + + String lwFrequencyPrepend = "HZ"; + + File sqlOutputFile; + Boolean sqlOutputFileCompression = true; + Boolean dropResultsTable = true; + + + + public PropagationProcessPathData getPropagationProcessPathData() { + return propagationProcessPathDataT.entrySet().iterator().next().getValue(); + } + + public PropagationProcessPathData getPropagationProcessPathData(String timestep) { + return propagationProcessPathDataT.get(timestep); + } + + /** + * @return if export rays, do not keep more than this number of rays (0 infinite) + */ + public int getMaximumRaysOutputCount() { + return maximumRaysOutputCount; + } + + /** + * @param maximumRaysOutputCount if export rays, do not keep more than this number of rays per computation area (0 infinite) + */ + public void setMaximumRaysOutputCount(int maximumRaysOutputCount) { + this.maximumRaysOutputCount = maximumRaysOutputCount; + } + + public void setPropagationProcessPathData(String timestep, PropagationProcessPathData propagationProcessPathData) { + propagationProcessPathDataT.put(timestep, propagationProcessPathData); + } + + + + public LTConfig() { + input_mode = null; + } + public String getLwFrequencyPrepend() { + return lwFrequencyPrepend; + } + + public void setLwFrequencyPrepend(String lwFrequencyPrepend) { + this.lwFrequencyPrepend = lwFrequencyPrepend; + } + + /** + * @return The filePath of results outputs as sql commands. + */ + public File getSqlOutputFile() { + return sqlOutputFile; + } + + /** + * @return Drop previous results tables before inserting results + */ + public Boolean getDropResultsTable() { + return dropResultsTable; + } + + public Boolean getSqlOutputFileCompression() { + return sqlOutputFileCompression; + } + + public void setSqlOutputFileCompression(Boolean sqlOutputFileCompression) { + this.sqlOutputFileCompression = sqlOutputFileCompression; + } + + /** + * @param dropResultsTable Drop previous results tables before inserting results + */ + public void setDropResultsTable(Boolean dropResultsTable) { + this.dropResultsTable = dropResultsTable; + } + + /** + * @param sqlOutputFile + */ + public void setSqlOutputFile(File sqlOutputFile) { + this.sqlOutputFile = sqlOutputFile; + } + + public ExportRaysMethods getExportRaysMethod() { + return exportRaysMethod; + } + + /** + * Export rays in table (beware this could take a lot of storage space) or keep on memory or do not keep + * @param exportRaysMethod + */ + public void setExportRaysMethod(ExportRaysMethods exportRaysMethod) { + this.exportRaysMethod = exportRaysMethod; + } + + /** + * @return For each ray export the ground profile under it as a geojson column (take large amount of disk) + */ + public boolean isExportProfileInRays() { + return exportProfileInRays; + } + + /** + * @param exportProfileInRays For each ray export the ground profile under it as a geojson column (take large amount of disk) + */ + public void setExportProfileInRays(boolean exportProfileInRays) { + this.exportProfileInRays = exportProfileInRays; + } + + public boolean isKeepAbsorption() { + return keepAbsorption; + } + + /** + * @param keepAbsorption If true store absorption values in propagation path objects + * @see #setKeepAbsorption(boolean) + */ + public void setKeepAbsorption(boolean keepAbsorption) { + this.keepAbsorption = keepAbsorption; + } + + /** + * @param coefficientVersion Cnossos revisions have multiple coefficients for road emission formulae this parameter + * will be removed when the final version of Cnossos will be published + */ + public void setCoefficientVersion(int coefficientVersion) { + this.coefficientVersion = coefficientVersion; + } + + public int getCoefficientVersion() { + return coefficientVersion; + } + + /** + * Maximum result stack to be inserted in database + * if the stack is full, the computation core is waiting + * @param outputMaximumQueue Maximum number of elements in stack + */ + public void setOutputMaximumQueue(int outputMaximumQueue) { + this.outputMaximumQueue = outputMaximumQueue; + } + + + public void setMergeSources(boolean mergeSources) { + this.mergeSources = mergeSources; + } + + public void setlTTable(String lTTable) { + this.lTTable = lTTable; + } + + public String getlTTable() { + return lTTable; + } + + /** + * @return Table name that contains rays dump (profile) + */ + public String getRaysTable() { + return raysTable; + } + + /** + * @param raysTable Table name that will contain rays dump (profile) + */ + public void setRaysTable(String raysTable) { + this.raysTable = raysTable; + } + + public boolean isMergeSources() { + return mergeSources; + } +} diff --git a/noisemodelling-jdbc/src/main/java/org/noise_planet/noisemodelling/jdbc/LTPointNoiseMapFactory.java b/noisemodelling-jdbc/src/main/java/org/noise_planet/noisemodelling/jdbc/LTPointNoiseMapFactory.java new file mode 100644 index 000000000..d941f3d16 --- /dev/null +++ b/noisemodelling-jdbc/src/main/java/org/noise_planet/noisemodelling/jdbc/LTPointNoiseMapFactory.java @@ -0,0 +1,527 @@ +/** + * NoiseModelling is a free and open-source tool designed to produce environmental noise maps on very large urban areas. It can be used as a Java library or be controlled through a user friendly web interface. + * + * This version is developed by Université Gustave Eiffel and CNRS + * + * as part of: + * the Eval-PDU project (ANR-08-VILL-0005) 2008-2011, funded by the Agence Nationale de la Recherche (French) + * the CENSE project (ANR-16-CE22-0012) 2017-2021, funded by the Agence Nationale de la Recherche (French) + * the Nature4cities (N4C) project, funded by European Union’s Horizon 2020 research and innovation programme under grant agreement No 730468 + * + * Noisemap is distributed under GPL 3 license. + * + * Contact: contact@noise-planet.org + * + * Copyright (C) 2011-2012 IRSTV (FR CNRS 2488) and Ifsttar + * Copyright (C) 2013-2019 Ifsttar and CNRS + * Copyright (C) 2020 Université Gustave Eiffel and CNRS + * + * @Author Pierre Aumond, Université Gustave Eiffel + * @Author Nicolas Fortin, Université Gustave Eiffel + */ + +package org.noise_planet.noisemodelling.jdbc; + +import org.h2gis.utilities.GeometryTableUtilities; +import org.h2gis.utilities.JDBCUtilities; +import org.locationtech.jts.geom.LineString; +import org.noise_planet.noisemodelling.jdbc.utils.StringPreparedStatements; +import org.noise_planet.noisemodelling.pathfinder.CnossosPropagationData; +import org.noise_planet.noisemodelling.pathfinder.IComputeRaysOut; +import org.noise_planet.noisemodelling.pathfinder.ProfileBuilder; +import org.noise_planet.noisemodelling.pathfinder.PropagationPath; +import org.noise_planet.noisemodelling.pathfinder.utils.ProfilerThread; +import org.noise_planet.noisemodelling.propagation.ComputeRaysOutAttenuation; +import org.noise_planet.noisemodelling.propagation.PropagationProcessPathData; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.io.*; +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.concurrent.ConcurrentLinkedDeque; +import java.util.zip.GZIPOutputStream; + +import static org.noise_planet.noisemodelling.pathfinder.utils.PowerUtils.*; + +/** + * + */ +public class LTPointNoiseMapFactory implements PointNoiseMap.PropagationProcessDataFactory, PointNoiseMap.IComputeRaysOutFactory, ProfilerThread.Metric { + LTConfig ltConfig; + TableWriter tableWriter; + Thread tableWriterThread; + Connection connection; + static final int BATCH_MAX_SIZE = 500; + static final int WRITER_CACHE = 65536; + LTComputeRaysOut.LtData ltData = new LTComputeRaysOut.LtData(); + int srid; + + + + public LTPointNoiseMapFactory(Connection connection, LTConfig ltConfig) { + this.ltConfig = ltConfig; + this.connection = connection; + } + + @Override + public String[] getColumnNames() { + return new String[] {"jdbc_stack"}; + } + + @Override + public String[] getCurrentValues() { + return new String[] {Long.toString(ltData.queueSize.get())}; + } + + @Override + public void tick(long currentMillis) { + + } + + public LTComputeRaysOut.LtData getLtData() { + return ltData; + } + + + @Override + public void initialize(Connection connection, PointNoiseMap pointNoiseMap) throws SQLException { + + // Fetch source fields + List sourceField = JDBCUtilities.getColumnNames(connection, pointNoiseMap.getSourcesTableName()); + this.srid = GeometryTableUtilities.getSRID(connection, pointNoiseMap.getSourcesTableName()); + List frequencyValues = new ArrayList<>(); + List allFrequencyValues = Arrays.asList(CnossosPropagationData.DEFAULT_FREQUENCIES_THIRD_OCTAVE); + + String freqField = ltConfig.lwFrequencyPrepend; + + for (String fieldName : sourceField) { + if (fieldName.startsWith(freqField)) { + int freq = Integer.parseInt(fieldName.substring(freqField.length())); + int index = allFrequencyValues.indexOf(freq); + if (index >= 0) { + frequencyValues.add(freq); + } + } + } + + // Sort frequencies values + Collections.sort(frequencyValues); + // Get associated values for each frequency + List exactFrequencies = new ArrayList<>(); + List aWeighting = new ArrayList<>(); + for (int freq : frequencyValues) { + int index = allFrequencyValues.indexOf(freq); + exactFrequencies.add(CnossosPropagationData.DEFAULT_FREQUENCIES_EXACT_THIRD_OCTAVE[index]); + aWeighting.add(CnossosPropagationData.DEFAULT_FREQUENCIES_A_WEIGHTING_THIRD_OCTAVE[index]); + } + if(frequencyValues.isEmpty()) { + throw new SQLException("Source table "+pointNoiseMap.getSourcesTableName()+" does not contains any frequency bands"); + } + + try { + pointNoiseMap.createSourcesTable(connection,frequencyValues); + } catch (IOException e) { + throw new RuntimeException(e); + } + + List sourcesList = null; + + try { + sourcesList = pointNoiseMap.fetchSourceNumber(connection); + ltConfig.timesteps = pointNoiseMap.fetchTimeSteps(connection); + + } catch (IOException e) { + throw new RuntimeException(e); + } + + pointNoiseMap.setSourcesTableName("LW_SOURCES_130DB"); + + // Instance of PropagationProcessPathData maybe already set + for(String timestep : ltConfig.timesteps) { + if (pointNoiseMap.getPropagationProcessPathData(timestep) == null) { + PropagationProcessPathData propagationProcessPathData = new PropagationProcessPathData(frequencyValues, exactFrequencies, aWeighting); + ltConfig.setPropagationProcessPathData(timestep, propagationProcessPathData); + pointNoiseMap.setPropagationProcessPathData(timestep, propagationProcessPathData); + } else { + pointNoiseMap.getPropagationProcessPathData(timestep).setFrequencies(frequencyValues); + pointNoiseMap.getPropagationProcessPathData(timestep).setFrequenciesExact(exactFrequencies); + pointNoiseMap.getPropagationProcessPathData(timestep).setFrequenciesAWeighting(aWeighting); + ltConfig.setPropagationProcessPathData(timestep, pointNoiseMap.getPropagationProcessPathData(timestep)); + } + } + } + + /** + * Start creating and filling database tables + */ + public void start() { + if(ltConfig.getPropagationProcessPathData() == null) { + throw new IllegalStateException("start() function must be called after PointNoiseMap initialization call"); + } + tableWriter = new TableWriter(connection, ltConfig, ltData, srid); + ltConfig.exitWhenDone = false; + tableWriterThread = new Thread(tableWriter); + tableWriterThread.start(); + while (!tableWriter.started && !ltConfig.aborted) { + try { + Thread.sleep(150); + } catch (InterruptedException e) { + // ignore + break; + } + } + } + + /** + * Write the last results and stop the sql writing thread + */ + public void stop() { + ltConfig.exitWhenDone = true; + while (tableWriterThread != null && tableWriterThread.isAlive()) { + try { + Thread.sleep(150); + } catch (InterruptedException e) { + // ignore + break; + } + } + } + + /** + * Abort writing results and kill the writing thread + */ + public void cancel() { + ltConfig.aborted = true; + while (tableWriterThread.isAlive()) { + try { + Thread.sleep(150); + } catch (InterruptedException e) { + // ignore + break; + } + } + } + + @Override + public LTPropagationProcessData create(ProfileBuilder builder) { + LTPropagationProcessData ltPropagationProcessData = new LTPropagationProcessData(builder, ltConfig, ltConfig.propagationProcessPathDataT.entrySet().iterator().next().getValue().freq_lvl); + + return ltPropagationProcessData; + } + + @Override + public IComputeRaysOut create(CnossosPropagationData threadData, PropagationProcessPathData pathDataT, PropagationProcessPathData pathDataEvening, PropagationProcessPathData pathDataNight) { + return new LTComputeRaysOut(pathDataT, + (LTPropagationProcessData)threadData, ltData, ltConfig); + } + + private static class TableWriter implements Runnable { + Logger LOGGER = LoggerFactory.getLogger(TableWriter.class); + File sqlFilePath; + private Connection connection; + LTConfig ltConfig; + LTComputeRaysOut.LtData ltData; + double[] a_weighting; + boolean started = false; + Writer o; + int srid; + + public TableWriter(Connection connection, LTConfig ltConfig, LTComputeRaysOut.LtData ltData, int srid) { + this.connection = connection; + this.sqlFilePath = ltConfig.sqlOutputFile; + this.ltConfig = ltConfig; + this.ltData = ltData; + PropagationProcessPathData propagationProcessPathData = ltConfig.propagationProcessPathDataT.entrySet().iterator().next().getValue(); + a_weighting = new double[propagationProcessPathData.freq_lvl_a_weighting.size()]; + for(int idfreq = 0; idfreq < a_weighting.length; idfreq++) { + a_weighting[idfreq] = propagationProcessPathData.freq_lvl_a_weighting.get(idfreq); + } + this.srid = srid; + } + + void processRaysStack(ConcurrentLinkedDeque stack) throws SQLException { + StringBuilder query = new StringBuilder("INSERT INTO " + ltConfig.raysTable + + "(the_geom , IDRECEIVER , IDSOURCE"); + if(ltConfig.exportProfileInRays) { + query.append(", GEOJSON"); + } + if(ltConfig.keepAbsorption) { + query.append(", LEQ, PERIOD"); + } + query.append(") VALUES (?, ?, ?"); + if(ltConfig.exportProfileInRays) { + query.append(", ?"); + } + if(ltConfig.keepAbsorption) { + query.append(", ?, ?"); + } + query.append(");"); + // PK, GEOM, ID_RECEIVER, ID_SOURCE + PreparedStatement ps; + if(sqlFilePath == null) { + ps = connection.prepareStatement(query.toString()); + } else { + ps = new StringPreparedStatements(o, query.toString()); + } + int batchSize = 0; + while(!stack.isEmpty()) { + PropagationPath row = stack.pop(); + ltData.queueSize.decrementAndGet(); + int parameterIndex = 1; + LineString lineString = row.asGeom(); + lineString.setSRID(srid); + ps.setObject(parameterIndex++, lineString); + ps.setLong(parameterIndex++, row.getIdReceiver()); + ps.setLong(parameterIndex++, row.getIdSource()); + if(ltConfig.exportProfileInRays) { + String geojson = ""; + try { + geojson = row.profileAsJSON(ltConfig.geojsonColumnSizeLimit); + } catch (IOException ex) { + //ignore + } + ps.setString(parameterIndex++, geojson); + } + if(ltConfig.keepAbsorption) { + double globalValue = sumDbArray(row.absorptionData.aGlobal); + ps.setDouble(parameterIndex++, globalValue); + ps.setString(parameterIndex++, row.getTimePeriod()); + } + ps.addBatch(); + batchSize++; + if (batchSize >= BATCH_MAX_SIZE) { + ps.executeBatch(); + ps.clearBatch(); + batchSize = 0; + } + } + if (batchSize > 0) { + ps.executeBatch(); + } + + } + + /** + * Pop values from stack and insert rows + * @param tableName Table to feed + * @param stack Stack to pop from + * @throws SQLException Got an error + */ + void processStack(String tableName, ConcurrentLinkedDeque stack) throws SQLException { + StringBuilder query = new StringBuilder("INSERT INTO "); + query.append(tableName); + query.append(" VALUES (? "); // ID_RECEIVER + if(!ltConfig.mergeSources) { + query.append(", ?"); // ID_SOURCE + } + if (!ltConfig.computeLAEQOnly) { + + query.append(", ?".repeat(ltConfig.propagationProcessPathDataT.entrySet().iterator().next().getValue().freq_lvl.size())); // freq value + query.append(", ?, ?);"); // laeq, leq + }else{ + query.append(", ?);"); // laeq, leq + } + PreparedStatement ps; + if(sqlFilePath == null) { + ps = connection.prepareStatement(query.toString()); + } else { + ps = new StringPreparedStatements(o, query.toString()); + } + int batchSize = 0; + while(!stack.isEmpty()) { + ComputeRaysOutAttenuation.VerticeSL row = stack.pop(); + ltData.queueSize.decrementAndGet(); + int parameterIndex = 1; + ps.setLong(parameterIndex++, row.receiverId); + if(!ltConfig.mergeSources) { + ps.setLong(parameterIndex++, row.sourceId); + } + + if (!ltConfig.computeLAEQOnly){ + for(int idfreq=0;idfreq < ltConfig.propagationProcessPathDataT.entrySet().iterator().next().getValue().freq_lvl.size(); idfreq++) { + double value = row.value[idfreq]; + if(!Double.isFinite(value)) { + value = -99.0; + row.value[idfreq] = value; + } + ps.setDouble(parameterIndex++, value); + } + + } + // laeq value + double value = wToDba(sumArray(dbaToW(sumArray(row.value, a_weighting)))); + if(!Double.isFinite(value)) { + value = -99; + } + ps.setDouble(parameterIndex++, value); + + // leq value + if (!ltConfig.computeLAEQOnly) { + ps.setDouble(parameterIndex++, wToDba(sumArray(dbaToW(row.value)))); + } + + ps.addBatch(); + batchSize++; + if (batchSize >= BATCH_MAX_SIZE) { + ps.executeBatch(); + ps.clearBatch(); + batchSize = 0; + } + } + if (batchSize > 0) { + ps.executeBatch(); + } + } + + private String forgeCreateTable(String tableName) { + StringBuilder sb = new StringBuilder("create table "); + sb.append(tableName); + if(!ltConfig.mergeSources) { + sb.append(" (IDRECEIVER bigint NOT NULL"); + sb.append(", IDSOURCE bigint NOT NULL"); + } else { + sb.append(" (IDRECEIVER bigint NOT NULL"); + } + if (ltConfig.computeLAEQOnly){ + sb.append(", LAEQ numeric(5, 2)"); + sb.append(");"); + } else { + for (int idfreq = 0; idfreq < ltConfig.propagationProcessPathDataT.entrySet().iterator().next().getValue().freq_lvl.size(); idfreq++) { + sb.append(", HZ"); + sb.append(ltConfig.propagationProcessPathDataT.entrySet().iterator().next().getValue().freq_lvl.get(idfreq)); + sb.append(" numeric(5, 2)"); + } + sb.append(", LAEQ numeric(5, 2), LEQ numeric(5, 2)"); + sb.append(");"); + } + return sb.toString(); + } + + private String forgePkTable(String tableName) { + if (ltConfig.mergeSources) { + return "ALTER TABLE " + tableName + " ADD PRIMARY KEY(IDRECEIVER);"; + } else { + return "CREATE INDEX ON " + tableName + " (IDRECEIVER);"; + } + } + + private void processQuery(String query) throws SQLException, IOException { + if(sqlFilePath == null) { + try(Statement sql = connection.createStatement()) { + sql.execute(query); + } + } else { + o.write(query+"\n"); + } + } + + public void init() throws SQLException, IOException { + if(ltConfig.getExportRaysMethod() == LTConfig.ExportRaysMethods.TO_RAYS_TABLE) { + if(ltConfig.dropResultsTable) { + String q = String.format("DROP TABLE IF EXISTS %s;", ltConfig.raysTable); + processQuery(q); + } + StringBuilder sb = new StringBuilder("CREATE TABLE IF NOT EXISTS " + ltConfig.raysTable + "(pk bigint auto_increment, the_geom " + + "geometry(LINESTRING Z,"); + sb.append(srid); + sb.append("), IDRECEIVER bigint NOT NULL, IDSOURCE bigint NOT NULL"); + if(ltConfig.exportProfileInRays) { + sb.append(", GEOJSON VARCHAR"); + } + if(ltConfig.keepAbsorption) { + sb.append(", LEQ DOUBLE, PERIOD VARCHAR"); + } + sb.append(");"); + processQuery(sb.toString()); + } + + + + if(ltConfig.dropResultsTable) { + String q = String.format("DROP TABLE IF EXISTS %s;", ltConfig.lTTable); + processQuery(q); + } + String q = forgeCreateTable(ltConfig.lTTable); + processQuery(q); + + } + + void mainLoop() throws SQLException, IOException { + while (!ltConfig.aborted) { + started = true; + try { + if(!ltData.lTLevels.isEmpty()) { + processStack(ltConfig.lTTable, ltData.lTLevels); + } else if(!ltData.rays.isEmpty()) { + processRaysStack(ltData.rays); + } else { + if(ltConfig.exitWhenDone) { + break; + } else { + Thread.sleep(50); + } + } + } catch (InterruptedException ex) { + // ignore + break; + } + } + } + + void createKeys() throws SQLException, IOException { + // Set primary keys + LOGGER.info("Write done, apply primary keys"); + processQuery(forgePkTable(ltConfig.lTTable)); + + } + + OutputStreamWriter getStream() throws IOException { + if(ltConfig.sqlOutputFileCompression) { + return new OutputStreamWriter(new GZIPOutputStream(new FileOutputStream(sqlFilePath), WRITER_CACHE)); + } else { + return new OutputStreamWriter(new BufferedOutputStream(new FileOutputStream(sqlFilePath), WRITER_CACHE)); + } + } + + @Override + public void run() { + // Drop and create tables + if(sqlFilePath == null) { + try { + init(); + mainLoop(); + createKeys(); + } catch (SQLException e) { + LOGGER.error("SQL Writer exception", e); + LOGGER.error(e.getLocalizedMessage(), e.getNextException()); + ltConfig.aborted = true; + } catch (Throwable e) { + LOGGER.error("Got exception on result writer, cancel calculation", e); + ltConfig.aborted = true; + } + } else { + try(OutputStreamWriter bw = getStream()) { + o = bw; + init(); + mainLoop(); + createKeys(); + } catch (SQLException e) { + LOGGER.error("SQL Writer exception", e); + LOGGER.error(e.getLocalizedMessage(), e.getNextException()); + ltConfig.aborted = true; + } catch (Throwable e) { + LOGGER.error("Got exception on result writer, cancel calculation", e); + ltConfig.aborted = true; + } + } + // LOGGER.info("Exit TableWriter"); + } + } +} diff --git a/noisemodelling-jdbc/src/main/java/org/noise_planet/noisemodelling/jdbc/LTPropagationProcessData.java b/noisemodelling-jdbc/src/main/java/org/noise_planet/noisemodelling/jdbc/LTPropagationProcessData.java new file mode 100644 index 000000000..ff90bd96b --- /dev/null +++ b/noisemodelling-jdbc/src/main/java/org/noise_planet/noisemodelling/jdbc/LTPropagationProcessData.java @@ -0,0 +1,140 @@ +/** + * NoiseModelling is a free and open-source tool designed to produce environmental noise maps on very large urban areas. It can be used as a Java library or be controlled through a user friendly web interface. + * + * This version is developed by Université Gustave Eiffel and CNRS + * + * as part of: + * the Eval-PDU project (ANR-08-VILL-0005) 2008-2011, funded by the Agence Nationale de la Recherche (French) + * the CENSE project (ANR-16-CE22-0012) 2017-2021, funded by the Agence Nationale de la Recherche (French) + * the Nature4cities (N4C) project, funded by European Union’s Horizon 2020 research and innovation programme under grant agreement No 730468 + * + * Noisemap is distributed under GPL 3 license. + * + * Contact: contact@noise-planet.org + * + * Copyright (C) 2011-2012 IRSTV (FR CNRS 2488) and Ifsttar + * Copyright (C) 2013-2019 Ifsttar and CNRS + * Copyright (C) 2020 Université Gustave Eiffel and CNRS + * + * @Author Pierre Aumond, Université Gustave Eiffel + * @Author Nicolas Fortin, Université Gustave Eiffel + */ + +package org.noise_planet.noisemodelling.jdbc; + +import org.h2gis.utilities.JDBCUtilities; +import org.h2gis.utilities.SpatialResultSet; +import org.locationtech.jts.geom.Geometry; +import org.noise_planet.noisemodelling.pathfinder.CnossosPropagationData; +import org.noise_planet.noisemodelling.pathfinder.ProfileBuilder; +import org.noise_planet.noisemodelling.propagation.PropagationProcessPathData; + +import java.io.IOException; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import static org.noise_planet.noisemodelling.pathfinder.utils.PowerUtils.dbaToW; + +/** + * Read source database and compute the sound emission spectrum of roads sources + */ +public class LTPropagationProcessData extends CnossosPropagationData { + public Map sourceFields = null; + + // Source value in energetic e = pow(10, dbVal / 10.0) + public List wjSources = new ArrayList<>(); + + public HashMap> wjSourcesT ; + + + + LTConfig ltConfig; + + public LTPropagationProcessData(ProfileBuilder builder, LTConfig ltConfig, List freq_lvl) { + super(builder, freq_lvl); + this.ltConfig = ltConfig; + } + + @Override + public void addSource(Long pk, Geometry geom, SpatialResultSet rs) throws SQLException, IOException { + super.addSource(pk, geom, rs); + double[][] res = computeLw(rs); + wjSources.add(res[0]); + } + + @Override + public boolean isOmnidirectional(int srcIndex) { + return sourcesPk.size() > srcIndex && !sourceDirection.containsKey(sourcesPk.get(srcIndex)); + } + + @Override + public double[] getSourceAttenuation(int srcIndex, double[] frequencies, double phi, double theta) { + int directivityIdentifier = sourceDirection.get(sourcesPk.get(srcIndex)); + // todo add direction attributes + // This direction identifier has not been found + return new double[frequencies.length]; + + } + + @Override + public double getSourceGs(int srcIndex){ + return sourceGs.get(sourcesPk.get(srcIndex)); + } + + /** + * @param rs result set of source + * @param period D or E or N + * @return Emission spectrum in dB + */ + public double[] getEmissionFromResultSet(ResultSet rs, String period) throws SQLException, IOException { + Map.Entry iterator = ltConfig.propagationProcessPathDataT.entrySet().iterator().next(); + List freq_lvl = iterator.getValue().freq_lvl; + if (sourceFields == null) { + sourceFields = new HashMap<>(); + int fieldId = 1; + for (String fieldName : JDBCUtilities.getColumnNames(rs.getMetaData())) { + sourceFields.put(fieldName.toUpperCase(), fieldId++); + } + } + double[] lvl = new double[freq_lvl.size()]; + // Set default values + String timestep = ""; // old format "total vehicles" + + // Read fields + if(sourceFields.containsKey("IT")) { + timestep = rs.getString(sourceFields.get("IT").toString()); + } + + // Compute emission + int idFreq = 0; + for (int freq : freq_lvl) { + lvl[idFreq++] = rs.getDouble(sourceFields.get("HZ" + freq)); + } + return lvl; + } + + public double[][] computeLw(SpatialResultSet rs) throws SQLException, IOException { + + // Compute day average level + double[] lt = new double[freq_lvl.size()]; + + for (int idfreq = 0; idfreq < freq_lvl.size(); idfreq++) { + lt[idfreq] = dbaToW(rs.getDouble(ltConfig.lwFrequencyPrepend + freq_lvl.get(idfreq))); + } + + return new double[][] {lt}; + } + + public double[] getMaximalSourcePower(int sourceId) { + if( sourceId < wjSources.size()) { + return wjSources.get(sourceId); + } else { + return new double[0]; + } + } + +} diff --git a/noisemodelling-jdbc/src/main/java/org/noise_planet/noisemodelling/jdbc/PointNoiseMap.java b/noisemodelling-jdbc/src/main/java/org/noise_planet/noisemodelling/jdbc/PointNoiseMap.java index c80ec281b..79312252e 100644 --- a/noisemodelling-jdbc/src/main/java/org/noise_planet/noisemodelling/jdbc/PointNoiseMap.java +++ b/noisemodelling-jdbc/src/main/java/org/noise_planet/noisemodelling/jdbc/PointNoiseMap.java @@ -43,11 +43,14 @@ public class PointNoiseMap extends JdbcNoiseMap { private final String receiverTableName; private PropagationProcessDataFactory propagationProcessDataFactory; + public String Type ="DEN"; private IComputeRaysOutFactory computeRaysOutFactory; private Logger logger = LoggerFactory.getLogger(PointNoiseMap.class); private int threadCount = 0; private ProfilerThread profilerThread; + + public PointNoiseMap(String buildingsTableName, String sourcesTableName, String receiverTableName) { super(buildingsTableName, sourcesTableName); this.receiverTableName = receiverTableName; @@ -62,6 +65,16 @@ public ProfilerThread getProfilerThread() { return profilerThread; } + + + public String getType() { + return Type; + } + + public void setType(String type) { + Type = type; + } + /** * Computation stacks and timing are collected by this class in order * to profile the execution of the simulation @@ -79,6 +92,7 @@ public void setPropagationProcessDataFactory(PropagationProcessDataFactory propa this.propagationProcessDataFactory = propagationProcessDataFactory; } + public int getThreadCount() { return threadCount; } @@ -127,9 +141,12 @@ public CnossosPropagationData prepareCell(Connection connection,int cellI, int c CnossosPropagationData propagationProcessData; if(propagationProcessDataFactory != null) { propagationProcessData = propagationProcessDataFactory.create(builder); - } else { + } else if(Objects.equals(this.getType(), "DEN")){ propagationProcessData = new CnossosPropagationData(builder, propagationProcessPathDataDay.freq_lvl); + } else { + propagationProcessData = new CnossosPropagationData(builder, propagationProcessPathDataT.entrySet().iterator().next().getValue().freq_lvl); } + propagationProcessData.reflexionOrder = soundReflectionOrder; propagationProcessData.setBodyBarrier(bodyBarrier); propagationProcessData.maximumError = getMaximumError(); @@ -263,12 +280,24 @@ public IComputeRaysOut evaluateCell(Connection connection, int cellI, int cellJ, threadData.receivers.size(), threadData.sourceGeometries.size(), threadData.profileBuilder.getBuildingCount())); } + IComputeRaysOut computeRaysOut; - if(computeRaysOutFactory == null) { - computeRaysOut = new ComputeRaysOutAttenuation(false, propagationProcessPathDataDay, threadData); + if (this.getType() == "DEN") { + if (computeRaysOutFactory == null) { + computeRaysOut = new ComputeRaysOutAttenuation(false, propagationProcessPathDataDay, threadData); + } else { + computeRaysOut = computeRaysOutFactory.create(threadData, propagationProcessPathDataDay, + propagationProcessPathDataEvening, propagationProcessPathDataNight); + } } else { - computeRaysOut = computeRaysOutFactory.create(threadData, propagationProcessPathDataDay, - propagationProcessPathDataEvening, propagationProcessPathDataNight); + propagationProcessPathDataDay = propagationProcessPathDataT.get(1); + if (computeRaysOutFactory == null) { + computeRaysOut = new ComputeRaysOutAttenuation(false, propagationProcessPathDataDay, threadData); + } else { + computeRaysOut = computeRaysOutFactory.create(threadData, propagationProcessPathDataDay, + propagationProcessPathDataEvening, propagationProcessPathDataNight); + } + } ComputeCnossosRays computeRays = new ComputeCnossosRays(threadData); @@ -313,6 +342,11 @@ IComputeRaysOut create(CnossosPropagationData threadData, PropagationProcessPath PropagationProcessPathData pathDataEvening, PropagationProcessPathData pathDataNight); } + public interface IComputeRaysOutFactoryT { + IComputeRaysOut create(CnossosPropagationData threadData, PropagationProcessPathData pathDataT); + } + + /** * Cell metadata computed from receivers table */ diff --git a/noisemodelling-jdbc/src/test/java/org/noise_planet/noisemodelling/jdbc/LTPointNoiseMapFactoryTest.java b/noisemodelling-jdbc/src/test/java/org/noise_planet/noisemodelling/jdbc/LTPointNoiseMapFactoryTest.java new file mode 100644 index 000000000..6ee9d6976 --- /dev/null +++ b/noisemodelling-jdbc/src/test/java/org/noise_planet/noisemodelling/jdbc/LTPointNoiseMapFactoryTest.java @@ -0,0 +1,108 @@ +package org.noise_planet.noisemodelling.jdbc; + +import org.h2gis.api.EmptyProgressVisitor; +import org.h2gis.functions.factory.H2GISDBFactory; +import org.h2gis.utilities.JDBCUtilities; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.noise_planet.noisemodelling.pathfinder.IComputeRaysOut; +import org.noise_planet.noisemodelling.pathfinder.RootProgressVisitor; +import org.noise_planet.noisemodelling.propagation.ComputeRaysOutAttenuation; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.sql.Connection; +import java.sql.Statement; +import java.util.HashSet; +import java.util.Set; + +public class LTPointNoiseMapFactoryTest { + + static Logger LOGGER = LoggerFactory.getLogger(LTPointNoiseMapFactoryTest.class); + + private Connection connection; + + @Before + public void tearUp() throws Exception { + connection = JDBCUtilities.wrapConnection(H2GISDBFactory.createSpatialDataBase(LTPointNoiseMapFactoryTest.class.getSimpleName(), true, "")); + } + + @After + public void tearDown() throws Exception { + if(connection != null) { + connection.close(); + } + } + + @Test + public void testPointDynamic() throws Exception { + try (Statement st = connection.createStatement()) { + st.execute("CREATE TABLE BUILDINGS(pk serial PRIMARY KEY, the_geom geometry, height real)"); + st.execute("drop table if exists LW_DYNAMIC;"); + st.execute("create table LW_DYNAMIC(IT integer, PK integer, the_geom GEOMETRY(POINTZ), Hz63 double precision, Hz125 double precision, Hz250 double precision, Hz500 double precision, Hz1000 double precision, Hz2000 double precision, Hz4000 double precision, Hz8000 double precision);"); + st.execute("INSERT INTO LW_DYNAMIC(IT , PK,the_geom,Hz63, Hz125, Hz250, Hz500, Hz1000,Hz2000, Hz4000, Hz8000) " + + "VALUES (1,1,'POINTZ (223915.72 6757290.22 2.0)',90,90,90,90,90,90,90,90);"); + st.execute("INSERT INTO LW_DYNAMIC(IT , PK,the_geom,Hz63, Hz125, Hz250, Hz500, Hz1000,Hz2000, Hz4000, Hz8000) " + + "VALUES (2,1,'POINTZ (223915.72 6757290.22 2.0)',90,90,90,90,90,90,90,90);"); + st.execute("INSERT INTO LW_DYNAMIC(IT , PK,the_geom,Hz63, Hz125, Hz250, Hz500, Hz1000,Hz2000, Hz4000, Hz8000) " + + "VALUES (3,1,'POINTZ (223915.72 6757290.22 2.0)',90,90,90,90,90,90,90,90);"); + st.execute("INSERT INTO LW_DYNAMIC(IT , PK,the_geom,Hz63, Hz125, Hz250, Hz500, Hz1000,Hz2000, Hz4000, Hz8000) " + + "VALUES (1,2,'POINTZ (223915.72 6757390.22 2.0)',90,90,90,90,90,90,90,90);"); + st.execute("INSERT INTO LW_DYNAMIC(IT , PK,the_geom,Hz63, Hz125, Hz250, Hz500, Hz1000,Hz2000, Hz4000, Hz8000) " + + "VALUES (2,5,'POINTZ (223915.72 6757390.22 2.0)',90,90,90,90,90,90,90,90);"); + + st.execute("create table receivers(id serial PRIMARY KEY, the_geom GEOMETRY(POINTZ));\n" + + "insert into receivers(the_geom) values ('POINTZ (223915.72 6757490.22 2.0)');" + + "insert into receivers(the_geom) values ('POINTZ (223925.72 6757480.22 2.0)');"); + + PointNoiseMap pointNoiseMap = new PointNoiseMap("BUILDINGS", "LW_DYNAMIC", "RECEIVERS"); + pointNoiseMap.setComputeHorizontalDiffraction(false); + pointNoiseMap.setType("T"); + pointNoiseMap.setComputeVerticalDiffraction(true); + pointNoiseMap.setSoundReflectionOrder(0); + pointNoiseMap.setReceiverHasAbsoluteZCoordinates(false); + pointNoiseMap.setMaximumPropagationDistance(10000); + pointNoiseMap.setSourceHasAbsoluteZCoordinates(false); + pointNoiseMap.setHeightField("HEIGHT"); + + + + LTConfig ltConfig = new LTConfig(); + ltConfig.setExportRaysMethod(LTConfig.ExportRaysMethods.TO_MEMORY); + LTPointNoiseMapFactory ltPointNoiseMapFactory = new LTPointNoiseMapFactory(connection, ltConfig); + + + pointNoiseMap.setPropagationProcessDataFactory(ltPointNoiseMapFactory); + pointNoiseMap.setComputeRaysOutFactory(ltPointNoiseMapFactory); + + pointNoiseMap.initialize(connection, new EmptyProgressVisitor()); + Set receivers = new HashSet<>(); + pointNoiseMap.setThreadCount(1); + pointNoiseMap.setGridDim(1); + RootProgressVisitor progressVisitor = new RootProgressVisitor(pointNoiseMap.getGridDim() * pointNoiseMap.getGridDim(), true, 5); + for(int i=0; i < pointNoiseMap.getGridDim(); i++) { + for(int j=0; j < pointNoiseMap.getGridDim(); j++) { + IComputeRaysOut out = pointNoiseMap.evaluateCell(connection, i, j, progressVisitor, receivers); + if(out instanceof LTComputeRaysOut) { + LTComputeRaysOut rout = (LTComputeRaysOut) out; + + ComputeRaysOutAttenuation.VerticeSL sl = rout.ltData.lTLevels.pop(); + // assertEquals(1, sl.receiverId); + // assertEquals(73.3, sl.value[0], 1); + sl = rout.ltData.lTLevels.pop(); + // assertEquals(2, sl.receiverId); + // assertEquals(53.3, sl.value[0], 1); + // assertTrue(rout.ltData.lTLevels.isEmpty()); + + + } else { + throw new IllegalStateException(); + } + } + } + } + } + + +} \ No newline at end of file diff --git a/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/Acoustic_Tools/DynamicIndicators.groovy b/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/Acoustic_Tools/DynamicIndicators.groovy new file mode 100644 index 000000000..85609ccd0 --- /dev/null +++ b/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/Acoustic_Tools/DynamicIndicators.groovy @@ -0,0 +1,121 @@ +/** + * NoiseModelling is an open-source tool designed to produce environmental noise maps on very large urban areas. It can be used as a Java library or be controlled through a user friendly web interface. + * + * This version is developed by the DECIDE team from the Lab-STICC (CNRS) and by the Mixt Research Unit in Environmental Acoustics (Université Gustave Eiffel). + * + * + * NoiseModelling is distributed under GPL 3 license. You can read a copy of this License in the file LICENCE provided with this software. + * + * Contact: contact@noise-planet.org + * + */ + +/** + * @Author Pierre Aumond, Université Gustave Eiffel + */ + +package org.noise_planet.noisemodelling.wps.Acoustic_Tools + +import geoserver.GeoServer +import geoserver.catalog.Store +import groovy.sql.Sql +import org.geotools.jdbc.JDBCDataStore +import org.slf4j.Logger +import org.slf4j.LoggerFactory + +import java.sql.Connection + +title = 'Compute dynamic indicators' +description = 'Compute dynamic indicators as L10, L90
The columns of the table should be named HZ63, HZ125,..., HZ8000 with an HZ prefix that can be changed.' + +inputs = [ + columnName : [ + name : 'Column name', + title : 'Column name', + description: 'Column name on which to perform the calculation. (STRING)
For example : LEQA', + type : String.class + ], + tableName: [ + title : 'Name of the table', + name : 'Name of the table', + description: 'Name of the table on which to perform the calculation. The table must contain multiple sound level values for a single receiver. (STRING)
For example : LDAY_GEOM', + type : String.class + ] +] + +outputs = [ + result: [ + name : 'Result output string', + title : 'Result output string', + description: 'This type of result does not allow the blocks to be linked together.', + type : String.class + ] +] + + +static Connection openGeoserverDataStoreConnection(String dbName) { + if (dbName == null || dbName.isEmpty()) { + dbName = new GeoServer().catalog.getStoreNames().get(0) + } + Store store = new GeoServer().catalog.getStore(dbName) + JDBCDataStore jdbcDataStore = (JDBCDataStore) store.getDataStoreInfo().getDataStore(null) + return jdbcDataStore.getDataSource().getConnection() +} + +def exec(Connection connection, input) { + + // output string, the information given back to the user + String resultString = null + + Logger logger = LoggerFactory.getLogger("org.noise_planet.noisemodelling") + + // print to command window + logger.info('Start : Add Leq and LAeq column') + logger.info("inputs {}", input) // log inputs of the run + + // Open connection + Sql sql = new Sql(connection) + + // ------------------- + // Get inputs + // ------------------- + + // Get name of the prefix + String columnName = input['columnName'] as String + // do it case-insensitive + columnName = columnName.toUpperCase() + + // Get name of the table + String table = input["tableName"] as String + // do it case-insensitive + table = table.toUpperCase() + + sql.execute("DROP TABLE " + table + "_DYN_IND IF EXISTS;") + sql.execute("CREATE TABLE " + table + "_DYN_IND AS SELECT THE_GEOM, " + + "ROUND(MEDIAN(" + columnName + "), 1) L50, " + + "ROUND(percentile_cont(0.9) WITHIN GROUP (ORDER BY " + columnName + "), 1) L10," + + "ROUND(percentile_cont(0.1) WITHIN GROUP (ORDER BY " + columnName + "), 1) L90 FROM " + table + " GROUP BY THE_GEOM;") + + resultString = "The columns LEQA and LEQ have been added to the table: " + table + "." + + // print to command window + logger.info('End : Add Dynamic Indicator') + + // print to WPS Builder + return resultString + +} + +def run(input) { + + // Get name of the database + // by default an embedded h2gis database is created + // Advanced user can replace this database for a postGis or h2Gis server database. + String dbName = "h2gisdb" + + // Open connection + openGeoserverDataStoreConnection(dbName).withCloseable { + Connection connection -> + return [result: exec(connection, input)] + } +} \ No newline at end of file diff --git a/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/Experimental_Matsim/Noise_From_Attenuation_Matrix.groovy b/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/Experimental_Matsim/Noise_From_Attenuation_Matrix.groovy deleted file mode 100644 index 37b235726..000000000 --- a/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/Experimental_Matsim/Noise_From_Attenuation_Matrix.groovy +++ /dev/null @@ -1,287 +0,0 @@ -/** - * NoiseModelling is an open-source tool designed to produce environmental noise maps on very large urban areas. It can be used as a Java library or be controlled through a user friendly web interface. - * - * This version is developed by Université Gustave Eiffel and CNRS - * - * - * NoiseModelling is distributed under GPL 3 license. You can read a copy of this License in the file LICENCE provided with this software. - * - * Contact: contact@noise-planet.org - * - */ -/** - * @Author Valentin Le Bescond, Université Gustave Eiffel - */ - -package org.noise_planet.noisemodelling.wps.Experimental_Matsim - -import geoserver.GeoServer -import geoserver.catalog.Store -import groovy.sql.GroovyRowResult -import org.geotools.jdbc.JDBCDataStore -import org.h2gis.utilities.wrapper.ConnectionWrapper -import org.locationtech.jts.geom.Geometry -import org.slf4j.Logger -import org.slf4j.LoggerFactory - -import java.sql.* -import groovy.sql.Sql - -title = 'Noise Map From Attenuation Matrix' -description = 'Noise Map From Attenuation Matrix.' + - '
' - -inputs = [ - matsimRoads: [ - name: 'Table name of the MATSIM table containing the roads geometries', - title: 'Table name of the MATSIM table containing the roads geometries', - description: 'Table name of the MATSIM table containing the roads geometries' + - '
The table must contain the following fields : (PK, LINK_ID, THE_GEOM)', - type: String.class - ], - matsimRoadsLw : [ - name: 'Table name of the MATSIM table containing the roads LW stats per timeBin', - title: 'Table name of the MATSIM table containing the roads LW stats per timeBin', - description: 'Table name of the MATSIM table containing the roads LW stats per timeBin' + - '
The table must contain the following fields : ' + - '
PK, LINK_ID, LW63, LW125, LW250, LW500, LW1000, LW2000, LW4000, LW8000, TIME', - type: String.class - ], - receiversTable : [ - name: 'Name of the table containing the receivers', - title: 'Name of the table containing the receivers', - description: 'Name of the table containing the receivers' + - '
The table must contain the following fields : ' + - '
PK, THE_GEOM', - type: String.class - ], - attenuationTable : [ - name: 'Attenuation Matrix Table name', - title: 'Attenuation Matrix Table name', - description: 'Attenuation Matrix Table name, Obtained from the Noise_level_from_source script with "confExportSourceId" enabled' + - '
The table must contain the following fields :' + - '
IDRECEIVER, IDSOURCE, THE_GEOM, HZ63, HZ125, HZ250, HZ500, HZ1000, HZ2000, HZ4000, HZ8000', - type: String.class - ], - timeBinSize: [ - name: 'The size of time bins in seconds.', - title: 'The size of time bins in seconds.', - description: 'This parameter dictates the time resolution of the resulting data ' + - '
The time information stored will be the starting time of the time bins ' + - '
For exemple with a timeBinSize of 3600, the data will be analysed using the following timeBins: ' + - '
0, 3600, 7200, ..., 79200, 82800', - type: Integer.class - ], - outTableName: [ - name: 'Output table name', - title: 'Output table name', - description: 'Output table name' + - '
The table will contain the following fields :' + - '
PK, IDRECEIVER, THE_GEOM, HZ63, HZ125, HZ250, HZ500, HZ1000, HZ2000, HZ000, HZ8000, TIME', - type: String.class - ] -] - -outputs = [ - result: [ - name: 'Result output string', - title: 'Result output string', - description: 'This type of result does not allow the blocks to be linked together.', - type: String.class - ] -] - -static Connection openGeoserverDataStoreConnection(String dbName) { - if (dbName == null || dbName.isEmpty()) { - dbName = new GeoServer().catalog.getStoreNames().get(0) - } - Store store = new GeoServer().catalog.getStore(dbName) - JDBCDataStore jdbcDataStore = (JDBCDataStore) store.getDataStoreInfo().getDataStore(null) - return jdbcDataStore.getDataSource().getConnection() -} - - -def run(input) { - - // Get name of the database - String dbName = "h2gisdb" - - // Open connection - openGeoserverDataStoreConnection(dbName).withCloseable { - Connection connection -> - return [result: exec(connection, input)] - } -} - -// main function of the script -def exec(Connection connection, input) { - - connection = new ConnectionWrapper(connection) - - Sql sql = new Sql(connection) - - String resultString - - Logger logger = LoggerFactory.getLogger("org.noise_planet.noisemodelling") - logger.info('Start : Noise_From_Attenuation_Matrix') - logger.info("inputs {}", input) - - String matsimRoads = input['matsimRoads'] - String matsimRoadsLw = input['matsimRoadsLw'] - String attenuationTable = input['attenuationTable'] - String receiversTable = input['receiversTable'] - String outTableName = input['outTableName'] - - int timeBinSize = 3600 - if (input["timeBinSize"]) { - timeBinSize = input["timeBinSize"] as int; - } - - DatabaseMetaData dbMeta = connection.getMetaData(); - ResultSet rs = dbMeta.getIndexInfo(null, null, attenuationTable, false, false); - - - sql.execute(String.format("DROP TABLE %s IF EXISTS", outTableName)) - String query = "CREATE TABLE " + outTableName + '''( - PK integer PRIMARY KEY AUTO_INCREMENT, - IDRECEIVER integer, - THE_GEOM geometry, - HZ63 double precision, - HZ125 double precision, - HZ250 double precision, - HZ500 double precision, - HZ1000 double precision, - HZ2000 double precision, - HZ4000 double precision, - HZ8000 double precision, - TIME int - ) - ''' - sql.execute(query) - PreparedStatement insert_stmt = connection.prepareStatement( - "INSERT INTO " + outTableName + " VALUES(DEFAULT, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", - ) - - logger.info("searching indexes on attenuation matrix ... ") - ensureIndex(connection, attenuationTable, "IDSOURCE", false) - ensureIndex(connection, attenuationTable, "IDRECEIVER", false) - logger.info("searching indexes on traffic tables ... ") - ensureIndex(connection, matsimRoads, "LINK_ID", false) - ensureIndex(connection, matsimRoadsLw, "LINK_ID", false) - ensureIndex(connection, matsimRoadsLw, "TIME", false) - - List mrs_freqs = ["LW63", "LW125", "LW250", "LW500", "LW1000", "LW2000", "LW4000", "LW8000"] - - long count = 0, do_print = 1 - List receivers_res = sql.rows("SELECT * FROM " + receiversTable); - long nb_receivers = receivers_res.size() - long start = System.currentTimeMillis(); - for (GroovyRowResult receiver: receivers_res) { - long receiver_id = receiver["PK"] as long; - Geometry receiver_geom = receiver["THE_GEOM"] as Geometry; - Map> levels = new HashMap>(); - List sources_att_res = sql.rows(String.format("SELECT lg.* FROM %s lg WHERE lg.IDRECEIVER = %d", attenuationTable, receiver_id)); - long nb_sources = sources_att_res.size(); - if (nb_sources == 0) { - count++ - continue - } - for (GroovyRowResult sources_att: sources_att_res) { - long source_id = sources_att["IDSOURCE"] as long; - List attenuation = [ - sources_att["HZ63"] as double, - sources_att["HZ125"] as double, - sources_att["HZ250"] as double, - sources_att["HZ500"] as double, - sources_att["HZ1000"] as double, - sources_att["HZ2000"] as double, - sources_att["HZ4000"] as double, - sources_att["HZ8000"] as double, - ]; - List roads_stats_res = sql.rows(String.format( - "SELECT mrs.* FROM %s mrs INNER JOIN %s mr ON mr.LINK_ID = mrs.LINK_ID WHERE mr.PK = %d", - matsimRoadsLw, matsimRoads, source_id)); - for (GroovyRowResult roads_stats: roads_stats_res) { - int timeBin = roads_stats["TIME"] as int - if (!levels.containsKey(timeBin)) { - levels[timeBin] = [-99.0, -99.0, -99.0, -99.0, -99.0, -99.0, -99.0, -99.0] as List - } - for (i in 0..<8) { - double new_level = (roads_stats[mrs_freqs[i]] as double) + attenuation[i]; - levels[timeBin][i] = 10 * Math.log10( Math.pow(10, levels[timeBin][i] / 10) + Math.pow(10, new_level / 10)) - } - } - } - - for (int timeBin = 0; timeBin < 86400; timeBin += timeBinSize) { - if (!levels.containsKey(timeBin)) { - levels[timeBin] = [-99.0, -99.0, -99.0, -99.0, -99.0, -99.0, -99.0, -99.0] as List - } - List ts_levels = levels[timeBin] - insert_stmt.setLong(1, receiver_id) - insert_stmt.setString(2, receiver_geom.toText()) - for (i in 0..<8) { - insert_stmt.setDouble(i+3, ts_levels[i]) - } - insert_stmt.setInt(11, timeBin) - insert_stmt.execute() - } - if (count >= do_print) { - double elapsed = (System.currentTimeMillis() - start + 1) / 1000 - logger.info(String.format("Processing Receiver %d (max:%d) - elapsed : %ss (%.1fit/s)", - count, nb_receivers, elapsed, count/elapsed)) - do_print *= 2 - } - count ++ - } - - String prefix = "HZ" - sql.execute("ALTER TABLE " + outTableName + " ADD COLUMN LEQA float as 10*log10((power(10,(" + prefix + "63-26.2)/10)+power(10,(" + prefix + "125-16.1)/10)+power(10,(" + prefix + "250-8.6)/10)+power(10,(" + prefix + "500-3.2)/10)+power(10,(" + prefix + "1000)/10)+power(10,(" + prefix + "2000+1.2)/10)+power(10,(" + prefix + "4000+1)/10)+power(10,(" + prefix + "8000-1.1)/10)))") - sql.execute("ALTER TABLE " + outTableName + " ADD COLUMN LEQ float as 10*log10((power(10,(" + prefix + "63)/10)+power(10,(" + prefix + "125)/10)+power(10,(" + prefix + "250)/10)+power(10,(" + prefix + "500)/10)+power(10,(" + prefix + "1000)/10)+power(10,(" + prefix + "2000)/10)+power(10,(" + prefix + "4000)/10)+power(10,(" + prefix + "8000)/10)))") - - logger.info('End : Noise_From_Attenuation_Matrix') - resultString = "Process done. Table of receivers " + outTableName + " created !" - logger.info('Result : ' + resultString) - return resultString -} - -static boolean tableExists(Connection connection, String table) { - DatabaseMetaData dbMeta = connection.getMetaData(); - ResultSet rs = dbMeta.getTables(null, null, table, null); - boolean table_found = false; - if (rs.next()) { - table_found = true - } - return table_found -} - -static boolean columnExists(Connection connection, String table, String column_name) { - DatabaseMetaData dbMeta = connection.getMetaData(); - ResultSet rs = dbMeta.getColumns(null, null, table, column_name); - boolean col_found = false; - if (rs.next()) { - col_found = true - } - return col_found -} - -static boolean indexExists(Connection connection, String table, String column_name) { - DatabaseMetaData dbMeta = connection.getMetaData(); - ResultSet rs = dbMeta.getIndexInfo(null, null, table, false, false); - boolean index_found = false; - while (rs.next()) { - String column = rs.getString("COLUMN_NAME"); - String pos = rs.getString("ORDINAL_POSITION"); - if (column == column_name && pos == "1") { - index_found = true; - } - } - return index_found -} - -static void ensureIndex(Connection connection, String table, String column_name, boolean spatial) { - if (!indexExists(connection, table, column_name)) { - Sql sql = new Sql(connection) - sql.execute("CREATE " + (spatial ? "SPATIAL " : "") + "INDEX ON " + table + " (" + column_name + ")"); - } -} diff --git a/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/Experimental_Matsim/Noise_From_Attenuation_Matrix_MatSim.groovy b/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/Experimental_Matsim/Noise_From_Attenuation_Matrix_MatSim.groovy new file mode 100644 index 000000000..c1cfa6f5b --- /dev/null +++ b/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/Experimental_Matsim/Noise_From_Attenuation_Matrix_MatSim.groovy @@ -0,0 +1,205 @@ +/** + * NoiseModelling is an open-source tool designed to produce environmental noise maps on very large urban areas. It can be used as a Java library or be controlled through a user friendly web interface. + * + * This version is developed by Université Gustave Eiffel and CNRS + * + * + * NoiseModelling is distributed under GPL 3 license. You can read a copy of this License in the file LICENCE provided with this software. + * + * Contact: contact@noise-planet.org + * + */ +/** + * @Author Valentin Le Bescond, Université Gustave Eiffel + */ + +package org.noise_planet.noisemodelling.wps.Experimental_Matsim + +import geoserver.GeoServer +import geoserver.catalog.Store +import org.geotools.jdbc.JDBCDataStore +import org.h2gis.utilities.wrapper.ConnectionWrapper +import org.slf4j.Logger +import org.slf4j.LoggerFactory + +import java.sql.* +import groovy.sql.Sql + +title = 'Noise Map From Attenuation Matrix' +description = 'Noise Map From Attenuation Matrix.' + + '
' + +inputs = [ + matsimRoads: [ + name: 'Table name of the MATSIM table containing the roads geometries', + title: 'Table name of the MATSIM table containing the roads geometries', + description: 'Table name of the MATSIM table containing the roads geometries' + + '
The table must contain the following fields : (PK, LINK_ID, THE_GEOM)', + type: String.class + ], + matsimRoadsStats : [ + name: 'Table name of the MATSIM table containing the roads LW stats per timeString', + title: 'Table name of the MATSIM table containing the roads LW stats per timeString', + description: 'Table name of the MATSIM table containing the roads LW stats per timeString' + + '
The table must contain the following fields : ' + + '
PK, LINK_ID, LW63, LW125, LW250, LW500, LW1000, LW2000, LW4000, LW8000, TIMESTRING', + type: String.class + ], + timeString: [ + name: 'TIMESTRING Field value', + title: 'TIMESTRING Field value.', + description: 'TIMESTRING Field value. If defined will only output data for the specified timeString.' + + '
The timeString can be "D", "E", "N" for DEN analysis, "12_14" for example for hour analysis or "0h15_0h30" for example for 15minutes analysis.', + min: 0, + max : 1, + type: String.class + ], + attenuationTable : [ + name: 'Attenuation Matrix Table name', + title: 'Attenuation Matrix Table name', + description: 'Attenuation Matrix Table name, Obtained from the Noise_level_from_source script with "confExportSourceId" enabled' + + '
The table must contain the following fields :' + + '
IDRECEIVER, IDSOURCE, THE_GEOM, HZ63, HZ125, HZ250, HZ500, HZ1000, HZ2000, HZ4000, HZ8000', + type: String.class + ], + outTableName: [ + name: 'Output table name', + title: 'Output table name', + description: 'Output table name' + + '
The table will contain the following fields :' + + '
PK, IDRECEIVER, THE_GEOM, HZ63, HZ125, HZ250, HZ500, HZ1000, HZ2000, HZ000, HZ8000, TIMESTRING', + type: String.class + ] +] + +outputs = [ + result: [ + name: 'Result output string', + title: 'Result output string', + description: 'This type of result does not allow the blocks to be linked together.', + type: String.class + ] +] + +static Connection openGeoserverDataStoreConnection(String dbName) { + if (dbName == null || dbName.isEmpty()) { + dbName = new GeoServer().catalog.getStoreNames().get(0) + } + Store store = new GeoServer().catalog.getStore(dbName) + JDBCDataStore jdbcDataStore = (JDBCDataStore) store.getDataStoreInfo().getDataStore(null) + return jdbcDataStore.getDataSource().getConnection() +} + + +def run(input) { + + // Get name of the database + String dbName = "h2gisdb" + + // Open connection + openGeoserverDataStoreConnection(dbName).withCloseable { + Connection connection -> + return [result: exec(connection, input)] + } +} + +// main function of the script +def exec(Connection connection, input) { + + connection = new ConnectionWrapper(connection) + + Sql sql = new Sql(connection) + + String resultString + + Logger logger = LoggerFactory.getLogger("org.noise_planet.noisemodelling") + logger.info('Start : Noise_From_Attenuation_Matrix_MatSim') + logger.info("inputs {}", input) + + String matsimRoads = input['matsimRoads'] + String matsimRoadsStats = input['matsimRoadsStats'] + + String timeString = "" + if (input["timeString"]) { + timeString = input["timeString"]; + } + + String attenuationTable = input['attenuationTable'] + String outTableName = input['outTableName'] + + DatabaseMetaData dbMeta = connection.getMetaData(); + ResultSet rs = dbMeta.getIndexInfo(null, null, attenuationTable, false, false); + + logger.info("searching indexes on attenuation matrix ... ") + boolean indexIDSOURCE = false; + boolean indexGEOM = false; + while (rs.next()) { + String column = rs.getString("COLUMN_NAME"); + String pos = rs.getString("ORDINAL_POSITION"); + if (column == "IDSOURCE" && pos == "1") { + indexIDSOURCE = true; + logger.info("index on attenuation matrix IDSOURCE found") + } + if (column == "THE_GEOM" && pos == "1") { + indexGEOM = true; + logger.info("index on attenuation matrix THE_GEOM found") + } + } + + if (!indexIDSOURCE) { + logger.info("index on attenuation matrix IDSOURCE, NOT found, creating one...") + sql.execute("CREATE INDEX ON " + attenuationTable + " (IDSOURCE)"); + } + if (!indexGEOM) { + logger.info("index on attenuation matrix THE_GEOM, NOT found, creating one...") + sql.execute("CREATE SPATIAL INDEX ON " + attenuationTable + " (THE_GEOM)"); + } + + sql.execute(String.format("DROP TABLE IF EXISTS %s", outTableName)) + + String query = "CREATE TABLE " + outTableName + '''( + PK integer PRIMARY KEY AUTO_INCREMENT, + IDRECEIVER integer, + THE_GEOM geometry, + HZ63 double precision, + HZ125 double precision, + HZ250 double precision, + HZ500 double precision, + HZ1000 double precision, + HZ2000 double precision, + HZ4000 double precision, + HZ8000 double precision, + TIMESTRING varchar + ); + INSERT INTO RESULT_GEOM(IDRECEIVER , THE_GEOM , HZ63 , HZ125 , HZ250 , HZ500 , HZ1000 , HZ2000 , HZ4000 , HZ8000 , TIMESTRING ) + SELECT lg.IDRECEIVER, lg.THE_GEOM, + 10 * LOG10( SUM(POWER(10,(mrs.LW63 + lg.HZ63) / 10))) AS HZ63, + 10 * LOG10( SUM(POWER(10,(mrs.LW125 + lg.HZ125) / 10))) AS HZ125, + 10 * LOG10( SUM(POWER(10,(mrs.LW250 + lg.HZ250) / 10))) AS HZ250, + 10 * LOG10( SUM(POWER(10,(mrs.LW500 + lg.HZ500) / 10))) AS HZ500, + 10 * LOG10( SUM(POWER(10,(mrs.LW1000 + lg.HZ1000) / 10))) AS HZ1000, + 10 * LOG10( SUM(POWER(10,(mrs.LW2000 + lg.HZ2000) / 10))) AS HZ2000, + 10 * LOG10( SUM(POWER(10,(mrs.LW4000 + lg.HZ4000) / 10))) AS HZ4000, + 10 * LOG10( SUM(POWER(10,(mrs.LW8000 + lg.HZ8000) / 10))) AS HZ8000, + mrs.TIMESTRING AS TIMESTRING + FROM ''' + attenuationTable + ''' lg + INNER JOIN ''' + matsimRoads + ''' mr ON lg.IDSOURCE = mr.PK + INNER JOIN ''' + matsimRoadsStats + ''' mrs ON mr.LINK_ID = mrs.LINK_ID + ''' + ((timeString != "") ? "WHERE mrs.TIMESTRING = \'" + timeString + "\' " : "") + ''' + GROUP BY lg.IDRECEIVER, lg.THE_GEOM, mrs.TIMESTRING; + ''' + + logger.info(query) + + sql.execute(query) + + String prefix = "HZ" + sql.execute("ALTER TABLE " + outTableName + " ADD COLUMN LEQA float as 10*log10((power(10,(" + prefix + "63-26.2)/10)+power(10,(" + prefix + "125-16.1)/10)+power(10,(" + prefix + "250-8.6)/10)+power(10,(" + prefix + "500-3.2)/10)+power(10,(" + prefix + "1000)/10)+power(10,(" + prefix + "2000+1.2)/10)+power(10,(" + prefix + "4000+1)/10)+power(10,(" + prefix + "8000-1.1)/10)))") + sql.execute("ALTER TABLE " + outTableName + " ADD COLUMN LEQ float as 10*log10((power(10,(" + prefix + "63)/10)+power(10,(" + prefix + "125)/10)+power(10,(" + prefix + "250)/10)+power(10,(" + prefix + "500)/10)+power(10,(" + prefix + "1000)/10)+power(10,(" + prefix + "2000)/10)+power(10,(" + prefix + "4000)/10)+power(10,(" + prefix + "8000)/10)))") + + logger.info('End : Noise_From_Attenuation_Matrix_MatSim') + resultString = "Process done. Table of receivers " + outTableName + " created !" + logger.info('Result : ' + resultString) + return resultString +} + diff --git a/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/NoiseModelling/Dynamic_Road_Emission_from_Traffic.groovy b/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/NoiseModelling/Dynamic_Road_Emission_from_Traffic.groovy new file mode 100644 index 000000000..3d4304ce3 --- /dev/null +++ b/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/NoiseModelling/Dynamic_Road_Emission_from_Traffic.groovy @@ -0,0 +1,881 @@ +/** + * NoiseModelling is an open-source tool designed to produce environmental noise maps on very large urban areas. It can be used as a Java library or be controlled through a user friendly web interface. + * + * This version is developed by the DECIDE team from the Lab-STICC (CNRS) and by the Mixt Research Unit in Environmental Acoustics (Université Gustave Eiffel). + * + * + * NoiseModelling is distributed under GPL 3 license. You can read a copy of this License in the file LICENCE provided with this software. + * + * Contact: contact@noise-planet.org + * + */ + +/** + * @Author Pierre Aumond, Université Gustave Eiffel + * @Author Valetin Le Bescond, Université Gustave Eiffel, Ghent University + */ + +package org.noise_planet.noisemodelling.wps.NoiseModelling + +import geoserver.GeoServer +import geoserver.catalog.Store +import groovy.sql.Sql +import groovy.time.TimeCategory +import org.geotools.jdbc.JDBCDataStore +import org.h2gis.utilities.GeometryTableUtilities +import org.h2gis.utilities.SpatialResultSet +import org.h2gis.utilities.TableLocation +import org.h2gis.utilities.wrapper.ConnectionWrapper +import org.locationtech.jts.geom.* +import org.noise_planet.noisemodelling.emission.road.cnossosvar.RoadVehicleCnossosvar +import org.noise_planet.noisemodelling.emission.road.cnossosvar.RoadVehicleCnossosvarParameters + +import java.security.InvalidParameterException +import java.sql.Connection +import java.sql.ResultSet +import java.sql.SQLException +import java.util.stream.Collectors + +title = 'Dynamic Road Emission from traffic' +description = 'Calculating dynamic road emissions based on average traffic flows.' + + '

The output table is called : LW_DYNAMIC ' + + 'and contain :
' + + '- TIMESTAMP : The TIMESTAMP iteration (STRING).
' + + '- IDRECEIVER : an identifier (INTEGER, PRIMARY KEY).
' + + '- THE_GEOM : the 3D geometry of the receivers (POINT).
' + + '- HZ63, HZ125, HZ250, HZ500, HZ1000,HZ2000, HZ4000, HZ8000 : 8 columns giving the day emission sound level for each octave band (FLOAT).' + +inputs = [ + tableRoads : [name : 'Roads table name', title: 'Roads table name', description: "Name of the Roads table.
" + + "
The table shall contain :
" + + "- PK : an identifier. It shall be a primary key (INTEGER, PRIMARY KEY)
" + + "- TV_D : Hourly average light and heavy vehicle count (DOUBLE)
" + + "- HV_D : Hourly average heavy vehicle count (DOUBLE)
" + + "- LV_SPD_D : Hourly average light vehicle speed (DOUBLE)
" + + "- HV_SPD_D : Hourly average heavy vehicle speed (DOUBLE)
" + + "- PVMT : CNOSSOS road pavement identifier (ex: NL05) (VARCHAR)" + + "

This table can be generated from the WPS Block 'Import_OSM'. .", type: String.class], + + method : [name : 'Selected Method', + title : "Selected Method", + description : "
Two methods are available : " + + "
- PROBA : Probabilistic representation of vehicle appearances for each time step (quicker, but sacrifices temporal coherence) Aumond, P., Jacquesson, L., & Can, A. (2018). Probabilistic modeling framework for multisource sound mapping. Applied Acoustics, 139, 34-43. ." + + "
- TNP : Simplified vehicle movements (slower, but maintaining temporal coherence) De Coensel, B.; Brown, A.L.; Tomerini, D. A road traffic noise pattern simulation model that includes distributions of vehicle sound power levels. Appl. Acoust. 2016, 111, 170–178. .", + type: String.class], + + timestep : [name : 'timestep', + title : "timestep", + description : "Number of iterations. Timestep in sec.
Default value : 1 ", + type: Integer.class], + + gridStep : [name : 'gridStep', + title : "gridStep", + description : "Distance between location of vehicle along the network in meters.
Default value : 10 ", + type: Integer.class], + + duration : [name : 'duration', title: 'duration in sec.', + description: 'Number of the iterations to compute (INTEGER).

Default value : 60 ', + type: Integer.class], +] + +outputs = [ + result: [ + name : 'Result output string', + title : 'Result output string', + description: 'This type of result does not allow the blocks to be linked together.', + type : String.class + ] +] + +// Open Connection to Geoserver +static Connection openGeoserverDataStoreConnection(String dbName) { + if (dbName == null || dbName.isEmpty()) { + dbName = new GeoServer().catalog.getStoreNames().get(0) + } + Store store = new GeoServer().catalog.getStore(dbName) + JDBCDataStore jdbcDataStore = (JDBCDataStore) store.getDataStoreInfo().getDataStore(null) + return jdbcDataStore.getDataSource().getConnection() +} + +// run the script +def run(input) { + + // Get name of the database + // by default an embedded h2gis database is created + // Advanced user can replace this database for a postGis or h2Gis server database. + String dbName = "h2gisdb" + + // Open connection + openGeoserverDataStoreConnection(dbName).withCloseable { + Connection connection -> + return [result: exec(connection, input)] + } +} + + +// main function of the script +def exec(Connection connection, input) { + + //Need to change the ConnectionWrapper to WpsConnectionWrapper to work under postGIS database + connection = new ConnectionWrapper(connection) + + // Open sql connection to communicate with the database + Sql sql = new Sql(connection) + + // output string, the information given back to the user + String resultString = null + + // print to command window + System.out.println('Start : Traffic Probabilistic Modelling') + def start = new Date() + + // ------------------- + // Get every inputs + // ------------------- + + double duration = 60 + if (input['duration']) { + duration = Double.valueOf(input['duration'] as String) + } + + int timestep = 1 + if (input['timestep']) { + timestep = Integer.valueOf(input['timestep'] as String) + } + + int gridStep = 10 + if (input['gridStep']) { + gridStep = Integer.valueOf(input['gridStep'] as String) + } + + int nIterations = (int) Math.round(duration/timestep); + + String method = "PROBA" + if (input['method']) { + method = input['method'] as String + } + + String sources_table_name = input['tableRoads'] + // do it case-insensitive + sources_table_name = sources_table_name.toUpperCase() + // Check if srid are in metric projection. + int sridSources = GeometryTableUtilities.getSRID(connection, TableLocation.parse(sources_table_name)) + if (sridSources == 3785 || sridSources == 4326) throw new IllegalArgumentException("Error : Please use a metric projection for "+sources_table_name+".") + if (sridSources == 0) throw new IllegalArgumentException("Error : The table "+sources_table_name+" does not have an associated SRID.") + + System.out.println('Start time : ' + TimeCategory.minus(new Date(), start)) + + sql.execute("DROP TABLE IF EXISTS ROAD_POINTS" ) + sql.execute("CREATE TABLE ROAD_POINTS(ROAD_ID serial, THE_GEOM geometry, LV int, LV_SPD real, HV int, HV_SPD real) AS SELECT r.PK, ST_Tomultipoint(ST_Densify(the_geom, "+gridStep+")), r.LV_D, r.LV_SPD_D, r.HGV_D, r.HGV_SPD_D FROM "+sources_table_name+" r WHERE NOT ST_IsEmpty(r.THE_GEOM) ;") + + sql.execute("drop table VEHICLES if exists;" + + " create table VEHICLES as SELECT ST_AddZ(ST_FORCE3D(the_geom),0.05) geom_3D,* from ST_Explode('ROAD_POINTS');" + + "ALTER TABLE VEHICLES DROP COLUMN the_geom;" + + " ALTER TABLE VEHICLES RENAME COLUMN geom_3D TO the_geom;" + + "alter table VEHICLES add PK INT AUTO_INCREMENT PRIMARY KEY;" + + "ALTER TABLE VEHICLES DROP COLUMN EXPLOD_ID;") + + + sql.execute("DROP TABLE IF EXISTS ALL_VEH_POS_0DB") + sql.execute("CREATE TABLE ALL_VEH_POS_0DB(PK int NOT NULL PRIMARY KEY, ROAD_ID long, THE_GEOM geometry, LWD63 real, LWD125 real, LWD250 real, LWD500 real, LWD1000 real, LWD2000 real, LWD4000 real, LWD8000 real) AS SELECT r.PK, r.ROAD_ID, r.THE_GEOM, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 FROM VEHICLES AS r;") + + + if (method == "PROBA"){ + System.println("Create the random road traffic table over the number of iterations... ") + + sql.execute("drop table VEHICLES_PROBA IF EXISTS;" + + "create table VEHICLES_PROBA AS SELECT *,case when LV_SPD < 20 then 0.001*LV/20 else 0.001*LV/LV_SPD end LV_DENS_D, case when HV_SPD < 20 then 0.001*HV/20 else 0.001*HV/HV_SPD end HGV_DENS_D FROM VEHICLES ;" + + "alter table VEHICLES_PROBA add LENGTH double as select ST_LENGTH(the_geom) ;" + + "ALTER TABLE VEHICLES_PROBA ALTER COLUMN LV_DENS_D double;" + + "ALTER TABLE VEHICLES_PROBA ALTER COLUMN HGV_DENS_D double;" ) + + IndividualVehicleEmissionProcessData probabilisticProcessData = new IndividualVehicleEmissionProcessData(); + probabilisticProcessData.setDynamicEmissionTable("VEHICLES_PROBA", sql) + + + // random number > Vehicle or not / Light of Heavy + // + sql.execute("drop table if exists LW_DYNAMIC;") + sql.execute("create table LW_DYNAMIC(IT integer, PK integer, Hz63 double precision, Hz125 double precision, Hz250 double precision, Hz500 double precision, Hz1000 double precision, Hz2000 double precision, Hz4000 double precision, Hz8000 double precision);") + def qry = 'INSERT INTO LW_DYNAMIC(IT , PK,Hz63, Hz125, Hz250, Hz500, Hz1000,Hz2000, Hz4000, Hz8000) VALUES (?,?,?,?,?,?,?,?,?,?);' + + int nCarsPos = probabilisticProcessData.getCarsPositions() + k = 0 + for (int it = 1; it < nIterations; it++) { + Map sourceLev = new HashMap<>() + for (int iCar = 1; iCar < nCarsPos; iCar++) { + + // get source SoundLevel + if (!sourceLev.containsKey(iCar)) { + double[] carsLevel = probabilisticProcessData.getCarsLevel(iCar) + + if (carsLevel.sum()!= 0) sourceLev.put(iCar, carsLevel) + } + } + sql.withBatch(100, qry) { ps -> + for (Map.Entry s : sourceLev.entrySet()) { + int time = it*timestep + ps.addBatch(time as Integer, s.key as Integer, + s.value[0] as Double, s.value[1] as Double, s.value[2] as Double, + s.value[3] as Double, s.value[4] as Double, s.value[5] as Double, + s.value[6] as Double, s.value[7] as Double) + + } + } + } + // Drop table LDEN_GEOM if exists + sql.execute("drop table if exists LW_DYNAMIC_GEOM;") + // Associate Geometry column to the table LDEN + sql.execute("CREATE INDEX ON LW_DYNAMIC(PK);") + sql.execute("CREATE INDEX ON VEHICLES(PK);") + sql.execute("create table LW_DYNAMIC_GEOM as select a.IT T,a.PK, b.THE_GEOM, a.Hz63, a.Hz125, a.Hz250, a.Hz500, a.Hz1000, a.Hz2000, a.Hz4000, a.Hz8000 FROM LW_DYNAMIC a LEFT JOIN VEHICLES b ON a.PK = b.PK;") + + } else { + + sql.execute("DROP TABLE IF EXISTS LW_DYNAMIC_GEOM") + sql.execute("CREATE TABLE LW_DYNAMIC_GEOM(PK long, T real, ROAD_ID long, THE_GEOM geometry, HZ63 real, HZ125 real, HZ250 real, HZ500 real, HZ1000 real, HZ2000 real, HZ4000 real, HZ8000 real)") + + int coundRoad + + String insert = "INSERT INTO LW_DYNAMIC_GEOM VALUES(?, ?, ?, ST_GeomFromText(?), ?, ?, ?, ?, ?, ?, ?, ?)" + + sql.query("SELECT COUNT(*) FROM "+sources_table_name+" ; ", { ResultSet countRes -> + ResultSet rs = countRes.unwrap(ResultSet.class) + while (rs.next()) { + coundRoad = rs.getLong(1) + } + } + ) + + + sql.query("SELECT * FROM "+sources_table_name+" ; ", { ResultSet result -> + + SpatialResultSet rs = result.unwrap(SpatialResultSet.class) + int k=1 + +// ... + + while (rs.next()) { + Road road = new Road() + System.out.println(k + "/" + coundRoad + " % " + 100*k/coundRoad) + k++ + + road.setRoad( + rs.getLong('PK'), + "", + rs.getGeometry('THE_GEOM'), + rs.getInt('LV_D'), + rs.getDouble('LV_SPD_D'), + rs.getInt('HGV_D'), + rs.getDouble('HGV_SPD_D') + ) + + + sql.query("SELECT * FROM ALL_VEH_POS_0DB WHERE ROAD_ID = " + road.id, { ResultSet result2 -> + SpatialResultSet rs2 = result2.unwrap(SpatialResultSet.class) + while (rs2.next()) { + road.source_points.add(new SourcePoint( + rs2.getLong('PK'), + rs2.getGeometry('THE_GEOM') + )) + } + }) + + + + for (double time = 0; time < duration; time += timestep) { + + road.move(time, duration) + + + + for (SourcePoint source in road.source_points) { + if (source.levels[0]> 0.0){ + sql.execute(insert, [ + source.id, + time, + road.id, + source.geom.toString(), + source.levels[0], + source.levels[1], + source.levels[2], + source.levels[3], + source.levels[4], + source.levels[5], + source.levels[6], + source.levels[7] + ]) + } + } + + } + + // roads.add(road) + } + }) + sql.execute("CREATE INDEX IF NOT EXISTS ST_TID ON LW_DYNAMIC_GEOM(T, PK)") + } + sql.execute("DROP TABLE IF EXISTS ROAD_POINTS") + sql.execute("DROP TABLE IF EXISTS VEHICLES") + sql.execute("drop table LW_DYNAMIC if exists;") + sql.execute("drop table VEHICLES_PROBA if exists;") + + + System.out.println('Intermediate time : ' + TimeCategory.minus(new Date(), start)) + System.out.println("Export data to table") + + + resultString = "Calculation Done ! The table LW_DYNAMIC_GEOM has been created." + + // print to command window + System.out.println('Result : ' + resultString) + System.out.println('End : Traffic Probabilistic Modelling') + System.out.println('Duration : ' + TimeCategory.minus(new Date(), start)) + + // print to WPS Builder + return resultString +} + + + +/** + * + */ +class Road { + + long id + String type + LineString geom + int lv + double lv_spd + int hv + double hv_spd + double length + + public List source_points = new ArrayList() + + List line_segments = new ArrayList() + + List vehicles = new ArrayList() + + Map lw_corr_generators = new LinkedHashMap<>() + + int seed = 2528432 + + Road(){ + line_segments.clear() + vehicles.clear() + lw_corr_generators.clear() + source_points.clear() + } + + void setRoad(long id, String type, Geometry geom, int lv, double lv_spd, int hv, double hv_spd) { + if (geom.getGeometryType() == "MultiLineString") { + geom = geom.getGeometryN(0) + } + if (geom.getGeometryType() != "LineString") { + throw new InvalidParameterException("Only LineString Geometry is supported") + } + this.id = id + this.type = type + this.geom = (LineString) geom + this.lv = lv + this.lv_spd = lv_spd + this.hv = hv + this.hv_spd = hv_spd + this.length = geom.getLength() + + Coordinate[] coordinates = geom.getCoordinates() + for(int i = 1; i < coordinates.length; i++){ + line_segments.add(new LineSegment(coordinates[i-1], coordinates[i])); + } + + /*for (String vehicle_type: [ + Vehicle.LIGHT_VEHICLE_TYPE, Vehicle.MEDIUM_VEHICLE_TYPE, Vehicle.HEAVY_VEHICLE_TYPE, + Vehicle.MOPEDS_VEHICLE_TYPE, Vehicle.MOTORCYCLE_VEHICLE_TYPE + ]) { + lw_corr_generators.put(vehicle_type, new LwCorrectionGenerator(vehicle_type, 1.0, "meanEn")) + }*/ + + double start + DisplacedNegativeExponentialDistribution distribution = new DisplacedNegativeExponentialDistribution(lv, 1, seed) + start = 0 + def samples = distribution.getSamples(lv) + for (int i = 0; i < lv; i++) { + start += samples[i] + vehicles.add(new Vehicle(lv_spd / 3.6, length, start, Vehicle.LIGHT_VEHICLE_TYPE, (i % 2 == 1), 0)) + } + distribution = new DisplacedNegativeExponentialDistribution(hv, 1, seed) + start = 0 + samples = distribution.getSamples(hv) + for (int i = 0; i < hv; i++) { + start += samples[i] + vehicles.add(new Vehicle(hv_spd / 3.6, length, start, Vehicle.HEAVY_VEHICLE_TYPE, (i % 2 == 1), 0)) + } + for (Vehicle vehicle: vehicles) { + vehicle.lw_correction = 2 //lw_corr_generators.get(vehicle.vehicle_type).generate() + } + } + + void move(double time, double max_time) { + resetSourceLevels() + for (Vehicle vehicle in vehicles) { + vehicle.move(time, max_time) + if (vehicle.exists) { + updateSourceLevels(vehicle) + } + } + } + + void updateSourceLevels(Vehicle vehicle) { + SourcePoint closest = null + SourcePoint secondary_closest = null + Coordinate vehicle_point = getPoint(vehicle.getPosition()) + double distance = -1 + double secondary_distance = -1 + for (SourcePoint source in source_points) { + double dist = vehicle_point.distance(source.geom.getCoordinate()) + if (distance == -1) { + closest = source + distance = dist + continue + } + if (dist < distance) { + secondary_closest = closest + secondary_distance = distance + closest = source + distance = dist + continue + } + if (dist < secondary_distance) { + secondary_closest = source + secondary_distance = dist + } + } + double[] vehicle_levels = vehicle.getLw() + double primary_weight = 1.0 + double secondary_weight = 0.0 + if (secondary_closest != null) { + primary_weight = 1 - distance / (distance + secondary_distance) + secondary_weight = 1 - secondary_distance / (distance + secondary_distance) + } + for (int freq = 0; freq < closest.levels.length; freq++) { + closest.levels[freq] = 10 * Math.log10(Math.pow(10, closest.levels[freq] / 10) + primary_weight * Math.pow(10, vehicle_levels[freq] / 10)) + if (secondary_closest != null) { + secondary_closest.levels[freq] = 10 * Math.log10(Math.pow(10, secondary_closest.levels[freq] / 10) + secondary_weight * Math.pow(10, vehicle_levels[freq] / 10)) + } + } + } + + void resetSourceLevels() { + for (SourcePoint source in source_points) { + for (int freq = 0; freq < source.levels.length; freq++) { + source.levels[freq] = -99.0 + } + } + } + + Coordinate getPoint(double position) { + double vh_pos = position % length + vh_pos = (vh_pos + length) % length // handle negative positions (backward vehicles) + double accum_length = 0.0 + Coordinate result = null + for (LineSegment line in line_segments) { + if ((line.getLength() + accum_length) < vh_pos) { + accum_length += line.getLength() + continue + } + double vh_pos_fraction = (vh_pos - accum_length) / line.getLength() + result = line.pointAlong(vh_pos_fraction) + break + } + return result + } + + int getCode() { + if (!type_codes.containsKey(type)) { + return 0 + } + return type_codes.get(type).toInteger() + } + + +} + + +class SourcePoint { + long id + Point geom + int[] freqs = [63, 125, 250, 500, 1000, 2000, 4000, 8000]; + double[] levels = new double[freqs.length]; + + SourcePoint(long id, Geometry geom) { + if (geom.getGeometryType() != "Point") { + throw new InvalidParameterException("Only Point Geometry is supported") + } + this.id = id + this.geom = (Point) geom + } +} + +class Vehicle { + + final static String LIGHT_VEHICLE_TYPE = "1" + final static String MEDIUM_VEHICLE_TYPE = "2" + final static String HEAVY_VEHICLE_TYPE = "3" + final static String MOPEDS_VEHICLE_TYPE = "4" + final static String MOTORCYCLE_VEHICLE_TYPE = "4" + + static int last_id = 0 + + static do_loop = false + static Random rand = new Random(681254665) + + String vehicle_type = LIGHT_VEHICLE_TYPE + int id = 0 + double position = 0.0 + double max_position = 0.0 + double speed = 0.0 // m/s + double time_offset = 10.0 // shift everything by X seconds to ensure enough traffic exists + double time = 0.0 + double start_time = 0 + boolean exists = false + boolean backward = false + + double lw_correction = 0.0 + + static int getNextId() { + last_id++ + return last_id + } + + Vehicle(double speed, double length, double start, String type, boolean is_back, int road_type) { + max_position = length + vehicle_type = type + start_time = start + backward = is_back + id = getNextId() + + if (road_type == 0 ) { + this.speed = (3 * speed / 4) + (rand.nextGaussian() + 1) * (speed / 4) + } + if (this.vehicle_type == HEAVY_VEHICLE_TYPE || this.vehicle_type == MEDIUM_VEHICLE_TYPE) { + this.speed = Math.min(this.speed, 90 / 3.6) // max 90km/h for heavy vehicles + } + } + + Vehicle(double speed, double length, double start) { + this(speed, length, start, LIGHT_VEHICLE_TYPE, false, 5113) + } + + Vehicle(double speed, double length) { + this(speed, length, 0.0, LIGHT_VEHICLE_TYPE, false, 5113) + } + + void move(double input_time, double max_time) { + time = (input_time + time_offset) % max_time + double real_speed = (backward ? (-1 * speed) : speed) + if (do_loop) { + exists = true + position = ((time + max_time + start_time) % max_time) * real_speed + } + else { + if (time >= start_time) { + exists = true + position = ((time - start_time) % max_time) * real_speed + } else { + exists = false + } + if (position > max_position || position < -max_position) { + exists = false + } + } + } + + double getPosition() { + return position % max_position; + } + + double[] getLw() { + int[] freqs = [63, 125, 250, 500, 1000, 2000, 4000, 8000]; + double[] result = new double[freqs.length]; + if (!exists) { + for (int i = 0; i < freqs.length; i++) { + result[i] = -99.0; + } + return result; + } + for (int i = 0; i < freqs.length; i++) { + + RoadVehicleCnossosvarParameters rsParametersDynamic = new RoadVehicleCnossosvarParameters( + speed * 3.6, 0, vehicle_type, 0, true, 1, id ) + rsParametersDynamic.setRoadSurface("DEF") + // remove lw_correction + result[i] = RoadVehicleCnossosvar.evaluate(rsParametersDynamic) + lw_correction; + } + return result; + } +} + + +class LwCorrectionGenerator { + + static Random rand = new Random(546656812) + + + final private static LinkedHashMap > distributions = [ + (Vehicle.LIGHT_VEHICLE_TYPE) : [0], + (Vehicle.MEDIUM_VEHICLE_TYPE) : [0], + (Vehicle.HEAVY_VEHICLE_TYPE) : [0], + (Vehicle.MOPEDS_VEHICLE_TYPE) : [0], + (Vehicle.MOTORCYCLE_VEHICLE_TYPE) : [0] + ]; + + List xy_values; + List partition; + double dx = 1.0 + + + LwCorrectionGenerator(String type, double dx, String zero_point) { + List values = new ArrayList(distributions.get(type)) + int n = values.size() + this.dx = dx + List cum_dist = cumDist(values) + partition = new ArrayList(cum_dist) + partition.remove(n-1) + xy_values = new ArrayList() + double median = 0 + double meandB = 0 + double meanEn = 0 + for (double i = 0; i < n; i +=dx) { + xy_values.add(i) + if (median <= 0 && cum_dist[(int) i] >= 50) { + median = i + } + } + List xy_values_en = new ArrayList() + for (int i = 0; i < xy_values.size(); i++) { + xy_values_en.add(Math.pow(10, xy_values[i] / 10)) + } + meandB = multiplyAndSum(values, xy_values) / sum(values) + meanEn = 10 * Math.log10(multiplyAndSum(values, xy_values_en) / sum(values)) + if (zero_point == "median") { + xy_values = xy_values.stream().map({ e -> e - median}).collect(Collectors.toList()) + } + else if (zero_point == "meandB") { + xy_values = xy_values.stream().map({ e -> e - meandB}).collect(Collectors.toList()) + } + else { + xy_values = xy_values.stream().map({ e -> e - meanEn}).collect(Collectors.toList()) + } + } + + double generate() { + def result = xy_values[rouletteRand(partition)] + result += uniRand(-dx/2.0,dx/2.0) + return result + } + + static List cumDist(List array) { + List input = new ArrayList(array) + double divide = sum(input) + input = input.stream().map({ e -> e / divide }).collect(Collectors.toList()) + List out = new ArrayList() + out.add(input[0]) + for (int i = 1; i < input.size(); i++) + out.add(out.last() + input[i]) + out = out.stream().map({ e -> e * 100.0}).collect(Collectors.toList()) + return out + } + static double sum(List list) { + double sum = 0; + for (double i : list) + sum = sum + i; + return sum; + } + static double multiplyAndSum(List list1, List list2) { + int max = Math.min(list1.size(), list2.size()); + double sum = 0; + for (int i = 0; i < max; i++) { + sum += list1[i] * list2[i]; + } + return sum; + } + + static double uniRand(double left, double right) { + return left + rand.nextDouble() * (right - left) + } + static double rouletteRand(List partition) { + double r = rand.nextDouble() * 100.0 + double v = 0 + for (i in 0.. partition[i]) { + v = i + 1 + } + } + return v + } + +} + + +abstract class HeadwayDistribution { + + protected static int seed; + Random random; + + HeadwayDistribution(int seed) { + this.seed = seed; + random = new Random(seed); + } + + HeadwayDistribution() { + this(1234) + } + + abstract double inverseCumulativeProbability(double p); + + double getNext() { + return inverseCumulativeProbability(random.nextDouble()) + } + + double[] getSamples(int n) { + double[] result = new double[n]; + for (i in 0.. SPEED_LV = new HashMap<>() + Map SPEED_HV = new HashMap<>() + Map LV = new HashMap<>() + Map HV = new HashMap<>() + int nCars = 0 + + double[] getCarsLevel(int idSource) throws SQLException { + double[] res_d = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0] + double[] res_LV = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0] + double[] res_HV = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0] + def list = [63, 125, 250, 500, 1000, 2000, 4000, 8000] + + + def random = Math.random() + if (random < LV.get(idSource)) { + int kk = 0 + for (f in list) { + + double speed = SPEED_LV.get(idSource) + int acc = 0 + int FreqParam = f + double Temperature = 20 + String RoadSurface = "DEF" + boolean Stud = false + double Junc_dist = 200 + int Junc_type = 1 + String veh_type = "1" + int acc_type = 1 + double LwStd = 1 + int VehId = 10 + + RoadVehicleCnossosvarParameters rsParameters = new RoadVehicleCnossosvarParameters(speed, acc, veh_type, acc_type, Stud, LwStd, VehId) + rsParameters.setRoadSurface(RoadSurface) + rsParameters.setSlopePercentage(0) + + res_LV[kk] = RoadVehicleCnossosvar.evaluate(rsParameters) + kk++ + } + + } + random = Math.random() + if (random < HV.get(idSource)) { + int kk = 0 + for (f in list) { + double speed = SPEED_HV.get(idSource) + double acc = 0 + int FreqParam = f + double Temperature = 20 + String RoadSurface = "DEF" + boolean Stud = false + double Junc_dist = 200 + int Junc_type = 1 + String veh_type = "3" + int acc_type = 1 + double LwStd = 1 + int VehId = 10 + + RoadVehicleCnossosvarParameters rsParameters = new RoadVehicleCnossosvarParameters(speed, acc, veh_type, acc_type, Stud, LwStd, VehId) + rsParameters.setSlopePercentage(0) + rsParameters.setRoadSurface(RoadSurface) + res_HV[kk] = RoadVehicleCnossosvar.evaluate(rsParameters) + kk++ + } + } + int kk = 0 + for (f in list) { + res_d[kk] = 10 * Math.log10( + (1.0 / 2.0) * + (Math.pow(10, (10 * Math.log10(Math.pow(10, res_LV[kk] / 10))) / 10) + + Math.pow(10, (10 * Math.log10(Math.pow(10, res_HV[kk] / 10))) / 10) + ) + ) + kk++ + } + + + return res_d + } + + int getCarsPositions(){ + nCars = SPEED_LV.size() + return nCars + } + void setDynamicEmissionTable(String tablename, Sql sql) { + ////////////////////// + // Import file text + ////////////////////// + + // Remplissage des variables avec le contenu du fichier plan d'exp + sql.eachRow('SELECT PK, LV_SPD, LV_DENS_D, HV_SPD, HGV_DENS_D FROM ' + tablename + ';') { row -> + int pk = (int) row[0] + SPEED_LV.put(pk, (double) row[1]) + LV.put(pk, (double) row[2]) + SPEED_HV.put(pk, (double) row[3]) + HV.put(pk, (double) row[4]) + + } + + + } + +} \ No newline at end of file diff --git a/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/NoiseModelling/Noise_From_Attenuation_Matrix.groovy b/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/NoiseModelling/Noise_From_Attenuation_Matrix.groovy new file mode 100644 index 000000000..16a4a1725 --- /dev/null +++ b/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/NoiseModelling/Noise_From_Attenuation_Matrix.groovy @@ -0,0 +1,204 @@ +/** + * NoiseModelling is an open-source tool designed to produce environmental noise maps on very large urban areas. It can be used as a Java library or be controlled through a user friendly web interface. + * + * This version is developed by Université Gustave Eiffel and CNRS + * + * + * NoiseModelling is distributed under GPL 3 license. You can read a copy of this License in the file LICENCE provided with this software. + * + * Contact: contact@noise-planet.org + * + */ +/** + * @Author Valentin Le Bescond, Université Gustave Eiffel + * @Author Pierre Aumond, Université Gustave Eiffel + */ + +package org.noise_planet.noisemodelling.wps.NoiseModelling + +import geoserver.GeoServer +import geoserver.catalog.Store +import org.geotools.jdbc.JDBCDataStore +import org.h2gis.utilities.wrapper.ConnectionWrapper +import org.slf4j.Logger +import org.slf4j.LoggerFactory + +import java.sql.* +import groovy.sql.Sql + +title = 'Noise Map From Attenuation Matrix' +description = 'Noise Map From Attenuation Matrix.' + + '
' + +inputs = [ + lwTable : [ + name: 'LW(t)', + title: 'LW(t)', + description: 'LW(t)' + + '
The table must contain the following fields :' + + '
PK, THE_GEOM, HZ63, HZ125, HZ250, HZ500, HZ1000, HZ2000, HZ4000, HZ8000, T' + + '
with PK, the IDSOURCE and T a timestring', + type: String.class + ], + attenuationTable : [ + name: 'Attenuation Matrix Table name', + title: 'Attenuation Matrix Table name', + description: 'Attenuation Matrix Table name, Obtained from the Noise_level_from_source script with "confExportSourceId" enabled' + + '
The table must contain the following fields :' + + '
IDRECEIVER, IDSOURCE, THE_GEOM, HZ63, HZ125, HZ250, HZ500, HZ1000, HZ2000, HZ4000, HZ8000', + type: String.class + ], + outputTable : [ + name: 'outputTable Matrix Table name', + title: 'outputTable Matrix Table name', + description: 'outputTable', + type: String.class + ] +] + +outputs = [ + result: [ + name: 'Result output string', + title: 'Result output string', + description: 'This type of result does not allow the blocks to be linked together.', + type: String.class + ] +] + +static Connection openGeoserverDataStoreConnection(String dbName) { + if (dbName == null || dbName.isEmpty()) { + dbName = new GeoServer().catalog.getStoreNames().get(0) + } + Store store = new GeoServer().catalog.getStore(dbName) + JDBCDataStore jdbcDataStore = (JDBCDataStore) store.getDataStoreInfo().getDataStore(null) + return jdbcDataStore.getDataSource().getConnection() +} + + +def run(input) { + + // Get name of the database + String dbName = "h2gisdb" + + // Open connection + openGeoserverDataStoreConnection(dbName).withCloseable { + Connection connection -> + return [result: exec(connection, input)] + } +} + +// main function of the script +def exec(Connection connection, input) { + + connection = new ConnectionWrapper(connection) + + Sql sql = new Sql(connection) + + String resultString + + Logger logger = LoggerFactory.getLogger("org.noise_planet.noisemodelling") + logger.info('Start : Noise_From_Attenuation_Matrix_MatSim') + logger.info("inputs {}", input) + + + String outputTable = input['outputTable'].toString().toUpperCase() + String attenuationTable = input['attenuationTable'].toString().toUpperCase() + String lwTable = input['lwTable'].toString().toUpperCase() + String timeString = "IT" + + DatabaseMetaData dbMeta = connection.getMetaData(); + ResultSet rs = dbMeta.getIndexInfo(null, null, attenuationTable, false, false); + + logger.info("searching indexes on attenuation matrix ... ") + boolean indexIDSOURCE = false; + boolean indexGEOM = false; + while (rs.next()) { + String column = rs.getString("COLUMN_NAME"); + String pos = rs.getString("ORDINAL_POSITION"); + if (column == "IDSOURCE" && pos == "1") { + indexIDSOURCE = true; + logger.info("index on attenuation matrix IDSOURCE found") + } + if (column == "THE_GEOM" && pos == "1") { + indexGEOM = true; + logger.info("index on attenuation matrix THE_GEOM found") + } + } + + if (!indexIDSOURCE) { + logger.info("index on attenuation matrix IDSOURCE, NOT found, creating one...") + sql.execute("CREATE INDEX ON " + attenuationTable + " (IDSOURCE)"); + } + if (!indexGEOM) { + logger.info("index on attenuation matrix THE_GEOM, NOT found, creating one...") + sql.execute("CREATE SPATIAL INDEX ON " + attenuationTable + " (THE_GEOM)"); + } + + + String query = '''CREATE TABLE ''' + outputTable + '''( + PK integer PRIMARY KEY AUTO_INCREMENT, + IDRECEIVER integer, + THE_GEOM geometry, + HZ63 double precision, + HZ125 double precision, + HZ250 double precision, + HZ500 double precision, + HZ1000 double precision, + HZ2000 double precision, + HZ4000 double precision, + HZ8000 double precision, + TIMESTRING varchar + ); + INSERT INTO ''' + outputTable +'''(IDRECEIVER , THE_GEOM , HZ63 , HZ125 , HZ250 , HZ500 , HZ1000 , HZ2000 , HZ4000 , HZ8000 , TIMESTRING ) + SELECT lg.IDRECEIVER, lg.THE_GEOM, + 10 * LOG10( SUM(POWER(10,(mr.HZ63 + lg.HZ63) / 10))) AS HZ63, + 10 * LOG10( SUM(POWER(10,(mr.HZ125 + lg.HZ125) / 10))) AS HZ125, + 10 * LOG10( SUM(POWER(10,(mr.HZ250 + lg.HZ250) / 10))) AS HZ250, + 10 * LOG10( SUM(POWER(10,(mr.HZ500 + lg.HZ500) / 10))) AS HZ500, + 10 * LOG10( SUM(POWER(10,(mr.HZ1000 + lg.HZ1000) / 10))) AS HZ1000, + 10 * LOG10( SUM(POWER(10,(mr.HZ2000 + lg.HZ2000) / 10))) AS HZ2000, + 10 * LOG10( SUM(POWER(10,(mr.HZ4000 + lg.HZ4000) / 10))) AS HZ4000, + 10 * LOG10( SUM(POWER(10,(mr.HZ8000 + lg.HZ8000) / 10))) AS HZ8000, + mr.T AS TIMESTRING + FROM ''' + attenuationTable + ''' lg + INNER JOIN ''' + lwTable + ''' mr ON lg.IDSOURCE = mr.PK + GROUP BY lg.IDRECEIVER, lg.THE_GEOM, mr.T; + ''' + + String query2 = '''CREATE TABLE '''+outputTable+''' AS SELECT lg.IDRECEIVER, lg.THE_GEOM, + 10 * LOG10( SUM(POWER(10,(mr.HZ63 + lg.HZ63) / 10))) AS HZ63, + 10 * LOG10( SUM(POWER(10,(mr.HZ125 + lg.HZ125) / 10))) AS HZ125, + 10 * LOG10( SUM(POWER(10,(mr.HZ250 + lg.HZ250) / 10))) AS HZ250, + 10 * LOG10( SUM(POWER(10,(mr.HZ500 + lg.HZ500) / 10))) AS HZ500, + 10 * LOG10( SUM(POWER(10,(mr.HZ1000 + lg.HZ1000) / 10))) AS HZ1000, + 10 * LOG10( SUM(POWER(10,(mr.HZ2000 + lg.HZ2000) / 10))) AS HZ2000, + 10 * LOG10( SUM(POWER(10,(mr.HZ4000 + lg.HZ4000) / 10))) AS HZ4000, + 10 * LOG10( SUM(POWER(10,(mr.HZ8000 + lg.HZ8000) / 10))) AS HZ8000, + mr.T AS TIMESTRING + FROM ''' + attenuationTable + ''' lg , ''' + lwTable + ''' mr WHERE lg.IDSOURCE = mr.PK + GROUP BY lg.IDRECEIVER, lg.THE_GEOM, mr.T; + ''' + + long start = System.currentTimeMillis(); + sql.execute(String.format("DROP TABLE IF EXISTS "+outputTable+"")) + //logger.info(query) + sql.execute(query) + long stop = System.currentTimeMillis(); + println(stop-start) + start = System.currentTimeMillis(); + sql.execute(String.format("DROP TABLE IF EXISTS "+outputTable+";")) + //logger.info(query2) + sql.execute(query2) + stop = System.currentTimeMillis(); + println(stop-start) + + String prefix = "HZ" + sql.execute("ALTER TABLE "+outputTable+" ADD COLUMN LEQA float as 10*log10((power(10,(" + prefix + "63-26.2)/10)+power(10,(" + prefix + "125-16.1)/10)+power(10,(" + prefix + "250-8.6)/10)+power(10,(" + prefix + "500-3.2)/10)+power(10,(" + prefix + "1000)/10)+power(10,(" + prefix + "2000+1.2)/10)+power(10,(" + prefix + "4000+1)/10)+power(10,(" + prefix + "8000-1.1)/10)))") + sql.execute("ALTER TABLE "+outputTable+" ADD COLUMN LEQ float as 10*log10((power(10,(" + prefix + "63)/10)+power(10,(" + prefix + "125)/10)+power(10,(" + prefix + "250)/10)+power(10,(" + prefix + "500)/10)+power(10,(" + prefix + "1000)/10)+power(10,(" + prefix + "2000)/10)+power(10,(" + prefix + "4000)/10)+power(10,(" + prefix + "8000)/10)))") + + logger.info('End : Noise_From_Attenuation_Matrix_MatSim') + resultString = "Process done. Table of receivers LT_GEOM created !" + logger.info('Result : ' + resultString) + return resultString +} + diff --git a/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/NoiseModelling/Traffic_Probabilistic_Modelling.groovy b/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/NoiseModelling/Traffic_Probabilistic_Modelling.groovy deleted file mode 100644 index 0dd45d556..000000000 --- a/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/NoiseModelling/Traffic_Probabilistic_Modelling.groovy +++ /dev/null @@ -1,935 +0,0 @@ -/** - * NoiseModelling is an open-source tool designed to produce environmental noise maps on very large urban areas. It can be used as a Java library or be controlled through a user friendly web interface. - * - * This version is developed by the DECIDE team from the Lab-STICC (CNRS) and by the Mixt Research Unit in Environmental Acoustics (Université Gustave Eiffel). - * - * - * NoiseModelling is distributed under GPL 3 license. You can read a copy of this License in the file LICENCE provided with this software. - * - * Contact: contact@noise-planet.org - * - */ - -/** - * @Author Pierre Aumond, Université Gustave Eiffel - */ - -package org.noise_planet.noisemodelling.wps.NoiseModelling - -import geoserver.GeoServer -import geoserver.catalog.Store -import groovy.sql.Sql -import groovy.time.TimeCategory -import org.geotools.jdbc.JDBCDataStore -import org.h2gis.api.EmptyProgressVisitor -import org.h2gis.api.ProgressVisitor -import org.h2gis.utilities.GeometryTableUtilities -import org.h2gis.utilities.SpatialResultSet -import org.h2gis.utilities.TableLocation -import org.h2gis.utilities.wrapper.ConnectionWrapper -import org.locationtech.jts.geom.Geometry -import org.noise_planet.noisemodelling.emission.road.cnossos.RoadCnossos -import org.noise_planet.noisemodelling.emission.road.cnossos.RoadCnossosParameters -import org.noise_planet.noisemodelling.emission.road.cnossosvar.RoadVehicleCnossosvar -import org.noise_planet.noisemodelling.emission.road.cnossosvar.RoadVehicleCnossosvarParameters -import org.noise_planet.noisemodelling.pathfinder.* -import org.noise_planet.noisemodelling.propagation.* -import org.noise_planet.noisemodelling.jdbc.* - - -import java.sql.Connection -import java.sql.SQLException - -title = 'Road traffic probabilistic modeling' -description = '➡️ Compute road traffic probabilistic modeling
' + - '
' + - 'This approach is described in Aumond, P., Jacquesson, L., & Can, A. (2018). Probabilistic modeling framework for multisource sound mapping. Applied Acoustics, 139, 34-43 .

' + - 'The user can indicate the number of iterations he wants the model to calculate.

' + - '✅ The first output table is called: L_PROBA_GEOM and contain the following columns:' + - '
    ' + - '
  • I : The i iteration (INTEGER)
    • ' + - '
  • IDRECEIVER : an identifier (INTEGER, PRIMARY KEY)
    • ' + - '
  • THE_GEOM : the 3D geometry of the receivers (POINT)
    • ' + - '
  • Hz63, Hz125, Hz250, Hz500, Hz1000,Hz2000, Hz4000, Hz8000 : 8 columns giving the day emission sound level for each octave band (FLOAT)
' - -inputs = [ - tableBuilding : [ - name : 'Buildings table name', - title: 'Buildings table name', - description: 'Name of the Buildings table.
' + - '
The table shall contain :
' + - '- THE_GEOM : the 2D geometry of the building (POLYGON or MULTIPOLYGON).
' + - '- HEIGHT : the height of the building (FLOAT)', - type : String.class], - tableRoads : [ - name: 'Roads table name', - title: 'Roads table name', - description: "Name of the Roads table.

" + - "The table shall contain:
" + - "- PK : an identifier. It shall be a primary key (INTEGER, PRIMARY KEY)
" + - "- TV_D : Hourly average light and heavy vehicle count (DOUBLE)
" + - "- HV_D : Hourly average heavy vehicle count (DOUBLE)
" + - "- LV_SPD_D : Hourly average light vehicle speed (DOUBLE)
" + - "- HV_SPD_D : Hourly average heavy vehicle speed (DOUBLE)
" + - "- PVMT : CNOSSOS road pavement identifier (ex: NL05) (VARCHAR)" + - "

This table can be generated from the WPS Block 'Import_OSM'. .", - type: String.class], - tableReceivers : [ - name : 'Receivers table name', - title: 'Receivers table name', - description: 'Name of the Receivers table.
' + - '
The table shall contain :
' + - '- PK : an identifier. It shall be a primary key (INTEGER, PRIMARY KEY).
' + - '- THE_GEOM : the 3D geometry of the sources (POINT, MULTIPOINT).
' + - '

This table can be generated from the WPS Blocks in the "Receivers" folder. ', - type : String.class], - tableDEM : [ - name : 'DEM table name', - title: 'DEM table name', - description: 'Name of the Digital Elevation Model table.
' + - 'The table shall contain :
' + - '- THE_GEOM : the 3D geometry of the sources (POINT, MULTIPOINT).

' + - ' This table can be generated from the WPS Block "Import_Asc_File". ', - min : 0, max: 1, - type: String.class], - tableGroundAbs : [ - name : 'Ground absorption table name', - title: 'Ground absorption table name', - description: 'Name of the surface/ground acoustic absorption table.
' + - '
The table shall contain :
' + - '- THE_GEOM : the 2D geometry of the sources (POLYGON or MULTIPOLYGON).
' + - '- G : the acoustic absorption of a ground (FLOAT between 0 : very hard and 1 : very soft).
', - min : 0, max: 1, - type: String.class], - paramWallAlpha : [ - name : 'wallAlpha', - title: 'Wall absorption coefficient', - description: 'Wall absorption coefficient (FLOAT between 0 : fully absorbent and strictly less than 1 : fully reflective)

' + - '🛠 Default value : 0.1 ', - min : 0, max: 1, - type: String.class], - confReflOrder : [ - name : 'Order of reflexion', - title: 'Order of reflexion', - description: 'Maximum number of reflections to be taken into account (INTEGER)

' + - '🛠 Default value: 1 ', - min : 0, max: 1, - type: String.class], - confMaxSrcDist : [ - name : 'Maximum source-receiver distance', - title: 'Maximum source-receiver distance', - description: 'Maximum distance between source and receiver (in meters) (FLOAT)

' + - '🛠 Default value: 150 ', - min : 0, max: 1, - type: String.class], - confMaxReflDist : [ - name : 'Maximum source-reflexion distance', - title: 'Maximum source-reflexion distance', - description: 'Maximum reflection distance from the source (in meters) (FLOAT)

' + - '🛠 Default value: 50 ', - min : 0, max: 1, - type: String.class], - confThreadNumber : [ - name : 'Thread number', - title: 'Thread number', - description: 'Number of thread to use on the computer (INTEGER).' + - '
To set this value, look at the number of cores you have.' + - '
If it is set to 0, use the maximum number of cores available.

' + - '🛠 Default value: 1 ', - min : 0, max: 1, - type: String.class], - confDiffVertical : [ - name : 'Diffraction on vertical edges', - title: 'Diffraction on vertical edges', - description: 'Compute or not the diffraction on vertical edges.

' + - '🛠 Default value: false ', - min : 0, max: 1, - type: Boolean.class], - confDiffHorizontal: [ - name : 'Diffraction on horizontal edges', - title: 'Diffraction on horizontal edges', - description: 'Compute or not the diffraction on horizontal edges.

' + - '🛠 Default value: false ', - min : 0, max: 1, - type: Boolean.class], - nIterations : [ - name : 'Iteration number', - title: 'Iteration number', - description: 'Number of the iterations to compute (INTEGER).

' + - '🛠 Default value : 100 ', - min : 0, max: 1, - type: Integer.class], -] - -outputs = [ - result: [ - name : 'Result output string', - title : 'Result output string', - description: 'This type of result does not allow the blocks to be linked together.', - type : String.class - ] -] - -// Open Connection to Geoserver -static Connection openGeoserverDataStoreConnection(String dbName) { - if (dbName == null || dbName.isEmpty()) { - dbName = new GeoServer().catalog.getStoreNames().get(0) - } - Store store = new GeoServer().catalog.getStore(dbName) - JDBCDataStore jdbcDataStore = (JDBCDataStore) store.getDataStoreInfo().getDataStore(null) - return jdbcDataStore.getDataSource().getConnection() -} - -// run the script -def run(input) { - - // Get name of the database - // by default an embedded h2gis database is created - // Advanced user can replace this database for a postGis or h2Gis server database. - String dbName = "h2gisdb" - - // Open connection - openGeoserverDataStoreConnection(dbName).withCloseable { - Connection connection -> - return [result: exec(connection, input)] - } -} - - -// main function of the script -def exec(Connection connection, input) { - - //Need to change the ConnectionWrapper to WpsConnectionWrapper to work under postGIS database - connection = new ConnectionWrapper(connection) - - // Open sql connection to communicate with the database - Sql sql = new Sql(connection) - - // output string, the information given back to the user - String resultString = null - - // print to command window - System.out.println('Start : Traffic Probabilistic Modelling') - def start = new Date() - - // ------------------- - // Get every inputs - // ------------------- - - int nIterations = 300 - if (input['nIterations']) { - nIterations = Integer.valueOf(input['nIterations'] as String) - } - - String sources_table_name = input['tableRoads'] - // do it case-insensitive - sources_table_name = sources_table_name.toUpperCase() - // Check if srid are in metric projection. - int sridSources = GeometryTableUtilities.getSRID(connection, TableLocation.parse(sources_table_name)) - if (sridSources == 3785 || sridSources == 4326) throw new IllegalArgumentException("Error : Please use a metric projection for "+sources_table_name+".") - if (sridSources == 0) throw new IllegalArgumentException("Error : The table "+sources_table_name+" does not have an associated SRID.") - - - String receivers_table_name = input['tableReceivers'] - // do it case-insensitive - receivers_table_name = receivers_table_name.toUpperCase() - //Get the geometry field of the receiver table - TableLocation receiverTableIdentifier = TableLocation.parse(receivers_table_name) - List geomFieldsRcv = GeometryTableUtilities.getGeometryColumnNames(connection, receiverTableIdentifier) - if (geomFieldsRcv.isEmpty()) { - throw new SQLException(String.format("The table %s does not exists or does not contain a geometry field", receiverTableIdentifier)) - } - // Check if srid are in metric projection and are all the same. - int sridReceivers = GeometryTableUtilities.getSRID(connection, TableLocation.parse(receivers_table_name)) - if (sridReceivers == 3785 || sridReceivers == 4326) throw new IllegalArgumentException("Error : Please use a metric projection for "+receivers_table_name+".") - if (sridReceivers == 0) throw new IllegalArgumentException("Error : The table "+receivers_table_name+" does not have an associated SRID.") - if (sridReceivers != sridSources) throw new IllegalArgumentException("Error : The SRID of table "+sources_table_name+" and "+receivers_table_name+" are not the same.") - - - String building_table_name = input['tableBuilding'] - // do it case-insensitive - building_table_name = building_table_name.toUpperCase() - // Check if srid are in metric projection and are all the same. - int sridBuildings = GeometryTableUtilities.getSRID(connection, TableLocation.parse(building_table_name)) - if (sridBuildings == 3785 || sridReceivers == 4326) throw new IllegalArgumentException("Error : Please use a metric projection for "+building_table_name+".") - if (sridBuildings == 0) throw new IllegalArgumentException("Error : The table "+building_table_name+" does not have an associated SRID.") - if (sridReceivers != sridBuildings) throw new IllegalArgumentException("Error : The SRID of table "+building_table_name+" and "+receivers_table_name+" are not the same.") - - String dem_table_name = "" - if (input['tableDEM']) { - dem_table_name = input['tableDEM'] - // do it case-insensitive - dem_table_name = dem_table_name.toUpperCase() - // Check if srid are in metric projection and are all the same. - int sridDEM = GeometryTableUtilities.getSRID(connection, TableLocation.parse(dem_table_name)) - if (sridDEM == 3785 || sridReceivers == 4326) throw new IllegalArgumentException("Error : Please use a metric projection for "+dem_table_name+".") - if (sridDEM == 0) throw new IllegalArgumentException("Error : The table "+dem_table_name+" does not have an associated SRID.") - if (sridDEM != sridSources) throw new IllegalArgumentException("Error : The SRID of table "+sources_table_name+" and "+dem_table_name+" are not the same.") - } - - - String ground_table_name = "" - if (input['tableGroundAbs']) { - ground_table_name = input['tableGroundAbs'] - // do it case-insensitive - ground_table_name = ground_table_name.toUpperCase() - // Check if srid are in metric projection and are all the same. - int sridGROUND = GeometryTableUtilities.getSRID(connection, TableLocation.parse(ground_table_name)) - if (sridGROUND == 3785 || sridReceivers == 4326) throw new IllegalArgumentException("Error : Please use a metric projection for "+ground_table_name+".") - if (sridGROUND == 0) throw new IllegalArgumentException("Error : The table "+ground_table_name+" does not have an associated SRID.") - if (sridGROUND != sridSources) throw new IllegalArgumentException("Error : The SRID of table "+ground_table_name+" and "+sources_table_name+" are not the same.") - } - - int reflexion_order = 0 - if (input['confReflOrder']) { - reflexion_order = Integer.valueOf(input['confReflOrder']) - } - - double max_src_dist = 150 - if (input['confMaxSrcDist']) { - max_src_dist = Double.valueOf(input['confMaxSrcDist']) - } - - double max_ref_dist = 50 - if (input['confMaxReflDist']) { - max_ref_dist = Double.valueOf(input['confMaxReflDist']) - } - - double wall_alpha = 0.1 - if (input['paramWallAlpha']) { - wall_alpha = Double.valueOf(input['paramWallAlpha']) - } - - int n_thread = 1 - if (input['confThreadNumber']) { - n_thread = Integer.valueOf(input['confThreadNumber']) - } - - boolean compute_vertical_diffraction = false - if (input['confDiffVertical']) { - compute_vertical_diffraction = input['confDiffVertical'] - } - - boolean compute_horizontal_diffraction = false - if (input['confDiffHorizontal']) { - compute_horizontal_diffraction = input['confDiffHorizontal'] - } - - - // ------------------------- - // Initialize some variables - // ------------------------- - - // Attenuation matrix table - List allLevels = new ArrayList<>() - // Set of already processed receivers - Set receivers = new HashSet<>() - - - // -------------------------------------------- - // Initialize NoiseModelling propagation part - // -------------------------------------------- - - PointNoiseMap pointNoiseMap = new PointNoiseMap(building_table_name, sources_table_name, receivers_table_name) - pointNoiseMap.setComputeHorizontalDiffraction(compute_horizontal_diffraction) - pointNoiseMap.setComputeVerticalDiffraction(compute_vertical_diffraction) - pointNoiseMap.setSoundReflectionOrder(reflexion_order) - // Building height field name - pointNoiseMap.setHeightField("HEIGHT") - // Import table with Snow, Forest, Grass, Pasture field polygons. Attribute G is associated with each polygon - if (ground_table_name != "") { - pointNoiseMap.setSoilTableName(ground_table_name) - } - // Point cloud height above sea level POINT(X Y Z) - if (dem_table_name != "") { - pointNoiseMap.setDemTable(dem_table_name) - } - - pointNoiseMap.setMaximumPropagationDistance(max_src_dist) - pointNoiseMap.setMaximumReflectionDistance(max_ref_dist) - pointNoiseMap.setWallAbsorption(wall_alpha) - pointNoiseMap.setThreadCount(n_thread) - - // Do not propagate for low emission or far away sources - // Maximum error in dB - pointNoiseMap.setMaximumError(0.0d) - // Init Map - pointNoiseMap.initialize(connection, new EmptyProgressVisitor()) - - - // -------------------------------------------- - // Initialize NoiseModelling emission part - // -------------------------------------------- - - WpsPropagationProcessDataProbaFactory wpsPropagationProcessDataProbaFactory = new WpsPropagationProcessDataProbaFactory() - pointNoiseMap.setPropagationProcessDataFactory(wpsPropagationProcessDataProbaFactory) - - // -------------------------------------------- - // Run Calculations - // -------------------------------------------- - - // Init ProgressLogger (loading bar) - RootProgressVisitor progressLogger = new RootProgressVisitor(1, true, 1) - ProgressVisitor progressVisitor = progressLogger.subProcess(pointNoiseMap.getGridDim() * pointNoiseMap.getGridDim()) - int fullGridSize = pointNoiseMap.getGridDim() * pointNoiseMap.getGridDim() - - System.println("Start calculation... ") - // Iterate over computation areas - int k=0 - for (int i = 0; i < pointNoiseMap.getGridDim(); i++) { - for (int j = 0; j < pointNoiseMap.getGridDim(); j++) { - System.println("Compute... " + 100*k++/fullGridSize + " % ") - - IComputeRaysOut out = pointNoiseMap.evaluateCell(connection, i, j, progressVisitor, receivers) - - if (out instanceof ComputeRaysOutAttenuation) { - allLevels.addAll(((ComputeRaysOutAttenuation) out).getVerticesSoundLevel()) - } - } - } - - System.out.println('Intermediate time : ' + TimeCategory.minus(new Date(), start)) - - System.println("Create the random road traffic table over the number of iterations... ") - - sql.execute("set @grid_density=10;\n" + - "create table TRAFIC_DENSITY (the_geom geometry, LV int, HV INT, SPEED double, DENSITY_LV double, DENSITY_HV double, DENSITY_TV double) as \n" + - " select THE_GEOM, TV_D - HV_D, HV_D , \n" + - " case when LV_SPD_D < 20 then 20 \n" + - " else LV_SPD_D end, \n" + - " case when LV_SPD_D < 20 then 0.001*(TV_D-HV_D)/20 \n" + - " else 0.001*(TV_D-HV_D)/LV_SPD_D end, \n" + - " case when HV_SPD_D < 20 then 0.001*HV_D/20 \n" + - " else 0.001*HV_D/HV_SPD_D end, \n" + - " case when LV_SPD_D< 20 then 0.001*(TV_D)/20 \n" + - " else 0.001*(TV_D)/LV_SPD_D end \n" + - " from " + sources_table_name + " WHERE (TV_D IS NOT NULL);" + - "drop table if exists traf_explode;\n" + - "create table traf_explode as SELECT * FROM ST_Explode('TRAFIC_DENSITY');\n" + - "alter table traf_explode add length double as select ST_LENGTH(the_geom) ;\n" + - "drop table grid_traf2 if exists;\n" + - "create table grid_traf2 (the_geom geometry, SPEED int, DENSITY_LV double, DENSITY_HV double, DENSITY_TV double) as SELECT ST_Tomultipoint(ST_Densify(the_geom, 10)), SPEED, DENSITY_LV, DENSITY_HV, DENSITY_TV from traf_explode;\n" + - "drop table grid_traf_tot if exists;\n" + - "create table grid_traf_tot as SELECT * from ST_explode('grid_traf2');\n" + - "alter table grid_traf_tot ADD number_veh double as select DENSITY_TV;\n" + - "drop table grid_traf2 if exists;\n" + - "drop table CARS2D if exists;\n" + - "create table CARS2D as SELECT ST_FORCE2D(the_geom) the_geom, speed, density_LV, density_HV, density_TV, explod_id exp_id, number_veh from grid_traf_tot WHERE DENSITY_TV > 0 and DENSITY_TV IS NOT NULL;\n" + - "alter table CARS2D add column PK serial ;\n" + - "drop table ROADS_PROBA if exists;\n" + - "create table ROADS_PROBA as SELECT ST_UPDATEZ(ST_FORCE3D(the_geom),0.05,1) the_geom,ST_Z(ST_AddZ(ST_FORCE3D(the_geom),0.05)) z, speed, density_LV LV, density_HV HV, DENSITY_TV TV, exp_id, number_veh from ST_Explode('CARS2D');\n" + - "alter table ROADS_PROBA add column PK serial ;\n" + - "drop table grid_traf_tot if exists;" + - "drop table CARS2D if exists;" + - "drop table grid_traf2 if exists;" + - "drop table if exists traf_explode;" + - "drop table TRAFIC_DENSITY if exists;") - - - ProbabilisticProcessData probabilisticProcessData = new ProbabilisticProcessData(); - probabilisticProcessData.setProbaTable("ROADS_PROBA", sql) - - sql.execute("drop table ROADS_PROBA if exists;") - - System.out.println('Intermediate time : ' + TimeCategory.minus(new Date(), start)) - System.out.println("Export data to table") - - sql.execute("drop table if exists L_PROBA;") - sql.execute("create table L_PROBA(IT integer, IDRECEIVER integer, Hz63 double precision, Hz125 double precision, Hz250 double precision, Hz500 double precision, Hz1000 double precision, Hz2000 double precision, Hz4000 double precision, Hz8000 double precision);") - def qry = 'INSERT INTO L_PROBA(IT , IDRECEIVER,Hz63, Hz125, Hz250, Hz500, Hz1000,Hz2000, Hz4000, Hz8000) VALUES (?,?,?,?,?,?,?,?,?,?);' - - k = 0 - for (int it = 1; it < nIterations; it++) { - // Iterate over attenuation matrix - Map soundLevels = new HashMap<>() - Map sourceLev = new HashMap<>() - - for (int i = 0; i < allLevels.size(); i++) { - k++ - - // get attenuation matrix value - double[] soundLevel = allLevels.get(i).value - - //get id from receiver and sound sources - int idReceiver = (Integer) allLevels.get(i).receiverId - int idSource = (Integer) allLevels.get(i).sourceId - - // get source SoundLevel - if (!sourceLev.containsKey(idSource)) { - double[] carsLevel = probabilisticProcessData.getCarsLevel(idSource) - sourceLev.put(idSource, carsLevel) - } - - if (sourceLev.get(idSource)[0] > 0) { - // if any attenuation matrix value is set to NaN - if (!Double.isNaN(soundLevel[0]) && !Double.isNaN(soundLevel[1]) - && !Double.isNaN(soundLevel[2]) && !Double.isNaN(soundLevel[3]) - && !Double.isNaN(soundLevel[4]) && !Double.isNaN(soundLevel[5]) - && !Double.isNaN(soundLevel[6]) && !Double.isNaN(soundLevel[7])) { - - if (soundLevels.containsKey(idReceiver)) { - // add Leq value to the pre-existing sound level on this receiver - double[] sumArray = tools.invokeMethod("sumArraySR", [soundLevel, sourceLev.get(idSource)]) - soundLevel = ComputeRays.sumDbArray(sumArray, soundLevels.get(idReceiver)) - soundLevels.replace(idReceiver, soundLevel) - } else { - // apply A ponderation - //soundLevel = DBToDBA(soundLevel) - // add a new Leq value on this receiver - double[] sumArray = tools.invokeMethod("sumArraySR", [soundLevel, sourceLev.get(idSource)]) - soundLevels.put(idReceiver, sumArray) - } - } - } - } - - sql.withBatch(100, qry) { ps -> - for (Map.Entry s : soundLevels.entrySet()) { - - ps.addBatch(it as Integer, s.key as Integer, - s.value[0] as Double, s.value[1] as Double, s.value[2] as Double, - s.value[3] as Double, s.value[4] as Double, s.value[5] as Double, - s.value[6] as Double, s.value[7] as Double) - - } - } - } - - - // Drop table LDEN_GEOM if exists - sql.execute("drop table if exists L_PROBA_GEOM;") - // Associate Geometry column to the table LDEN - sql.execute("CREATE INDEX ON L_PROBA(IDRECEIVER);") - sql.execute("CREATE INDEX ON RECEIVERS(PK);") - sql.execute("create table L_PROBA_GEOM as select a.IT,a.IDRECEIVER, b.THE_GEOM, a.Hz63, a.Hz125, a.Hz250, a.Hz500, a.Hz1000, a.Hz2000, a.Hz4000, a.Hz8000 FROM L_PROBA a LEFT JOIN RECEIVERS b ON a.IDRECEIVER = b.PK;") - - - resultString = "Calculation Done ! The table L_PROBA_GEOM has been created." - - // print to command window - System.out.println('Result : ' + resultString) - System.out.println('End : Traffic Probabilistic Modelling') - System.out.println('Duration : ' + TimeCategory.minus(new Date(), start)) - - // print to WPS Builder - return resultString -} - - - - - - -/** - * Read source database and compute the sound emission spectrum of roads sources - * */ -class WpsPropagationProcessDataProba extends CnossosPropagationData { - static List freq_lvl = Arrays.asList(CnossosPropagationData.asOctaveBands(CnossosPropagationData.DEFAULT_FREQUENCIES_THIRD_OCTAVE)) - - // Lden values - public List wjSourcesD = new ArrayList<>() - public List wjSourcesE = new ArrayList<>() - public List wjSourcesN = new ArrayList<>() - public List wjSourcesDEN = new ArrayList<>() - - public Map SourcesPk = new HashMap<>() - - public String inputFormat = "Proba" - int idSource = 0 - - WpsPropagationProcessDataProba(ProfileBuilder profileBuilder) { - super(profileBuilder) - } - - @Override - void addSource(Long pk, Geometry geom, SpatialResultSet rs) throws SQLException, IOException { - super.addSource(pk, geom, rs) - SourcesPk.put(pk, idSource++) - - def res = computeLw(inputFormat, rs) - wjSourcesD.add(res[0]) - wjSourcesE.add(res[1]) - wjSourcesN.add(res[2]) - wjSourcesDEN.add(res[3]) - } - - double[][] computeLw(String Format, SpatialResultSet rs) throws SQLException { - - // Compute day average level - double[] ld = new double[freq_lvl.size()] - double[] le = new double[freq_lvl.size()] - double[] ln = new double[freq_lvl.size()] - double[] lden = new double[freq_lvl.size()] - - if (Format == 'Proba') { - double val = ComputeRays.dbaToW((BigDecimal) 90.0) - ld = [val,val,val,val,val,val,val,val] - le = [val,val,val,val,val,val,val,val] - ln = [val,val,val,val,val,val,val,val] - } - - if (Format == 'EmissionDEN') { - // Read average 24h traffic - ld = [ComputeRays.dbaToW(rs.getDouble('LWD63')), - ComputeRays.dbaToW(rs.getDouble('LWD125')), - ComputeRays.dbaToW(rs.getDouble('LWD250')), - ComputeRays.dbaToW(rs.getDouble('LWD500')), - ComputeRays.dbaToW(rs.getDouble('LWD1000')), - ComputeRays.dbaToW(rs.getDouble('LWD2000')), - ComputeRays.dbaToW(rs.getDouble('LWD4000')), - ComputeRays.dbaToW(rs.getDouble('LWD8000'))] - - le = [ComputeRays.dbaToW(rs.getDouble('LWE63')), - ComputeRays.dbaToW(rs.getDouble('LWE125')), - ComputeRays.dbaToW(rs.getDouble('LWE250')), - ComputeRays.dbaToW(rs.getDouble('LWE500')), - ComputeRays.dbaToW(rs.getDouble('LWE1000')), - ComputeRays.dbaToW(rs.getDouble('LWE2000')), - ComputeRays.dbaToW(rs.getDouble('LWE4000')), - ComputeRays.dbaToW(rs.getDouble('LWE8000'))] - - ln = [ComputeRays.dbaToW(rs.getDouble('LWN63')), - ComputeRays.dbaToW(rs.getDouble('LWN125')), - ComputeRays.dbaToW(rs.getDouble('LWN250')), - ComputeRays.dbaToW(rs.getDouble('LWN500')), - ComputeRays.dbaToW(rs.getDouble('LWN1000')), - ComputeRays.dbaToW(rs.getDouble('LWN2000')), - ComputeRays.dbaToW(rs.getDouble('LWN4000')), - ComputeRays.dbaToW(rs.getDouble('LWN8000'))] - } - if (Format == 'Classic') { - // Get input traffic data - double tvD = rs.getDouble("TV_D") - double tvE = rs.getDouble("TV_E") - double tvN = rs.getDouble("TV_N") - - double hvD = rs.getDouble("HV_D") - double hvE = rs.getDouble("HV_E") - double hvN = rs.getDouble("HV_N") - - double lvSpeedD = rs.getDouble("LV_SPD_D") - double lvSpeedE = rs.getDouble("LV_SPD_E") - double lvSpeedN = rs.getDouble("LV_SPD_N") - - double hvSpeedD = rs.getDouble("HV_SPD_D") - double hvSpeedE = rs.getDouble("HV_SPD_E") - double hvSpeedN = rs.getDouble("HV_SPD_N") - - String pavement = rs.getString("PVMT") - - // this options can be activated if needed - double Temperature = 20.0d - double Ts_stud = 0 - double Pm_stud = 0 - double Junc_dist = 300 - int Junc_type = 0 - - // Day - int idFreq = 0 - for (int freq : freq_lvl) { - RoadCnossosParameters rsParametersCnossos = new RoadCnossosParameters(lvSpeedD, hvSpeedD, hvSpeedD, lvSpeedD, - lvSpeedD, Math.max(0, tvD - hvD), 0, hvD, 0, 0, freq, Temperature, - pavement, Ts_stud, Pm_stud, Junc_dist, Junc_type) - ld[idFreq++] += RoadCnossos.evaluate(rsParametersCnossos) - } - - // Evening - idFreq = 0 - for (int freq : freq_lvl) { - RoadCnossosParameters rsParametersCnossos = new RoadCnossosParameters(lvSpeedE, hvSpeedE, hvSpeedE, lvSpeedE, - lvSpeedE, Math.max(0, tvE - hvE), 0, hvE, 0, 0, freq, Temperature, - pavement, Ts_stud, Pm_stud, Junc_dist, Junc_type) - le[idFreq++] += RoadCnossos.evaluate(rsParametersCnossos) - } - - // Night - idFreq = 0 - for (int freq : freq_lvl) { - RoadCnossosParameters rsParametersCnossos = new RoadCnossosParameters(lvSpeedN, hvSpeedN, hvSpeedN, lvSpeedN, - lvSpeedN, Math.max(0, tvN - hvN), 0, hvN, 0, 0, freq, Temperature, - pavement, Ts_stud, Pm_stud, Junc_dist, Junc_type) - ln[idFreq++] += RoadCnossos.evaluate(rsParametersCnossos) - } - - - } - - if (Format == "AADF") { - String AAFD_FIELD_NAME = "AADF" - - // Annual Average Daily Flow (AADF) estimates - String ROAD_CATEGORY_FIELD_NAME = "CLAS_ADM" - def lv_hourly_distribution = [0.56, 0.3, 0.21, 0.26, 0.69, 1.8, 4.29, 7.56, 7.09, 5.5, 4.96, 5.04, - 5.8, 6.08, 6.23, 6.67, 7.84, 8.01, 7.12, 5.44, 3.45, 2.26, 1.72, 1.12]; - def hv_hourly_distribution = [1.01, 0.97, 1.06, 1.39, 2.05, 3.18, 4.77, 6.33, 6.72, 7.32, 7.37, 7.4, - 6.16, 6.22, 6.84, 6.74, 6.23, 4.88, 3.79, 3.05, 2.36, 1.76, 1.34, 1.07]; - - int LDAY_START_HOUR = 6 - int LDAY_STOP_HOUR = 18 - int LEVENING_STOP_HOUR = 22 - int[] nightHours = [22, 23, 0, 1, 2, 3, 4, 5] - double HV_PERCENTAGE = 0.1 - - int idSource = 0 - - idSource = idSource + 1 - // Read average 24h traffic - double tmja = rs.getDouble(AAFD_FIELD_NAME) - - //130 km/h 1:Autoroute - //80 km/h 2:Nationale - //50 km/h 3:Départementale - //50 km/h 4:Voirie CUN - //50 km/h 5:Inconnu - //50 km/h 6:Privée - //50 km/h 7:Communale - int road_cat = rs.getInt(ROAD_CATEGORY_FIELD_NAME) - - int roadType; - if (road_cat == 1) { - roadType = 10; - } else { - if (road_cat == 2) { - roadType = 42; - } else { - roadType = 62; - } - } - double speed_lv = 50; - if (road_cat == 1) { - speed_lv = 120; - } else { - if (road_cat == 2) { - speed_lv = 80; - } - } - - /** - * Vehicles category Table 3 P.31 CNOSSOS_EU_JRC_REFERENCE_REPORT - * lv : Passenger cars, delivery vans ≤ 3.5 tons, SUVs , MPVs including trailers and caravans - * mv: Medium heavy vehicles, delivery vans > 3.5 tons, buses, touring cars, etc. with two axles and twin tyre mounting on rear axle - * hgv: Heavy duty vehicles, touring cars, buses, with three or more axles - * wav: mopeds, tricycles or quads ≤ 50 cc - * wbv: motorcycles, tricycles or quads > 50 cc - * @param lv_speed Average light vehicle speed - * @param mv_speed Average medium vehicle speed - * @param hgv_speed Average heavy goods vehicle speed - * @param wav_speed Average light 2 wheels vehicle speed - * @param wbv_speed Average heavy 2 wheels vehicle speed - * @param lvPerHour Average light vehicle per hour - * @param mvPerHour Average heavy vehicle per hour - * @param hgvPerHour Average heavy vehicle per hour - * @param wavPerHour Average heavy vehicle per hour - * @param wbvPerHour Average heavy vehicle per hour - * @param FreqParam Studied Frequency - * @param Temperature Temperature (Celsius) - * @param roadSurface roadSurface empty default, NL01 FR01 .. - * @param Ts_stud A limited period Ts (in months) over the year where a average proportion pm of light vehicles are equipped with studded tyres and during . - * @param Pm_stud Average proportion of vehicles equipped with studded tyres - * @param Junc_dist Distance to junction - * @param Junc_type Type of junction ((k = 1 for a crossing with traffic lights ; k = 2 for a roundabout) - */ - - double lvPerHour = 0; - double mvPerHour = 0; - double hgvPerHour = 0; - double wavPerHour = 0; - double wbvPerHour = 0; - double Temperature = 20.0d; - String roadSurface = "FR_R2"; - double Ts_stud = 0.5; - double Pm_stud = 4; - double Junc_dist = 0; - int Junc_type = 0; - double slopePercentage = 0; - double speedLv = speed_lv; - double speedMv = speed_lv; - double speedHgv = speed_lv; - double speedWav = speed_lv; - double speedWbv = speed_lv; - - for (int h = LDAY_START_HOUR; h < LDAY_STOP_HOUR; h++) { - lvPerHour = tmja * (1 - HV_PERCENTAGE) * (lv_hourly_distribution[h] / 100.0); - hgvPerHour = tmja * HV_PERCENTAGE * (hv_hourly_distribution[h] / 100.0); - int idFreq = 0; - for (int freq : freq_lvl) { - RoadCnossosParameters rsParametersCnossos = new RoadCnossosParameters(speedLv, speedMv, speedHgv, speedWav, - speedWbv, lvPerHour, mvPerHour, hgvPerHour, wavPerHour, wbvPerHour, freq, Temperature, - roadSurface, Ts_stud, Pm_stud, Junc_dist, Junc_type); - rsParametersCnossos.setSpeedFromRoadCaracteristics(speed_lv, speed_lv, false, speed_lv, roadType); - ld[idFreq++] += RoadCnossos.evaluate(rsParametersCnossos) - } - } - // Average - for (int i = 0; i < ld.length; i++) { - ld[i] = ld[i] / (LDAY_STOP_HOUR - LDAY_START_HOUR); - } - - // Evening - for (int h = LDAY_STOP_HOUR; h < LEVENING_STOP_HOUR; h++) { - lvPerHour = tmja * (1 - HV_PERCENTAGE) * (lv_hourly_distribution[h] / 100.0) - mvPerHour = tmja * HV_PERCENTAGE * (hv_hourly_distribution[h] / 100.0) - int idFreq = 0 - for (int freq : freq_lvl) { - RoadCnossosParameters rsParametersCnossos = new RoadCnossosParameters(speedLv, speedMv, speedHgv, speedWav, - speedWbv, lvPerHour, mvPerHour, hgvPerHour, wavPerHour, wbvPerHour, freq, Temperature, - roadSurface, Ts_stud, Pm_stud, Junc_dist, Junc_type); - rsParametersCnossos.setSpeedFromRoadCaracteristics(speed_lv, speed_lv, false, speed_lv, roadType) - le[idFreq++] += RoadCnossos.evaluate(rsParametersCnossos) - } - } - - for (int i = 0; i < le.size(); i++) { - le[i] = (le[i] / (LEVENING_STOP_HOUR - LDAY_STOP_HOUR)) - } - - // Night - for (int h : nightHours) { - lvPerHour = tmja * (1 - HV_PERCENTAGE) * (lv_hourly_distribution[h] / 100.0) - mvPerHour = tmja * HV_PERCENTAGE * (hv_hourly_distribution[h] / 100.0) - int idFreq = 0 - for (int freq : freq_lvl) { - RoadCnossosParameters rsParametersCnossos = new RoadCnossosParameters(speedLv, speedMv, speedHgv, speedWav, - speedWbv, lvPerHour, mvPerHour, hgvPerHour, wavPerHour, wbvPerHour, freq, Temperature, - roadSurface, Ts_stud, Pm_stud, Junc_dist, Junc_type); - rsParametersCnossos.setSpeedFromRoadCaracteristics(speed_lv, speed_lv, false, speed_lv, roadType) - ln[idFreq++] += RoadCnossos.evaluate(rsParametersCnossos) - } - } - for (int i = 0; i < ln.size(); i++) { - ln[i] = (ln[i] / nightHours.length) - } - } - - int idFreq = 0 - // Combine day evening night sound levels - for (int freq : freq_lvl) { - lden[idFreq++] = (12 * ld[idFreq] + 4 * ComputeRays.dbaToW(ComputeRays.wToDba(le[idFreq]) + 5) + 8 * ComputeRays.dbaToW(ComputeRays.wToDba(ln[idFreq]) + 10)) / 24.0 - } - - return [ld, le, ln, lden] - } - - - @Override - double[] getMaximalSourcePower(int sourceId) { - return wjSourcesD.get(sourceId) - } -} - -class WpsPropagationProcessDataProbaFactory implements PointNoiseMap.PropagationProcessDataFactory { - - @Override - CnossosPropagationData create(ProfileBuilder builder) { - return new WpsPropagationProcessDataProba(builder) - } - - @Override - void initialize(Connection connection, PointNoiseMap pointNoiseMap) throws SQLException { - - } -} - - -/** - * - */ -class ProbabilisticProcessData { - - Map SPEED_LV = new HashMap<>() - Map SPEED_HV = new HashMap<>() - Map LV = new HashMap<>() - Map HV = new HashMap<>() - - double[] getCarsLevel(int idSource) throws SQLException { - double[] res_d = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0] - double[] res_LV = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0] - double[] res_HV = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0] - def list = [63, 125, 250, 500, 1000, 2000, 4000, 8000] - // memes valeurs d e et n - - - def random = Math.random() - if (random < LV.get(idSource)) { - int kk = 0 - for (f in list) { - - double speed = SPEED_LV.get(idSource) - int acc = 0 - int FreqParam = f - double Temperature = 20 - String RoadSurface = "DEF" - boolean Stud = true - double Junc_dist = 200 - int Junc_type = 1 - String veh_type = "1" - int acc_type = 1 - double LwStd = 1 - int VehId = 10 - - RoadVehicleCnossosvarParameters rsParameters = new RoadVehicleCnossosvarParameters(speed, acc, veh_type, acc_type, FreqParam, Temperature, RoadSurface, Stud, Junc_dist, Junc_type, LwStd, VehId) - rsParameters.setSlopePercentage(0) - - res_LV[kk] = RoadVehicleCnossosvar.evaluate(rsParameters) - kk++ - } - - } - if (random < HV.get(idSource)) { - int kk = 0 - for (f in list) { - double speed = SPEED_HV.get(idSource) - int acc = 0 - int FreqParam = f - double Temperature = 20 - String RoadSurface = "DEF" - boolean Stud = true - double Junc_dist = 200 - int Junc_type = 1 - String veh_type = "3" - int acc_type = 1 - double LwStd = 1 - int VehId = 10 - - RoadVehicleCnossosvarParameters rsParameters = new RoadVehicleCnossosvarParameters(speed, acc, veh_type, acc_type, FreqParam, Temperature, RoadSurface, Stud, Junc_dist, Junc_type, LwStd, VehId) - rsParameters.setSlopePercentage(0) - - res_HV[kk] = RoadVehicleCnossosvar.evaluate(rsParameters) - kk++ - } - } - int kk = 0 - for (f in list) { - res_d[kk] = 10 * Math.log10( - (1.0 / 2.0) * - (Math.pow(10, (10 * Math.log10(Math.pow(10, res_LV[kk] / 10))) / 10) - + Math.pow(10, (10 * Math.log10(Math.pow(10, res_HV[kk] / 10))) / 10) - ) - ) - kk++ - } - - - return res_d - } - - void setProbaTable(String tablename, Sql sql) { - ////////////////////// - // Import file text - ////////////////////// - - // Remplissage des variables avec le contenu du fichier plan d'exp - sql.eachRow('SELECT PK, SPEED, HV,LV FROM ' + tablename + ';') { row -> - int pk = (int) row[0] - - SPEED_HV.put(pk, (double) row[1]) - SPEED_LV.put(pk, (double) row[1]) - HV.put(pk, (double) row[2]) - LV.put(pk, (double) row[3]) - - } - - - } - -} \ No newline at end of file diff --git a/wps_scripts/src/test/groovy/org/noise_planet/noisemodelling/wps/JdbcTestCase.groovy b/wps_scripts/src/test/groovy/org/noise_planet/noisemodelling/wps/JdbcTestCase.groovy index fe65d4c62..9b5dbf8e9 100644 --- a/wps_scripts/src/test/groovy/org/noise_planet/noisemodelling/wps/JdbcTestCase.groovy +++ b/wps_scripts/src/test/groovy/org/noise_planet/noisemodelling/wps/JdbcTestCase.groovy @@ -26,7 +26,8 @@ class JdbcTestCase extends GroovyTestCase { @Before void setUp() { - connection = JDBCUtilities.wrapConnection(H2GISDBFactory.createSpatialDataBase(UUID.randomUUID().toString().replace("-", ""), true)) + // connection = JDBCUtilities.wrapConnection(H2GISDBFactory.createSpatialDataBase(UUID.randomUUID().toString().replace("-", ""), true)) + connection = JDBCUtilities.wrapConnection(H2GISDBFactory.createSpatialDataBase("test", true)) } @After diff --git a/wps_scripts/src/test/groovy/org/noise_planet/noisemodelling/wps/TestNoiseModelling.groovy b/wps_scripts/src/test/groovy/org/noise_planet/noisemodelling/wps/TestNoiseModelling.groovy index 1b95bd361..dd68cffc2 100644 --- a/wps_scripts/src/test/groovy/org/noise_planet/noisemodelling/wps/TestNoiseModelling.groovy +++ b/wps_scripts/src/test/groovy/org/noise_planet/noisemodelling/wps/TestNoiseModelling.groovy @@ -14,13 +14,17 @@ package org.noise_planet.noisemodelling.wps import groovy.sql.Sql import org.h2.value.ValueBoolean -import org.h2gis.functions.io.dbf.DBFRead import org.h2gis.functions.io.shp.SHPRead import org.h2gis.utilities.JDBCUtilities import org.junit.Test +import org.noise_planet.noisemodelling.wps.Acoustic_Tools.DynamicIndicators +import org.noise_planet.noisemodelling.wps.Experimental.Noise_Map_Difference +import org.noise_planet.noisemodelling.wps.Experimental_Matsim.Noise_From_Attenuation_Matrix_MatSim import org.noise_planet.noisemodelling.wps.Geometric_Tools.Set_Height import org.noise_planet.noisemodelling.wps.Import_and_Export.Import_File import org.noise_planet.noisemodelling.wps.Import_and_Export.Export_Table +import org.noise_planet.noisemodelling.wps.NoiseModelling.Dynamic_Road_Emission_from_Traffic +import org.noise_planet.noisemodelling.wps.NoiseModelling.Noise_From_Attenuation_Matrix import org.noise_planet.noisemodelling.wps.NoiseModelling.Noise_level_from_source import org.noise_planet.noisemodelling.wps.NoiseModelling.Noise_level_from_traffic import org.noise_planet.noisemodelling.wps.NoiseModelling.Railway_Emission_from_Traffic @@ -45,6 +49,110 @@ class TestNoiseModelling extends JdbcTestCase { assertEquals("Calculation Done ! The table LW_ROADS has been created.", res) } + @Test + void testDynamicRoadEmission() { + + SHPRead.importTable(connection, TestDatabaseManager.getResource("ROADS2.shp").getPath()) + + String res = new Dynamic_Road_Emission_from_Traffic().exec(connection, + ["tableRoads": "ROADS2", + "method" : "oj", + "timestep" : 1, + "gridStep":10, + "duration":100]) + + + assertEquals("Calculation Done ! The table LW_DYNAMIC_GEOM has been created.", res) + } + + @Test + void testDynamicRoadEmissionPropagation() { + + SHPRead.importTable(connection, TestDatabaseManager.getResource("ROADS2.shp").getPath()) + + new Import_File().exec(connection, + ["pathFile" : TestNoiseModelling.getResource("buildings.shp").getPath(), + "inputSRID": "2154", + "tableName": "buildings"]) + + new Import_File().exec(connection, + ["pathFile" : TestNoiseModelling.getResource("receivers.shp").getPath(), + "inputSRID": "2154", + "tableName": "receivers"]) + new Set_Height().exec(connection, + [ "tableName":"RECEIVERS", + "height": 1 + ] + ) + + String res = new Dynamic_Road_Emission_from_Traffic().exec(connection, + ["tableRoads": "ROADS2", + "method" : "PROBA", + "timestep" : 1, + "gridStep":20, + "duration":100]) + + res = new Noise_level_from_source().exec(connection, + ["tableBuilding" : "BUILDINGS", + "tableSources" : "ALL_VEH_POS_0DB", + "tableReceivers": "RECEIVERS", + "confMaxSrcDist" : 100, + "confDiffHorizontal" : false, + "confExportSourceId": true, + "confSkipLevening":true, + "confSkipLnight":true, + "confSkipLden":true + ]) + + res = new Noise_From_Attenuation_Matrix().exec(connection, + ["lwTable" : "LW_DYNAMIC_GEOM", + "attenuationTable" : "LDAY_GEOM", + "outputTable" : "LT_GEOM_PROBA" + ]) + + + res = new DynamicIndicators().exec(connection, + ["tableName" : "LT_GEOM_PROBA", + "columnName" : "LEQA" + ]) + + + res = new Dynamic_Road_Emission_from_Traffic().exec(connection, + ["tableRoads": "ROADS2", + "method" : "VALENTIN", + "timestep" : 1, + "gridStep":20, + "duration":100]) + + res = new Noise_level_from_source().exec(connection, + ["tableBuilding" : "BUILDINGS", + "tableSources" : "ALL_VEH_POS_0DB", + "tableReceivers": "RECEIVERS", + "confMaxSrcDist" : 100, + "confDiffHorizontal" : false, + "confExportSourceId": true, + "confSkipLevening":true, + "confSkipLnight":true, + "confSkipLden":true + ]) + + + res = new Noise_From_Attenuation_Matrix().exec(connection, + ["lwTable" : "LW_DYNAMIC_GEOM", + "attenuationTable" : "LDAY_GEOM", + "outputTable" : "LT_GEOM_VAL" + ]) + + res = new DynamicIndicators().exec(connection, + ["tableName" : "LT_GEOM_VAL", + "columnName" : "LEQA" + ]) + + + + + assertEquals("The columns LEQA and LEQ have been added to the table: LT_GEOM_VAL.", res) + } @Test void testRailWayEmissionFromDEN() { diff --git a/wps_scripts/src/test/resources/org/noise_planet/noisemodelling/wps/ROADS2.dbf b/wps_scripts/src/test/resources/org/noise_planet/noisemodelling/wps/ROADS2.dbf index 04c11939ae40ea5a4cf7be770975d8f918c473ff..ed6e49dd69b6965157d7994874793ff26424b0e0 100644 GIT binary patch delta 301 zcmca}SMttXNfzcBCiaOeG4(!S@h%Jy;0B^Z1fe`A1(bJ%GI7cK;gk1phg*P6zdi#< z0n`R;3c&JE8-VhY`523RfjWW%TtM!|sRJYrG!?Hr&{Uv&^Et-$bBrL&1jNih%mT!$ L+s`qw@#O*l$!8^N delta 301 zcmca}SMttXNfu^dZjp&BG4&x~@h%Jy;3mMxz#t+B-KYuY<#%@Yj-E3 From 695a88707a38b2d3408e264b831331716d531650 Mon Sep 17 00:00:00 2001 From: Pierre Aumond Date: Wed, 11 Sep 2024 13:32:22 +0200 Subject: [PATCH 2/3] For Pedestrian --- .../ZerodB_Source.groovy} | 16 +- .../Import_OSM_Pedestrian.groovy | 69 +- ...es_Emission_from_PedestrianActivity.groovy | 372 + .../wps/Receivers/Building_Grid3D.groovy | 3 +- .../Source_Activity/PedestrianActivity.groovy | 709 ++ .../main/resources/VoiceModel/BDD_Info.json | 98 + .../resources/VoiceModel/Spectrums_500ms.json | 7716 +++++++++++++++++ .../wps/TestNoiseModelling.groovy | 111 +- 8 files changed, 9042 insertions(+), 52 deletions(-) rename wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/{Geometric_Tools/ZerodB_Source_From_Roads.groovy => Acoustic_Tools/ZerodB_Source.groovy} (91%) create mode 100644 wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/NoiseModelling/Dynamic_Voices_Emission_from_PedestrianActivity.groovy create mode 100644 wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/Source_Activity/PedestrianActivity.groovy create mode 100644 wps_scripts/src/main/resources/VoiceModel/BDD_Info.json create mode 100644 wps_scripts/src/main/resources/VoiceModel/Spectrums_500ms.json diff --git a/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/Geometric_Tools/ZerodB_Source_From_Roads.groovy b/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/Acoustic_Tools/ZerodB_Source.groovy similarity index 91% rename from wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/Geometric_Tools/ZerodB_Source_From_Roads.groovy rename to wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/Acoustic_Tools/ZerodB_Source.groovy index 76a7cf709..de19263cc 100644 --- a/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/Geometric_Tools/ZerodB_Source_From_Roads.groovy +++ b/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/Acoustic_Tools/ZerodB_Source.groovy @@ -13,7 +13,7 @@ * @Author Valentin Le Bescond, Université Gustave Eiffel */ -package org.noise_planet.noisemodelling.wps.Geometric_Tools +package org.noise_planet.noisemodelling.wps.Acoustic_Tools import geoserver.GeoServer import geoserver.catalog.Store @@ -25,17 +25,17 @@ import org.slf4j.LoggerFactory import java.sql.Connection -title = 'Create 0db Source From Roads' -description = '➡️ Creates a SOURCE table from a ROAD table.' + +title = 'Create 0db Source table' +description = '➡️ Creates a SOURCE table' + '
' + 'The SOURCE table can then be used in the Noise_level_from_source WPS block with the "confExportSourceId" set to true.

' + 'The Noise_level_from_source output will contain a list of "source-receiver" attenuation matrix independent of the source absolute noise power levels.' inputs = [ - roadsTableName: [ + tableName: [ name: 'Input table name', title: 'Intput table name', - description: 'Name of the Roads table.

' + + description: 'Name of the table.

' + 'Must contain at least:
'+ '- PK: identifier with a Primary Key constraint
' + '- THE_GEOM: geometric column', @@ -93,7 +93,7 @@ def exec(connection, input) { logger.info('Start : Create_0db_Source_From_Roads') logger.info("inputs {}", input) - String roadsTableName = input['roadsTableName'] + String tableName = input['tableName'] String sourcesTableName = input['sourcesTableName'] @@ -110,12 +110,12 @@ def exec(connection, input) { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 - FROM ''' + roadsTableName + ''' + FROM ''' + tableName + ''' ;''' sql.execute(query) - logger.info('End : Create_0db_Source_From_Roads') + logger.info('End : Create_0db_Source') resultString = "Process done. Table " + sourcesTableName + " created !" logger.info('Result : ' + resultString) return resultString diff --git a/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/Import_and_Export/Import_OSM_Pedestrian.groovy b/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/Import_and_Export/Import_OSM_Pedestrian.groovy index ec3876337..2625fa38f 100644 --- a/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/Import_and_Export/Import_OSM_Pedestrian.groovy +++ b/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/Import_and_Export/Import_OSM_Pedestrian.groovy @@ -9,65 +9,60 @@ * Contact: contact@noise-planet.org * */ + /** * @Author Pierre Aumond, Université Gustave Eiffel - * @Author Nicolas Fortin, Université Gustave Eiffel - * @Author Gwendall Petit, Cerema - * @Author Part of this file are inspired of https://github.com/orbisgis/geoclimate/wiki + * @Author Jonathan Siliezar, Université Gustave Eiffel + * @Author buildingParams.json is from https://github.com/orbisgis/geoclimate/ */ -package org.noise_planet.noisemodelling.wps.Import_and_Export; +package org.noise_planet.noisemodelling.wps.Import_and_Export -import geoserver.GeoServer; +import crosby.binary.osmosis.OsmosisReader +import geoserver.GeoServer import geoserver.catalog.Store -import groovy.json.JsonSlurper; +import groovy.json.JsonSlurper import groovy.sql.Sql import org.geotools.jdbc.JDBCDataStore -import org.h2gis.utilities.wrapper.ConnectionWrapper; -import org.locationtech.jts.geom.Geometry -import org.locationtech.jts.geom.GeometryFactory; +import org.h2gis.utilities.wrapper.ConnectionWrapper import org.locationtech.jts.geom.Coordinate -import org.openstreetmap.osmosis.core.container.v0_6.EntityContainer; -import org.openstreetmap.osmosis.core.container.v0_6.NodeContainer; -import org.openstreetmap.osmosis.core.container.v0_6.RelationContainer; -import org.openstreetmap.osmosis.core.container.v0_6.WayContainer; -import org.openstreetmap.osmosis.core.domain.v0_6.Tag; -import org.openstreetmap.osmosis.core.domain.v0_6.Way; -import org.openstreetmap.osmosis.core.domain.v0_6.Relation; -import org.openstreetmap.osmosis.core.domain.v0_6.WayNode; -import org.openstreetmap.osmosis.core.domain.v0_6.Node; -import org.openstreetmap.osmosis.core.task.v0_6.Sink; - -import org.openstreetmap.osmosis.xml.v0_6.XmlReader; -import org.openstreetmap.osmosis.xml.common.CompressionMethod; - -import crosby.binary.osmosis.OsmosisReader +import org.locationtech.jts.geom.Geometry +import org.locationtech.jts.geom.GeometryFactory +import org.openstreetmap.osmosis.core.container.v0_6.EntityContainer +import org.openstreetmap.osmosis.core.container.v0_6.NodeContainer +import org.openstreetmap.osmosis.core.container.v0_6.RelationContainer +import org.openstreetmap.osmosis.core.container.v0_6.WayContainer +import org.openstreetmap.osmosis.core.domain.v0_6.* +import org.openstreetmap.osmosis.core.task.v0_6.Sink +import org.openstreetmap.osmosis.xml.common.CompressionMethod +import org.openstreetmap.osmosis.xml.v0_6.XmlReader import org.slf4j.Logger -import org.slf4j.LoggerFactory; +import org.slf4j.LoggerFactory import java.sql.Connection title = 'Import Pedestrian tables from OSM' -description = '➡️ Convert .osm, .osm.gz or .osm.pbf file into NoiseModelling input tables.

' + +description = 'Convert .osm, .osm.gz or .osm.pbf file into NoiseModelling input tables dedicated for pedestrian voices simulation.

' + 'The following output tables will be created:
' + - '- BUILDINGS : a table containing the buildings
' + - '💡 The user can choose to avoid creating some of these tables by checking the dedicated boxes' + '- PEDESTRIAN_AREA : a table containing the area where pedestrians can move, sit, talk, etc.
' + '- PEDESTRIAN_WAYS : a table containing the ways where pedestrians can move, sit, talk, etc.
' + '- PEDESTRIAN_POIS : a table containing the point of interests to estimate pedestrians density
' inputs = [ pathFile : [ name : 'Path of the OSM file', title : 'Path of the OSM file', - description: '📂 Path of the OSM file, including its extension (.osm, .osm.gz or .osm.pbf).
' + + description: 'Path of the OSM file, including its extension (.osm, .osm.gz or .osm.pbf).
' + 'For example: c:/home/area.osm.pbf', type : String.class ], targetSRID : [ name : 'Target projection identifier', title : 'Target projection identifier', - description: '🌍 Target projection identifier (also called SRID) of your table.
' + + description: 'arget projection identifier (also called SRID) of your table.
' + 'It should be an EPSG code, an integer with 4 or 5 digits (ex: 3857 is Web Mercator projection).

' + - '❗ The target SRID must be in metric coordinates.', + 'The target SRID must be in metric coordinates.', type : Integer.class ] ] @@ -143,8 +138,8 @@ def exec(Connection connection, input) { } OsmHandlerPedestrian handler = new OsmHandlerPedestrian(logger) - reader.setSink(handler); - reader.run(); + reader.setSink(handler) + reader.run() logger.info('OSM Read done') @@ -162,6 +157,7 @@ def exec(Connection connection, input) { sql.execute("INSERT INTO " + tableName + " VALUES (" + building.id + ", ST_MakeValid(ST_SIMPLIFYPRESERVETOPOLOGY(ST_Transform(ST_GeomFromText('" + building.geom + "', 4326), "+srid+"),0.1)), " + building.height + ")") } + // CREATE BUILDING TABLE sql.execute(''' CREATE SPATIAL INDEX IF NOT EXISTS BUILDINGS_INDEX ON ''' + tableName + '''(the_geom); -- List buildings that intersects with other buildings that have a greater area @@ -394,7 +390,8 @@ def exec(Connection connection, input) { return resultString } -public class OsmHandlerPedestrian implements Sink { +// get all osm objects link with pedestrians +class OsmHandlerPedestrian implements Sink { public int nb_ways = 0; public int nb_nodes = 0; @@ -424,11 +421,11 @@ public class OsmHandlerPedestrian implements Sink { } @Override - public void initialize(Map arg0) { + void initialize(Map arg0) { } @Override - public void process(EntityContainer entityContainer) { + void process(EntityContainer entityContainer) { if (entityContainer instanceof NodeContainer) { nb_nodes++; Node node = ((NodeContainer) entityContainer).getEntity(); diff --git a/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/NoiseModelling/Dynamic_Voices_Emission_from_PedestrianActivity.groovy b/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/NoiseModelling/Dynamic_Voices_Emission_from_PedestrianActivity.groovy new file mode 100644 index 000000000..a4a207173 --- /dev/null +++ b/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/NoiseModelling/Dynamic_Voices_Emission_from_PedestrianActivity.groovy @@ -0,0 +1,372 @@ +/** + * NoiseModelling is an open-source tool designed to produce environmental noise maps on very large urban areas. It can be used as a Java library or be controlled through a user friendly web interface. + * + * This version is developed by the DECIDE team from the Lab-STICC (CNRS) and by the Mixt Research Unit in Environmental Acoustics (Université Gustave Eiffel). + * + * + * NoiseModelling is distributed under GPL 3 license. You can read a copy of this License in the file LICENCE provided with this software. + * + * Contact: contact@noise-planet.org + * + */ + +/** + * @Author Pierre Aumond, Université Gustave Eiffel + */ + +package org.noise_planet.noisemodelling.wps.NoiseModelling + +import crosby.binary.osmosis.OsmosisReader +import geoserver.GeoServer +import geoserver.catalog.Store +import groovy.sql.Sql +import org.geotools.jdbc.JDBCDataStore +import org.h2gis.utilities.JDBCUtilities +import org.h2gis.utilities.GeometryTableUtilities +import org.h2gis.utilities.SpatialResultSet +import org.h2gis.utilities.TableLocation +import org.h2gis.utilities.wrapper.ConnectionWrapper +import org.locationtech.jts.geom.Geometry + +import org.noise_planet.noisemodelling.emission.* +import org.noise_planet.noisemodelling.pathfinder.* +import org.noise_planet.noisemodelling.propagation.* +import org.noise_planet.noisemodelling.jdbc.* +import org.noise_planet.noisemodelling.pathfinder.utils.PowerUtils + +import org.slf4j.Logger +import org.slf4j.LoggerFactory + +import java.sql.Connection +import java.sql.PreparedStatement +import java.sql.ResultSet +import java.sql.SQLException +import groovy.json.JsonSlurper + +title = 'Compute voice emission noise map from pedestrians table.' +description = '➡️ -----------details).
' + + '
' + + '✅ The output table is called: LW_PEDESTRIAN ' + +inputs = [ + + pathBDD: [ + name : 'pathBDD table name', + title : 'pathBDD table name', + description: "Name of the Pedestrians table.
" + + "
This function recognize the following columns (* mandatory) :
    " + + "
  • PK * : an identifier. It shall be a primary key (INTEGER, PRIMARY KEY)
    • " + + "

This table can be generated from the WPS Block 'PedestrianLocalisation'. .", + type : String.class, + min : 0, max: 1 + ], + + pathSpectrums: [ + name : 'pathSpectrums table name', + title : 'pathSpectrums table name', + description: "Name of the Pedestrians table.
" + + "
This function recognize the following columns (* mandatory) :
    " + + "
  • PK * : an identifier. It shall be a primary key (INTEGER, PRIMARY KEY)
    • " + + "

This table can be generated from the WPS Block 'PedestrianLocalisation'. .", + type : String.class, + min : 0, max: 1 + ], + + tablePedestrian: [ + name : 'Pedestrians table name', + title : 'Pedestrians table name', + description: "Name of the Pedestrians table.
" + + "
This function recognize the following columns (* mandatory) :
    " + + "
  • PK * : an identifier. It shall be a primary key (INTEGER, PRIMARY KEY)
    • " + + "

This table can be generated from the WPS Block 'PedestrianLocalisation'. .", + type : String.class + ], + populationDistribution: [ + name : 'Population distribution', + title : 'Population distribution', + description: "This parameter allows the user to populate the area in terms of 3 different types of voice:
" + + "
Male, Female, Children
    " + + "
  • This is an optional input parameter
    • " + + "
  • This variable takes the percentage (%) of male, female and children in the study area
    • " + + "
  • The percentages should be separated by a coma (H,F,C)
    • ", + type : Double.class, + min : 0, max: 1 + ] +] + +outputs = [ + result: [ + name : 'Result output string', + title : 'Result output string', + description: 'This type of result does not allow the blocks to be linked together.', + type : String.class + ] +] +// Open Connection to Geoserver +static Connection openGeoserverDataStoreConnection(String dbName) { + if (dbName == null || dbName.isEmpty()) { + dbName = new GeoServer().catalog.getStoreNames().get(0) + } + Store store = new GeoServer().catalog.getStore(dbName) + JDBCDataStore jdbcDataStore = (JDBCDataStore) store.getDataStoreInfo().getDataStore(null) + return jdbcDataStore.getDataSource().getConnection() +} + +// run the script +def run(input) { + + // Get name of the database + // by default an embedded h2gis database is created + // Advanced user can replace this database for a postGis or h2Gis server database. + String dbName = "h2gisdb" + + // Open connection + openGeoserverDataStoreConnection(dbName).withCloseable { + Connection connection -> + return [result: exec(connection, input)] + } +} + +// main function of the script +def exec(Connection connection, input) { + + //Need to change the ConnectionWrapper to WpsConnectionWrapper to work under postGIS database + connection = new ConnectionWrapper(connection) + + // output string, the information given back to the user + String resultString = null + + // Create a logger to display messages in the geoserver logs and in the command prompt. + Logger logger = LoggerFactory.getLogger("org.noise_planet.noisemodelling") + + // print to command window + logger.info('Start : Pedestrian Emission') + logger.info("inputs {}", input) // log inputs of the run + + + // ------------------- + // Get every inputs + // ------------------- + def BDD_Info = null + def spectrumDB = null + if (input['pathBDD']!=null){ + // Read the database info table. This table contains the information of the audio database + BDD_Info = new JsonSlurper().parse(new File(input['pathBDD'] as String)) + logger.info('\nTHIS IS THE BDD_INFO FILE : ' + BDD_Info) + } + if (input['pathBDD']!=null){ + // Read the spectrum table. This table contains the spectrum of the voice database + spectrumDB = new JsonSlurper().parse(new File( input['pathSpectrums'] as String)) + logger.info('\nTHIS IS THE spectrumDB FILE : ' + spectrumDB) + } + String sources_table_name = input['tablePedestrian'] + // do it case-insensitive + sources_table_name = sources_table_name.toUpperCase() + // Check if srid are in metric projection. + int sridSources = GeometryTableUtilities.getSRID(connection, TableLocation.parse(sources_table_name)) + if (sridSources == 3785 || sridSources == 4326) throw new IllegalArgumentException("Error : Please use a metric projection for "+sources_table_name+".") + if (sridSources == 0) throw new IllegalArgumentException("Error : The table "+sources_table_name+" does not have an associated SRID.") + + //Get the geometry field of the source table + TableLocation sourceTableIdentifier = TableLocation.parse(sources_table_name) + List geomFields = GeometryTableUtilities.getGeometryColumnNames(connection, sourceTableIdentifier) + if (geomFields.isEmpty()) { + throw new SQLException(String.format("The table %s does not exists or does not contain a geometry field", sourceTableIdentifier)) + } + + //Get the primary key field of the source table + int pkIndex = JDBCUtilities.getIntegerPrimaryKey(connection, TableLocation.parse( sources_table_name)) + if (pkIndex < 1) { + throw new IllegalArgumentException(String.format("Source table %s does not contain a primary key", sourceTableIdentifier)) + } + + + // ------------------- + // Init table LW_ROADS + // ------------------- + + // Create a sql connection to interact with the database in SQL + Sql sql = new Sql(connection) + + // drop table LW_PEDESTRIAN if exists and then create and prepare the table + sql.execute("drop table if exists LW_PEDESTRIAN;") + sql.execute("create table LW_PEDESTRIAN (pk integer, the_geom Geometry, " + + "HZ63 double precision, HZ125 double precision, HZ250 double precision, HZ500 double precision, HZ1000 double precision, HZ2000 double precision, HZ4000 double precision, HZ8000 double precision," + + "TIMESTEP VARCHAR);") + + def qry = 'INSERT INTO LW_PEDESTRIAN(pk,the_geom, ' + + 'HZ63, HZ125, HZ250, HZ500, HZ1000,HZ2000, HZ4000, HZ8000,' + + 'TIMESTEP) ' + + 'VALUES (?,?,?,?,?,?,?,?,?,?,?);' + + + // -------------------------------------- + // Start calculation and fill the table + // -------------------------------------- + + + if (spectrumDB!=null){ + // We create a new table BDD_INFO in SQL that we are going to populate next + sql.execute("DROP TABLE IF EXISTS BDD_INFO;") + sql.execute("CREATE TABLE BDD_INFO (ID integer, NbPers_min integer, NbPers_max integer);") + + // We convert the Spectrum object into SQL in order to perform basic operations (T4) + BDD_Info.each { bdd -> + sql.execute(""" + INSERT INTO BDD_INFO (ID, NbPers_min,NbPers_max) + VALUES (?, ?,?) + """, [bdd.ID, bdd.NbPers_min, bdd.NbPers_max]) + } + } + def dataType = BDD_Info.getClass().getName() + println("data type: $dataType") + + if (spectrumDB!=null){ + // We create a new table Spectrum in SQL that we are going to populate next + sql.execute("DROP TABLE IF EXISTS Voice_SPECTRUM;") + sql.execute("CREATE TABLE Voice_SPECTRUM(ID_g integer, ID_File integer, HZ63 double, HZ125 double, HZ250 double, HZ500 double, HZ1000 double, HZ2000 double, HZ4000 double, HZ8000 double," + + "Alpha double, T integer);") + + // We convert the Spectrum object into SQL in order to perform basic operations (T5) + spectrumDB.each { spect -> + sql.execute(""" + INSERT INTO Voice_SPECTRUM(ID_g, ID_File, HZ63, HZ125, HZ250, HZ500, HZ1000, HZ2000, HZ4000, HZ8000, Alpha, T) + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) + """, [spect.ID_g, spect.ID_File, spect.HZ63, spect.HZ125, spect.HZ250, spect.HZ500, spect.HZ1000, spect.HZ2000, spect.HZ4000, spect.HZ8000, spect.Alpha, spect.T]) + } + } + + // We load the PEDESTRIANS table into a list/object + def query = 'SELECT * from PEDESTRIANS' + def pedestriansTable = sql.rows(query) + + def resultTable = [] + + // Attribution TEST + + // I've decided to perform this step (Obtention of T4) in SQL for simplicity + + // We add a new column AudioFileID to our PEDESTRIANS table. This column stores the id of the audio file corresponding to the number of pedestrians calculated in PEDESTRIANS and BDD_INFO + sql.execute("ALTER TABLE PEDESTRIANS ADD COLUMN AudioFileID INT;") + // We store the unique audio file identifiers from BDD_INFO. The point is that, even though we have many audio files for a single number of pedestrians, the assignment will only take one of them randomly + // sql.execute("SELECT DISTINCT NbPers_min FROM BDD_INFO;") + // This is the equivalent of the AudioChooser function. We assign an audio file identifier to our PEDESTRIANS table where it corresponds + sql.execute("UPDATE PEDESTRIANS AS spc SET AudioFileID = (SELECT ID FROM BDD_INFO AS bi WHERE bi.NbPers_min <= spc.NBPEDESTRIAN AND bi.NbPers_max >= spc.NBPEDESTRIAN ORDER BY RAND() LIMIT 1) WHERE spc.NBPEDESTRIAN IN (SELECT DISTINCT NbPers_min FROM BDD_INFO);") + // Since not all of the points in PEDESTRIANS correspond to a particular number of pedestrians in BDD_INFO, we'll take them out and only work with those who correspond + sql.execute("DELETE FROM PEDESTRIANS WHERE AudioFileID IS NULL;") + + // Now we assign the Voice_SPECTRUM values to PEDESTRIANS in function of the AudioFileID + sql.execute("DROP TABLE T6,T5, PED_SPECTRUMS IF EXISTS;") + sql.execute("CREATE TABLE T5 AS SELECT * FROM PEDESTRIANS INNER JOIN Voice_SPECTRUM ON PEDESTRIANS.AudioFileID = Voice_SPECTRUM.ID_File") + // Add PK + String queryPK = ''' + ALTER TABLE T5 DROP COLUMN PK; + ALTER TABLE T5 ADD PK INT AUTO_INCREMENT PRIMARY KEY; + ''' + sql.execute(queryPK) + + sql.execute(''' + DROP TABLE T6,T5, PED_SPECTRUMS, PED_SPECTRUMS_LW,PED_SPECTRUMS_GEOM IF EXISTS; + CREATE TABLE T6 (PK INT AUTO_INCREMENT PRIMARY KEY,THE_GEOM Geometry,LINK_ID int,T int,HZ63 real,HZ125 real,HZ250 real,HZ500 real,HZ1000 real,HZ2000 real,HZ4000 real,HZ8000 real); + + INSERT INTO T6(THE_GEOM ,LINK_ID ,T ,HZ63 ,HZ125 ,HZ250 ,HZ500 ,HZ1000 ,HZ2000 ,HZ4000,HZ8000) SELECT pd.THE_GEOM, pd.PK AS LINK_ID, sp.T, sp.HZ63, sp.HZ125, sp.HZ250, sp.HZ500, sp.HZ1000, sp.HZ2000, sp.HZ4000, sp.HZ8000 FROM PEDESTRIANS pd INNER JOIN Voice_SPECTRUM sp ON pd.AUDIOFILEID = sp.ID_File; + + -- SELECT pd.THE_GEOM, pd.PK AS LINK_ID, sp.T, sp.HZ63, sp.HZ125, sp.HZ250, sp.HZ500, sp.HZ1000, sp.HZ2000, sp.HZ4000, sp.HZ8000 FROM PEDESTRIANS pd INNER JOIN Voice_SPECTRUM sp ON pd.AUDIOFILEID = sp.ID_File; + + UPDATE T6 SET THE_GEOM = ST_UPDATEZ(The_geom,1.5); + ALTER TABLE T6 RENAME TO PED_SPECTRUMS; + + CREATE TABLE PED_SPECTRUMS_LW AS (SELECT PK, LINK_ID, HZ63, HZ125, HZ250, HZ500, HZ1000, HZ2000, HZ4000, HZ8000, T AS TIME FROM PED_SPECTRUMS); + + CREATE TABLE PED_SPECTRUMS_geom AS SELECT min(PK) AS PK, LINK_ID, THE_GEOM FROM PED_SPECTRUMS GROUP BY LINK_ID; + ALTER TABLE PED_SPECTRUMS_geom ALTER COLUMN PK INT NOT NULL; + ALTER TABLE PED_SPECTRUMS_geom ADD PRIMARY KEY (PK); + DROP TABLE T5 IF EXISTS; + ''') + + sql.execute("DROP TABLE IF EXISTS PED_SPECTRUMS_0DB") + sql.execute("CREATE TABLE PED_SPECTRUMS_0DB(PK int NOT NULL PRIMARY KEY,PED_ID long, THE_GEOM geometry, HZ63 real, HZ125 real, HZ250 real, HZ500 real, HZ1000 real, HZ2000 real, HZ4000 real, HZ8000 real) AS SELECT r.PK, r.LINK_ID, r.THE_GEOM, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 FROM PED_SPECTRUMS_GEOM AS r;") + + + + // Get Class to compute LW + LDENConfig ldenConfig = new LDENConfig(LDENConfig.INPUT_MODE.INPUT_MODE_TRAFFIC_FLOW) + ldenConfig.setCoefficientVersion(2) + ldenConfig.setPropagationProcessPathData(LDENConfig.TIME_PERIOD.DAY, new PropagationProcessPathData(false)); + ldenConfig.setPropagationProcessPathData(LDENConfig.TIME_PERIOD.EVENING, new PropagationProcessPathData(false)); + ldenConfig.setPropagationProcessPathData(LDENConfig.TIME_PERIOD.NIGHT, new PropagationProcessPathData(false)); + + LDENPropagationProcessData ldenData = new LDENPropagationProcessData(null, ldenConfig) + + // At this step, the LW_PEDESTRIAN table is filled using the class computation and the number of pedestrian in each cell + /* + // We can actually skip this since the T5 would be the correct/equivalent table to use here. I'm not going to touch this for the moment. Discuss with Pierre about optimizing implementation + + // THIS APPROACH IS NOT USED ANYMORE AS THE SPECTRUM IS ATTRIBUTED BY THE AUDIO FILE DATABASE + // Get size of the table (number of pedestrians points) + PreparedStatement st = connection.prepareStatement("SELECT COUNT(*) AS total FROM " + sources_table_name) + ResultSet rs1 = st.executeQuery().unwrap(ResultSet.class) + int nbPedestrianPoints = 0 + while (rs1.next()) { + nbRoads = rs1.getInt("total") + logger.info('The table Pedestrian has ' + nbPedestrianPoints + ' pedestrian positions.') + } + + int k = 0 + sql.withBatch(100, qry) { ps -> + st = connection.prepareStatement("SELECT * FROM " + sources_table_name) + SpatialResultSet rs = st.executeQuery().unwrap(SpatialResultSet.class) + + while (rs.next()) { + k++ + //logger.info(rs) + Geometry geo = rs.getGeometry() + int nbPedestrianOnPoint = rs.getDouble("NBPEDESTRIAN") + // Compute emission sound level for each point source + def results = ldenData.computeLw(rs) + // fill the LW_PEDESTRIAN table + ps.addBatch(rs.getLong(pkIndex) as Integer, geo as Geometry, + 70 + 10*Math.log10(nbPedestrianOnPoint) as Double, 70+ 10*Math.log10(nbPedestrianOnPoint) as Double, 70+ 10*Math.log10(nbPedestrianOnPoint) as Double, + 70+ 10*Math.log10(nbPedestrianOnPoint) as Double, 70+ 10*Math.log10(nbPedestrianOnPoint) as Double, 70 + 10*Math.log10(nbPedestrianOnPoint) as Double, + 70+ 10*Math.log10(nbPedestrianOnPoint) as Double, 70+ 10*Math.log10(nbPedestrianOnPoint) as Double, "DAY") + } + } + + // Add Z dimension to the pedestrian points + sql.execute("UPDATE T5 SET THE_GEOM = ST_UPDATEZ(The_geom,1.5);") + + // Add primary key to the pedestrian table + sql.execute("ALTER TABLE LW_PEDESTRIAN ALTER COLUMN PK INT NOT NULL;") + sql.execute("ALTER TABLE LW_PEDESTRIAN ADD PRIMARY KEY (PK); ") + // Clean the unused attributes in T5 + sql.execute("ALTER TABLE T5 DROP COLUMN NBPEDESTRIAN, AUDIOFILEID, ID_G, ID_FILE, ALPHA;") + + // In order to produce a dynamic map, we will follow the architecture of the Matsim script + // This will require to "separate" T5 in 2 different tables: One containing the geometry and the other one containing the sound power levels + // These 2 tables will be "linked" by a LINK_ID attribute + sql.execute("ALTER TABLE T5 ADD COLUMN LINK_ID INT;") // We add the LINK_ID column + sql.execute("SET @counter = 0;") // We initialize a counter for LINK_ID + sql.execute("UPDATE T5 SET LINK_ID = (@counter := @counter + 1);") // We update the LINK_ID column + + // Now we are going to "divide" our T5 table in T5_geom (geometries) and T5_Lw (Sound levels) + // First, we obtain T5_LW (PK, LINK_ID, HZ..., TIME) + sql.execute("CREATE TABLE T5_LW AS (SELECT PK, LINK_ID, HZ63, HZ125, HZ250, HZ500, HZ1000, HZ2000, HZ4000, HZ8000, T FROM T5);") + sql.execute("ALTER TABLE T5_LW RENAME COLUMN T TO TIME; ") // We rename the column T to TIME + + // Then, we obtain T5_geom (PK, LINK_ID, THE_GEOM) + sql.execute("CREATE TABLE T5_geom AS (SELECT PK, LINK_ID, THE_GEOM FROM T5);") + sql.execute("ALTER TABLE T5_geom RENAME TO ") +*/ + resultString = "Calculation Done ! The table LW_PEDESTRIAN has been created." + + // print to command window + logger.info('\nResult : ' + resultString) + logger.info('End : LW_PEDESTRIAN from Emission') + + // print to WPS Builder + return resultString + +} + + + diff --git a/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/Receivers/Building_Grid3D.groovy b/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/Receivers/Building_Grid3D.groovy index 9360da594..d9b0e9527 100644 --- a/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/Receivers/Building_Grid3D.groovy +++ b/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/Receivers/Building_Grid3D.groovy @@ -238,7 +238,8 @@ def exec(Connection connection, input) { // union of truncated receivers and non tructated, split line to points sql.execute("DROP TABLE IF EXISTS TMP_SCREENS_MERGE") - sql.execute("CREATE TABLE TMP_SCREENS_MERGE (the_geom geometry, hBuilding float, pk_building integer) as SELECT s.the_geom, s.height, s.pk_building FROM tmp_receivers_lines s WHERE not st_isempty(s.the_geom) ;") + sql.execute("CREATE TABLE TMP_SCREENS_MERGE (the_geom geometry, hBuilding float, pk_building integer) " + + "as SELECT s.the_geom, s.height, s.pk_building FROM tmp_receivers_lines s WHERE not st_isempty(s.the_geom) ;") sql.execute("ALTER TABLE TMP_SCREENS_MERGE ADD COLUMN PK SERIAL PRIMARY KEY") // Collect all lines and convert into points using custom method diff --git a/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/Source_Activity/PedestrianActivity.groovy b/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/Source_Activity/PedestrianActivity.groovy new file mode 100644 index 000000000..b3428f6b9 --- /dev/null +++ b/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/Source_Activity/PedestrianActivity.groovy @@ -0,0 +1,709 @@ +/** + * NoiseModelling is an open-source tool designed to produce environmental noise maps on very large urban areas. It can be used as a Java library or be controlled through a user friendly web interface. + * + * This version is developed by the DECIDE team from the Lab-STICC (CNRS) and by the Mixt Research Unit in Environmental Acoustics (Université Gustave Eiffel). + * + * + * NoiseModelling is distributed under GPL 3 license. You can read a copy of this License in the file LICENCE provided with this software. + * + * Contact: contact@noise-planet.org + * + */ + +/** + * @Author Pierre Aumond, Université Gustave Eiffel + * @Author Paul Chapron, IGN + */ + + +package org.noise_planet.noisemodelling.wps.Source_Activity + + +import geoserver.GeoServer +import geoserver.catalog.Store +import groovy.sql.Sql +import org.geotools.jdbc.JDBCDataStore +import org.h2gis.utilities.GeometryTableUtilities +import org.h2gis.utilities.TableLocation +import org.locationtech.jts.geom.Geometry +import org.locationtech.jts.geom.Point +import org.noise_planet.noisemodelling.pathfinder.RootProgressVisitor +import org.slf4j.Logger +import org.slf4j.LoggerFactory + +import java.sql.Connection + +title = 'Pedestrian localisation ' + +description = '➡️ Locate some pedestrian in the city thanks to a walkable area polygon and a PointsOfInterests layer

    ' + + 'The following output tables will be created:
    ' + + '- PEDESTRIANS : a table containing the pedestrians in their corresponding areas' + + +inputs = [ + walkableArea : [ + name : 'walkableArea', + title : 'walkableArea', + description: 'Walkable area polygon generated in the Import_OSM_Pedestrian script', + type : String.class + ], + cellSize : [ + name : 'cellSize', + title : 'cellSize', + description: 'Size of the grid cell used to perform the spatial density analysis KDE', + type : Double.class, + min : 0, max: 1 + ], + pointsOfInterests : [ + name : 'PointsOfInterests', + description: 'Layer containing the points of interest in the study area issued from the Import_OSM_Pedestrian script ', + title : 'PointsOfInterests', + type : String.class + ], + bandwidthKDE : [ + name : 'bandwidthKDE', + description: 'Bandwidth to be used in the KDE analysis. This will modify the extent to which the KDE will search for the points of interest and therefore their density.
    ' + + 'This is an optional parameter.', + title : 'bandwidthKDE', + type : Double.class, + min : 0, max: 1 + ], + coeffLeisure : [ + name : 'coeffLeisure', + description: 'Weight/coefficient of the Leisure points of interest in the linear regression.
    ' + + 'This is an optional parameter.', + title : 'coeffLeisure', + type : Double.class, + min : 0, max: 1 + ], + coeffCulture : [ + name : 'coeffCulture', + description: 'Weight/coefficient of the Culture points of interest in the linear regression.
    ' + + 'This is an optional parameter.', + title : 'coeffCulture', + type : Double.class, + min : 0, max: 1 + ], + coeffFoodDrink : [ + name : 'coeffFoodDrink', + description: 'Weight/coefficient of the Food_Drink points of interest in the linear regression.
    ' + + 'This is an optional parameter.', + title : 'coeffFoodDrink', + type : Double.class, + min : 0, max: 1 + ], + coeffEducation : [ + name : 'coeffEducation', + description: 'Weight/coefficient of the Education points of interest in the linear regression.
    ' + + 'This is an optional parameter.', + title : 'coeffEducation', + type : Double.class, + min : 0, max: 1 + ], + coeffFootpath : [ + name : 'coeffFootpath', + description: 'Weight/coefficient of the Footpath points of interest in the linear regression.
    ' + + 'This is an optional parameter.', + title : 'coeffFootpath', + type : Double.class, + min : 0, max: 1 + ], + coeffTourismSleep : [ + name : 'coeffTourismSleep', + description: 'Weight/coefficient of the Tourism_Sleep points of interest in the linear regression.
    ' + + 'This is an optional parameter.', + title : 'coeffTourismSleep', + type : Double.class, + min : 0, max: 1 + ], + coeffPublicTransport: [ + name : 'coeffPublicTransport', + description: 'Weight/coefficient of the Public_Transport points of interest in the linear regression.
    ' + + 'This is an optional parameter.', + title : 'coeffPublicTransport', + type : Double.class, + min : 0, max: 1 + ], + coeffReligion : [ + name : 'coeffReligion', + description: 'Weight/coefficient of the Religion points of interest in the linear regression.
    ' + + 'This is an optional parameter.', + title : 'coeffReligion', + type : Double.class, + min : 0, max: 1 + ], + coeffTourism : [ + name : 'coeffTourism', + description: 'Weight/coefficient of the Tourism points of interest in the linear regression.
    ' + + 'This is an optional parameter.', + title : 'coeffTourism', + type : Double.class, + min : 0, max: 1 + ], + coeffShop : [ + name : 'coeffShop', + description: 'Weight/coefficient of the Shop points of interest in the linear regression.
    ' + + 'This is an optional parameter.', + title : 'coeffShop', + type : Double.class, + min : 0, max: 1 + ], + coeffSport : [ + name : 'coeffSport', + description: 'Weight/coefficient of the Sport points of interest in the linear regression.
    ' + + 'This is an optional parameter.', + title : 'coeffSport', + type : Double.class, + min : 0, max: 1 + ], + coeffTrees : [ + name : 'coeffTrees', + description: 'Weight/coefficient of the Trees points of interest in the linear regression.
    ' + + 'This is an optional parameter.', + title : 'coeffTrees', + type : Double.class, + min : 0, max: 1 + ], + coeffIntercept : [ + name : 'coeffIntercept', + description: ' intercept in the linear regression.
    ' + + 'This is an optional parameter.', + title : 'coeffIntercept', + type : Double.class, + min : 0, max: 1 + ], + coeffIndTransport : [ + name : 'coeffIndTransport', + description: 'Weight/coefficient of the Individual_Transport points of interest in the linear regression.
    ' + + 'This is an optional parameter.', + title : 'coeffIndTransport', + type : Double.class, + min : 0, max: 1 + ] +] + +outputs = [ + result: [ + name : 'Result output string', + title : 'Result output string', + description: 'This type of result does not allow the blocks to be linked together.', + type : String.class + ] +] + +static Connection openGeoserverDataStoreConnection(String dbName) { + if (dbName == null || dbName.isEmpty()) { + dbName = new GeoServer().catalog.getStoreNames().get(0) + } + Store store = new GeoServer().catalog.getStore(dbName) + JDBCDataStore jdbcDataStore = (JDBCDataStore) store.getDataStoreInfo().getDataStore(null) + return jdbcDataStore.getDataSource().getConnection() +} + + +def run(input) { + + // Get name of the database + // by default an embedded h2gis database is created + // Advanced user can replace this database for a postGis or h2Gis server database. + String dbName = "h2gisdb" + + // Open connection + openGeoserverDataStoreConnection(dbName).withCloseable { + Connection connection -> + return [result: exec(connection, input)] + } +} + + +def exec(connection, input) { + + // output string, the information given back to the user + String resultString = null + + + // Create a logger to display messages in the geoserver logs and in the command prompt. + Logger logger = LoggerFactory.getLogger("org.noise_planet.noisemodelling") + + // print to command window + logger.info('Start : Sampling Pietons') + logger.info("inputs {}", input) // log inputs of the run + + // Defining input variables + Double coeffLeisure = 1 + if (input['coeffLeisure']) { + coeffLeisure = input['coeffLeisure'] + } + + Double coeffCulture = 1 + if (input['coeffCulture']) { + coeffCulture = input['coeffCulture'] + } + + Double coeffFoodDrink = 1 + if (input['coeffFoodDrink']) { + coeffFoodDrink = input['coeffFoodDrink'] + } + + Double coeffEducation = 1 + if (input['coeffEducation']) { + coeffEducation = input['coeffEducation'] + } + + Double coeffFootpath = 1 + if (input['coeffFootpath']) { + coeffFootpath = input['coeffFootpath'] + } + + Double coeffTourismSleep = 1 + if (input['coeffTourismSleep']) { + coeffTourismSleep = input['coeffTourismSleep'] + } + + Double coeffPublicTransport = 1 + if (input['coeffPublicTransport']) { + coeffPublicTransport = input['coeffPublicTransport'] + } + + Double coeffReligion = 1 + if (input['coeffReligion']) { + coeffReligion = input['coeffReligion'] + } + + Double coeffTourism = 1 + if (input['coeffTourism']) { + coeffTourism = input['coeffTourism'] + } + + Double coeffShop = 1 + if (input['coeffShop']) { + coeffShop = input['coeffShop'] + } + + Double coeffSport = 1 + if (input['coeffSport']) { + coeffSport = input['coeffSport'] + } + + Double coeffTrees = 1 + if (input['coeffTrees']) { + coeffTrees = input['coeffTrees'] + } + Double coeffIntercept = 1 + if (input['coeffIntercept']) { + coeffIntercept = input['coeffIntercept'] + } + + + Double coeffIndTransport = 1 + if (input['coeffIndTransport']) { + coeffIndTransport = input['coeffIndTransport'] + } + + + String walkableArea = "PEDESTRIAN_AREA" + if (input['walkableArea']) { + walkableArea = input['walkableArea'] + } + walkableArea = walkableArea.toUpperCase() + + + Double cellSize = 2 + if (input['cellSize']) { + cellSize = input['cellSize'] + } + + Double bwKDE = 150 + if (input['bandwidthKDE']) { + bwKDE = input['bandwidthKDE'] + } + logger.info("bandwidthKDE") + + String pointsOfInterests = "PEDESTRIAN_POIS" + if (input['pointsOfInterests']) { + pointsOfInterests = input['pointsOfInterests'] + } + pointsOfInterests = pointsOfInterests.toUpperCase() + + Sql sql = new Sql(connection) + + + int srid = GeometryTableUtilities.getSRID(connection, TableLocation.parse(pointsOfInterests)) + logger.info("SRID de la couche de lines" + srid) + + int poly_srid = GeometryTableUtilities.getSRID(connection, TableLocation.parse(walkableArea)) + logger.info("SRID de la couche de polygones" + poly_srid) + + /** Centroids in cells upon a polygon collection **/ + logger.info("#########################") + logger.info("RASTERIZE...") + + def table_exists = sql.firstRow("SELECT COUNT (*) FROM information_schema.TABLES WHERE TABLE_NAME = ('CELLGRID_ON_AREA');") + if (table_exists[0] == 1) { + logger.info("Table CELLGRID_ON_AREA already exists...") + } else { + sql.execute("DROP TABLE CELLGRID IF EXISTS;") + sql.execute("CREATE TABLE CELLGRID AS SELECT * FROM ST_MakeGrid(\'" + walkableArea + "\' , " + cellSize + " , " + cellSize + ");") + //sql.execute("CREATE TABLE CELLGRID AS SELECT * FROM ST_MakeGrid('"+walkableArea+"', " +cellSize+ ", " +cellSize+");") + sql.execute("CREATE SPATIAL INDEX ON CELLGRID(the_geom);") + sql.execute("CREATE SPATIAL INDEX ON " + walkableArea + "(the_geom);") + + sql.execute("DROP TABLE CELLGRID_ON_AREA IF EXISTS ;") + sql.execute("CREATE TABLE CELLGRID_ON_AREA AS SELECT c.id pk, ST_ACCUM(ST_Intersection(zem.the_geom,c.the_geom)) the_geom FROM " + walkableArea + " zem , CELLGRID c WHERE ST_intersects(c.the_geom,zem.the_geom) AND c.the_geom && zem.the_geom GROUP BY c.id ;") + + sql.execute("DROP TABLE CELLGRID IF EXISTS ;") + + } + + /** KDE computation**/ + table_exists = sql.firstRow("SELECT COUNT (*) FROM information_schema.TABLES WHERE TABLE_NAME = ('POIS_DENSITY');") + if (table_exists[0] == 1) { + logger.info("Density table POIS_DENSITY already exists!") + + sql.execute("DROP TABLE POIS_DENSITY_TEMP IF EXISTS;") + sql.execute("CREATE TABLE POIS_DENSITY_TEMP (pk INTEGER,the_geom GEOMETRY,density FLOAT,leisure_density FLOAT,culture_density FLOAT,foodDrink_density FLOAT,education_density FLOAT,footpath_density FLOAT,tourismSleep_density FLOAT,publicTransport_density FLOAT,religion_density FLOAT,tourism_density FLOAT,shop_density FLOAT,sport_density FLOAT,trees_density FLOAT,indTransport_density FLOAT) ;") + + // Insert data into the 'POIS_DENSITY' table using placeholders '?' + def qry_add_density_values = 'INSERT INTO POIS_DENSITY_TEMP (pk,the_geom,density,leisure_density,culture_density,foodDrink_density,education_density,footpath_density,tourismSleep_density,publicTransport_density,religion_density,tourism_density,shop_density,sport_density,trees_density,indTransport_density) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);' + // Batch insert operation using the SQL query defined above. It batches the insert operations in groups of 3. Why 3? + sql.withBatch(3, qry_add_density_values) { ps2 -> + // Retrieve rows with columns 'pk' and 'the_geom' from the 'POIS_DENSITY' table + sql.eachRow("SELECT pk,the_geom,density,leisure_density,culture_density,foodDrink_density,education_density,footpath_density,tourismSleep_density,publicTransport_density,religion_density,tourism_density,shop_density,sport_density,trees_density,indTransport_density FROM POIS_DENSITY ") { row -> + // Extract the current 'pk' value as an integer + int pk = row[0] as Integer + // Extract current 'the_geom' value as a geometry object (polygon) + Geometry the_poly = row[1] as Geometry + double leisure_density = row[3] as Double + double culture_density = row[4] as Double + double foodDrink_density = row[5] as Double + double education_density = row[6] as Double + double footpath_density = row[7] as Double + double tourismSleep_density = row[8] as Double + double publicTransport_density = row[9] as Double + double religion_density = row[10] as Double + double tourism_density = row[11] as Double + double shop_density = row[12] as Double + double sport_density = row[13] as Double + double trees_density = row[14] as Double + double indTransport_density = row[15] as Double + double density = coeffLeisure * leisure_density + coeffCulture * culture_density + coeffFoodDrink * foodDrink_density + +coeffEducation * education_density + coeffFootpath * footpath_density + coeffTourismSleep * tourismSleep_density + +coeffPublicTransport * publicTransport_density + coeffReligion * religion_density + coeffTourism * tourism_density + +coeffShop * shop_density + coeffSport * sport_density + coeffTrees * trees_density + coeffIndTransport * indTransport_density + + //logger.info("here density is " + density) + // Add the values 'pk', 'the_poly' and 'density' to the batch for insertion + ps2.addBatch(pk, the_poly, density, leisure_density, culture_density, foodDrink_density, education_density, footpath_density, tourismSleep_density, publicTransport_density, religion_density, + tourism_density, shop_density, sport_density, trees_density, indTransport_density) + } + // densityprogressLogger.endStep() + } + + sql.execute("DROP TABLE POIS_DENSITY IF EXISTS;") + sql.execute("CREATE TABLE POIS_DENSITY AS SELECT * FROM POIS_DENSITY_TEMP;") + sql.execute("DROP TABLE POIS_DENSITY_TEMP IF EXISTS;") + + } else { + + logger.info("#########################") + logger.info("POINTS OF INTERESTS") + + // Retrieve the count of records in the table specified by the 'pointsOfInterests' variable where TYPE is 'food_drink' + // Result s assigned to 'food_drink_count' as integer + int food_drink_count = sql.firstRow('SELECT COUNT(*) FROM ' + pointsOfInterests + ' WHERE \'TYPE\' = \'food_drink\'')[0] as Integer + // Create a new ArrayList named 'poi_food_drink' to store Point objects + List poi_leisure = new ArrayList() + List poi_culture = new ArrayList() + List poi_food_drink = new ArrayList() + List poi_education = new ArrayList() + List poi_footpath = new ArrayList() + List poi_tourism_sleep = new ArrayList() + List poi_public_transport = new ArrayList() + List poi_religion = new ArrayList() + List poi_tourism = new ArrayList() + List poi_shop = new ArrayList() + List poi_sport = new ArrayList() + List poi_trees = new ArrayList() + List poi_individual_transport = new ArrayList() + // Progress tracking with 'food_drink_count' as the total number of steps, 'true' for logging and 1 for the step increment + RootProgressVisitor KDEprogressLogger = new RootProgressVisitor(food_drink_count, true, 1) + // Retrieve records with columns 'pk' and 'the_geom' from the table specified by the 'pointsOfInterests' variable + // Iteration over each returned row by the query and processes it by using the closure defined inside the curly braces + sql.eachRow("SELECT pk, the_geom, type from " + pointsOfInterests) { row -> + // Extract the geometry from the second column of the current row and cast it to a geometry object + def geom = row[1] as Geometry + def type = row[2] as String + // Is the extracted geometry an instance of 'Point'? If it is, add it to the 'poi_food_drink' list + if (geom instanceof Point) { + + switch (type) { + case "leisure": + poi_leisure.add(geom) + break + + case "culture": + poi_culture.add(geom) + break + + case "food_drink": + poi_food_drink.add(geom) + break + + case "education": + poi_education.add(geom) + break + + case "footpath": + poi_footpath.add(geom) + break + + case "tourism_sleep": + poi_tourism_sleep.add(geom) + break + + case "public_transport": + poi_public_transport.add(geom) + break + + case "religion": + poi_religion.add(geom) + break + + case "tourism": + poi_tourism.add(geom) + break + + case "shop": + poi_shop.add(geom) + break + + case "sport": + poi_sport.add(geom) + break + + case "trees": + poi_trees.add(geom) + break + + case "individual_transport": + poi_individual_transport.add(geom) + break + } + + } + // Completion of the current step in the progress tracking + KDEprogressLogger.endStep() + } + + sql.execute("DROP TABLE POIS_DENSITY IF EXISTS;") + sql.execute("CREATE TABLE POIS_DENSITY (pk INTEGER,the_geom GEOMETRY,density FLOAT,leisure_density FLOAT,culture_density FLOAT,foodDrink_density FLOAT,education_density FLOAT,footpath_density FLOAT,tourismSleep_density FLOAT,publicTransport_density FLOAT,religion_density FLOAT,tourism_density FLOAT,shop_density FLOAT,sport_density FLOAT,trees_density FLOAT,indTransport_density FLOAT) ;") + + logger.info("(empty) Density table POIS_DENSITY created") + + RootProgressVisitor densityprogressLogger = new RootProgressVisitor(food_drink_count, true, 1) + + // Insert data into the 'POIS_DENSITY' table using placeholders '?' + def qry_add_density_values = 'INSERT INTO POIS_DENSITY (pk,the_geom,density,leisure_density,culture_density,foodDrink_density,education_density,footpath_density,tourismSleep_density,publicTransport_density,religion_density,tourism_density,shop_density,sport_density,trees_density,indTransport_density) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);' + // Batch insert operation using the SQL query defined above. It batches the insert operations in groups of 3. Why 3? + sql.withBatch(3, qry_add_density_values) { ps -> + // Retrieve rows with columns 'pk' and 'the_geom' from the 'CELLGRID_ON_AREA' table + sql.eachRow("SELECT pk, the_geom FROM CELLGRID_ON_AREA ") { row -> + // Extract the current 'pk' value as an integer + int pk = row[0] as Integer + // Extract current 'the_geom' value as a geometry object (polygon) + Geometry the_poly = row[1] as Geometry + // Calculate the centroid of the bounding envelope of the geometry + Point centroid = the_poly.getEnvelope().getCentroid() + // Uses a function called 'densityChatGPT' that is defined later in the code to calculate the density of POIs in the geometry + double leisure_density = densityChatGPT(bwKDE, centroid, poi_leisure) + double culture_density = densityChatGPT(bwKDE, centroid, poi_culture) + double foodDrink_density = densityChatGPT(bwKDE, centroid, poi_food_drink) + double education_density = densityChatGPT(bwKDE, centroid, poi_education) + double footpath_density = densityChatGPT(bwKDE, centroid, poi_footpath) + double tourismSleep_density = densityChatGPT(bwKDE, centroid, poi_tourism_sleep) + double publicTransport_density = densityChatGPT(bwKDE, centroid, poi_public_transport) + double religion_density = densityChatGPT(bwKDE, centroid, poi_religion) + double tourism_density = densityChatGPT(bwKDE, centroid, poi_tourism) + double shop_density = densityChatGPT(bwKDE, centroid, poi_shop) + double sport_density = densityChatGPT(bwKDE, centroid, poi_sport) + double trees_density = densityChatGPT(bwKDE, centroid, poi_trees) + double indTransport_density = densityChatGPT(bwKDE, centroid, poi_individual_transport) + + double density = coeffLeisure * leisure_density + coeffCulture * culture_density + coeffFoodDrink * foodDrink_density + +coeffEducation * education_density + coeffFootpath * footpath_density + coeffTourismSleep * tourismSleep_density + +coeffPublicTransport * publicTransport_density + coeffReligion * religion_density + coeffTourism * tourism_density + +coeffShop * shop_density + coeffSport * sport_density + coeffTrees * trees_density + coeffIndTransport * indTransport_density + coeffIntercept + + //logger.info("here density is " + density) + // Add the values 'pk', 'the_poly' and 'density' to the batch for insertion + ps.addBatch(pk, the_poly, density, leisure_density, culture_density, foodDrink_density, education_density, footpath_density, tourismSleep_density, publicTransport_density, religion_density, + tourism_density, shop_density, sport_density, trees_density, indTransport_density) + } + densityprogressLogger.endStep() + } + } + // Retrieve the sum of density values from the 'POIS_DENSITY' table and store in 'sum_densities' as a double + double sum_densities = sql.firstRow('SELECT SUM(density) FROM POIS_DENSITY')[0] as Double + + // Explode polygons in order to calculate density in each polygon + sql.execute("DROP TABLE POIS_DENSITY_POLYGONS IF EXISTS;") + sql.execute("CREATE TABLE POIS_DENSITY_POLYGONS AS SELECT * FROM ST_EXPLODE(\'POIS_DENSITY\');") + + // Retrieve the POIs in each polygon and store + // Calculate the probability for each point within the polygon. Multiply the density value associated with each polygon by the area of the polygon + // Probability of a pedestrian being present in each specific area + sql.execute("DROP TABLE PEDESTRIANS_PROBABILITY IF EXISTS;") + sql.execute("CREATE TABLE PEDESTRIANS_PROBABILITY AS SELECT ST_POINTONSURFACE(the_geom) the_geom , density * ST_AREA(the_geom) probability FROM POIS_DENSITY_POLYGONS ORDER BY THE_GEOM ;") + sql.execute("ALTER TABLE PEDESTRIANS_PROBABILITY ADD PK INT AUTO_INCREMENT PRIMARY KEY;") + sql.execute("DROP TABLE POIS_DENSITY_POLYGONS IF EXISTS;") + + + logger.info("somme des densités" + sum_densities) + + logger.info("#########################") + logger.info("It is the time to sample") + + // Sampling + sql.execute("DROP TABLE PEDESTRIANS IF EXISTS;") + // Calculate the number of pedestrians 'nbPedestrian' in each area based on the 'probability' value for each area. The GREATEST function ensures that there is at least one pedestrian in each area + // FLOOR(probability*10) Calculates the integer part of the product of 'probability' and 10 + // RAND() < (probability*10 - FLOOR(probability*10)) Generates a random value between 0 and 1 and compares it with the fractional part of probability*10 + // If the random value is less than the fractional part, it adds 1 pedestrian to the count; otherwise it adds 0 WHY? + // FROM PEDESTRIANS_PROBABILITY WHERE RAND() < probability*10 Filters the rows from PEDESTRIANS_PROBABILITY based on the condition that a random value is less than the 'probability' value * 10. This filters out areas with low probabilities. + // The resulting PEDESTRIANS table will contain 'the_geom' and 'nbPedestrian' + sql.execute("CREATE TABLE PEDESTRIANS AS SELECT PK PK, the_geom the_geom, GREATEST(FLOOR(probability)+ CASE WHEN RAND() < (probability - FLOOR(probability)) THEN 1 ELSE 0 END,1) AS nbPedestrian FROM PEDESTRIANS_PROBABILITY WHERE RAND() < probability ;") + // sql.execute("DROP TABLE PEDESTRIANS_PROBABILITY IF EXISTS;") + sql.execute("ALTER TABLE PEDESTRIANS ALTER COLUMN PK int NOT NULL;") + sql.execute("ALTER TABLE PEDESTRIANS ADD PRIMARY KEY (PK);") + + // sql.execute("ALTER TABLE PEDESTRIANS ADD PK INT AUTO_INCREMENT PRIMARY KEY;") + + return ["Process done. Table of outputs created !"] +} + + +//compute the density estimate of sample points at a given location X(x,y) + +/** + * Compute density using KDE + * Thank you to my new friend ChatGPT + * @param bandwidth + * @param location + * @param poi + * @return + */ +double densityChatGPT(double bandwidth, Point location, List poi) { + //double density = 0 + if (!poi.isEmpty()) { + // Compute the distances between the target point and all input objects + List distances = poi.collect { object -> + // new DistanceToPoint(object).computeDistance(location,object,) + location.distance(object) + } + +// Compute the kernel density estimate for the target point + double kernelSum = distances.collect { distance -> + Math.exp(-0.5 * Math.pow((distance / bandwidth), 2)) + }.sum() + + //double density = kernelSum / (Math.sqrt(2 * Math.PI) * bandwidth * poi.size()) + density = kernelSum / (Math.PI * 2 * bandwidth * bandwidth) + } + + return density +} + + +double density_2(Point location, List poi) { + + + List poiX = poi.collect { p -> p.x } + List poiY = poi.collect { p -> p.y } + + Double wX = Math.sqrt(variance(vecX)) + Double wY = Math.sqrt(variance(vecY)) + + + Double locx = location.x + Double locy = location.y + + List terms = [] + + for (p in poi) { + Double Xi = p.x + Double Yi = p.y + Double kernelTerm = exp(-(Math.pow((locx - Xi), 2) / (2 * Math.pow(wX, 2))) - (Math.pow((locy - Yi), 2) / (2 * Math.pow(wY, 2)))) + terms.add(kernelTerm) + } + + Double kernelSum = terms.sum() + + int n = poi.size() + Double result = kernelSum / (n * 2 * Math.PI * wX * wY) + return (result) +} + + +double densityEstimate(double[] sample_x, double[] sample_y, double[] X) { + assert (sample_x.size() == sample_y.size()) + + int n = sample_x.size() + double[] bandwidth = bandwidthMatrixSelectionScott(sample_x, sample_y, 2) + double[] X_minus_Xi = [0] + //double res= (1/n) * X_minus_Xi.collect(i -> gaussianKernelwithDiagonalBandwidth(X_minus_Xi bandwidth ) ) + double res = 0.0 + return res + +} + + +/** + Compute the value of the density estimate at point location(x,y) + full formula of the 2D multivariate kernel density estimate is + density = {\textstyle K_{\mathbf {H}}(\mathbf {x} )={(2\pi )^{-d/2}}\mathbf {|H|} ^{-1/2}e^{-{\frac {1}{2}}\mathbf {x^{T}} \mathbf {H^{-1}} \mathbf {x}}}Here H is diagonal + **/ +double gaussianKernelwithDiagonalBandwidth(Double[] X, Double poi_x, Double poi_y, Double[] bandwidth_matrix_diagonal_values) { + + // coordinates of the X vector + double x = X[1] + double y = X[2] + + // determinant of the diagonal matrix + double Hdet = bandwidth_matrix_diagonal_values[1] * bandwidth_matrix_diagonal_values[2] + // H inverse matrix + double[] H_inverse = [1 / bandwidth_matrix_diagonal_values[1], 1 / bandwidth_matrix_diagonal_values[2]] + // argument of the exponential : Xtransposed . H^-1 .X = x * Hinverse11 * x + y * Hinverse22 * y since H is diagonal + double x_THinverse_x = x * H_inverse[1] * x + y * H_inverse[2] * y + + // kernel value for vector X=[x,y] + Double density = 1 / (2 * Math.PI) * 1 / (sqrt(Hdet)) * exp(-0.5 * x_THinverse_x) + return (density) +} + + +double variance(List x) { + int n = x.size() + double mu = x.sum() / n + double variance = x.collect { i -> return Math.pow(i - mu, 2) }.sum() * (1 / (n - 1)) + // variance empirique debiaisée + return (variance) +} + + +// Based on Scott's rule of thumb : sqrt(Hii) = n ^( -1 / d+4) * sigma_j, +// with n the number of data points +// with d the number of spatial dimension +// j is the index of these dimension +// 2D case ; j=1 sigma_1 = std(x) , j=2sigma_2=std(y) coordinates of the sample +// return the two diagonal term of the bandwidth Matrix H +double[] bandwidthMatrixSelectionScott(double[] x, double[] y, d = 2) { + assert (x.size() == y.size()) + int n = x.size() //number of sample points + double sigma_x = Math.sqrt(variance(x)) + double sigma_y = Math.sqrt(variance(y)) + double H11 = Math.pow(Math.pow(n, (-1 / d + 4)) * sigma_x, 2) //first diagonal term + double H22 = Math.pow(Math.pow(n, (-1 / d + 4)) * sigma_y, 2) //first diagonal term + double[] res = [H11, H22] + return res +} + diff --git a/wps_scripts/src/main/resources/VoiceModel/BDD_Info.json b/wps_scripts/src/main/resources/VoiceModel/BDD_Info.json new file mode 100644 index 000000000..86006bcf3 --- /dev/null +++ b/wps_scripts/src/main/resources/VoiceModel/BDD_Info.json @@ -0,0 +1,98 @@ +[ + { + "ID": 0, + "NbPers_min": 70, + "NbPers_max": 100000000, + "Audio": "100" + }, + { + "ID": 1, + "NbPers_min": 2, + "NbPers_max": 2, + "Audio": "2.2" + }, + { + "ID": 2, + "NbPers_min": 2, + "NbPers_max": 2, + "Audio": "2.3" + }, + { + "ID": 3, + "NbPers_min": 10, + "NbPers_max": 30, + "Audio": "20" + }, + { + "ID": 4, + "NbPers_min": 3, + "NbPers_max": 3, + "Audio": "3.1" + }, + { + "ID": 5, + "NbPers_min": 3, + "NbPers_max": 3, + "Audio": "3.2" + }, + { + "ID": 6, + "NbPers_min": 3, + "NbPers_max": 3, + "Audio": "3.3" + }, + { + "ID": 7, + "NbPers_min": 25, + "NbPers_max": 40, + "Audio": "30" + }, + { + "ID": 8, + "NbPers_min": 4, + "NbPers_max": 4, + "Audio": "4.1" + }, + { + "ID": 9, + "NbPers_min": 30, + "NbPers_max": 50, + "Audio": "40.1" + }, + { + "ID": 10, + "NbPers_min": 30, + "NbPers_max": 50, + "Audio": "40.2" + }, + { + "ID": 11, + "NbPers_min": 4, + "NbPers_max": 6, + "Audio": "5.2" + }, + { + "ID": 12, + "NbPers_min": 4, + "NbPers_max": 6, + "Audio": "5" + }, + { + "ID": 13, + "NbPers_min": 50, + "NbPers_max": 70, + "Audio": "60" + }, + { + "ID": 14, + "NbPers_min": 5, + "NbPers_max": 9, + "Audio": "7" + }, + { + "ID": 15, + "NbPers_min": 50, + "NbPers_max": 90, + "Audio": "70" + } +] diff --git a/wps_scripts/src/main/resources/VoiceModel/Spectrums_500ms.json b/wps_scripts/src/main/resources/VoiceModel/Spectrums_500ms.json new file mode 100644 index 000000000..8a25ac4b7 --- /dev/null +++ b/wps_scripts/src/main/resources/VoiceModel/Spectrums_500ms.json @@ -0,0 +1,7716 @@ +[ + { + "ID_g": 0, + "ID_File": 0, + "LWD63": 28.5800321, + "LWD125": 23.22039705, + "LWD250": 33.02951432, + "LWD500": 32.6073498, + "LWD1000": 23.42452795, + "LWD2000": 13.80562885, + "LWD4000": 9.189914635, + "LWD8000": 10.85698554, + "P10": "-90.3089987", + "P25": -84.28839879, + "P50": -73.4070379, + "P75": -65.70002027, + "P90": -62.00953174, + "Alpha": 0, + "T": 1 + }, + { + "ID_g": 1, + "ID_File": 0, + "LWD63": 34.35424332, + "LWD125": 35.35305491, + "LWD250": 39.28524319, + "LWD500": 39.25263748, + "LWD1000": 32.42237835, + "LWD2000": 22.07188221, + "LWD4000": 14.68940499, + "LWD8000": 13.93974783, + "P10": "-78.26779887", + "P25": -70.3089987, + "P50": -63.8646128, + "P75": -59.18294868, + "P90": -55.50174491, + "Alpha": 0.5, + "T": 2 + }, + { + "ID_g": 2, + "ID_File": 0, + "LWD63": 41.52542728, + "LWD125": 39.8914353, + "LWD250": 46.55278991, + "LWD500": 48.46888602, + "LWD1000": 41.64075148, + "LWD2000": 35.70065459, + "LWD4000": 18.55142459, + "LWD8000": 15.26823276, + "P10": "-71.22414851", + "P25": -63.07444198, + "P50": -56.15759518, + "P75": -50.84644163, + "P90": -47.20227795, + "Alpha": 1, + "T": 3 + }, + { + "ID_g": 3, + "ID_File": 0, + "LWD63": 45.43636393, + "LWD125": 44.91818262, + "LWD250": 50.81487173, + "LWD500": 50.78134338, + "LWD1000": 45.09195805, + "LWD2000": 39.96359775, + "LWD4000": 23.62663871, + "LWD8000": 18.53158473, + "P10": "-67.38643799", + "P25": -59.18294868, + "P50": -52.46710665, + "P75": -47.14174886, + "P90": -43.82334959, + "Alpha": 1.5, + "T": 4 + }, + { + "ID_g": 4, + "ID_File": 0, + "LWD63": 46.84684195, + "LWD125": 48.61257023, + "LWD250": 56.31731322, + "LWD500": 51.86752744, + "LWD1000": 47.05954887, + "LWD2000": 38.42505456, + "LWD4000": 26.70331421, + "LWD8000": 21.46986524, + "P10": "-64.28839879", + "P25": -55.98893183, + "P50": -49.17090167, + "P75": -44.15907794, + "P90": -40.59457017, + "Alpha": 2, + "T": 5 + }, + { + "ID_g": 5, + "ID_File": 0, + "LWD63": 48.12195333, + "LWD125": 52.72858513, + "LWD250": 60.55259119, + "LWD500": 57.31928522, + "LWD1000": 48.95574261, + "LWD2000": 42.88373457, + "LWD4000": 30.75973935, + "LWD8000": 29.62011514, + "P10": "-59.18294868", + "P25": -51.03324215, + "P50": -44.73392668, + "P75": -39.96508074, + "P90": -36.66609717, + "Alpha": 2.5, + "T": 6 + }, + { + "ID_g": 6, + "ID_File": 0, + "LWD63": 51.60843724, + "LWD125": 59.41244786, + "LWD250": 64.77963438, + "LWD500": 63.6167225, + "LWD1000": 53.13816684, + "LWD2000": 52.17404897, + "LWD4000": 37.69494391, + "LWD8000": 31.89010827, + "P10": "-55.50174491", + "P25": -47.20227795, + "P50": -40.23318504, + "P75": -34.93623667, + "P90": -31.30170161, + "Alpha": 3, + "T": 7 + }, + { + "ID_g": 7, + "ID_File": 0, + "LWD63": 49.74826376, + "LWD125": 56.23639445, + "LWD250": 64.68954264, + "LWD500": 69.00324705, + "LWD1000": 64.50532785, + "LWD2000": 60.26134132, + "LWD4000": 49.18032448, + "LWD8000": 43.6701882, + "P10": "-50.66357404", + "P25": -42.52567701, + "P50": -35.53338753, + "P75": -30.59149155, + "P90": -27.47937632, + "Alpha": 3.5, + "T": 8 + }, + { + "ID_g": 8, + "ID_File": 0, + "LWD63": 48.25265655, + "LWD125": 59.98150109, + "LWD250": 65.61978707, + "LWD500": 64.51372572, + "LWD1000": 57.63817637, + "LWD2000": 51.09536173, + "LWD4000": 42.26764245, + "LWD8000": 35.83703972, + "P10": "-53.4070379", + "P25": -45.01264224, + "P50": -38.5547794, + "P75": -33.73580077, + "P90": -30.37876526, + "Alpha": 4, + "T": 9 + }, + { + "ID_g": 9, + "ID_File": 0, + "LWD63": 51.65425313, + "LWD125": 61.02357484, + "LWD250": 67.69508501, + "LWD500": 66.81143952, + "LWD1000": 59.57264194, + "LWD2000": 58.33301823, + "LWD4000": 48.94669147, + "LWD8000": 37.59473834, + "P10": "-50.48447719", + "P25": -42.66865785, + "P50": -36.45206031, + "P75": -31.52860317, + "P90": -28.1580161, + "Alpha": 4.5, + "T": 10 + }, + { + "ID_g": 10, + "ID_File": 0, + "LWD63": 49.04153228, + "LWD125": 56.25824811, + "LWD250": 66.45588761, + "LWD500": 61.23852909, + "LWD1000": 57.95732453, + "LWD2000": 50.85837288, + "LWD4000": 39.13690687, + "LWD8000": 33.3416064, + "P10": "-54.46116491", + "P25": -46.22659905, + "P50": -39.70500474, + "P75": -34.9956276, + "P90": -31.06161199, + "Alpha": 5, + "T": 11 + }, + { + "ID_g": 11, + "ID_File": 0, + "LWD63": 50.7335993, + "LWD125": 56.22943899, + "LWD250": 68.27426328, + "LWD500": 68.92848391, + "LWD1000": 60.42752562, + "LWD2000": 51.3651625, + "LWD4000": 41.98752119, + "LWD8000": 32.27752189, + "P10": "-53.67168867", + "P25": -45.34953337, + "P50": -38.13847803, + "P75": -32.18229786, + "P90": -27.43621399, + "Alpha": 5.5, + "T": 12 + }, + { + "ID_g": 12, + "ID_File": 0, + "LWD63": 51.17544988, + "LWD125": 56.53023166, + "LWD250": 72.61918454, + "LWD500": 65.28749552, + "LWD1000": 60.87690937, + "LWD2000": 52.98911521, + "LWD4000": 44.79948801, + "LWD8000": 38.08434318, + "P10": "-50.22257122", + "P25": -42.21232437, + "P50": -35.17627653, + "P75": -30.0606912, + "P90": -25.78680044, + "Alpha": 6, + "T": 13 + }, + { + "ID_g": 13, + "ID_File": 0, + "LWD63": 52.071657, + "LWD125": 60.11198185, + "LWD250": 66.81188251, + "LWD500": 66.91431202, + "LWD1000": 60.95636901, + "LWD2000": 54.04837244, + "LWD4000": 47.3104794, + "LWD8000": 37.5314452, + "P10": "-50.84644163", + "P25": -42.81403178, + "P50": -36.39936517, + "P75": -31.63925294, + "P90": -28.27405722, + "Alpha": 6.5, + "T": 14 + }, + { + "ID_g": 14, + "ID_File": 0, + "LWD63": 51.07134803, + "LWD125": 55.10740685, + "LWD250": 61.26604461, + "LWD500": 62.24162772, + "LWD1000": 59.26437829, + "LWD2000": 48.0160612, + "LWD4000": 40.03773083, + "LWD8000": 39.81874918, + "P10": "-56.15759518", + "P25": -48.03013165, + "P50": -41.42810278, + "P75": -36.61209147, + "P90": -33.02946375, + "Alpha": 7, + "T": 15 + }, + { + "ID_g": 15, + "ID_File": 0, + "LWD63": 52.09205372, + "LWD125": 53.91396175, + "LWD250": 63.09756478, + "LWD500": 62.4262505, + "LWD1000": 56.04886499, + "LWD2000": 45.01236966, + "LWD4000": 36.21916769, + "LWD8000": 39.02720554, + "P10": "-56.15759518", + "P25": -48.03013165, + "P50": -41.30401653, + "P75": -36.52282152, + "P90": -32.94787146, + "Alpha": 7.5, + "T": 16 + }, + { + "ID_g": 16, + "ID_File": 0, + "LWD63": 52.83595376, + "LWD125": 59.90985705, + "LWD250": 69.41813576, + "LWD500": 66.03720918, + "LWD1000": 59.39316907, + "LWD2000": 52.77110001, + "LWD4000": 44.45852449, + "LWD8000": 35.31610418, + "P10": "-50.58256502", + "P25": -42.49029656, + "P50": -35.90581263, + "P75": -31.06161199, + "P90": -27.87780182, + "Alpha": 8, + "T": 17 + }, + { + "ID_g": 17, + "ID_File": 0, + "LWD63": 51.4554166, + "LWD125": 61.57772067, + "LWD250": 67.84116604, + "LWD500": 71.74155844, + "LWD1000": 58.27512489, + "LWD2000": 53.89604743, + "LWD4000": 47.01200201, + "LWD8000": 39.55192282, + "P10": "-48.65329129", + "P25": -40.31525705, + "P50": -33.73580077, + "P75": -28.91563676, + "P90": -25.78215696, + "Alpha": 8.5, + "T": 18 + }, + { + "ID_g": 18, + "ID_File": 0, + "LWD63": 52.46358225, + "LWD125": 55.74668319, + "LWD250": 66.15765826, + "LWD500": 65.05010802, + "LWD1000": 59.04773138, + "LWD2000": 50.58297141, + "LWD4000": 42.27320037, + "LWD8000": 38.42302699, + "P10": "-53.78750265", + "P25": -45.44823773, + "P50": -38.64502322, + "P75": -33.41945518, + "P90": -30.12848386, + "Alpha": 9, + "T": 19 + }, + { + "ID_g": 19, + "ID_File": 0, + "LWD63": 51.90883292, + "LWD125": 57.11719075, + "LWD250": 67.24716546, + "LWD500": 68.10132933, + "LWD1000": 64.60386124, + "LWD2000": 51.53185627, + "LWD4000": 43.58871783, + "LWD8000": 38.79091302, + "P10": "-51.51861365", + "P25": -43.78228148, + "P50": -37.42022691, + "P75": -32.36745864, + "P90": -28.50383764, + "Alpha": 9.5, + "T": 20 + }, + { + "ID_g": 20, + "ID_File": 1, + "LWD63": 40.92625229, + "LWD125": 45.34331258, + "LWD250": 41.04977674, + "LWD500": 35.3345088, + "LWD1000": 30.75212395, + "LWD2000": 21.74364676, + "LWD4000": 14.65275385, + "LWD8000": 13.68973399, + "P10": "-90.3089987", + "P25": -80.7665736, + "P50": -73.4070379, + "P75": -67.38643799, + "P90": -60.20599913, + "Alpha": 0, + "T": 1 + }, + { + "ID_g": 21, + "ID_File": 1, + "LWD63": 44.56799899, + "LWD125": 49.76990017, + "LWD250": 46.87700165, + "LWD500": 43.01712626, + "LWD1000": 40.0909368, + "LWD2000": 33.23980278, + "LWD4000": 19.49856692, + "LWD8000": 17.85404802, + "P10": "-84.28839879", + "P25": -76.32959861, + "P50": -68.72537378, + "P75": -62.35019853, + "P90": -55.19150159, + "Alpha": 0.5, + "T": 2 + }, + { + "ID_g": 22, + "ID_File": 1, + "LWD63": 46.74612753, + "LWD125": 64.01451796, + "LWD250": 61.70929962, + "LWD500": 66.56679565, + "LWD1000": 61.22905324, + "LWD2000": 57.94034992, + "LWD4000": 51.78854815, + "LWD8000": 32.8109372, + "P10": "-59.42763781", + "P25": -51.51861365, + "P50": -45.25193808, + "P75": -40.48176482, + "P90": -36.92266109, + "Alpha": 1, + "T": 3 + }, + { + "ID_g": 23, + "ID_File": 1, + "LWD63": 43.48107985, + "LWD125": 56.76407984, + "LWD250": 49.0879455, + "LWD500": 49.1562472, + "LWD1000": 48.9639333, + "LWD2000": 45.74490841, + "LWD4000": 35.20162547, + "LWD8000": 36.70689573, + "P10": "-78.26779887", + "P25": -70.3089987, + "P50": -63.07444198, + "P75": -57.24474842, + "P90": -50.93933973, + "Alpha": 1.5, + "T": 4 + }, + { + "ID_g": 24, + "ID_File": 1, + "LWD63": 40.745378, + "LWD125": 45.78356622, + "LWD250": 57.54238718, + "LWD500": 64.49925508, + "LWD1000": 62.1960398, + "LWD2000": 57.42514248, + "LWD4000": 56.16488352, + "LWD8000": 43.09881976, + "P10": "-66.22659905", + "P25": -57.63962959, + "P50": -50.39629481, + "P75": -44.28839879, + "P90": -39.70500474, + "Alpha": 2, + "T": 5 + }, + { + "ID_g": 25, + "ID_File": 1, + "LWD63": 50.86215574, + "LWD125": 68.91226253, + "LWD250": 64.50250082, + "LWD500": 67.27297545, + "LWD1000": 57.56493148, + "LWD2000": 53.80500855, + "LWD4000": 46.13433234, + "LWD8000": 40.41538348, + "P10": "-73.4070379", + "P25": -64.73392668, + "P50": -57.05384207, + "P75": -43.46054508, + "P90": -35.36076254, + "Alpha": 2.5, + "T": 6 + }, + { + "ID_g": 26, + "ID_File": 1, + "LWD63": 52.27122886, + "LWD125": 72.75524035, + "LWD250": 66.21669331, + "LWD500": 73.48849739, + "LWD1000": 69.03646807, + "LWD2000": 64.09664782, + "LWD4000": 55.06385562, + "LWD8000": 53.48320604, + "P10": "-53.4070379", + "P25": -45.49801373, + "P50": -38.62237421, + "P75": -33.59518727, + "P90": -30.02699227, + "Alpha": 3, + "T": 7 + }, + { + "ID_g": 27, + "ID_File": 1, + "LWD63": 54.35423662, + "LWD125": 69.38426718, + "LWD250": 70.74977873, + "LWD500": 74.30978272, + "LWD1000": 64.04016835, + "LWD2000": 58.46190138, + "LWD4000": 52.785335, + "LWD8000": 39.05379705, + "P10": "-63.07444198", + "P25": -54.89195847, + "P50": -46.44650673, + "P75": -36.94128037, + "P90": -30.61845243, + "Alpha": 3.5, + "T": 8 + }, + { + "ID_g": 28, + "ID_File": 1, + "LWD63": 48.86396824, + "LWD125": 53.74582164, + "LWD250": 52.94802336, + "LWD500": 52.24263249, + "LWD1000": 55.03715343, + "LWD2000": 43.72595893, + "LWD4000": 35.19311902, + "LWD8000": 35.93571067, + "P10": "-70.3089987", + "P25": -62.00953174, + "P50": -55.04043883, + "P75": -50.22257122, + "P90": -47.02194158, + "Alpha": 4, + "T": 9 + }, + { + "ID_g": 29, + "ID_File": 1, + "LWD63": 45.92600173, + "LWD125": 53.55006882, + "LWD250": 62.77806107, + "LWD500": 69.4219841, + "LWD1000": 59.84711457, + "LWD2000": 53.88674968, + "LWD4000": 54.47337645, + "LWD8000": 46.70256642, + "P10": "-61.06103874", + "P25": -53.0425415, + "P50": -46.22659905, + "P75": -40.42590682, + "P90": -36.00565154, + "Alpha": 4.5, + "T": 10 + }, + { + "ID_g": 30, + "ID_File": 1, + "LWD63": 55.00779871, + "LWD125": 58.8153, + "LWD250": 65.57470441, + "LWD500": 67.70619766, + "LWD1000": 58.78551236, + "LWD2000": 53.10403535, + "LWD4000": 48.31732983, + "LWD8000": 43.57051081, + "P10": "-59.42763781", + "P25": -51.32119857, + "P50": -44.73392668, + "P75": -40.01804365, + "P90": -36.92266109, + "Alpha": 5, + "T": 11 + }, + { + "ID_g": 31, + "ID_File": 1, + "LWD63": 46.08443726, + "LWD125": 51.71152985, + "LWD250": 55.592421, + "LWD500": 50.11291835, + "LWD1000": 49.87245004, + "LWD2000": 43.79113312, + "LWD4000": 37.05621565, + "LWD8000": 37.29087256, + "P10": "-71.22414851", + "P25": -63.46054508, + "P50": -57.24474842, + "P75": -52.24719896, + "P90": -48.51089647, + "Alpha": 5.5, + "T": 12 + }, + { + "ID_g": 32, + "ID_File": 1, + "LWD63": 51.60903848, + "LWD125": 56.24040866, + "LWD250": 54.55917777, + "LWD500": 51.78834216, + "LWD1000": 46.40530005, + "LWD2000": 43.426749, + "LWD4000": 38.03909869, + "LWD8000": 39.09567312, + "P10": "-72.24719896", + "P25": -64.28839879, + "P50": -57.43994517, + "P75": -52.5791842, + "P90": -48.3015878, + "Alpha": 6, + "T": 13 + }, + { + "ID_g": 33, + "ID_File": 1, + "LWD63": 56.85339755, + "LWD125": 75.92984625, + "LWD250": 73.24409562, + "LWD500": 74.47275621, + "LWD1000": 71.62717054, + "LWD2000": 63.24646347, + "LWD4000": 54.58160039, + "LWD8000": 48.46940169, + "P10": "-49.80288139", + "P25": -41.58574576, + "P50": -35.31427239, + "P75": -30.62745802, + "P90": -27.29325628, + "Alpha": 6.5, + "T": 14 + }, + { + "ID_g": 34, + "ID_File": 1, + "LWD63": 51.70121905, + "LWD125": 71.31236317, + "LWD250": 64.9377966, + "LWD500": 72.33622676, + "LWD1000": 67.98591485, + "LWD2000": 54.68696205, + "LWD4000": 45.90271896, + "LWD8000": 48.99365103, + "P10": "-56.32959861", + "P25": -48.16479931, + "P50": -41.39691463, + "P75": -35.95558864, + "P90": -32.23634838, + "Alpha": 7, + "T": 15 + }, + { + "ID_g": 35, + "ID_File": 1, + "LWD63": 53.35549601, + "LWD125": 72.72897796, + "LWD250": 71.84738841, + "LWD500": 71.12876902, + "LWD1000": 65.43789486, + "LWD2000": 56.8357187, + "LWD4000": 51.98555934, + "LWD8000": 42.49071199, + "P10": "-53.53201688", + "P25": -45.59842976, + "P50": -39.25563438, + "P75": -34.59173137, + "P90": -30.79025829, + "Alpha": 7.5, + "T": 16 + }, + { + "ID_g": 36, + "ID_File": 1, + "LWD63": 52.00096753, + "LWD125": 69.18097771, + "LWD250": 68.86589126, + "LWD500": 74.07988691, + "LWD1000": 65.04005884, + "LWD2000": 47.78752068, + "LWD4000": 41.36075773, + "LWD8000": 34.27423795, + "P10": "-60.7665736", + "P25": -52.24719896, + "P50": -43.6602295, + "P75": -35.23733752, + "P90": -30.53781956, + "Alpha": 8, + "T": 17 + }, + { + "ID_g": 37, + "ID_File": 1, + "LWD63": 54.45839687, + "LWD125": 72.01734572, + "LWD250": 67.26951961, + "LWD500": 71.38006855, + "LWD1000": 64.55391769, + "LWD2000": 50.68605202, + "LWD4000": 43.20253599, + "LWD8000": 36.82152423, + "P10": "-56.32959861", + "P25": -47.83196588, + "P50": -40.56623119, + "P75": -35.10054903, + "P90": -31.498669, + "Alpha": 8.5, + "T": 18 + }, + { + "ID_g": 38, + "ID_File": 1, + "LWD63": 55.47639423, + "LWD125": 72.11490143, + "LWD250": 66.81400675, + "LWD500": 71.56162204, + "LWD1000": 74.40795349, + "LWD2000": 64.08273061, + "LWD4000": 56.4946285, + "LWD8000": 52.25034214, + "P10": "-54.32218771", + "P25": -46.05196539, + "P50": -38.31133726, + "P75": -32.69272685, + "P90": -28.95270848, + "Alpha": 9, + "T": 19 + }, + { + "ID_g": 39, + "ID_File": 1, + "LWD63": 44.94560518, + "LWD125": 60.28617958, + "LWD250": 55.72862075, + "LWD500": 61.76902362, + "LWD1000": 62.84779593, + "LWD2000": 49.90543962, + "LWD4000": 42.69318364, + "LWD8000": 35.72627474, + "P10": "-66.78717352", + "P25": -58.94496422, + "P50": -52.35645687, + "P75": -46.22659905, + "P90": -40.97164629, + "Alpha": 9.5, + "T": 20 + }, + { + "ID_g": 40, + "ID_File": 2, + "LWD63": 41.6551895, + "LWD125": 44.89768852, + "LWD250": 61.5741173, + "LWD500": 61.86553465, + "LWD1000": 57.66946804, + "LWD2000": 57.86715351, + "LWD4000": 47.12427347, + "LWD8000": 37.33072638, + "P10": "-70.3089987", + "P25": -48.51089647, + "P50": -35.3918948, + "P75": -25.32992639, + "P90": -21.34105663, + "Alpha": 0, + "T": 1 + }, + { + "ID_g": 41, + "ID_File": 2, + "LWD63": 33.71148936, + "LWD125": 42.69708702, + "LWD250": 59.17901978, + "LWD500": 60.42472112, + "LWD1000": 64.50652658, + "LWD2000": 60.57709256, + "LWD4000": 53.7360279, + "LWD8000": 45.3504405, + "P10": "-46.44650673", + "P25": -38.1813714, + "P50": -29.88521272, + "P75": -23.60786831, + "P90": -19.5423006, + "Alpha": 0.5, + "T": 2 + }, + { + "ID_g": 42, + "ID_File": 2, + "LWD63": 38.19972301, + "LWD125": 49.73990299, + "LWD250": 60.97661602, + "LWD500": 67.72551624, + "LWD1000": 55.82685755, + "LWD2000": 55.85164516, + "LWD4000": 42.42943235, + "LWD8000": 35.5952854, + "P10": "-57.84401289", + "P25": -48.16479931, + "P50": -32.87753999, + "P75": -22.98894948, + "P90": -17.82542018, + "Alpha": 1, + "T": 3 + }, + { + "ID_g": 43, + "ID_File": 2, + "LWD63": 35.82744337, + "LWD125": 53.09519029, + "LWD250": 61.45033352, + "LWD500": 64.24152413, + "LWD1000": 51.89180731, + "LWD2000": 50.72282335, + "LWD4000": 49.66354976, + "LWD8000": 42.63664995, + "P10": "-45.59842976", + "P25": -37.26407188, + "P50": -30.23978806, + "P75": -24.3101407, + "P90": -20.16781104, + "Alpha": 1.5, + "T": 4 + }, + { + "ID_g": 44, + "ID_File": 2, + "LWD63": 30.41168337, + "LWD125": 41.59628146, + "LWD250": 50.75991933, + "LWD500": 56.62799579, + "LWD1000": 42.3827219, + "LWD2000": 50.98720011, + "LWD4000": 37.16964627, + "LWD8000": 32.36828308, + "P10": "-60.20599913", + "P25": -51.92743685, + "P50": -43.98959179, + "P75": -35.92652095, + "P90": -29.36350135, + "Alpha": 2, + "T": 5 + }, + { + "ID_g": 45, + "ID_File": 2, + "LWD63": 28.46865831, + "LWD125": 46.13509263, + "LWD250": 60.06555039, + "LWD500": 64.67488991, + "LWD1000": 59.25497044, + "LWD2000": 52.53291607, + "LWD4000": 48.01027693, + "LWD8000": 50.43571689, + "P10": "-48.58180209", + "P25": -40.0446467, + "P50": -31.89609867, + "P75": -24.75223204, + "P90": -19.87813053, + "Alpha": 2.5, + "T": 6 + }, + { + "ID_g": 46, + "ID_File": 2, + "LWD63": 29.31658717, + "LWD125": 30.53963696, + "LWD250": 39.76779262, + "LWD500": 46.952822, + "LWD1000": 59.09581397, + "LWD2000": 52.49916955, + "LWD4000": 35.61028998, + "LWD8000": 36.95624625, + "P10": "-61.06103874", + "P25": -51.92743685, + "P50": -41.77877347, + "P75": -32.77309918, + "P90": -26.68356327, + "Alpha": 3, + "T": 7 + }, + { + "ID_g": 47, + "ID_File": 2, + "LWD63": 31.42274521, + "LWD125": 48.65324073, + "LWD250": 50.77099079, + "LWD500": 61.66761989, + "LWD1000": 52.6174557, + "LWD2000": 45.19286651, + "LWD4000": 39.50995607, + "LWD8000": 44.33243253, + "P10": "-59.67942036", + "P25": -48.37079844, + "P50": -39.07505622, + "P75": -30.29164427, + "P90": -24.17192373, + "Alpha": 3.5, + "T": 8 + }, + { + "ID_g": 48, + "ID_File": 2, + "LWD63": 33.46683417, + "LWD125": 49.17249564, + "LWD250": 57.44618753, + "LWD500": 62.43596507, + "LWD1000": 50.8802898, + "LWD2000": 45.55161623, + "LWD4000": 42.74538137, + "LWD8000": 36.25310242, + "P10": "-48.94528146", + "P25": -40.88316448, + "P50": -33.75515533, + "P75": -27.58092974, + "P90": -23.61188491, + "Alpha": 4, + "T": 9 + }, + { + "ID_g": 49, + "ID_File": 2, + "LWD63": 29.34027694, + "LWD125": 37.24707179, + "LWD250": 47.87895665, + "LWD500": 52.43619654, + "LWD1000": 54.48946344, + "LWD2000": 50.29154914, + "LWD4000": 40.17508262, + "LWD8000": 34.30298628, + "P10": "-53.16234877", + "P25": -44.91873981, + "P50": -37.80274968, + "P75": -32.69272685, + "P90": -29.02732998, + "Alpha": 4.5, + "T": 10 + }, + { + "ID_g": 50, + "ID_File": 2, + "LWD63": 29.33439367, + "LWD125": 34.48158997, + "LWD250": 48.68580642, + "LWD500": 54.5740967, + "LWD1000": 48.23380178, + "LWD2000": 39.81528092, + "LWD4000": 44.245808, + "LWD8000": 48.60509784, + "P10": "-53.28383172", + "P25": -45.39874534, + "P50": -38.92152051, + "P75": -33.89183891, + "P90": -30.20538845, + "Alpha": 5, + "T": 11 + }, + { + "ID_g": 51, + "ID_File": 2, + "LWD63": 27.77695236, + "LWD125": 54.25650544, + "LWD250": 60.0421829, + "LWD500": 63.57654466, + "LWD1000": 52.43623567, + "LWD2000": 54.29104612, + "LWD4000": 41.25727444, + "LWD8000": 41.67508795, + "P10": "-53.28383172", + "P25": -43.06502126, + "P50": -31.34073938, + "P75": -24.78435954, + "P90": -20.84480841, + "Alpha": 5.5, + "T": 12 + }, + { + "ID_g": 52, + "ID_File": 2, + "LWD63": 38.2455563, + "LWD125": 57.41583659, + "LWD250": 63.8104558, + "LWD500": 63.3569591, + "LWD1000": 52.87446826, + "LWD2000": 58.06145224, + "LWD4000": 44.73205161, + "LWD8000": 44.09460461, + "P10": "-45.39874534", + "P25": -36.86704154, + "P50": -29.82749895, + "P75": -23.74752633, + "P90": -19.87551713, + "Alpha": 6, + "T": 13 + }, + { + "ID_g": 53, + "ID_File": 2, + "LWD63": 37.77811157, + "LWD125": 42.58054468, + "LWD250": 57.41893994, + "LWD500": 56.27205103, + "LWD1000": 45.20070117, + "LWD2000": 50.00686485, + "LWD4000": 41.24692823, + "LWD8000": 37.98170498, + "P10": "-59.42763781", + "P25": -51.72062018, + "P50": -43.07444198, + "P75": -34.4471667, + "P90": -27.52968934, + "Alpha": 6.5, + "T": 14 + }, + { + "ID_g": 54, + "ID_File": 2, + "LWD63": 43.23887183, + "LWD125": 32.60877044, + "LWD250": 57.58762044, + "LWD500": 54.30779043, + "LWD1000": 48.58663722, + "LWD2000": 46.03807312, + "LWD4000": 44.52638041, + "LWD8000": 46.92268587, + "P10": "-51.32119857", + "P25": -42.70477386, + "P50": -35.65308845, + "P75": -30.71803121, + "P90": -27.61271129, + "Alpha": 7, + "T": 15 + }, + { + "ID_g": 55, + "ID_File": 2, + "LWD63": 30.14716798, + "LWD125": 45.70244256, + "LWD250": 63.07837368, + "LWD500": 60.73196087, + "LWD1000": 47.01694011, + "LWD2000": 51.84331764, + "LWD4000": 44.51320464, + "LWD8000": 55.0817526, + "P10": "-48.72537378", + "P25": -40.23318504, + "P50": -32.9950775, + "P75": -26.29198874, + "P90": -21.48735603, + "Alpha": 7.5, + "T": 16 + }, + { + "ID_g": 56, + "ID_File": 2, + "LWD63": 23.14116951, + "LWD125": 31.05835417, + "LWD250": 44.08162864, + "LWD500": 46.68034913, + "LWD1000": 41.73301467, + "LWD2000": 36.69262347, + "LWD4000": 32.22997427, + "LWD8000": 26.68613132, + "P10": "-65.2035486", + "P25": -56.86704154, + "P50": -49.72132315, + "P75": -42.49029656, + "P90": -37.05384207, + "Alpha": 8, + "T": 17 + }, + { + "ID_g": 57, + "ID_File": 2, + "LWD63": 17.41361316, + "LWD125": 21.47843301, + "LWD250": 41.96727561, + "LWD500": 39.69747989, + "LWD1000": 37.72402823, + "LWD2000": 37.93187553, + "LWD4000": 32.08790935, + "LWD8000": 22.85980867, + "P10": "-78.26779887", + "P25": -68.72537378, + "P50": -57.63962959, + "P75": -46.39100565, + "P90": -41.18167804, + "Alpha": 8.5, + "T": 18 + }, + { + "ID_g": 58, + "ID_File": 2, + "LWD63": 20.0255059, + "LWD125": 29.78342364, + "LWD250": 50.89154645, + "LWD500": 48.0046098, + "LWD1000": 37.13459364, + "LWD2000": 37.41110842, + "LWD4000": 32.4173763, + "LWD8000": 29.63589668, + "P10": "-73.4070379", + "P25": -64.28839879, + "P50": -51.92743685, + "P75": -40.68014613, + "P90": -34.01073507, + "Alpha": 9, + "T": 19 + }, + { + "ID_g": 59, + "ID_File": 2, + "LWD63": 21.51209308, + "LWD125": 31.22749779, + "LWD250": 48.8056598, + "LWD500": 46.92434451, + "LWD1000": 46.90096082, + "LWD2000": 46.35489579, + "LWD4000": 38.8613812, + "LWD8000": 43.51137967, + "P10": "-58.05332156", + "P25": -49.96833191, + "P50": -42.999239, + "P75": -37.07274499, + "P90": -32.98325192, + "Alpha": 9.5, + "T": 20 + }, + { + "ID_g": 60, + "ID_File": 3, + "LWD63": 6.879083029, + "LWD125": 0.083390745, + "LWD250": 7.43088695, + "LWD500": -1.555508412, + "LWD1000": -10.16617085, + "LWD2000": -11.23697708, + "LWD4000": -9.562688419, + "LWD8000": -2.627292332, + "P10": "#NAME?", + "P25": -90.3089987, + "P50": -78.26779887, + "P75": -70.3089987, + "P90": -65.2035486, + "Alpha": 0, + "T": 1 + }, + { + "ID_g": 61, + "ID_File": 3, + "LWD63": 13.39356246, + "LWD125": 18.48323055, + "LWD250": 22.27727833, + "LWD500": 16.20522922, + "LWD1000": 12.4129952, + "LWD2000": 13.30007757, + "LWD4000": 7.570095829, + "LWD8000": 1.500768485, + "P10": "-78.26779887", + "P25": -68.72537378, + "P50": -62.00953174, + "P75": -56.5050771, + "P90": -52.03272165, + "Alpha": 0.5, + "T": 2 + }, + { + "ID_g": 62, + "ID_File": 3, + "LWD63": 20.61013227, + "LWD125": 26.38706218, + "LWD250": 35.26600564, + "LWD500": 48.49596797, + "LWD1000": 33.44618785, + "LWD2000": 33.16594458, + "LWD4000": 29.46849923, + "LWD8000": 8.247624387, + "P10": "-61.06103874", + "P25": -53.0425415, + "P50": -46.11869841, + "P75": -39.73066469, + "P90": -30.95803917, + "Alpha": 1, + "T": 3 + }, + { + "ID_g": 63, + "ID_File": 3, + "LWD63": 29.29760814, + "LWD125": 33.38507522, + "LWD250": 46.33172577, + "LWD500": 43.38087301, + "LWD1000": 30.74159142, + "LWD2000": 35.23926205, + "LWD4000": 30.28539476, + "LWD8000": 8.166160731, + "P10": "-54.32218771", + "P25": -46.44650673, + "P50": -39.78221315, + "P75": -34.87724908, + "P90": -30.74538836, + "Alpha": 1.5, + "T": 4 + }, + { + "ID_g": 64, + "ID_File": 3, + "LWD63": 35.54909896, + "LWD125": 38.60778306, + "LWD250": 48.40701624, + "LWD500": 44.39616237, + "LWD1000": 36.75747191, + "LWD2000": 35.40321158, + "LWD4000": 31.75708276, + "LWD8000": 9.286201753, + "P10": "-51.61902967", + "P25": -43.11228905, + "P50": -36.15759518, + "P75": -30.82798064, + "P90": -26.87446963, + "Alpha": 2, + "T": 5 + }, + { + "ID_g": 65, + "ID_File": 3, + "LWD63": 41.68258301, + "LWD125": 41.70567534, + "LWD250": 50.16720732, + "LWD500": 51.10910764, + "LWD1000": 53.48926825, + "LWD2000": 43.49953613, + "LWD4000": 33.96313618, + "LWD8000": 17.66417257, + "P10": "-45.80281306", + "P25": -37.82335678, + "P50": -31.09007478, + "P75": -25.43459945, + "P90": -20.6312646, + "Alpha": 2.5, + "T": 6 + }, + { + "ID_g": 66, + "ID_File": 3, + "LWD63": 45.69927079, + "LWD125": 48.20635335, + "LWD250": 54.25762995, + "LWD500": 52.20125572, + "LWD1000": 54.95563086, + "LWD2000": 45.86395628, + "LWD4000": 33.47397212, + "LWD8000": 16.57184618, + "P10": "-43.57980402", + "P25": -35.25267008, + "P50": -28.14446557, + "P75": -22.37455313, + "P90": -17.71836042, + "Alpha": 3, + "T": 7 + }, + { + "ID_g": 67, + "ID_File": 3, + "LWD63": 46.26210959, + "LWD125": 53.86656738, + "LWD250": 57.18597704, + "LWD500": 55.78850783, + "LWD1000": 42.55276912, + "LWD2000": 47.4055081, + "LWD4000": 39.42699527, + "LWD8000": 20.73427745, + "P10": "-39.67942036", + "P25": -31.86487315, + "P50": -25.09326533, + "P75": -20.10614471, + "P90": -16.78226103, + "Alpha": 3.5, + "T": 8 + }, + { + "ID_g": 68, + "ID_File": 3, + "LWD63": 44.66310328, + "LWD125": 52.61976775, + "LWD250": 55.69753506, + "LWD500": 44.81121569, + "LWD1000": 31.47757862, + "LWD2000": 36.2651833, + "LWD4000": 37.62790275, + "LWD8000": 19.4349713, + "P10": "-46.962652", + "P25": -38.69049919, + "P50": -31.27253799, + "P75": -24.08239965, + "P90": -18.69962302, + "Alpha": 4, + "T": 9 + }, + { + "ID_g": 69, + "ID_File": 3, + "LWD63": 42.64227193, + "LWD125": 48.58682716, + "LWD250": 46.37307987, + "LWD500": 39.74712074, + "LWD1000": 30.55235566, + "LWD2000": 40.97378599, + "LWD4000": 38.8940665, + "LWD8000": 20.55905941, + "P10": "-49.40253912", + "P25": -41.03113892, + "P50": -34.37751203, + "P75": -29.09504189, + "P90": -25.13146611, + "Alpha": 4.5, + "T": 10 + }, + { + "ID_g": 70, + "ID_File": 3, + "LWD63": 47.35834369, + "LWD125": 52.19015065, + "LWD250": 51.80095647, + "LWD500": 38.88651987, + "LWD1000": 36.89582038, + "LWD2000": 52.58648586, + "LWD4000": 44.32256355, + "LWD8000": 20.55996703, + "P10": "-43.53986883", + "P25": -35.85632025, + "P50": -28.95270848, + "P75": -23.54784119, + "P90": -19.89932804, + "Alpha": 5, + "T": 11 + }, + { + "ID_g": 71, + "ID_File": 3, + "LWD63": 46.75225996, + "LWD125": 55.72937989, + "LWD250": 61.50837379, + "LWD500": 50.23972905, + "LWD1000": 49.53357014, + "LWD2000": 58.26619453, + "LWD4000": 47.66163627, + "LWD8000": 28.32072034, + "P10": "-36.75685964", + "P25": -28.440565, + "P50": -21.66565331, + "P75": -16.47720298, + "P90": -13.18288137, + "Alpha": 5.5, + "T": 12 + }, + { + "ID_g": 72, + "ID_File": 3, + "LWD63": 45.22481732, + "LWD125": 51.23157367, + "LWD250": 59.5185193, + "LWD500": 56.29889488, + "LWD1000": 49.11669478, + "LWD2000": 54.04625559, + "LWD4000": 43.86792064, + "LWD8000": 27.78673322, + "P10": "-39.70500474", + "P25": -31.32852225, + "P50": -24.13771043, + "P75": -18.88472456, + "P90": -14.96127983, + "Alpha": 6, + "T": 13 + }, + { + "ID_g": 73, + "ID_File": 3, + "LWD63": 45.59085762, + "LWD125": 52.6446192, + "LWD250": 54.16913484, + "LWD500": 63.18556496, + "LWD1000": 52.29184603, + "LWD2000": 50.36902014, + "LWD4000": 37.8941237, + "LWD8000": 19.5049001, + "P10": "-37.16788164", + "P25": -28.98993909, + "P50": -21.95292425, + "P75": -16.64310374, + "P90": -12.58561645, + "Alpha": 6.5, + "T": 14 + }, + { + "ID_g": 74, + "ID_File": 3, + "LWD63": 46.19872004, + "LWD125": 54.05709259, + "LWD250": 55.89177092, + "LWD500": 54.54849346, + "LWD1000": 44.77089474, + "LWD2000": 46.40155673, + "LWD4000": 37.17900166, + "LWD8000": 15.95044276, + "P10": "-40.07400818", + "P25": -31.84411833, + "P50": -25.53804095, + "P75": -20.81884592, + "P90": -17.36505705, + "Alpha": 7, + "T": 15 + }, + { + "ID_g": 75, + "ID_File": 3, + "LWD63": 42.499572, + "LWD125": 50.71662874, + "LWD250": 57.54846247, + "LWD500": 47.16865489, + "LWD1000": 44.6918256, + "LWD2000": 40.84951883, + "LWD4000": 32.47307703, + "LWD8000": 13.15534567, + "P10": "-42.999239", + "P25": -34.93623667, + "P50": -28.39166963, + "P75": -22.73377519, + "P90": -18.34632578, + "Alpha": 7.5, + "T": 16 + }, + { + "ID_g": 76, + "ID_File": 3, + "LWD63": 43.83893651, + "LWD125": 51.43321173, + "LWD250": 57.07816647, + "LWD500": 53.17449396, + "LWD1000": 40.10941658, + "LWD2000": 48.25349513, + "LWD4000": 37.5039263, + "LWD8000": 16.84904549, + "P10": "-41.2121015", + "P25": -32.91263454, + "P50": -25.79764443, + "P75": -20.78686436, + "P90": -17.7228459, + "Alpha": 8, + "T": 17 + }, + { + "ID_g": 77, + "ID_File": 3, + "LWD63": 44.29980154, + "LWD125": 54.85213462, + "LWD250": 59.72024712, + "LWD500": 53.05039205, + "LWD1000": 40.1549309, + "LWD2000": 49.96747227, + "LWD4000": 43.0848233, + "LWD8000": 22.97667978, + "P10": "-41.15136076", + "P25": -32.66989927, + "P50": -25.56566741, + "P75": -19.99417037, + "P90": -15.92237296, + "Alpha": 8.5, + "T": 18 + }, + { + "ID_g": 78, + "ID_File": 3, + "LWD63": 42.24310008, + "LWD125": 45.11240656, + "LWD250": 52.4964935, + "LWD500": 49.3744048, + "LWD1000": 49.03373427, + "LWD2000": 46.04937989, + "LWD4000": 38.77930689, + "LWD8000": 17.39351097, + "P10": "-44.41967418", + "P25": -36.34698779, + "P50": -29.22056905, + "P75": -23.91542904, + "P90": -20.42590682, + "Alpha": 9, + "T": 19 + }, + { + "ID_g": 79, + "ID_File": 3, + "LWD63": 43.7882723, + "LWD125": 48.19150198, + "LWD250": 55.41470628, + "LWD500": 52.76741472, + "LWD1000": 45.80626059, + "LWD2000": 46.59313542, + "LWD4000": 40.33340802, + "LWD8000": 19.64687127, + "P10": "-41.64961288", + "P25": -33.56986396, + "P50": -26.96856278, + "P75": -22.18927253, + "P90": -18.88880525, + "Alpha": 9.5, + "T": 20 + }, + { + "ID_g": 80, + "ID_File": 4, + "LWD63": 31.29960825, + "LWD125": 33.64778039, + "LWD250": 34.47486462, + "LWD500": 30.11166125, + "LWD1000": 27.22557136, + "LWD2000": 26.77190724, + "LWD4000": 22.6103484, + "LWD8000": 15.76305121, + "P10": "#NAME?", + "P25": -64.73392668, + "P50": -54.18539922, + "P75": -48.3015878, + "P90": -44.59785252, + "Alpha": 0, + "T": 1 + }, + { + "ID_g": 81, + "ID_File": 4, + "LWD63": 31.47720706, + "LWD125": 52.76048278, + "LWD250": 55.96795468, + "LWD500": 59.27026332, + "LWD1000": 57.13762753, + "LWD2000": 50.47123262, + "LWD4000": 41.1472919, + "LWD8000": 30.78233378, + "P10": "-58.26779887", + "P25": -49.01983891, + "P50": -34.84058732, + "P75": -26.79296604, + "P90": -21.08503293, + "Alpha": 0.5, + "T": 2 + }, + { + "ID_g": 82, + "ID_File": 4, + "LWD63": 27.20371621, + "LWD125": 30.06814896, + "LWD250": 49.19739937, + "LWD500": 46.90253159, + "LWD1000": 32.3886076, + "LWD2000": 34.08416195, + "LWD4000": 34.41253523, + "LWD8000": 35.17756488, + "P10": "-68.03013165", + "P25": -59.67942036, + "P50": -52.24719896, + "P75": -41.81136597, + "P90": -31.75133049, + "Alpha": 1, + "T": 3 + }, + { + "ID_g": 83, + "ID_File": 4, + "LWD63": 50.65903913, + "LWD125": 52.09437885, + "LWD250": 47.58542191, + "LWD500": 45.76842183, + "LWD1000": 42.73278664, + "LWD2000": 39.01136739, + "LWD4000": 33.9625482, + "LWD8000": 29.58454688, + "P10": "-59.67942036", + "P25": -50.39629481, + "P50": -39.80810256, + "P75": -32.42267745, + "P90": -27.64460956, + "Alpha": 1.5, + "T": 4 + }, + { + "ID_g": 84, + "ID_File": 4, + "LWD63": 35.59318585, + "LWD125": 49.81031011, + "LWD250": 42.16943439, + "LWD500": 39.35597036, + "LWD1000": 46.86767114, + "LWD2000": 43.45776753, + "LWD4000": 34.44970874, + "LWD8000": 28.70070204, + "P10": "-59.67942036", + "P25": -51.51861365, + "P50": -43.46054508, + "P75": -35.31427239, + "P90": -30.09452139, + "Alpha": 2, + "T": 5 + }, + { + "ID_g": 85, + "ID_File": 4, + "LWD63": 39.35560289, + "LWD125": 39.39537991, + "LWD250": 44.24742371, + "LWD500": 49.9575128, + "LWD1000": 41.62348926, + "LWD2000": 42.16586109, + "LWD4000": 46.46661758, + "LWD8000": 42.48740498, + "P10": "-58.48770656", + "P25": -50.22257122, + "P50": -43.18848156, + "P75": -37.14877077, + "P90": -29.89348894, + "Alpha": 2.5, + "T": 6 + }, + { + "ID_g": 86, + "ID_File": 4, + "LWD63": 43.30871052, + "LWD125": 53.65292522, + "LWD250": 57.78766681, + "LWD500": 57.13498167, + "LWD1000": 49.12427693, + "LWD2000": 45.60352393, + "LWD4000": 48.54963542, + "LWD8000": 42.07371385, + "P10": "-46.78717352", + "P25": -38.42114769, + "P50": -30.76367445, + "P75": -25.63892349, + "P90": -22.26377105, + "Alpha": 3, + "T": 7 + }, + { + "ID_g": 87, + "ID_File": 4, + "LWD63": 49.89885794, + "LWD125": 60.09320634, + "LWD250": 63.41142032, + "LWD500": 57.17222769, + "LWD1000": 63.74040347, + "LWD2000": 59.59361766, + "LWD4000": 53.76458773, + "LWD8000": 35.35863817, + "P10": "-39.78221315", + "P25": -31.80275687, + "P50": -24.19767243, + "P75": -17.87924141, + "P90": -14.33709062, + "Alpha": 3.5, + "T": 8 + }, + { + "ID_g": 88, + "ID_File": 4, + "LWD63": 33.60761837, + "LWD125": 48.94452384, + "LWD250": 53.17539629, + "LWD500": 61.97684018, + "LWD1000": 63.206164, + "LWD2000": 56.56991312, + "LWD4000": 55.06392411, + "LWD8000": 37.51488866, + "P10": "-45.54807664", + "P25": -36.72044077, + "P50": -27.79612146, + "P75": -20.47336319, + "P90": -15.82823528, + "Alpha": 4, + "T": 9 + }, + { + "ID_g": 89, + "ID_File": 4, + "LWD63": 28.71156026, + "LWD125": 48.53408857, + "LWD250": 56.53874492, + "LWD500": 57.12530966, + "LWD1000": 57.82182717, + "LWD2000": 53.54102119, + "LWD4000": 51.15851588, + "LWD8000": 31.73546002, + "P10": "-43.86875882", + "P25": -35.82348131, + "P50": -28.96014184, + "P75": -23.64106109, + "P90": -19.93345732, + "Alpha": 4.5, + "T": 10 + }, + { + "ID_g": 90, + "ID_File": 4, + "LWD63": 29.15358971, + "LWD125": 40.48905256, + "LWD250": 55.57077055, + "LWD500": 51.28815355, + "LWD1000": 64.57727142, + "LWD2000": 55.33460493, + "LWD4000": 46.28150041, + "LWD8000": 37.45729547, + "P10": "-47.83196588", + "P25": -39.57782985, + "P50": -31.29196952, + "P75": -23.21242959, + "P90": -16.86131446, + "Alpha": 5, + "T": 11 + }, + { + "ID_g": 91, + "ID_File": 4, + "LWD63": 45.62624776, + "LWD125": 48.08603342, + "LWD250": 50.01808889, + "LWD500": 53.42344467, + "LWD1000": 55.2422918, + "LWD2000": 47.69195158, + "LWD4000": 44.39768298, + "LWD8000": 36.06670768, + "P10": "-51.61902967", + "P25": -43.37217977, + "P50": -35.85632025, + "P75": -29.04420914, + "P90": -24.25372453, + "Alpha": 5.5, + "T": 12 + }, + { + "ID_g": 92, + "ID_File": 4, + "LWD63": 32.39709778, + "LWD125": 44.53061878, + "LWD250": 47.67132745, + "LWD500": 53.07499458, + "LWD1000": 57.51905729, + "LWD2000": 52.77865909, + "LWD4000": 47.67111258, + "LWD8000": 34.80673933, + "P10": "-50.66357404", + "P25": -42.56120217, + "P50": -35.61300211, + "P75": -29.30914156, + "P90": -23.47239756, + "Alpha": 6, + "T": 13 + }, + { + "ID_g": 93, + "ID_File": 4, + "LWD63": 29.55954626, + "LWD125": 37.84927076, + "LWD250": 50.1584021, + "LWD500": 53.13167493, + "LWD1000": 41.10017754, + "LWD2000": 46.52235133, + "LWD4000": 47.96171206, + "LWD8000": 36.76090443, + "P10": "-57.24474842", + "P25": -48.79805947, + "P50": -39.99152182, + "P75": -31.96939775, + "P90": -27.14778282, + "Alpha": 6.5, + "T": 14 + }, + { + "ID_g": 94, + "ID_File": 4, + "LWD63": 27.27520448, + "LWD125": 45.44428898, + "LWD250": 50.87895262, + "LWD500": 50.50690616, + "LWD1000": 42.78883738, + "LWD2000": 42.6408967, + "LWD4000": 36.4459163, + "LWD8000": 26.9411167, + "P10": "-57.24474842", + "P25": -48.94528146, + "P50": -40.97164629, + "P75": -33.33290468, + "P90": -28.73986234, + "Alpha": 7, + "T": 15 + }, + { + "ID_g": 95, + "ID_File": 4, + "LWD63": 28.05877343, + "LWD125": 39.84882526, + "LWD250": 50.9698617, + "LWD500": 59.4386694, + "LWD1000": 47.77932827, + "LWD2000": 52.9808033, + "LWD4000": 46.75558168, + "LWD8000": 32.82597407, + "P10": "-56.68417395", + "P25": -48.09720449, + "P50": -37.88547306, + "P75": -29.03482751, + "P90": -24.0692621, + "Alpha": 7.5, + "T": 16 + }, + { + "ID_g": 96, + "ID_File": 4, + "LWD63": 32.86608657, + "LWD125": 48.17342166, + "LWD250": 55.10149552, + "LWD500": 57.67934576, + "LWD1000": 50.85586478, + "LWD2000": 58.56108143, + "LWD4000": 49.99387885, + "LWD8000": 42.1078024, + "P10": "-60.7665736", + "P25": -51.03324215, + "P50": -39.06314141, + "P75": -28.43356307, + "P90": -21.18745035, + "Alpha": 8, + "T": 17 + }, + { + "ID_g": 97, + "ID_File": 5, + "LWD63": 43.78502878, + "LWD125": 54.41546204, + "LWD250": 51.40180472, + "LWD500": 52.93003733, + "LWD1000": 51.27439992, + "LWD2000": 43.95904554, + "LWD4000": 40.79355772, + "LWD8000": 38.30732013, + "P10": "-62.70477386", + "P25": -54.46116491, + "P50": -46.962652, + "P75": -37.47951649, + "P90": -30.40419506, + "Alpha": 0, + "T": 1 + }, + { + "ID_g": 98, + "ID_File": 5, + "LWD63": 45.3399419, + "LWD125": 58.87485121, + "LWD250": 57.8736458, + "LWD500": 61.6724125, + "LWD1000": 55.57278567, + "LWD2000": 46.71933586, + "LWD4000": 36.34840573, + "LWD8000": 29.23089689, + "P10": "-53.0425415", + "P25": -44.07392148, + "P50": -34.74597369, + "P75": -28.44757257, + "P90": -24.12875182, + "Alpha": 0.5, + "T": 2 + }, + { + "ID_g": 99, + "ID_File": 5, + "LWD63": 46.95325815, + "LWD125": 50.7845065, + "LWD250": 46.40256344, + "LWD500": 45.89583087, + "LWD1000": 50.36029835, + "LWD2000": 38.69826311, + "LWD4000": 29.19568093, + "LWD8000": 25.70654265, + "P10": "-63.07444198", + "P25": -54.602402, + "P50": -46.962652, + "P75": -38.7821717, + "P90": -33.34521636, + "Alpha": 1, + "T": 3 + }, + { + "ID_g": 100, + "ID_File": 5, + "LWD63": 38.069828, + "LWD125": 53.32344044, + "LWD250": 53.58806488, + "LWD500": 54.55836409, + "LWD1000": 50.98692049, + "LWD2000": 48.47508839, + "LWD4000": 46.50404412, + "LWD8000": 46.39304628, + "P10": "-60.7665736", + "P25": -51.92743685, + "P50": -43.07444198, + "P75": -34.34980582, + "P90": -29.21673761, + "Alpha": 1.5, + "T": 4 + }, + { + "ID_g": 101, + "ID_File": 5, + "LWD63": 42.21089534, + "LWD125": 53.18468218, + "LWD250": 53.30611202, + "LWD500": 55.81177288, + "LWD1000": 59.48190519, + "LWD2000": 54.01007831, + "LWD4000": 42.59630125, + "LWD8000": 29.88822922, + "P10": "-60.20599913", + "P25": -51.72062018, + "P50": -43.11228905, + "P75": -34.29465713, + "P90": -28.23976626, + "Alpha": 2, + "T": 5 + }, + { + "ID_g": 102, + "ID_File": 5, + "LWD63": 46.25179798, + "LWD125": 52.53005996, + "LWD250": 57.41980093, + "LWD500": 59.6441778, + "LWD1000": 53.28810759, + "LWD2000": 50.46272912, + "LWD4000": 43.6450316, + "LWD8000": 34.38373761, + "P10": "-56.15759518", + "P25": -47.70232333, + "P50": -39.88623703, + "P75": -33.03065116, + "P90": -26.46880685, + "Alpha": 2.5, + "T": 6 + }, + { + "ID_g": 103, + "ID_File": 5, + "LWD63": 47.49351262, + "LWD125": 57.07906182, + "LWD250": 65.28146412, + "LWD500": 64.25268504, + "LWD1000": 56.1308208, + "LWD2000": 49.43853913, + "LWD4000": 43.66484233, + "LWD8000": 33.62548481, + "P10": "-45.90683694", + "P25": -37.78219135, + "P50": -30.38752561, + "P75": -24.98907129, + "P90": -21.08203003, + "Alpha": 3, + "T": 7 + }, + { + "ID_g": 104, + "ID_File": 5, + "LWD63": 47.983625, + "LWD125": 50.00954702, + "LWD250": 55.16575669, + "LWD500": 56.00681675, + "LWD1000": 54.82713793, + "LWD2000": 54.1850305, + "LWD4000": 43.42731478, + "LWD8000": 35.96472581, + "P10": "-53.78750265", + "P25": -45.75126461, + "P50": -38.31133726, + "P75": -32.171528, + "P90": -27.70875971, + "Alpha": 3.5, + "T": 8 + }, + { + "ID_g": 105, + "ID_File": 5, + "LWD63": 42.07081785, + "LWD125": 42.82457254, + "LWD250": 49.52107269, + "LWD500": 52.06373398, + "LWD1000": 46.50922768, + "LWD2000": 44.21954754, + "LWD4000": 41.76607711, + "LWD8000": 35.03012457, + "P10": "-59.18294868", + "P25": -50.73178845, + "P50": -44.03165429, + "P75": -38.31133726, + "P90": -33.51818166, + "Alpha": 4, + "T": 9 + }, + { + "ID_g": 106, + "ID_File": 5, + "LWD63": 39.20302899, + "LWD125": 39.80576234, + "LWD250": 60.74739507, + "LWD500": 58.22248371, + "LWD1000": 63.15064502, + "LWD2000": 60.93032825, + "LWD4000": 43.39266601, + "LWD8000": 34.08046886, + "P10": "-52.35645687", + "P25": -43.90607298, + "P50": -35.13076085, + "P75": -28.28265167, + "P90": -22.16628295, + "Alpha": 4.5, + "T": 10 + }, + { + "ID_g": 107, + "ID_File": 5, + "LWD63": 37.94750816, + "LWD125": 38.59368743, + "LWD250": 60.04206765, + "LWD500": 54.19799381, + "LWD1000": 60.27007791, + "LWD2000": 54.8874694, + "LWD4000": 42.57971457, + "LWD8000": 32.20177819, + "P10": "-55.6611235", + "P25": -46.55858428, + "P50": -37.09168914, + "P75": -29.77016614, + "P90": -24.59785252, + "Alpha": 5, + "T": 11 + }, + { + "ID_g": 108, + "ID_File": 5, + "LWD63": 40.18745887, + "LWD125": 38.22337359, + "LWD250": 62.71624167, + "LWD500": 57.51862251, + "LWD1000": 64.90789205, + "LWD2000": 55.91262102, + "LWD4000": 40.44566417, + "LWD8000": 33.22664075, + "P10": "-47.20227795", + "P25": -38.48770656, + "P50": -31.32119857, + "P75": -25.45320251, + "P90": -22.04971326, + "Alpha": 5.5, + "T": 12 + }, + { + "ID_g": 109, + "ID_File": 5, + "LWD63": 39.2046939, + "LWD125": 41.34635902, + "LWD250": 67.52787602, + "LWD500": 59.89722927, + "LWD1000": 50.08445401, + "LWD2000": 47.24975795, + "LWD4000": 46.12634473, + "LWD8000": 32.77715648, + "P10": "-57.43994517", + "P25": -49.01983891, + "P50": -40.20599913, + "P75": -26.03864356, + "P90": -20.56877796, + "Alpha": 6, + "T": 13 + }, + { + "ID_g": 110, + "ID_File": 5, + "LWD63": 41.16353741, + "LWD125": 43.47662347, + "LWD250": 62.10477241, + "LWD500": 57.55928294, + "LWD1000": 62.68495435, + "LWD2000": 59.86058437, + "LWD4000": 44.44005148, + "LWD8000": 36.14249861, + "P10": "-52.24719896", + "P25": -43.46054508, + "P50": -34.06410476, + "P75": -26.95674524, + "P90": -22.21916634, + "Alpha": 6.5, + "T": 14 + }, + { + "ID_g": 111, + "ID_File": 5, + "LWD63": 39.25809006, + "LWD125": 43.20929472, + "LWD250": 59.82340976, + "LWD500": 50.70491903, + "LWD1000": 46.12183474, + "LWD2000": 41.22853853, + "LWD4000": 43.0476048, + "LWD8000": 30.47806374, + "P10": "-63.07444198", + "P25": -54.18539922, + "P50": -46.28105621, + "P75": -34.87724908, + "P90": -27.48564953, + "Alpha": 7, + "T": 15 + }, + { + "ID_g": 112, + "ID_File": 5, + "LWD63": 41.1359302, + "LWD125": 44.2419254, + "LWD250": 60.71116365, + "LWD500": 51.7841915, + "LWD1000": 56.62244937, + "LWD2000": 50.23620868, + "LWD4000": 41.82237255, + "LWD8000": 45.33008688, + "P10": "-57.63962959", + "P25": -48.79805947, + "P50": -39.78221315, + "P75": -32.35645687, + "P90": -26.79296604, + "Alpha": 7.5, + "T": 16 + }, + { + "ID_g": 113, + "ID_File": 6, + "LWD63": 29.11755127, + "LWD125": 33.35814313, + "LWD250": 52.71272113, + "LWD500": 57.42509279, + "LWD1000": 59.30491452, + "LWD2000": 54.46316935, + "LWD4000": 48.73856844, + "LWD8000": 46.04069123, + "P10": "-50.3089987", + "P25": -38.99204233, + "P50": -29.38690295, + "P75": -22.13402658, + "P90": -16.64625607, + "Alpha": 0, + "T": 1 + }, + { + "ID_g": 114, + "ID_File": 6, + "LWD63": 28.00007041, + "LWD125": 35.39744268, + "LWD250": 54.22557858, + "LWD500": 51.77243768, + "LWD1000": 48.39035031, + "LWD2000": 44.78520985, + "LWD4000": 41.78163598, + "LWD8000": 40.11463257, + "P10": "-55.6611235", + "P25": -47.14174886, + "P50": -37.86471824, + "P75": -29.27052038, + "P90": -22.92839426, + "Alpha": 0.5, + "T": 2 + }, + { + "ID_g": 115, + "ID_File": 6, + "LWD63": 26.82638866, + "LWD125": 34.42215405, + "LWD250": 57.83720606, + "LWD500": 52.25419225, + "LWD1000": 43.47567684, + "LWD2000": 41.88580282, + "LWD4000": 41.92851495, + "LWD8000": 39.75290229, + "P10": "-52.03272165", + "P25": -44.03165429, + "P50": -34.4892292, + "P75": -24.3735026, + "P90": -19.71987841, + "Alpha": 1, + "T": 3 + }, + { + "ID_g": 116, + "ID_File": 6, + "LWD63": 25.20564888, + "LWD125": 34.89264091, + "LWD250": 52.04837372, + "LWD500": 53.9609946, + "LWD1000": 54.88846331, + "LWD2000": 54.41508849, + "LWD4000": 41.21955448, + "LWD8000": 35.15976618, + "P10": "-62.00953174", + "P25": -53.91811999, + "P50": -46.78717352, + "P75": -33.06637111, + "P90": -22.33978171, + "Alpha": 1.5, + "T": 4 + }, + { + "ID_g": 117, + "ID_File": 6, + "LWD63": 27.51603366, + "LWD125": 34.50195111, + "LWD250": 50.89358969, + "LWD500": 51.83356819, + "LWD1000": 55.40595371, + "LWD2000": 50.6353157, + "LWD4000": 36.17696688, + "LWD8000": 38.37335113, + "P10": "-52.03272165", + "P25": -43.78228148, + "P50": -35.70951299, + "P75": -28.37079844, + "P90": -21.20509509, + "Alpha": 2, + "T": 5 + }, + { + "ID_g": 118, + "ID_File": 6, + "LWD63": 29.45835808, + "LWD125": 39.52262956, + "LWD250": 51.06924771, + "LWD500": 51.51708519, + "LWD1000": 42.48049424, + "LWD2000": 41.48446715, + "LWD4000": 38.91033481, + "LWD8000": 26.19744399, + "P10": "-47.89752008", + "P25": -39.62847658, + "P50": -33.07831048, + "P75": -27.47530138, + "P90": -23.86874993, + "Alpha": 2.5, + "T": 6 + }, + { + "ID_g": 119, + "ID_File": 6, + "LWD63": 34.74703824, + "LWD125": 50.62668433, + "LWD250": 52.82259105, + "LWD500": 56.45559481, + "LWD1000": 42.64794223, + "LWD2000": 43.02328678, + "LWD4000": 45.17975099, + "LWD8000": 42.66700349, + "P10": "-55.04043883", + "P25": -46.44650673, + "P50": -38.39907426, + "P75": -28.48269551, + "P90": -19.6028631, + "Alpha": 3, + "T": 7 + }, + { + "ID_g": 120, + "ID_File": 6, + "LWD63": 46.31290925, + "LWD125": 54.78660882, + "LWD250": 58.44703072, + "LWD500": 60.85173129, + "LWD1000": 56.28528334, + "LWD2000": 48.87238899, + "LWD4000": 38.95477363, + "LWD8000": 36.18472027, + "P10": "-42.00953174", + "P25": -33.73580077, + "P50": -26.64360183, + "P75": -19.5879356, + "P90": -14.76336287, + "Alpha": 3.5, + "T": 8 + }, + { + "ID_g": 121, + "ID_File": 6, + "LWD63": 45.63458557, + "LWD125": 47.23312997, + "LWD250": 44.97781842, + "LWD500": 48.50616359, + "LWD1000": 39.75025271, + "LWD2000": 35.00771559, + "LWD4000": 25.84331325, + "LWD8000": 26.56140732, + "P10": "-58.71332677", + "P25": -50.13699526, + "P50": -41.49081706, + "P75": -32.71848122, + "P90": -26.26959201, + "Alpha": 4, + "T": 9 + }, + { + "ID_g": 122, + "ID_File": 6, + "LWD63": 48.23128859, + "LWD125": 47.72440906, + "LWD250": 47.01637198, + "LWD500": 51.92181629, + "LWD1000": 46.97720213, + "LWD2000": 41.84797688, + "LWD4000": 36.65114288, + "LWD8000": 37.11444147, + "P10": "-52.03272165", + "P25": -43.5001164, + "P50": -36.05600467, + "P75": -29.15567662, + "P90": -23.89735, + "Alpha": 4.5, + "T": 10 + }, + { + "ID_g": 123, + "ID_File": 6, + "LWD63": 45.28785619, + "LWD125": 49.35084033, + "LWD250": 51.70239153, + "LWD500": 51.32252952, + "LWD1000": 37.32916483, + "LWD2000": 36.51315374, + "LWD4000": 46.52817597, + "LWD8000": 45.06186124, + "P10": "-50.84644163", + "P25": -42.56120217, + "P50": -35.25267008, + "P75": -28.46862928, + "P90": -23.28815466, + "Alpha": 5, + "T": 11 + }, + { + "ID_g": 124, + "ID_File": 6, + "LWD63": 48.13642818, + "LWD125": 49.33410466, + "LWD250": 49.17461508, + "LWD500": 51.96547768, + "LWD1000": 40.53937727, + "LWD2000": 37.64313745, + "LWD4000": 44.07740396, + "LWD8000": 42.01568507, + "P10": "-50.13699526", + "P25": -41.77877347, + "P50": -33.65882045, + "P75": -27.50512513, + "P90": -23.60786831, + "Alpha": 5.5, + "T": 12 + }, + { + "ID_g": 125, + "ID_File": 6, + "LWD63": 47.87598799, + "LWD125": 44.69159736, + "LWD250": 44.74540311, + "LWD500": 50.01601932, + "LWD1000": 48.32004787, + "LWD2000": 38.8010666, + "LWD4000": 33.95913015, + "LWD8000": 31.92281474, + "P10": "-50.84644163", + "P25": -42.66865785, + "P50": -36.07285412, + "P75": -30.34381193, + "P90": -24.6746993, + "Alpha": 6, + "T": 13 + }, + { + "ID_g": 126, + "ID_File": 6, + "LWD63": 30.40273647, + "LWD125": 33.35405426, + "LWD250": 30.68083061, + "LWD500": 23.75416255, + "LWD1000": 21.57519829, + "LWD2000": 19.91307555, + "LWD4000": 19.46742144, + "LWD8000": 15.30602377, + "P10": "-65.2035486", + "P25": -57.43994517, + "P50": -50.84644163, + "P75": -46.33585696, + "P90": -43.18848156, + "Alpha": 6.5, + "T": 14 + }, + { + "ID_g": 127, + "ID_File": 6, + "LWD63": 45.90388188, + "LWD125": 53.30342756, + "LWD250": 58.38523384, + "LWD500": 59.54306405, + "LWD1000": 56.15089351, + "LWD2000": 55.12188217, + "LWD4000": 46.02570336, + "LWD8000": 36.44037263, + "P10": "-55.34523816", + "P25": -45.39874534, + "P50": -30.0480398, + "P75": -21.3356452, + "P90": -15.46785749, + "Alpha": 7, + "T": 15 + }, + { + "ID_g": 128, + "ID_File": 6, + "LWD63": 37.22963287, + "LWD125": 46.26590165, + "LWD250": 51.5035342, + "LWD500": 54.06639034, + "LWD1000": 45.50739709, + "LWD2000": 45.04426483, + "LWD4000": 35.52649986, + "LWD8000": 35.30300028, + "P10": "-51.32119857", + "P25": -42.88764145, + "P50": -35.92237296, + "P75": -30.0606912, + "P90": -24.24939996, + "Alpha": 7.5, + "T": 16 + }, + { + "ID_g": 129, + "ID_File": 6, + "LWD63": 41.58961715, + "LWD125": 53.22697657, + "LWD250": 54.84829834, + "LWD500": 50.47411995, + "LWD1000": 47.6974799, + "LWD2000": 45.54308594, + "LWD4000": 34.41581492, + "LWD8000": 29.43826363, + "P10": "-58.94496422", + "P25": -49.72132315, + "P50": -37.03498019, + "P75": -27.83849908, + "P90": -21.13624172, + "Alpha": 8, + "T": 17 + }, + { + "ID_g": 130, + "ID_File": 7, + "LWD63": 55.64781646, + "LWD125": 67.46815985, + "LWD250": 72.29411885, + "LWD500": 74.95803112, + "LWD1000": 73.83483878, + "LWD2000": 64.1189596, + "LWD4000": 52.671685, + "LWD8000": 37.04590335, + "P10": "-74.74597369", + "P25": -66.78717352, + "P50": -53.91811999, + "P75": -45.70002027, + "P90": -41.61762062, + "Alpha": 0, + "T": 1 + }, + { + "ID_g": 131, + "ID_File": 7, + "LWD63": 55.84548267, + "LWD125": 70.1038765, + "LWD250": 76.18566621, + "LWD500": 78.55965547, + "LWD1000": 74.40050512, + "LWD2000": 65.18589878, + "LWD4000": 55.34673626, + "LWD8000": 42.07804899, + "P10": "-61.68172342", + "P25": -53.53201688, + "P50": -47.20227795, + "P75": -42.59687323, + "P90": -39.52747672, + "Alpha": 0.5, + "T": 2 + }, + { + "ID_g": 132, + "ID_File": 7, + "LWD63": 56.05237057, + "LWD125": 69.50490244, + "LWD250": 74.93622326, + "LWD500": 78.1485815, + "LWD1000": 73.56806326, + "LWD2000": 65.72281964, + "LWD4000": 55.6577336, + "LWD8000": 40.27773164, + "P10": "-62.70477386", + "P25": -54.89195847, + "P50": -48.23292428, + "P75": -43.34290144, + "P90": -40.01804365, + "Alpha": 1, + "T": 3 + }, + { + "ID_g": 133, + "ID_File": 7, + "LWD63": 57.07644748, + "LWD125": 70.16086431, + "LWD250": 75.0265038, + "LWD500": 79.07015113, + "LWD1000": 73.28726911, + "LWD2000": 65.64146279, + "LWD4000": 55.21287431, + "LWD8000": 41.17508964, + "P10": "-63.07444198", + "P25": -54.74597369, + "P50": -47.96357279, + "P75": -43.18848156, + "P90": -39.86011403, + "Alpha": 1.5, + "T": 4 + }, + { + "ID_g": 134, + "ID_File": 7, + "LWD63": 54.68707665, + "LWD125": 70.19563352, + "LWD250": 75.08057727, + "LWD500": 77.14247208, + "LWD1000": 71.2717873, + "LWD2000": 65.17343561, + "LWD4000": 57.04154369, + "LWD8000": 39.61666818, + "P10": "-63.46054508", + "P25": -55.50174491, + "P50": -49.01983891, + "P75": -44.33193717, + "P90": -41.03113892, + "Alpha": 2, + "T": 5 + }, + { + "ID_g": 135, + "ID_File": 7, + "LWD63": 56.43135382, + "LWD125": 72.12288781, + "LWD250": 75.45226375, + "LWD500": 78.0258328, + "LWD1000": 74.6659171, + "LWD2000": 66.03913321, + "LWD4000": 56.20376927, + "LWD8000": 38.93740098, + "P10": "-62.70477386", + "P25": -54.46116491, + "P50": -47.83196588, + "P75": -43.0367591, + "P90": -39.75640068, + "Alpha": 2.5, + "T": 6 + }, + { + "ID_g": 136, + "ID_File": 7, + "LWD63": 55.83927028, + "LWD125": 69.77326757, + "LWD250": 76.84656522, + "LWD500": 77.35598989, + "LWD1000": 70.94242601, + "LWD2000": 65.21022262, + "LWD4000": 54.55031832, + "LWD8000": 38.23542456, + "P10": "-63.07444198", + "P25": -55.04043883, + "P50": -48.37079844, + "P75": -43.78228148, + "P90": -40.37040574, + "Alpha": 3, + "T": 7 + }, + { + "ID_g": 137, + "ID_File": 7, + "LWD63": 56.54143921, + "LWD125": 68.12706025, + "LWD250": 74.72441739, + "LWD500": 77.68801162, + "LWD1000": 74.46361953, + "LWD2000": 66.08365803, + "LWD4000": 57.14020394, + "LWD8000": 40.83360127, + "P10": "-63.07444198", + "P25": -54.74597369, + "P50": -48.16479931, + "P75": -43.42115323, + "P90": -40.17889805, + "Alpha": 3.5, + "T": 8 + }, + { + "ID_g": 138, + "ID_File": 7, + "LWD63": 55.98247275, + "LWD125": 68.52689161, + "LWD250": 75.0177391, + "LWD500": 76.93722887, + "LWD1000": 76.06595571, + "LWD2000": 69.5542239, + "LWD4000": 55.88631238, + "LWD8000": 39.33055151, + "P10": "-62.70477386", + "P25": -54.46116491, + "P50": -47.96357279, + "P75": -43.15030176, + "P90": -39.83406936, + "Alpha": 4, + "T": 9 + }, + { + "ID_g": 139, + "ID_File": 7, + "LWD63": 56.62216653, + "LWD125": 69.03810259, + "LWD250": 75.75941071, + "LWD500": 79.29875945, + "LWD1000": 75.20722532, + "LWD2000": 67.72631287, + "LWD4000": 57.27164332, + "LWD8000": 41.02444181, + "P10": "-60.7665736", + "P25": -52.9243643, + "P50": -46.50236474, + "P75": -42.17819509, + "P90": -39.01567741, + "Alpha": 4.5, + "T": 10 + }, + { + "ID_g": 140, + "ID_File": 7, + "LWD63": 57.7684736, + "LWD125": 69.701012, + "LWD250": 75.05450053, + "LWD500": 75.79572649, + "LWD1000": 75.53944254, + "LWD2000": 70.13481229, + "LWD4000": 57.93309748, + "LWD8000": 41.25843282, + "P10": "-62.70477386", + "P25": -54.74597369, + "P50": -48.37079844, + "P75": -43.46054508, + "P90": -40.04198639, + "Alpha": 5, + "T": 11 + }, + { + "ID_g": 141, + "ID_File": 7, + "LWD63": 57.56703139, + "LWD125": 69.28446642, + "LWD250": 74.77703807, + "LWD500": 75.24952491, + "LWD1000": 70.31490555, + "LWD2000": 65.85009369, + "LWD4000": 55.7959827, + "LWD8000": 42.33095994, + "P10": "-64.28839879", + "P25": -56.15759518, + "P50": -49.88521272, + "P75": -45.19151825, + "P90": -42.11033623, + "Alpha": 5.5, + "T": 12 + }, + { + "ID_g": 142, + "ID_File": 7, + "LWD63": 57.93723843, + "LWD125": 69.11263292, + "LWD250": 74.37413399, + "LWD500": 75.70124136, + "LWD1000": 71.50185221, + "LWD2000": 65.36124281, + "LWD4000": 53.81710832, + "LWD8000": 37.9101527, + "P10": "-64.28839879", + "P25": -55.82348131, + "P50": -49.64052359, + "P75": -45.10757094, + "P90": -41.84408122, + "Alpha": 6, + "T": 13 + }, + { + "ID_g": 143, + "ID_File": 7, + "LWD63": 59.32911676, + "LWD125": 71.25978353, + "LWD250": 75.77730851, + "LWD500": 79.09511585, + "LWD1000": 72.3150199, + "LWD2000": 64.68092141, + "LWD4000": 55.31055852, + "LWD8000": 40.84519474, + "P10": "-61.68172342", + "P25": -53.53201688, + "P50": -47.08163865, + "P75": -42.59687323, + "P90": -39.5526168, + "Alpha": 6.5, + "T": 14 + }, + { + "ID_g": 144, + "ID_File": 7, + "LWD63": 59.97042337, + "LWD125": 69.47352465, + "LWD250": 74.7721586, + "LWD500": 76.6112909, + "LWD1000": 70.60667063, + "LWD2000": 64.94770228, + "LWD4000": 53.98574044, + "LWD8000": 38.64551178, + "P10": "-64.28839879", + "P25": -56.32959861, + "P50": -49.64052359, + "P75": -44.64297413, + "P90": -41.45940332, + "Alpha": 7, + "T": 15 + }, + { + "ID_g": 145, + "ID_File": 7, + "LWD63": 58.64308771, + "LWD125": 67.49438756, + "LWD250": 72.72682304, + "LWD500": 75.79362262, + "LWD1000": 70.62123872, + "LWD2000": 62.93647111, + "LWD4000": 52.29276065, + "LWD8000": 37.67746872, + "P10": "-64.73392668", + "P25": -56.68417395, + "P50": -50.3089987, + "P75": -45.75126461, + "P90": -42.45505963, + "Alpha": 7.5, + "T": 16 + }, + { + "ID_g": 146, + "ID_File": 7, + "LWD63": 58.96775881, + "LWD125": 69.55580642, + "LWD250": 74.78998016, + "LWD500": 75.11376742, + "LWD1000": 70.67604242, + "LWD2000": 61.606188, + "LWD4000": 52.15347122, + "LWD8000": 38.63640337, + "P10": "-64.28839879", + "P25": -56.32959861, + "P50": -49.72132315, + "P75": -45.1554272, + "P90": -42.07660458, + "Alpha": 8, + "T": 17 + }, + { + "ID_g": 147, + "ID_File": 7, + "LWD63": 58.65732618, + "LWD125": 69.06927316, + "LWD250": 74.52112218, + "LWD500": 77.73633141, + "LWD1000": 71.3033773, + "LWD2000": 63.0429387, + "LWD4000": 52.25926684, + "LWD8000": 37.31883494, + "P10": "-62.70477386", + "P25": -54.602402, + "P50": -48.23292428, + "P75": -43.82334959, + "P90": -40.62300191, + "Alpha": 8.5, + "T": 18 + }, + { + "ID_g": 148, + "ID_File": 7, + "LWD63": 58.15320634, + "LWD125": 66.66715432, + "LWD250": 73.8506769, + "LWD500": 78.52418332, + "LWD1000": 72.59536514, + "LWD2000": 67.84370128, + "LWD4000": 57.47902913, + "LWD8000": 42.01327513, + "P10": "-62.35019853", + "P25": -54.32218771, + "P50": -47.96357279, + "P75": -43.34290144, + "P90": -40.37040574, + "Alpha": 9, + "T": 19 + }, + { + "ID_g": 149, + "ID_File": 7, + "LWD63": 58.16343485, + "LWD125": 65.85595709, + "LWD250": 73.82125967, + "LWD500": 76.65840261, + "LWD1000": 72.94285456, + "LWD2000": 65.93925382, + "LWD4000": 57.34025113, + "LWD8000": 41.84430402, + "P10": "-63.8646128", + "P25": -55.6611235, + "P50": -49.24742983, + "P75": -44.41967418, + "P90": -41.2121015, + "Alpha": 9.5, + "T": 20 + }, + { + "ID_g": 150, + "ID_File": 8, + "LWD63": 36.38258913, + "LWD125": 56.70576649, + "LWD250": 48.35419699, + "LWD500": 54.26609313, + "LWD1000": 52.36728149, + "LWD2000": 41.58177045, + "LWD4000": 37.03505271, + "LWD8000": 25.84484166, + "P10": "-55.6611235", + "P25": -46.21306958, + "P50": -34.4892292, + "P75": -25.66432828, + "P90": -20.86264777, + "Alpha": 0, + "T": 1 + }, + { + "ID_g": 151, + "ID_File": 8, + "LWD63": 38.72785542, + "LWD125": 54.06955212, + "LWD250": 47.84816563, + "LWD500": 56.60494548, + "LWD1000": 45.05509457, + "LWD2000": 41.87444467, + "LWD4000": 41.07871858, + "LWD8000": 38.10156512, + "P10": "-55.98893183", + "P25": -47.83196588, + "P50": -39.18294868, + "P75": -29.44961723, + "P90": -22.47971046, + "Alpha": 0.5, + "T": 2 + }, + { + "ID_g": 152, + "ID_File": 8, + "LWD63": 35.84348821, + "LWD125": 43.31979873, + "LWD250": 38.55946237, + "LWD500": 41.37651859, + "LWD1000": 38.73587383, + "LWD2000": 34.07924376, + "LWD4000": 39.78004217, + "LWD8000": 34.02340741, + "P10": "-60.7665736", + "P25": -53.28383172, + "P50": -45.70002027, + "P75": -38.94496422, + "P90": -32.68130556, + "Alpha": 1, + "T": 3 + }, + { + "ID_g": 153, + "ID_File": 8, + "LWD63": 27.00878267, + "LWD125": 30.28817329, + "LWD250": 54.01442223, + "LWD500": 56.36008142, + "LWD1000": 59.9975842, + "LWD2000": 54.65986841, + "LWD4000": 44.84960501, + "LWD8000": 37.63324597, + "P10": "-55.04043883", + "P25": -41.45940332, + "P50": -29.36350135, + "P75": -22.68308624, + "P90": -18.52788808, + "Alpha": 1.5, + "T": 4 + }, + { + "ID_g": 154, + "ID_File": 8, + "LWD63": 32.91226278, + "LWD125": 38.13121797, + "LWD250": 54.84653242, + "LWD500": 50.18454651, + "LWD1000": 58.23298563, + "LWD2000": 50.82224272, + "LWD4000": 43.64019871, + "LWD8000": 35.17934993, + "P10": "-53.16234877", + "P25": -44.50830647, + "P50": -35.10054903, + "P75": -26.71222014, + "P90": -20.40088744, + "Alpha": 2, + "T": 5 + }, + { + "ID_g": 155, + "ID_File": 8, + "LWD63": 27.02588205, + "LWD125": 35.1418985, + "LWD250": 43.25136721, + "LWD500": 56.82257699, + "LWD1000": 46.7534648, + "LWD2000": 48.69931481, + "LWD4000": 46.05883986, + "LWD8000": 38.63573172, + "P10": "-58.05332156", + "P25": -49.88521272, + "P50": -41.55398744, + "P75": -31.84671113, + "P90": -24.37920545, + "Alpha": 2.5, + "T": 6 + }, + { + "ID_g": 156, + "ID_File": 8, + "LWD63": 29.82927286, + "LWD125": 36.80022732, + "LWD250": 46.89109283, + "LWD500": 55.93755343, + "LWD1000": 54.29899173, + "LWD2000": 53.43750681, + "LWD4000": 43.31904451, + "LWD8000": 44.2109966, + "P10": "-50.57356401", + "P25": -41.36583807, + "P50": -32.49499254, + "P75": -25.64907649, + "P90": -21.47478191, + "Alpha": 3, + "T": 7 + }, + { + "ID_g": 157, + "ID_File": 8, + "LWD63": 30.76290077, + "LWD125": 42.63749748, + "LWD250": 50.47733486, + "LWD500": 56.35228476, + "LWD1000": 48.7352996, + "LWD2000": 49.50858248, + "LWD4000": 44.97449031, + "LWD8000": 47.87869068, + "P10": "-44.33193717", + "P25": -36.15759518, + "P50": -29.5684411, + "P75": -24.98907129, + "P90": -22.40946431, + "Alpha": 3.5, + "T": 8 + }, + { + "ID_g": 158, + "ID_File": 8, + "LWD63": 28.70531097, + "LWD125": 40.4648673, + "LWD250": 47.23708337, + "LWD500": 46.6930751, + "LWD1000": 48.43477367, + "LWD2000": 43.26767198, + "LWD4000": 38.4341424, + "LWD8000": 41.9222481, + "P10": "-56.32959861", + "P25": -48.09720449, + "P50": -40.68014613, + "P75": -34.17183811, + "P90": -28.81998432, + "Alpha": 4, + "T": 9 + }, + { + "ID_g": 159, + "ID_File": 8, + "LWD63": 29.54221337, + "LWD125": 33.32310864, + "LWD250": 49.98013421, + "LWD500": 52.44062411, + "LWD1000": 58.48415033, + "LWD2000": 47.30386946, + "LWD4000": 36.70259074, + "LWD8000": 43.53872397, + "P10": "-50.22257122", + "P25": -40.70885984, + "P50": -31.58878278, + "P75": -24.65655644, + "P90": -20.4147782, + "Alpha": 4.5, + "T": 10 + }, + { + "ID_g": 160, + "ID_File": 8, + "LWD63": 28.71372126, + "LWD125": 38.19234973, + "LWD250": 46.7264768, + "LWD500": 54.41044692, + "LWD1000": 60.68119719, + "LWD2000": 56.31013693, + "LWD4000": 46.87739217, + "LWD8000": 29.85068148, + "P10": "-51.61902967", + "P25": -41.74630282, + "P50": -31.55864086, + "P75": -23.63602357, + "P90": -18.28692898, + "Alpha": 5, + "T": 11 + }, + { + "ID_g": 161, + "ID_File": 8, + "LWD63": 29.45217345, + "LWD125": 36.64835091, + "LWD250": 38.22850434, + "LWD500": 48.6851121, + "LWD1000": 56.28942486, + "LWD2000": 46.64110396, + "LWD4000": 43.5060375, + "LWD8000": 33.7021483, + "P10": "-64.28839879", + "P25": -55.6611235, + "P50": -47.89752008, + "P75": -37.65985286, + "P90": -24.24896772, + "Alpha": 5.5, + "T": 12 + }, + { + "ID_g": 162, + "ID_File": 8, + "LWD63": 25.89852372, + "LWD125": 31.01047731, + "LWD250": 57.77332339, + "LWD500": 55.55833915, + "LWD1000": 56.7301456, + "LWD2000": 47.18983257, + "LWD4000": 43.94684132, + "LWD8000": 34.64941759, + "P10": "-57.84401289", + "P25": -48.72537378, + "P50": -32.63577, + "P75": -23.57180228, + "P90": -19.2873214, + "Alpha": 6, + "T": 13 + }, + { + "ID_g": 163, + "ID_File": 8, + "LWD63": 28.7091556, + "LWD125": 30.63770387, + "LWD250": 49.38805457, + "LWD500": 59.78457288, + "LWD1000": 59.50797537, + "LWD2000": 56.54135914, + "LWD4000": 47.26872275, + "LWD8000": 43.05297724, + "P10": "-43.38193921", + "P25": -34.81501291, + "P50": -27.30923011, + "P75": -21.31634569, + "P90": -17.19470771, + "Alpha": 6.5, + "T": 14 + }, + { + "ID_g": 164, + "ID_File": 8, + "LWD63": 25.77766039, + "LWD125": 28.42255044, + "LWD250": 47.46080459, + "LWD500": 55.00648819, + "LWD1000": 56.50206871, + "LWD2000": 50.4878883, + "LWD4000": 42.13298598, + "LWD8000": 29.37179989, + "P10": "-51.51861365", + "P25": -42.00953174, + "P50": -31.97991973, + "P75": -24.62151235, + "P90": -20.27686025, + "Alpha": 7, + "T": 15 + }, + { + "ID_g": 165, + "ID_File": 8, + "LWD63": 25.58131266, + "LWD125": 26.44472936, + "LWD250": 48.31353034, + "LWD500": 57.01435085, + "LWD1000": 51.5772555, + "LWD2000": 39.20401949, + "LWD4000": 36.64396746, + "LWD8000": 21.89709565, + "P10": "-55.50174491", + "P25": -44.49719917, + "P50": -32.86587324, + "P75": -26.81036683, + "P90": -21.92608172, + "Alpha": 7.5, + "T": 16 + }, + { + "ID_g": 166, + "ID_File": 9, + "LWD63": 21.58001133, + "LWD125": 19.57297126, + "LWD250": 25.75139757, + "LWD500": 27.61685697, + "LWD1000": 28.15176681, + "LWD2000": 21.62112597, + "LWD4000": 10.94156029, + "LWD8000": 5.198714429, + "P10": "-90.3089987", + "P25": -84.28839879, + "P50": -72.24719896, + "P75": -63.8646128, + "P90": -56.32959861, + "Alpha": 0, + "T": 1 + }, + { + "ID_g": 167, + "ID_File": 9, + "LWD63": 34.48691706, + "LWD125": 43.00524508, + "LWD250": 53.63733727, + "LWD500": 53.26791841, + "LWD1000": 53.02918313, + "LWD2000": 44.8524143, + "LWD4000": 34.50786872, + "LWD8000": 19.73725831, + "P10": "-57.84401289", + "P25": -49.64052359, + "P50": -42.14419939, + "P75": -35.69335319, + "P90": -30.58162724, + "Alpha": 0.5, + "T": 2 + }, + { + "ID_g": 168, + "ID_File": 9, + "LWD63": 43.06476053, + "LWD125": 47.79423195, + "LWD250": 59.0506692, + "LWD500": 60.09507133, + "LWD1000": 58.6637051, + "LWD2000": 52.97609311, + "LWD4000": 47.1176319, + "LWD8000": 36.24005877, + "P10": "-47.20227795", + "P25": -38.99204233, + "P50": -32.50057832, + "P75": -27.92388091, + "P90": -24.9234109, + "Alpha": 1, + "T": 3 + }, + { + "ID_g": 169, + "ID_File": 9, + "LWD63": 44.39763194, + "LWD125": 49.79797477, + "LWD250": 56.10626285, + "LWD500": 57.40522626, + "LWD1000": 60.96043966, + "LWD2000": 56.15150677, + "LWD4000": 51.49715747, + "LWD8000": 39.97073466, + "P10": "-47.02194158", + "P25": -38.96847138, + "P50": -32.37847435, + "P75": -27.79286954, + "P90": -24.88564723, + "Alpha": 1.5, + "T": 4 + }, + { + "ID_g": 170, + "ID_File": 9, + "LWD63": 40.99875957, + "LWD125": 50.02190494, + "LWD250": 58.09423043, + "LWD500": 59.35083763, + "LWD1000": 60.04293099, + "LWD2000": 53.85657853, + "LWD4000": 46.54638519, + "LWD8000": 34.85982683, + "P10": "-47.14174886", + "P25": -38.99204233, + "P50": -32.32353495, + "P75": -27.80588211, + "P90": -24.60640771, + "Alpha": 2, + "T": 5 + }, + { + "ID_g": 171, + "ID_File": 9, + "LWD63": 40.45813859, + "LWD125": 50.62553909, + "LWD250": 57.5596317, + "LWD500": 58.40525723, + "LWD1000": 58.50967979, + "LWD2000": 51.09560829, + "LWD4000": 40.85134637, + "LWD8000": 27.77213109, + "P10": "-48.440565", + "P25": -40.48176482, + "P50": -34.01073507, + "P75": -29.08937964, + "P90": -25.8494697, + "Alpha": 2.5, + "T": 6 + }, + { + "ID_g": 172, + "ID_File": 9, + "LWD63": 43.70321572, + "LWD125": 48.73628317, + "LWD250": 55.15514244, + "LWD500": 57.65582702, + "LWD1000": 56.2740436, + "LWD2000": 48.85449207, + "LWD4000": 40.99392799, + "LWD8000": 30.763291, + "P10": "-50.13699526", + "P25": -41.94297287, + "P50": -35.22203198, + "P75": -30.54897477, + "P90": -27.54231326, + "Alpha": 3, + "T": 7 + }, + { + "ID_g": 173, + "ID_File": 9, + "LWD63": 47.53064938, + "LWD125": 62.70206192, + "LWD250": 61.6418016, + "LWD500": 62.75512897, + "LWD1000": 57.48885509, + "LWD2000": 53.18113068, + "LWD4000": 50.47490431, + "LWD8000": 38.12198179, + "P10": "-45.80281306", + "P25": -37.43994517, + "P50": -30.52000235, + "P75": -25.42345628, + "P90": -21.37825536, + "Alpha": 3.5, + "T": 8 + }, + { + "ID_g": 174, + "ID_File": 9, + "LWD63": 46.59713359, + "LWD125": 55.84207506, + "LWD250": 59.2652032, + "LWD500": 63.99104384, + "LWD1000": 61.3941587, + "LWD2000": 54.52109579, + "LWD4000": 43.71482443, + "LWD8000": 31.71708008, + "P10": "-44.41967418", + "P25": -36.20883951, + "P50": -29.80288139, + "P75": -25.16503018, + "P90": -22.05642829, + "Alpha": 4, + "T": 9 + }, + { + "ID_g": 175, + "ID_File": 9, + "LWD63": 44.52395316, + "LWD125": 53.7425003, + "LWD250": 59.39272597, + "LWD500": 60.85341547, + "LWD1000": 57.96134744, + "LWD2000": 50.85059624, + "LWD4000": 43.46162702, + "LWD8000": 32.02471831, + "P10": "-47.57458736", + "P25": -39.01567741, + "P50": -32.36745864, + "P75": -27.51141697, + "P90": -24.31449562, + "Alpha": 4.5, + "T": 10 + }, + { + "ID_g": 176, + "ID_File": 9, + "LWD63": 43.36105957, + "LWD125": 48.59727593, + "LWD250": 54.18636059, + "LWD500": 57.74711031, + "LWD1000": 55.36974419, + "LWD2000": 49.98370009, + "LWD4000": 43.36755639, + "LWD8000": 34.72229023, + "P10": "-49.80288139", + "P25": -41.7139531, + "P50": -35.23733752, + "P75": -30.90206117, + "P90": -27.84438339, + "Alpha": 5, + "T": 11 + }, + { + "ID_g": 177, + "ID_File": 9, + "LWD63": 42.76877601, + "LWD125": 54.14708566, + "LWD250": 57.36999406, + "LWD500": 62.78923336, + "LWD1000": 58.54709881, + "LWD2000": 50.97952254, + "LWD4000": 44.88067336, + "LWD8000": 34.90555868, + "P10": "-46.72945975", + "P25": -38.42114769, + "P50": -31.90653217, + "P75": -27.12367208, + "P90": -23.71697373, + "Alpha": 5.5, + "T": 12 + }, + { + "ID_g": 178, + "ID_File": 9, + "LWD63": 44.35757793, + "LWD125": 50.6713528, + "LWD250": 54.07698596, + "LWD500": 60.7434017, + "LWD1000": 57.463136, + "LWD2000": 52.10725883, + "LWD4000": 43.23563347, + "LWD8000": 32.75326268, + "P10": "-48.79805947", + "P25": -40.50982911, + "P50": -34.05073157, + "P75": -29.34793524, + "P90": -26.02219064, + "Alpha": 6, + "T": 13 + }, + { + "ID_g": 179, + "ID_File": 9, + "LWD63": 43.99500684, + "LWD125": 48.67049271, + "LWD250": 57.36941566, + "LWD500": 60.0258395, + "LWD1000": 60.31050401, + "LWD2000": 53.79232583, + "LWD4000": 46.45858088, + "LWD8000": 34.21658952, + "P10": "-47.14174886", + "P25": -39.18294868, + "P50": -32.71561459, + "P75": -27.80751051, + "P90": -24.65655644, + "Alpha": 6.5, + "T": 14 + }, + { + "ID_g": 180, + "ID_File": 9, + "LWD63": 42.48183103, + "LWD125": 49.43405003, + "LWD250": 60.70727779, + "LWD500": 63.72675399, + "LWD1000": 59.93224454, + "LWD2000": 52.95803112, + "LWD4000": 49.79511568, + "LWD8000": 36.99265756, + "P10": "-45.60349443", + "P25": -37.22546786, + "P50": -30.52000235, + "P75": -25.66432828, + "P90": -22.24658828, + "Alpha": 7, + "T": 15 + }, + { + "ID_g": 181, + "ID_File": 9, + "LWD63": 43.13139344, + "LWD125": 51.03874913, + "LWD250": 58.16356088, + "LWD500": 62.57917676, + "LWD1000": 59.03858947, + "LWD2000": 52.51880241, + "LWD4000": 45.14558555, + "LWD8000": 34.31342765, + "P10": "-47.38643799", + "P25": -39.20710973, + "P50": -32.43376346, + "P75": -27.35547221, + "P90": -23.65174983, + "Alpha": 7.5, + "T": 16 + }, + { + "ID_g": 182, + "ID_File": 9, + "LWD63": 44.30991137, + "LWD125": 50.83610156, + "LWD250": 56.5582971, + "LWD500": 58.22862895, + "LWD1000": 56.23954236, + "LWD2000": 50.45884759, + "LWD4000": 41.45651146, + "LWD8000": 32.03859338, + "P10": "-49.88521272", + "P25": -41.68172342, + "P50": -34.76046225, + "P75": -29.94331253, + "P90": -26.84469058, + "Alpha": 8, + "T": 17 + }, + { + "ID_g": 183, + "ID_File": 9, + "LWD63": 44.72809905, + "LWD125": 53.51538202, + "LWD250": 58.57759727, + "LWD500": 62.14825652, + "LWD1000": 60.39801467, + "LWD2000": 53.47935375, + "LWD4000": 48.83684325, + "LWD8000": 35.36083355, + "P10": "-46.17248118", + "P25": -38.03216226, + "P50": -31.48871383, + "P75": -26.63221796, + "P90": -23.0367591, + "Alpha": 8.5, + "T": 18 + }, + { + "ID_g": 184, + "ID_File": 9, + "LWD63": 44.76774742, + "LWD125": 50.64943348, + "LWD250": 61.86902161, + "LWD500": 64.07634758, + "LWD1000": 61.507216, + "LWD2000": 52.74002266, + "LWD4000": 44.71274384, + "LWD8000": 32.81658858, + "P10": "-43.947732", + "P25": -35.90581263, + "P50": -29.481145, + "P75": -24.93393028, + "P90": -21.90988373, + "Alpha": 9, + "T": 19 + }, + { + "ID_g": 185, + "ID_File": 9, + "LWD63": 42.58858829, + "LWD125": 49.11336449, + "LWD250": 59.230365, + "LWD500": 62.06005815, + "LWD1000": 61.31515581, + "LWD2000": 55.1324027, + "LWD4000": 43.09209177, + "LWD8000": 32.14516782, + "P10": "-46.22659905", + "P25": -37.98999767, + "P50": -31.58878278, + "P75": -26.70217983, + "P90": -23.24568268, + "Alpha": 9.5, + "T": 20 + }, + { + "ID_g": 186, + "ID_File": 10, + "LWD63": 17.56201806, + "LWD125": 26.78777595, + "LWD250": 26.52613146, + "LWD500": 18.948295, + "LWD1000": 7.036549691, + "LWD2000": 8.072266737, + "LWD4000": 3.610612727, + "LWD8000": 1.56661315, + "P10": "-90.3089987", + "P25": -84.28839879, + "P50": -74.74597369, + "P75": -66.22659905, + "P90": -53.0425415, + "Alpha": 0, + "T": 1 + }, + { + "ID_g": 187, + "ID_File": 10, + "LWD63": 25.71763078, + "LWD125": 42.1191112, + "LWD250": 45.99232534, + "LWD500": 47.34827193, + "LWD1000": 43.35426125, + "LWD2000": 39.14418391, + "LWD4000": 27.35272042, + "LWD8000": 14.04634272, + "P10": "-59.18294868", + "P25": -50.57356401, + "P50": -41.84408122, + "P75": -35.48596672, + "P90": -31.56867655, + "Alpha": 0.5, + "T": 2 + }, + { + "ID_g": 188, + "ID_File": 10, + "LWD63": 28.15822809, + "LWD125": 48.84000577, + "LWD250": 56.09299389, + "LWD500": 57.285404, + "LWD1000": 54.03193143, + "LWD2000": 48.59837058, + "LWD4000": 42.18297646, + "LWD8000": 27.27072805, + "P10": "-45.75126461", + "P25": -37.49936996, + "P50": -30.57356401, + "P75": -25.67960689, + "P90": -22.02290494, + "Alpha": 1, + "T": 3 + }, + { + "ID_g": 189, + "ID_File": 10, + "LWD63": 29.2922055, + "LWD125": 51.19427516, + "LWD250": 53.9857919, + "LWD500": 56.76206478, + "LWD1000": 54.97241106, + "LWD2000": 48.77089499, + "LWD4000": 42.67569348, + "LWD8000": 28.74212826, + "P10": "-45.2035486", + "P25": -36.95993964, + "P50": -30.37876526, + "P75": -25.55812394, + "P90": -22.31517829, + "Alpha": 1.5, + "T": 4 + }, + { + "ID_g": 190, + "ID_File": 10, + "LWD63": 27.60514191, + "LWD125": 48.38622008, + "LWD250": 54.36390147, + "LWD500": 55.56534908, + "LWD1000": 54.39812339, + "LWD2000": 53.08366485, + "LWD4000": 47.55761158, + "LWD8000": 29.7334158, + "P10": "-45.44823773", + "P25": -37.34179848, + "P50": -30.5556734, + "P75": -25.77828969, + "P90": -22.43398589, + "Alpha": 2, + "T": 5 + }, + { + "ID_g": 191, + "ID_File": 10, + "LWD63": 31.3991548, + "LWD125": 51.49272654, + "LWD250": 55.49374157, + "LWD500": 56.89816419, + "LWD1000": 53.26618193, + "LWD2000": 51.47258346, + "LWD4000": 44.69039972, + "LWD8000": 28.65361969, + "P10": "-45.49801373", + "P25": -37.01615919, + "P50": -30.3089987, + "P75": -25.52300912, + "P90": -22.09311678, + "Alpha": 2.5, + "T": 6 + }, + { + "ID_g": 192, + "ID_File": 10, + "LWD63": 31.76176783, + "LWD125": 48.69938458, + "LWD250": 57.2068098, + "LWD500": 60.43733572, + "LWD1000": 58.86019857, + "LWD2000": 54.13786465, + "LWD4000": 45.92724637, + "LWD8000": 31.71687946, + "P10": "-40.53798437", + "P25": -32.57636593, + "P50": -26.25923236, + "P75": -21.72041341, + "P90": -18.489934, + "Alpha": 3, + "T": 7 + }, + { + "ID_g": 193, + "ID_File": 10, + "LWD63": 34.01012253, + "LWD125": 51.47130613, + "LWD250": 56.73096265, + "LWD500": 58.47749028, + "LWD1000": 59.65436053, + "LWD2000": 55.67585275, + "LWD4000": 48.68114129, + "LWD8000": 33.01697215, + "P10": "-42.07660458", + "P25": -34.03737893, + "P50": -27.55558795, + "P75": -22.63628133, + "P90": -19.09652121, + "Alpha": 3.5, + "T": 8 + }, + { + "ID_g": 194, + "ID_File": 10, + "LWD63": 27.49176145, + "LWD125": 45.04322552, + "LWD250": 57.49409789, + "LWD500": 56.71605025, + "LWD1000": 55.06504228, + "LWD2000": 52.89984912, + "LWD4000": 46.37390957, + "LWD8000": 31.07716361, + "P10": "-44.33631294", + "P25": -36.45206031, + "P50": -29.77833341, + "P75": -24.79816493, + "P90": -21.36242648, + "Alpha": 4, + "T": 9 + }, + { + "ID_g": 195, + "ID_File": 10, + "LWD63": 26.58126031, + "LWD125": 39.47354845, + "LWD250": 52.41462307, + "LWD500": 56.83790144, + "LWD1000": 54.59969585, + "LWD2000": 49.35383688, + "LWD4000": 40.10035257, + "LWD8000": 28.96445292, + "P10": "-45.59842976", + "P25": -37.80274968, + "P50": -31.20486795, + "P75": -26.41455062, + "P90": -23.10811787, + "Alpha": 4.5, + "T": 10 + }, + { + "ID_g": 196, + "ID_File": 10, + "LWD63": 27.74199868, + "LWD125": 46.36012623, + "LWD250": 51.8738561, + "LWD500": 54.00702702, + "LWD1000": 53.20861578, + "LWD2000": 48.02535527, + "LWD4000": 40.04066171, + "LWD8000": 24.88679971, + "P10": "-48.23292428", + "P25": -40.37040574, + "P50": -33.73580077, + "P75": -28.57468542, + "P90": -24.6746993, + "Alpha": 5, + "T": 11 + }, + { + "ID_g": 197, + "ID_File": 10, + "LWD63": 28.24649624, + "LWD125": 44.20733314, + "LWD250": 56.08986304, + "LWD500": 61.71756051, + "LWD1000": 55.73165554, + "LWD2000": 54.62075835, + "LWD4000": 44.74586973, + "LWD8000": 28.94569363, + "P10": "-42.45858333", + "P25": -34.57397026, + "P50": -27.79937339, + "P75": -22.78841506, + "P90": -19.19018994, + "Alpha": 5.5, + "T": 12 + }, + { + "ID_g": 198, + "ID_File": 10, + "LWD63": 28.20818437, + "LWD125": 41.30865826, + "LWD250": 57.39859549, + "LWD500": 59.00493545, + "LWD1000": 59.70261406, + "LWD2000": 53.67440857, + "LWD4000": 47.25333873, + "LWD8000": 31.80407829, + "P10": "-41.84408122", + "P25": -33.55722993, + "P50": -27.15382098, + "P75": -22.2089054, + "P90": -18.89323799, + "Alpha": 6, + "T": 13 + }, + { + "ID_g": 199, + "ID_File": 10, + "LWD63": 31.33287429, + "LWD125": 44.10106039, + "LWD250": 59.08848693, + "LWD500": 57.2192959, + "LWD1000": 58.31572071, + "LWD2000": 52.84167679, + "LWD4000": 44.58163517, + "LWD8000": 29.71718909, + "P10": "-41.68172342", + "P25": -33.64605646, + "P50": -26.962652, + "P75": -22.4585769, + "P90": -19.49990643, + "Alpha": 6.5, + "T": 14 + }, + { + "ID_g": 200, + "ID_File": 10, + "LWD63": 30.16182776, + "LWD125": 43.36684603, + "LWD250": 52.21946786, + "LWD500": 54.65649326, + "LWD1000": 55.65831948, + "LWD2000": 51.37342943, + "LWD4000": 47.95907607, + "LWD8000": 28.94961124, + "P10": "-45.80281306", + "P25": -37.84401289, + "P50": -31.17602712, + "P75": -26.30430462, + "P90": -22.99175439, + "Alpha": 7, + "T": 15 + }, + { + "ID_g": 201, + "ID_File": 10, + "LWD63": 27.46336333, + "LWD125": 45.13120642, + "LWD250": 52.44409179, + "LWD500": 56.18174168, + "LWD1000": 54.75323657, + "LWD2000": 51.10727663, + "LWD4000": 44.6755626, + "LWD8000": 33.32778527, + "P10": "-46.33585696", + "P25": -38.09579544, + "P50": -31.27253799, + "P75": -26.37994787, + "P90": -22.92839426, + "Alpha": 7.5, + "T": 16 + }, + { + "ID_g": 202, + "ID_File": 10, + "LWD63": 26.68178279, + "LWD125": 44.08282687, + "LWD250": 50.11876349, + "LWD500": 57.81780816, + "LWD1000": 58.27500144, + "LWD2000": 49.94779112, + "LWD4000": 43.40889688, + "LWD8000": 28.65136398, + "P10": "-44.5529641", + "P25": -36.53615707, + "P50": -29.80288139, + "P75": -24.58885626, + "P90": -20.99242239, + "Alpha": 8, + "T": 17 + }, + { + "ID_g": 203, + "ID_File": 10, + "LWD63": 34.3008967, + "LWD125": 48.40970891, + "LWD250": 57.88455421, + "LWD500": 58.96393557, + "LWD1000": 56.09047366, + "LWD2000": 55.21361946, + "LWD4000": 46.26101576, + "LWD8000": 27.77909948, + "P10": "-44.11639535", + "P25": -35.88928382, + "P50": -29.15948122, + "P75": -24.08239965, + "P90": -20.24408327, + "Alpha": 8.5, + "T": 18 + }, + { + "ID_g": 204, + "ID_File": 10, + "LWD63": 32.20406531, + "LWD125": 41.35459976, + "LWD250": 53.2111308, + "LWD500": 58.00234891, + "LWD1000": 54.28644188, + "LWD2000": 52.85972545, + "LWD4000": 46.17065691, + "LWD8000": 37.39994743, + "P10": "-45.49801373", + "P25": -37.53921356, + "P50": -30.92068045, + "P75": -25.57321671, + "P90": -21.91979724, + "Alpha": 9, + "T": 19 + }, + { + "ID_g": 205, + "ID_File": 10, + "LWD63": 29.47478035, + "LWD125": 39.74781466, + "LWD250": 57.6712306, + "LWD500": 59.20294467, + "LWD1000": 58.24388503, + "LWD2000": 55.38489332, + "LWD4000": 46.99440582, + "LWD8000": 35.0552888, + "P10": "-41.64961288", + "P25": -33.58251639, + "P50": -27.31230476, + "P75": -22.7011555, + "P90": -19.46992921, + "Alpha": 9.5, + "T": 20 + }, + { + "ID_g": 206, + "ID_File": 11, + "LWD63": 47.85332528, + "LWD125": 63.59904316, + "LWD250": 66.07198444, + "LWD500": 64.24642854, + "LWD1000": 55.07667635, + "LWD2000": 45.49752232, + "LWD4000": 38.88408445, + "LWD8000": 32.92802915, + "P10": "-60.7665736", + "P25": -52.5791842, + "P50": -43.90607298, + "P75": -28.07031317, + "P90": -22.92097043, + "Alpha": 0, + "T": 1 + }, + { + "ID_g": 207, + "ID_File": 11, + "LWD63": 47.96303688, + "LWD125": 56.18856859, + "LWD250": 61.34741666, + "LWD500": 58.41229425, + "LWD1000": 55.48330756, + "LWD2000": 48.95700093, + "LWD4000": 39.2911194, + "LWD8000": 31.35456442, + "P10": "-61.06103874", + "P25": -53.16234877, + "P50": -45.90683694, + "P75": -36.88554184, + "P90": -29.2397466, + "Alpha": 0.5, + "T": 2 + }, + { + "ID_g": 208, + "ID_File": 11, + "LWD63": 45.97812327, + "LWD125": 49.06073664, + "LWD250": 62.18178209, + "LWD500": 59.90393383, + "LWD1000": 60.15987966, + "LWD2000": 54.85252121, + "LWD4000": 47.00115165, + "LWD8000": 39.90836387, + "P10": "-60.48176482", + "P25": -52.46710665, + "P50": -45.44823773, + "P75": -37.7412201, + "P90": -28.58892459, + "Alpha": 1, + "T": 3 + }, + { + "ID_g": 209, + "ID_File": 11, + "LWD63": 47.00007055, + "LWD125": 45.13470142, + "LWD250": 61.10555825, + "LWD500": 51.31739374, + "LWD1000": 52.51809203, + "LWD2000": 50.73277354, + "LWD4000": 55.38138608, + "LWD8000": 46.95853408, + "P10": "-56.86704154", + "P25": -48.72537378, + "P50": -41.90988373, + "P75": -35.72570291, + "P90": -30.72714069, + "Alpha": 1.5, + "T": 4 + }, + { + "ID_g": 210, + "ID_File": 11, + "LWD63": 44.17976477, + "LWD125": 50.31070539, + "LWD250": 59.20563973, + "LWD500": 55.28031251, + "LWD1000": 57.37829882, + "LWD2000": 52.4212797, + "LWD4000": 50.76064453, + "LWD8000": 53.76027706, + "P10": "-55.50174491", + "P25": -47.81570009, + "P50": -40.34278762, + "P75": -34.36364788, + "P90": -30.35253708, + "Alpha": 2, + "T": 5 + }, + { + "ID_g": 211, + "ID_File": 11, + "LWD63": 45.06919683, + "LWD125": 50.39574473, + "LWD250": 55.8665498, + "LWD500": 53.19649576, + "LWD1000": 47.67068279, + "LWD2000": 42.5751215, + "LWD4000": 43.54300073, + "LWD8000": 37.10426945, + "P10": "-61.06103874", + "P25": -53.0425415, + "P50": -44.96556413, + "P75": -38.20289778, + "P90": -33.99744373, + "Alpha": 2.5, + "T": 6 + }, + { + "ID_g": 212, + "ID_File": 11, + "LWD63": 40.19470299, + "LWD125": 41.02109462, + "LWD250": 37.67557418, + "LWD500": 36.53060274, + "LWD1000": 33.93140079, + "LWD2000": 33.32053377, + "LWD4000": 27.40396391, + "LWD8000": 21.79420834, + "P10": "-71.22414851", + "P25": -62.70477386, + "P50": -55.82348131, + "P75": -51.22414851, + "P90": -48.16479931, + "Alpha": 3, + "T": 7 + }, + { + "ID_g": 213, + "ID_File": 11, + "LWD63": 40.94730003, + "LWD125": 40.99651505, + "LWD250": 37.60459172, + "LWD500": 34.39673268, + "LWD1000": 31.71907462, + "LWD2000": 30.24719547, + "LWD4000": 24.70421516, + "LWD8000": 18.99022407, + "P10": "-70.3089987", + "P25": -62.70477386, + "P50": -55.82348131, + "P75": -50.93933973, + "P90": -47.76690273, + "Alpha": 3.5, + "T": 8 + }, + { + "ID_g": 214, + "ID_File": 11, + "LWD63": 49.75303138, + "LWD125": 55.46298797, + "LWD250": 56.00623308, + "LWD500": 52.57049888, + "LWD1000": 56.17137091, + "LWD2000": 44.18012256, + "LWD4000": 39.69075965, + "LWD8000": 27.55277489, + "P10": "-68.03013165", + "P25": -59.67942036, + "P50": -52.80777343, + "P75": -46.39100565, + "P90": -33.51943775, + "Alpha": 4, + "T": 9 + }, + { + "ID_g": 215, + "ID_File": 11, + "LWD63": 57.91817483, + "LWD125": 61.88608465, + "LWD250": 62.64655948, + "LWD500": 63.31277619, + "LWD1000": 64.19027888, + "LWD2000": 50.02397965, + "LWD4000": 44.14166378, + "LWD8000": 31.59001882, + "P10": "-47.96357279", + "P25": -40.07133148, + "P50": -33.4070379, + "P75": -28.0770282, + "P90": -24.02743886, + "Alpha": 4.5, + "T": 10 + }, + { + "ID_g": 216, + "ID_File": 11, + "LWD63": 55.88859825, + "LWD125": 59.54514753, + "LWD250": 59.887993, + "LWD500": 56.65652457, + "LWD1000": 58.03868652, + "LWD2000": 43.40166862, + "LWD4000": 41.11029251, + "LWD8000": 26.36043495, + "P10": "-53.4070379", + "P25": -45.44823773, + "P50": -38.53236419, + "P75": -32.6017743, + "P90": -28.33612418, + "Alpha": 5, + "T": 11 + }, + { + "ID_g": 217, + "ID_File": 11, + "LWD63": 50.61360833, + "LWD125": 54.28004752, + "LWD250": 53.963198, + "LWD500": 45.56540689, + "LWD1000": 38.32623493, + "LWD2000": 30.28440574, + "LWD4000": 29.45617945, + "LWD8000": 21.24218067, + "P10": "-67.38643799", + "P25": -58.94496422, + "P50": -51.72062018, + "P75": -45.39874534, + "P90": -38.26779887, + "Alpha": 5.5, + "T": 12 + }, + { + "ID_g": 218, + "ID_File": 11, + "LWD63": 39.94503119, + "LWD125": 42.01380193, + "LWD250": 36.29164668, + "LWD500": 32.11681271, + "LWD1000": 29.61730975, + "LWD2000": 29.62413701, + "LWD4000": 25.27535611, + "LWD8000": 18.2232388, + "P10": "-71.22414851", + "P25": -62.70477386, + "P50": -55.98893183, + "P75": -51.41934526, + "P90": -48.09720449, + "Alpha": 6, + "T": 13 + }, + { + "ID_g": 219, + "ID_File": 11, + "LWD63": 42.00327076, + "LWD125": 42.69422651, + "LWD250": 35.5347444, + "LWD500": 33.27942924, + "LWD1000": 32.65079735, + "LWD2000": 31.89783336, + "LWD4000": 25.76227944, + "LWD8000": 19.57798347, + "P10": "-69.481145", + "P25": -62.00953174, + "P50": -55.04043883, + "P75": -49.88521272, + "P90": -46.78717352, + "Alpha": 6.5, + "T": 14 + }, + { + "ID_g": 220, + "ID_File": 11, + "LWD63": 53.27896162, + "LWD125": 60.56243035, + "LWD250": 62.63122071, + "LWD500": 52.96969818, + "LWD1000": 37.76457151, + "LWD2000": 35.34620251, + "LWD4000": 41.31165338, + "LWD8000": 27.29965759, + "P10": "-60.20599913", + "P25": -51.61902967, + "P50": -43.8646128, + "P75": -34.25352419, + "P90": -27.97618001, + "Alpha": 7, + "T": 15 + }, + { + "ID_g": 221, + "ID_File": 11, + "LWD63": 53.89774759, + "LWD125": 59.8679208, + "LWD250": 59.57201782, + "LWD500": 61.06553636, + "LWD1000": 46.69809251, + "LWD2000": 46.30050429, + "LWD4000": 42.71316849, + "LWD8000": 31.24636567, + "P10": "-58.71332677", + "P25": -50.39629481, + "P50": -42.16119724, + "P75": -32.71561459, + "P90": -27.87058321, + "Alpha": 7.5, + "T": 16 + }, + { + "ID_g": 222, + "ID_File": 11, + "LWD63": 41.13271376, + "LWD125": 44.72558533, + "LWD250": 39.39370923, + "LWD500": 35.2787508, + "LWD1000": 35.04054133, + "LWD2000": 34.94539094, + "LWD4000": 30.35440124, + "LWD8000": 24.12186824, + "P10": "-68.03013165", + "P25": -60.20599913, + "P50": -53.53201688, + "P75": -48.72537378, + "P90": -45.59842976, + "Alpha": 8, + "T": 17 + }, + { + "ID_g": 223, + "ID_File": 11, + "LWD63": 50.0040426, + "LWD125": 55.99740334, + "LWD250": 57.62273602, + "LWD500": 58.16494594, + "LWD1000": 49.84406782, + "LWD2000": 42.79200875, + "LWD4000": 38.50192192, + "LWD8000": 30.02231299, + "P10": "-66.22659905", + "P25": -58.05332156, + "P50": -50.93933973, + "P75": -41.87692016, + "P90": -33.0890707, + "Alpha": 8.5, + "T": 18 + }, + { + "ID_g": 224, + "ID_File": 11, + "LWD63": 51.91187693, + "LWD125": 62.97436748, + "LWD250": 62.35716654, + "LWD500": 60.32919687, + "LWD1000": 57.86869925, + "LWD2000": 48.41180795, + "LWD4000": 52.52281326, + "LWD8000": 53.98682059, + "P10": "-52.15008839", + "P25": -43.74140663, + "P50": -36.41689472, + "P75": -30.85568685, + "P90": -26.34685872, + "Alpha": 9, + "T": 19 + }, + { + "ID_g": 225, + "ID_File": 11, + "LWD63": 50.1057825, + "LWD125": 56.45601265, + "LWD250": 67.71154767, + "LWD500": 73.44241837, + "LWD1000": 65.58706953, + "LWD2000": 51.72683659, + "LWD4000": 50.72621241, + "LWD8000": 40.39028318, + "P10": "-48.72537378", + "P25": -39.88623703, + "P50": -32.0592451, + "P75": -22.99175439, + "P90": -16.9059378, + "Alpha": 9.5, + "T": 20 + }, + { + "ID_g": 226, + "ID_File": 12, + "LWD63": 49.34822593, + "LWD125": 58.42158971, + "LWD250": 58.60741504, + "LWD500": 53.48280316, + "LWD1000": 41.71264007, + "LWD2000": 34.90866982, + "LWD4000": 31.55491434, + "LWD8000": 22.80269555, + "P10": "-65.70002027", + "P25": -57.63962959, + "P50": -50.48447719, + "P75": -44.64297413, + "P90": -39.37814543, + "Alpha": 0, + "T": 1 + }, + { + "ID_g": 227, + "ID_File": 12, + "LWD63": 60.58767772, + "LWD125": 69.95170529, + "LWD250": 70.63601555, + "LWD500": 65.20311247, + "LWD1000": 56.58800916, + "LWD2000": 51.16389927, + "LWD4000": 41.96918363, + "LWD8000": 31.1894309, + "P10": "-50.3089987", + "P25": -42.63269138, + "P50": -35.95558864, + "P75": -30.91136582, + "P90": -27.14174886, + "Alpha": 0.5, + "T": 2 + }, + { + "ID_g": 228, + "ID_File": 12, + "LWD63": 57.73974854, + "LWD125": 68.71357667, + "LWD250": 70.64880726, + "LWD500": 72.02619597, + "LWD1000": 57.95734152, + "LWD2000": 46.50083741, + "LWD4000": 41.41821034, + "LWD8000": 31.6699919, + "P10": "-53.53201688", + "P25": -44.64297413, + "P50": -36.92266109, + "P75": -30.22257122, + "P90": -25.43782103, + "Alpha": 1, + "T": 3 + }, + { + "ID_g": 229, + "ID_File": 12, + "LWD63": 50.64981454, + "LWD125": 69.72447007, + "LWD250": 70.36219422, + "LWD500": 71.12821664, + "LWD1000": 60.35824125, + "LWD2000": 50.92287448, + "LWD4000": 44.69811336, + "LWD8000": 31.85373121, + "P10": "-52.46710665", + "P25": -43.947732, + "P50": -35.92237296, + "P75": -29.63248482, + "P90": -25.91207098, + "Alpha": 1.5, + "T": 4 + }, + { + "ID_g": 230, + "ID_File": 12, + "LWD63": 53.02420002, + "LWD125": 63.6512781, + "LWD250": 64.23986613, + "LWD500": 60.23439395, + "LWD1000": 48.99286306, + "LWD2000": 40.06887339, + "LWD4000": 38.66317141, + "LWD8000": 28.73034993, + "P10": "-58.26779887", + "P25": -49.88521272, + "P50": -43.46054508, + "P75": -38.13847803, + "P90": -33.89183891, + "Alpha": 2, + "T": 5 + }, + { + "ID_g": 231, + "ID_File": 12, + "LWD63": 52.09620536, + "LWD125": 63.02262711, + "LWD250": 64.16292985, + "LWD500": 61.37730781, + "LWD1000": 48.48912417, + "LWD2000": 40.65632012, + "LWD4000": 36.03671726, + "LWD8000": 27.61056986, + "P10": "-57.43994517", + "P25": -49.56046874, + "P50": -42.999239, + "P75": -37.57924077, + "P90": -33.65882045, + "Alpha": 2.5, + "T": 6 + }, + { + "ID_g": 232, + "ID_File": 12, + "LWD63": 51.21277502, + "LWD125": 66.17815856, + "LWD250": 67.23156947, + "LWD500": 66.93109132, + "LWD1000": 64.85578361, + "LWD2000": 54.45714484, + "LWD4000": 41.94122385, + "LWD8000": 26.41794583, + "P10": "-59.42763781", + "P25": -50.39629481, + "P50": -43.07444198, + "P75": -35.10054903, + "P90": -28.83463169, + "Alpha": 3, + "T": 7 + }, + { + "ID_g": 233, + "ID_File": 12, + "LWD63": 54.13036711, + "LWD125": 64.12647551, + "LWD250": 66.69104921, + "LWD500": 65.78299405, + "LWD1000": 56.12871461, + "LWD2000": 43.74823481, + "LWD4000": 38.23888674, + "LWD8000": 28.57092173, + "P10": "-55.82348131", + "P25": -47.96357279, + "P50": -40.53798437, + "P75": -34.9066928, + "P90": -30.79117597, + "Alpha": 3.5, + "T": 8 + }, + { + "ID_g": 234, + "ID_File": 12, + "LWD63": 53.93856981, + "LWD125": 62.73583585, + "LWD250": 65.75072602, + "LWD500": 65.39821598, + "LWD1000": 59.34423513, + "LWD2000": 45.95358242, + "LWD4000": 34.94638624, + "LWD8000": 23.82236992, + "P10": "-55.82348131", + "P25": -47.76690273, + "P50": -40.8685171, + "P75": -35.90581263, + "P90": -31.24347197, + "Alpha": 4, + "T": 9 + }, + { + "ID_g": 235, + "ID_File": 12, + "LWD63": 58.00813564, + "LWD125": 66.034208, + "LWD250": 65.51775039, + "LWD500": 64.67241441, + "LWD1000": 56.10664602, + "LWD2000": 41.84522964, + "LWD4000": 33.19120833, + "LWD8000": 23.20847652, + "P10": "-56.5050771", + "P25": -48.79805947, + "P50": -41.94297287, + "P75": -35.75817356, + "P90": -30.79117597, + "Alpha": 4.5, + "T": 10 + }, + { + "ID_g": 236, + "ID_File": 12, + "LWD63": 58.47057277, + "LWD125": 67.44502, + "LWD250": 69.72796686, + "LWD500": 67.54629099, + "LWD1000": 55.09192711, + "LWD2000": 45.6803989, + "LWD4000": 37.85453864, + "LWD8000": 25.49028436, + "P10": "-54.74597369", + "P25": -46.61517008, + "P50": -39.42763781, + "P75": -32.80777343, + "P90": -28.16479931, + "Alpha": 5, + "T": 11 + }, + { + "ID_g": 237, + "ID_File": 12, + "LWD63": 49.84143176, + "LWD125": 61.89845299, + "LWD250": 61.17196203, + "LWD500": 59.15828986, + "LWD1000": 45.15063356, + "LWD2000": 34.42482866, + "LWD4000": 32.8482077, + "LWD8000": 21.76654913, + "P10": "-59.9387199", + "P25": -51.82341298, + "P50": -44.91873981, + "P75": -39.62847658, + "P90": -36.19001631, + "Alpha": 5.5, + "T": 12 + }, + { + "ID_g": 238, + "ID_File": 12, + "LWD63": 49.7684066, + "LWD125": 60.42264669, + "LWD250": 60.42583425, + "LWD500": 58.64258429, + "LWD1000": 46.08717362, + "LWD2000": 39.63116703, + "LWD4000": 31.33774598, + "LWD8000": 20.93606232, + "P10": "-59.9387199", + "P25": -51.92743685, + "P50": -45.49801373, + "P75": -40.53798437, + "P90": -37.12970185, + "Alpha": 6, + "T": 13 + }, + { + "ID_g": 239, + "ID_File": 12, + "LWD63": 50.51126853, + "LWD125": 66.06165244, + "LWD250": 66.88240056, + "LWD500": 64.56213081, + "LWD1000": 54.13561183, + "LWD2000": 41.29744937, + "LWD4000": 35.30742484, + "LWD8000": 27.46357659, + "P10": "-57.43994517", + "P25": -48.72537378, + "P50": -41.94297287, + "P75": -36.55396517, + "P90": -31.60893567, + "Alpha": 6.5, + "T": 14 + }, + { + "ID_g": 240, + "ID_File": 12, + "LWD63": 52.57822004, + "LWD125": 63.62065016, + "LWD250": 64.11411125, + "LWD500": 59.25268167, + "LWD1000": 47.88206864, + "LWD2000": 40.44839166, + "LWD4000": 37.37015034, + "LWD8000": 32.57701686, + "P10": "-59.9387199", + "P25": -51.82341298, + "P50": -45.25193808, + "P75": -39.23133817, + "P90": -34.43319101, + "Alpha": 7, + "T": 15 + }, + { + "ID_g": 241, + "ID_File": 12, + "LWD63": 58.57714631, + "LWD125": 62.82568241, + "LWD250": 65.49390096, + "LWD500": 64.16818525, + "LWD1000": 48.2512059, + "LWD2000": 36.30915429, + "LWD4000": 35.09797311, + "LWD8000": 24.36684719, + "P10": "-60.20599913", + "P25": -52.24719896, + "P50": -44.77976262, + "P75": -37.84401289, + "P90": -32.21468779, + "Alpha": 7.5, + "T": 16 + }, + { + "ID_g": 242, + "ID_File": 12, + "LWD63": 42.7144526, + "LWD125": 53.20972809, + "LWD250": 57.28440839, + "LWD500": 49.80759002, + "LWD1000": 37.2707202, + "LWD2000": 30.10673858, + "LWD4000": 27.54427886, + "LWD8000": 18.24179921, + "P10": "-71.22414851", + "P25": -63.46054508, + "P50": -56.5050771, + "P75": -50.93933973, + "P90": -45.39874534, + "Alpha": 8, + "T": 17 + }, + { + "ID_g": 243, + "ID_File": 12, + "LWD63": 55.17615979, + "LWD125": 63.84448529, + "LWD250": 63.28950956, + "LWD500": 57.88661891, + "LWD1000": 44.4020765, + "LWD2000": 34.37436513, + "LWD4000": 28.88949676, + "LWD8000": 20.27156133, + "P10": "-58.26779887", + "P25": -50.75452659, + "P50": -43.30403833, + "P75": -37.57924077, + "P90": -33.91811999, + "Alpha": 8.5, + "T": 18 + }, + { + "ID_g": 244, + "ID_File": 12, + "LWD63": 53.11828848, + "LWD125": 64.28311053, + "LWD250": 63.65324626, + "LWD500": 58.53713621, + "LWD1000": 48.80859565, + "LWD2000": 37.76923855, + "LWD4000": 32.86921265, + "LWD8000": 24.75704582, + "P10": "-57.05384207", + "P25": -48.94528146, + "P50": -42.52567701, + "P75": -37.43994517, + "P90": -33.65882045, + "Alpha": 9, + "T": 19 + }, + { + "ID_g": 245, + "ID_File": 12, + "LWD63": 58.3552928, + "LWD125": 65.64629841, + "LWD250": 66.73400097, + "LWD500": 65.92741873, + "LWD1000": 52.22139742, + "LWD2000": 42.275004, + "LWD4000": 34.30731122, + "LWD8000": 23.85476237, + "P10": "-58.05332156", + "P25": -49.24742983, + "P50": -40.62300191, + "P75": -34.32218771, + "P90": -29.95998411, + "Alpha": 9.5, + "T": 20 + }, + { + "ID_g": 246, + "ID_File": 13, + "LWD63": 9.766166014, + "LWD125": 8.515973453, + "LWD250": 16.67852589, + "LWD500": 12.76381054, + "LWD1000": 5.299627338, + "LWD2000": -0.246819937, + "LWD4000": -5.835225926, + "LWD8000": -4.600628023, + "P10": "-84.28839879", + "P25": -73.4070379, + "P50": -64.73392668, + "P75": -55.19150159, + "P90": -48.37079844, + "Alpha": 0, + "T": 1 + }, + { + "ID_g": 247, + "ID_File": 13, + "LWD63": 22.28222614, + "LWD125": 26.70514398, + "LWD250": 32.08499594, + "LWD500": 26.20807769, + "LWD1000": 16.43585215, + "LWD2000": 10.96770166, + "LWD4000": 3.251571059, + "LWD8000": -0.944173297, + "P10": "-57.43994517", + "P25": -49.01983891, + "P50": -41.84408122, + "P75": -36.88554184, + "P90": -32.97501879, + "Alpha": 0.5, + "T": 2 + }, + { + "ID_g": 248, + "ID_File": 13, + "LWD63": 31.20247974, + "LWD125": 35.08887277, + "LWD250": 38.40528645, + "LWD500": 36.50186374, + "LWD1000": 29.48858997, + "LWD2000": 24.74971132, + "LWD4000": 15.01221657, + "LWD8000": 4.44990141, + "P10": "-49.09504189", + "P25": -41.00134167, + "P50": -33.97092191, + "P75": -28.96758158, + "P90": -25.39874534, + "Alpha": 1, + "T": 3 + }, + { + "ID_g": 249, + "ID_File": 13, + "LWD63": 37.51381505, + "LWD125": 42.93404499, + "LWD250": 47.46918433, + "LWD500": 43.34924476, + "LWD1000": 36.37172812, + "LWD2000": 32.66306764, + "LWD4000": 25.5706343, + "LWD8000": 8.684043869, + "P10": "-40.01804365", + "P25": -31.83375948, + "P50": -25.53052214, + "P75": -20.8480226, + "P90": -17.27743019, + "Alpha": 1.5, + "T": 4 + }, + { + "ID_g": 250, + "ID_File": 13, + "LWD63": 36.80029126, + "LWD125": 48.68486003, + "LWD250": 51.79342489, + "LWD500": 47.33709061, + "LWD1000": 39.60830948, + "LWD2000": 33.57943724, + "LWD4000": 24.61309782, + "LWD8000": 8.883279188, + "P10": "-35.25267008", + "P25": -27.18407489, + "P50": -20.90078888, + "P75": -16.52104544, + "P90": -12.94010732, + "Alpha": 2, + "T": 5 + }, + { + "ID_g": 251, + "ID_File": 13, + "LWD63": 39.51127162, + "LWD125": 45.25881128, + "LWD250": 48.08776633, + "LWD500": 44.90837516, + "LWD1000": 36.87097418, + "LWD2000": 31.94118535, + "LWD4000": 22.68072497, + "LWD8000": 10.78127501, + "P10": "-36.90408164", + "P25": -29.58440782, + "P50": -23.6602295, + "P75": -19.22648707, + "P90": -16.09463832, + "Alpha": 2.5, + "T": 6 + }, + { + "ID_g": 252, + "ID_File": 13, + "LWD63": 42.40493595, + "LWD125": 44.55685901, + "LWD250": 47.14500135, + "LWD500": 44.73163619, + "LWD1000": 36.89861503, + "LWD2000": 31.73957372, + "LWD4000": 25.34282394, + "LWD8000": 12.97731654, + "P10": "-39.11326231", + "P25": -31.20486795, + "P50": -24.44616903, + "P75": -19.50992187, + "P90": -15.77119588, + "Alpha": 3, + "T": 7 + }, + { + "ID_g": 253, + "ID_File": 13, + "LWD63": 34.07845837, + "LWD125": 44.53778216, + "LWD250": 48.04517096, + "LWD500": 46.43902183, + "LWD1000": 39.53051025, + "LWD2000": 33.75183099, + "LWD4000": 26.4086608, + "LWD8000": 14.36764136, + "P10": "-37.96899188", + "P25": -29.94123158, + "P50": -23.48426623, + "P75": -18.82837334, + "P90": -15.64184294, + "Alpha": 3.5, + "T": 8 + }, + { + "ID_g": 254, + "ID_File": 13, + "LWD63": 33.41628725, + "LWD125": 42.35464952, + "LWD250": 47.75911042, + "LWD500": 48.93272867, + "LWD1000": 41.25781499, + "LWD2000": 34.49077316, + "LWD4000": 25.80287818, + "LWD8000": 9.316372683, + "P10": "-37.55920411", + "P25": -29.30140357, + "P50": -22.64885805, + "P75": -18.13847803, + "P90": -15.19912413, + "Alpha": 4, + "T": 9 + }, + { + "ID_g": 255, + "ID_File": 13, + "LWD63": 30.19189054, + "LWD125": 45.51474262, + "LWD250": 52.06520665, + "LWD500": 50.39943952, + "LWD1000": 42.20764141, + "LWD2000": 36.91225948, + "LWD4000": 31.1263455, + "LWD8000": 20.05030648, + "P10": "-34.86256456", + "P25": -26.41316354, + "P50": -20.10614471, + "P75": -15.58624989, + "P90": -12.74660901, + "Alpha": 4.5, + "T": 10 + }, + { + "ID_g": 256, + "ID_File": 13, + "LWD63": 38.91556299, + "LWD125": 49.67542588, + "LWD250": 54.16479157, + "LWD500": 50.54589723, + "LWD1000": 44.25989878, + "LWD2000": 37.24867505, + "LWD4000": 28.16843664, + "LWD8000": 14.5494931, + "P10": "-32.98325192", + "P25": -24.53507349, + "P50": -18.15989823, + "P75": -13.73741182, + "P90": -10.63493996, + "Alpha": 5, + "T": 11 + }, + { + "ID_g": 257, + "ID_File": 13, + "LWD63": 47.21215668, + "LWD125": 49.58847686, + "LWD250": 55.68750236, + "LWD500": 52.13739791, + "LWD1000": 45.95262173, + "LWD2000": 37.96140045, + "LWD4000": 30.23704681, + "LWD8000": 16.98308391, + "P10": "-32.02213556", + "P25": -23.7373297, + "P50": -17.2950791, + "P75": -12.35975594, + "P90": -8.97726277, + "Alpha": 5.5, + "T": 12 + }, + { + "ID_g": 258, + "ID_File": 13, + "LWD63": 42.38533865, + "LWD125": 47.87865877, + "LWD250": 53.0822208, + "LWD500": 49.7314123, + "LWD1000": 45.05572982, + "LWD2000": 38.27234533, + "LWD4000": 29.0995698, + "LWD8000": 14.12118455, + "P10": "-33.43189025", + "P25": -25.66432828, + "P50": -19.18294868, + "P75": -14.24156371, + "P90": -11.28224832, + "Alpha": 6, + "T": 13 + }, + { + "ID_g": 259, + "ID_File": 13, + "LWD63": 38.16070555, + "LWD125": 47.54769419, + "LWD250": 51.95434892, + "LWD500": 48.92361031, + "LWD1000": 41.94987843, + "LWD2000": 35.60583569, + "LWD4000": 26.67635565, + "LWD8000": 16.2563703, + "P10": "-34.84790483", + "P25": -26.92727155, + "P50": -20.6458145, + "P75": -15.81529093, + "P90": -12.91251733, + "Alpha": 6.5, + "T": 14 + }, + { + "ID_g": 260, + "ID_File": 13, + "LWD63": 37.50593398, + "LWD125": 46.18071208, + "LWD250": 52.14361934, + "LWD500": 48.10840537, + "LWD1000": 41.73283425, + "LWD2000": 33.46159323, + "LWD4000": 21.64734268, + "LWD8000": 6.575987577, + "P10": "-34.8347333", + "P25": -26.92138879, + "P50": -20.74633014, + "P75": -16.04759218, + "P90": -12.91146243, + "Alpha": 7, + "T": 15 + }, + { + "ID_g": 261, + "ID_File": 13, + "LWD63": 32.7900783, + "LWD125": 45.86243533, + "LWD250": 51.25029944, + "LWD500": 49.23273875, + "LWD1000": 44.78220339, + "LWD2000": 38.65762744, + "LWD4000": 27.55234269, + "LWD8000": 11.15258883, + "P10": "-35.13076085", + "P25": -26.98039642, + "P50": -20.29878049, + "P75": -15.84316977, + "P90": -12.83712371, + "Alpha": 7.5, + "T": 16 + }, + { + "ID_g": 262, + "ID_File": 13, + "LWD63": 38.80944362, + "LWD125": 48.8817975, + "LWD250": 52.29253495, + "LWD500": 50.24554108, + "LWD1000": 45.88750563, + "LWD2000": 40.93287291, + "LWD4000": 30.41969471, + "LWD8000": 13.4849289, + "P10": "-33.76161324", + "P25": -25.70896652, + "P50": -19.1204427, + "P75": -14.42481637, + "P90": -11.2212537, + "Alpha": 8, + "T": 17 + }, + { + "ID_g": 263, + "ID_File": 13, + "LWD63": 34.71069531, + "LWD125": 49.84282415, + "LWD250": 52.44655455, + "LWD500": 50.45984939, + "LWD1000": 44.98277732, + "LWD2000": 39.14948065, + "LWD4000": 31.63123614, + "LWD8000": 16.29673238, + "P10": "-32.68130556", + "P25": -24.6474992, + "P50": -18.52788808, + "P75": -14.35118904, + "P90": -11.58606598, + "Alpha": 8.5, + "T": 18 + }, + { + "ID_g": 264, + "ID_File": 13, + "LWD63": 36.31608241, + "LWD125": 45.19585981, + "LWD250": 48.96240831, + "LWD500": 48.8839225, + "LWD1000": 43.02174775, + "LWD2000": 36.37847568, + "LWD4000": 25.36958148, + "LWD8000": 12.44321928, + "P10": "-36.26038797", + "P25": -28.33612418, + "P50": -21.74630282, + "P75": -17.35058789, + "P90": -14.36364788, + "Alpha": 9, + "T": 19 + }, + { + "ID_g": 265, + "ID_File": 13, + "LWD63": 34.25514656, + "LWD125": 46.15172509, + "LWD250": 50.49362916, + "LWD500": 48.96886782, + "LWD1000": 40.4479665, + "LWD2000": 36.35279572, + "LWD4000": 29.12362227, + "LWD8000": 9.150226098, + "P10": "-35.66273349", + "P25": -27.79937339, + "P50": -21.41249471, + "P75": -16.95620458, + "P90": -13.61410125, + "Alpha": 9.5, + "T": 20 + }, + { + "ID_g": 266, + "ID_File": 14, + "LWD63": 17.71919808, + "LWD125": 28.58449301, + "LWD250": 27.74086115, + "LWD500": 22.69677926, + "LWD1000": 11.89206106, + "LWD2000": 9.196888475, + "LWD4000": 6.135250412, + "LWD8000": 6.427417721, + "P10": "-90.3089987", + "P25": -80.7665736, + "P50": -71.22414851, + "P75": -59.42763781, + "P90": -52.03272165, + "Alpha": 0, + "T": 1 + }, + { + "ID_g": 267, + "ID_File": 14, + "LWD63": 34.12295965, + "LWD125": 46.71655641, + "LWD250": 45.85028832, + "LWD500": 41.30975795, + "LWD1000": 35.14858343, + "LWD2000": 36.21181818, + "LWD4000": 29.46718687, + "LWD8000": 16.48711981, + "P10": "-58.94496422", + "P25": -50.48447719, + "P50": -43.82334959, + "P75": -38.37705679, + "P90": -33.296074, + "Alpha": 0.5, + "T": 2 + }, + { + "ID_g": 268, + "ID_File": 14, + "LWD63": 43.50580917, + "LWD125": 56.29406015, + "LWD250": 57.14058571, + "LWD500": 54.33094282, + "LWD1000": 46.36392701, + "LWD2000": 46.68558108, + "LWD4000": 38.16816439, + "LWD8000": 23.94599101, + "P10": "-46.55858428", + "P25": -38.73049257, + "P50": -32.02213556, + "P75": -26.82780254, + "P90": -22.36062785, + "Alpha": 1, + "T": 3 + }, + { + "ID_g": 269, + "ID_File": 14, + "LWD63": 50.11180352, + "LWD125": 60.46693994, + "LWD250": 58.95105319, + "LWD500": 54.94351102, + "LWD1000": 49.1802889, + "LWD2000": 47.11495067, + "LWD4000": 38.80052351, + "LWD8000": 25.72964725, + "P10": "-43.0367591", + "P25": -34.65954622, + "P50": -27.74747845, + "P75": -22.85167895, + "P90": -19.73580579, + "Alpha": 1.5, + "T": 4 + }, + { + "ID_g": 270, + "ID_File": 14, + "LWD63": 45.50564616, + "LWD125": 56.64658516, + "LWD250": 53.9618251, + "LWD500": 48.27419068, + "LWD1000": 45.52487199, + "LWD2000": 45.14364932, + "LWD4000": 34.96687009, + "LWD8000": 22.01591619, + "P10": "-46.7929835", + "P25": -38.85156666, + "P50": -31.86487315, + "P75": -27.15986334, + "P90": -24.08664185, + "Alpha": 2, + "T": 5 + }, + { + "ID_g": 271, + "ID_File": 14, + "LWD63": 47.60691022, + "LWD125": 60.46897609, + "LWD250": 58.57060475, + "LWD500": 52.62860104, + "LWD1000": 45.38801108, + "LWD2000": 43.57576439, + "LWD4000": 38.16878243, + "LWD8000": 27.45365847, + "P10": "-43.6602295", + "P25": -35.26802974, + "P50": -28.6103272, + "P75": -23.90191804, + "P90": -20.22230046, + "Alpha": 2.5, + "T": 6 + }, + { + "ID_g": 272, + "ID_File": 14, + "LWD63": 41.83538007, + "LWD125": 53.89933, + "LWD250": 51.80506794, + "LWD500": 44.11671083, + "LWD1000": 36.30423909, + "LWD2000": 32.75596697, + "LWD4000": 30.32836741, + "LWD8000": 19.92639151, + "P10": "-50.66357404", + "P25": -42.52567701, + "P50": -35.59702071, + "P75": -30.22257122, + "P90": -27.0457712, + "Alpha": 3, + "T": 7 + }, + { + "ID_g": 273, + "ID_File": 14, + "LWD63": 40.95904325, + "LWD125": 54.7558449, + "LWD250": 53.5019022, + "LWD500": 47.01504222, + "LWD1000": 43.49543181, + "LWD2000": 43.99445126, + "LWD4000": 39.92100715, + "LWD8000": 27.52962133, + "P10": "-50.13699526", + "P25": -42.28098788, + "P50": -35.08549548, + "P75": -29.38690295, + "P90": -25.42791186, + "Alpha": 3.5, + "T": 8 + }, + { + "ID_g": 274, + "ID_File": 14, + "LWD63": 44.30807002, + "LWD125": 57.67851301, + "LWD250": 56.2612523, + "LWD500": 46.35872308, + "LWD1000": 44.11438668, + "LWD2000": 46.03188406, + "LWD4000": 40.34529945, + "LWD8000": 30.24072938, + "P10": "-44.96556413", + "P25": -37.30284824, + "P50": -30.91136582, + "P75": -26.28652076, + "P90": -22.89133836, + "Alpha": 4, + "T": 9 + }, + { + "ID_g": 275, + "ID_File": 14, + "LWD63": 45.42990261, + "LWD125": 58.93632727, + "LWD250": 55.06783475, + "LWD500": 47.65726951, + "LWD1000": 42.91054631, + "LWD2000": 45.00278177, + "LWD4000": 40.65792884, + "LWD8000": 30.20505032, + "P10": "-44.96556413", + "P25": -37.01615919, + "P50": -30.67262656, + "P75": -25.92779205, + "P90": -22.70839374, + "Alpha": 4.5, + "T": 10 + }, + { + "ID_g": 276, + "ID_File": 14, + "LWD63": 51.03657056, + "LWD125": 63.87064698, + "LWD250": 59.42262804, + "LWD500": 52.84689572, + "LWD1000": 46.15682589, + "LWD2000": 42.51496462, + "LWD4000": 38.84311874, + "LWD8000": 29.4139932, + "P10": "-39.1108662", + "P25": -31.53360656, + "P50": -25.0599769, + "P75": -20.63725276, + "P90": -18.21583926, + "Alpha": 5, + "T": 11 + }, + { + "ID_g": 277, + "ID_File": 14, + "LWD63": 52.13095551, + "LWD125": 64.83576588, + "LWD250": 63.54964246, + "LWD500": 58.40362917, + "LWD1000": 52.99554844, + "LWD2000": 51.56953397, + "LWD4000": 45.61735022, + "LWD8000": 35.45780731, + "P10": "-39.50742996", + "P25": -30.49334486, + "P50": -23.42508438, + "P75": -18.45048171, + "P90": -15.59702071, + "Alpha": 5.5, + "T": 12 + }, + { + "ID_g": 278, + "ID_File": 14, + "LWD63": 47.80747564, + "LWD125": 60.31784097, + "LWD250": 57.25069186, + "LWD500": 51.32001911, + "LWD1000": 43.35646694, + "LWD2000": 44.07240742, + "LWD4000": 36.02981809, + "LWD8000": 25.08958958, + "P10": "-44.50830647", + "P25": -36.19172445, + "P50": -29.45748845, + "P75": -24.6746993, + "P90": -21.05804412, + "Alpha": 6, + "T": 13 + }, + { + "ID_g": 279, + "ID_File": 14, + "LWD63": 47.3773304, + "LWD125": 56.48314081, + "LWD250": 53.50695554, + "LWD500": 49.01654858, + "LWD1000": 43.02183436, + "LWD2000": 44.06722034, + "LWD4000": 36.59920946, + "LWD8000": 24.34093393, + "P10": "-48.44759814", + "P25": -39.88623703, + "P50": -33.12623275, + "P75": -27.23879891, + "P90": -23.77409111, + "Alpha": 6.5, + "T": 14 + }, + { + "ID_g": 280, + "ID_File": 14, + "LWD63": 48.04035393, + "LWD125": 56.62657911, + "LWD250": 49.0269415, + "LWD500": 43.18959358, + "LWD1000": 41.04199102, + "LWD2000": 40.33693974, + "LWD4000": 41.91074392, + "LWD8000": 29.02147714, + "P10": "-48.09720449", + "P25": -39.96508074, + "P50": -33.56986396, + "P75": -28.94528146, + "P90": -25.25193808, + "Alpha": 7, + "T": 15 + }, + { + "ID_g": 281, + "ID_File": 14, + "LWD63": 45.94892245, + "LWD125": 55.31178319, + "LWD250": 49.50610754, + "LWD500": 43.69003839, + "LWD1000": 37.30584836, + "LWD2000": 38.54758193, + "LWD4000": 36.22371116, + "LWD8000": 30.2583977, + "P10": "-50.57356401", + "P25": -41.90988373, + "P50": -34.53149638, + "P75": -29.58440782, + "P90": -26.4520764, + "Alpha": 7.5, + "T": 16 + }, + { + "ID_g": 282, + "ID_File": 14, + "LWD63": 46.89214379, + "LWD125": 58.06110965, + "LWD250": 53.80063771, + "LWD500": 47.11610916, + "LWD1000": 42.73837621, + "LWD2000": 38.51011039, + "LWD4000": 32.21488078, + "LWD8000": 20.47095953, + "P10": "-47.20227795", + "P25": -39.20710973, + "P50": -32.6017743, + "P75": -27.87780182, + "P90": -23.98539672, + "Alpha": 8, + "T": 17 + }, + { + "ID_g": 283, + "ID_File": 14, + "LWD63": 43.78923862, + "LWD125": 55.26108355, + "LWD250": 48.93065417, + "LWD500": 44.67996205, + "LWD1000": 37.42397605, + "LWD2000": 40.25083789, + "LWD4000": 35.32560479, + "LWD8000": 24.61506518, + "P10": "-49.32463825", + "P25": -41.45940332, + "P50": -34.89195847, + "P75": -30.04382539, + "P90": -26.79876243, + "Alpha": 8.5, + "T": 18 + }, + { + "ID_g": 284, + "ID_File": 14, + "LWD63": 45.99015449, + "LWD125": 57.52837503, + "LWD250": 57.18785187, + "LWD500": 47.96234072, + "LWD1000": 41.91146329, + "LWD2000": 42.64150921, + "LWD4000": 37.05539847, + "LWD8000": 27.82491214, + "P10": "-46.01212174", + "P25": -37.63962959, + "P50": -31.19524369, + "P75": -26.62084899, + "P90": -23.165172, + "Alpha": 9, + "T": 19 + }, + { + "ID_g": 285, + "ID_File": 14, + "LWD63": 47.28782207, + "LWD125": 59.04912086, + "LWD250": 56.42959327, + "LWD500": 49.87261851, + "LWD1000": 44.58874254, + "LWD2000": 43.73502203, + "LWD4000": 38.26029962, + "LWD8000": 24.74230623, + "P10": "-45.2035486", + "P25": -37.03498019, + "P50": -30.13699526, + "P75": -25.47806909, + "P90": -22.37768946, + "Alpha": 9.5, + "T": 20 + }, + { + "ID_g": 286, + "ID_File": 15, + "LWD63": 56.5056042, + "LWD125": 65.76455003, + "LWD250": 67.43446891, + "LWD500": 71.38850575, + "LWD1000": 66.66676327, + "LWD2000": 59.5383858, + "LWD4000": 53.31526399, + "LWD8000": 41.90234016, + "P10": "-59.67942036", + "P25": -51.72062018, + "P50": -45.10757094, + "P75": -40.31525705, + "P90": -36.84858056, + "Alpha": 0, + "T": 1 + }, + { + "ID_g": 287, + "ID_File": 15, + "LWD63": 58.22732245, + "LWD125": 68.5567752, + "LWD250": 70.20610698, + "LWD500": 74.44162535, + "LWD1000": 67.74206741, + "LWD2000": 59.29903889, + "LWD4000": 51.69486606, + "LWD8000": 39.94015264, + "P10": "-57.05384207", + "P25": -48.87135855, + "P50": -42.35019853, + "P75": -37.22546786, + "P90": -34.06410476, + "Alpha": 0.5, + "T": 2 + }, + { + "ID_g": 288, + "ID_File": 15, + "LWD63": 55.9777377, + "LWD125": 67.10164047, + "LWD250": 70.36042236, + "LWD500": 72.78235971, + "LWD1000": 67.72819255, + "LWD2000": 58.30997971, + "LWD4000": 49.98321639, + "LWD8000": 37.57942339, + "P10": "-58.48770656", + "P25": -50.3089987, + "P50": -43.42115323, + "P75": -38.48770656, + "P90": -35.08548244, + "Alpha": 1, + "T": 3 + }, + { + "ID_g": 289, + "ID_File": 15, + "LWD63": 56.0791141, + "LWD125": 66.55012449, + "LWD250": 71.75935074, + "LWD500": 72.65396163, + "LWD1000": 68.8515015, + "LWD2000": 59.21296052, + "LWD4000": 53.05220619, + "LWD8000": 39.73050075, + "P10": "-57.84401289", + "P25": -49.64052359, + "P50": -42.85075864, + "P75": -37.88547306, + "P90": -34.47518572, + "Alpha": 1.5, + "T": 4 + }, + { + "ID_g": 290, + "ID_File": 15, + "LWD63": 56.6849683, + "LWD125": 64.49048917, + "LWD250": 67.06627262, + "LWD500": 70.47087045, + "LWD1000": 67.5582407, + "LWD2000": 60.79156733, + "LWD4000": 50.4961638, + "LWD8000": 38.02578078, + "P10": "-60.20599913", + "P25": -52.13929832, + "P50": -45.1554272, + "P75": -40.50982911, + "P90": -37.1106747, + "Alpha": 2, + "T": 5 + }, + { + "ID_g": 291, + "ID_File": 15, + "LWD63": 56.00442766, + "LWD125": 64.87505383, + "LWD250": 66.74943807, + "LWD500": 70.35439001, + "LWD1000": 63.9585443, + "LWD2000": 55.61147631, + "LWD4000": 48.54787272, + "LWD8000": 37.35558972, + "P10": "-61.06103874", + "P25": -53.0425415, + "P50": -46.22659905, + "P75": -41.27326999, + "P90": -37.78014037, + "Alpha": 2.5, + "T": 6 + }, + { + "ID_g": 292, + "ID_File": 15, + "LWD63": 56.72236687, + "LWD125": 62.77290549, + "LWD250": 66.52924502, + "LWD500": 71.56761377, + "LWD1000": 69.38336116, + "LWD2000": 58.60834052, + "LWD4000": 47.02977619, + "LWD8000": 36.48954529, + "P10": "-58.94496422", + "P25": -51.12817085, + "P50": -44.33193717, + "P75": -39.78221315, + "P90": -36.39936517, + "Alpha": 3, + "T": 7 + }, + { + "ID_g": 293, + "ID_File": 15, + "LWD63": 57.46768459, + "LWD125": 66.00229907, + "LWD250": 69.27590781, + "LWD500": 70.93218056, + "LWD1000": 69.01899054, + "LWD2000": 60.09207859, + "LWD4000": 51.97639465, + "LWD8000": 37.75619107, + "P10": "-58.71332677", + "P25": -50.66357404, + "P50": -44.07392148, + "P75": -39.15885466, + "P90": -35.87278639, + "Alpha": 3.5, + "T": 8 + }, + { + "ID_g": 294, + "ID_File": 15, + "LWD63": 57.31422119, + "LWD125": 65.9692621, + "LWD250": 68.46167549, + "LWD500": 71.79334656, + "LWD1000": 65.94641849, + "LWD2000": 58.15963701, + "LWD4000": 49.09246117, + "LWD8000": 36.3863223, + "P10": "-59.67942036", + "P25": -51.51861365, + "P50": -44.73392668, + "P75": -39.80810256, + "P90": -36.24317114, + "Alpha": 4, + "T": 9 + }, + { + "ID_g": 295, + "ID_File": 15, + "LWD63": 57.05119273, + "LWD125": 64.46158887, + "LWD250": 71.09297932, + "LWD500": 73.40602619, + "LWD1000": 74.19234073, + "LWD2000": 66.55694868, + "LWD4000": 56.4629475, + "LWD8000": 40.77397186, + "P10": "-55.34523816", + "P25": -47.14174886, + "P50": -40.56623119, + "P75": -35.80710828, + "P90": -32.5791842, + "Alpha": 4.5, + "T": 10 + }, + { + "ID_g": 296, + "ID_File": 15, + "LWD63": 58.1885569, + "LWD125": 68.47284284, + "LWD250": 71.35294491, + "LWD500": 74.0395565, + "LWD1000": 71.11507614, + "LWD2000": 63.88092003, + "LWD4000": 56.34395191, + "LWD8000": 40.15218628, + "P10": "-55.50174491", + "P25": -47.51141697, + "P50": -40.97164629, + "P75": -36.52282152, + "P90": -33.25817975, + "Alpha": 5, + "T": 11 + }, + { + "ID_g": 297, + "ID_File": 15, + "LWD63": 57.66699039, + "LWD125": 64.37081808, + "LWD250": 69.37879956, + "LWD500": 71.33111643, + "LWD1000": 68.91200585, + "LWD2000": 61.13224949, + "LWD4000": 53.99078017, + "LWD8000": 38.27720971, + "P10": "-57.63962959", + "P25": -49.56046874, + "P50": -43.42115323, + "P75": -39.03937699, + "P90": -35.75817356, + "Alpha": 5.5, + "T": 12 + }, + { + "ID_g": 298, + "ID_File": 15, + "LWD63": 56.50106329, + "LWD125": 63.1132515, + "LWD250": 66.75832559, + "LWD500": 69.74849767, + "LWD1000": 66.56312274, + "LWD2000": 56.73577108, + "LWD4000": 48.4442856, + "LWD8000": 36.01845321, + "P10": "-60.20599913", + "P25": -52.46710665, + "P50": -46.06524661, + "P75": -41.12114894, + "P90": -37.86471824, + "Alpha": 6, + "T": 13 + }, + { + "ID_g": 299, + "ID_File": 15, + "LWD63": 57.27691603, + "LWD125": 62.77311108, + "LWD250": 66.15891473, + "LWD500": 68.54292436, + "LWD1000": 67.83478883, + "LWD2000": 58.23335958, + "LWD4000": 48.79227259, + "LWD8000": 37.24816967, + "P10": "-60.20599913", + "P25": -52.35645687, + "P50": -45.85466928, + "P75": -41.06103874, + "P90": -37.80274968, + "Alpha": 6.5, + "T": 14 + }, + { + "ID_g": 300, + "ID_File": 15, + "LWD63": 57.81635525, + "LWD125": 65.89878571, + "LWD250": 68.69536256, + "LWD500": 71.67129399, + "LWD1000": 68.77479452, + "LWD2000": 60.75993923, + "LWD4000": 53.92820282, + "LWD8000": 39.93648684, + "P10": "-58.48770656", + "P25": -50.48447719, + "P50": -43.82334959, + "P75": -38.92152051, + "P90": -35.80547406, + "Alpha": 7, + "T": 15 + }, + { + "ID_g": 301, + "ID_File": 15, + "LWD63": 57.83201757, + "LWD125": 65.6440432, + "LWD250": 67.59392525, + "LWD500": 72.82884776, + "LWD1000": 72.48471161, + "LWD2000": 60.59664463, + "LWD4000": 53.45409759, + "LWD8000": 39.69414388, + "P10": "-57.63962959", + "P25": -49.56046874, + "P50": -42.999239, + "P75": -37.68012332, + "P90": -33.89183891, + "Alpha": 7.5, + "T": 16 + }, + { + "ID_g": 302, + "ID_File": 15, + "LWD63": 58.03008822, + "LWD125": 65.93942437, + "LWD250": 71.70777634, + "LWD500": 74.13196991, + "LWD1000": 69.54168581, + "LWD2000": 60.06013544, + "LWD4000": 51.83442637, + "LWD8000": 38.43488443, + "P10": "-55.82348131", + "P25": -47.83196588, + "P50": -41.42810278, + "P75": -37.07274499, + "P90": -33.87872813, + "Alpha": 8, + "T": 17 + }, + { + "ID_g": 303, + "ID_File": 15, + "LWD63": 57.34339169, + "LWD125": 63.73290331, + "LWD250": 67.16763328, + "LWD500": 72.78009543, + "LWD1000": 69.33716467, + "LWD2000": 61.12804205, + "LWD4000": 52.01404524, + "LWD8000": 37.9051386, + "P10": "-57.84401289", + "P25": -49.72132315, + "P50": -43.34290144, + "P75": -38.69049919, + "P90": -35.31427239, + "Alpha": 8.5, + "T": 18 + }, + { + "ID_g": 304, + "ID_File": 15, + "LWD63": 57.5734185, + "LWD125": 65.11651824, + "LWD250": 68.92047067, + "LWD500": 72.47222352, + "LWD1000": 68.70631629, + "LWD2000": 62.011329, + "LWD4000": 52.40184919, + "LWD8000": 44.01387219, + "P10": "-58.05332156", + "P25": -49.64052359, + "P50": -43.0367591, + "P75": -38.37705679, + "P90": -35.28341662, + "Alpha": 9, + "T": 19 + }, + { + "ID_g": 305, + "ID_File": 15, + "LWD63": 57.34626461, + "LWD125": 64.46765151, + "LWD250": 66.29444045, + "LWD500": 69.32115825, + "LWD1000": 64.865499, + "LWD2000": 57.02193869, + "LWD4000": 55.05339551, + "LWD8000": 42.47158279, + "P10": "-61.68172342", + "P25": -52.9243643, + "P50": -46.06524661, + "P75": -41.55398744, + "P90": -38.30915761, + "Alpha": 9.5, + "T": 20 + }, + { + "ID_g": 306, + "ID_File": 16, + "LWD63": 38.98463618, + "LWD125": 55.57096974, + "LWD250": 61.67096391, + "LWD500": 60.29599296, + "LWD1000": 53.65295207, + "LWD2000": 45.73680869, + "LWD4000": 31.98199309, + "LWD8000": 19.55103237, + "P10": "-49.01983891", + "P25": -40.37040574, + "P50": -33.99744373, + "P75": -29.62445348, + "P90": -26.55858428, + "Alpha": 0, + "T": 1 + }, + { + "ID_g": 307, + "ID_File": 16, + "LWD63": 36.9241178, + "LWD125": 55.18063704, + "LWD250": 62.56569392, + "LWD500": 61.33501516, + "LWD1000": 56.3608735, + "LWD2000": 44.4226658, + "LWD4000": 32.9166874, + "LWD8000": 19.21754787, + "P10": "-48.03013165", + "P25": -40.0446467, + "P50": -33.45681391, + "P75": -28.76891216, + "P90": -25.36918471, + "Alpha": 0.5, + "T": 2 + }, + { + "ID_g": 308, + "ID_File": 16, + "LWD63": 35.63601569, + "LWD125": 56.20345201, + "LWD250": 63.04611964, + "LWD500": 59.40762684, + "LWD1000": 53.53890938, + "LWD2000": 43.39071305, + "LWD4000": 31.87420422, + "LWD8000": 21.7213339, + "P10": "-47.51141697", + "P25": -40.11154419, + "P50": -33.78750265, + "P75": -29.29367247, + "P90": -26.17140286, + "Alpha": 1, + "T": 3 + }, + { + "ID_g": 309, + "ID_File": 16, + "LWD63": 36.35549071, + "LWD125": 58.23871463, + "LWD250": 61.92471468, + "LWD500": 57.55904817, + "LWD1000": 51.57848959, + "LWD2000": 45.192553, + "LWD4000": 32.12914154, + "LWD8000": 18.06454793, + "P10": "-50.3089987", + "P25": -41.81136597, + "P50": -35.11565494, + "P75": -30.46676894, + "P90": -27.02194158, + "Alpha": 1.5, + "T": 4 + }, + { + "ID_g": 310, + "ID_File": 16, + "LWD63": 38.26486714, + "LWD125": 56.42322563, + "LWD250": 61.98227295, + "LWD500": 62.1386636, + "LWD1000": 55.983399, + "LWD2000": 51.63564238, + "LWD4000": 41.17794163, + "LWD8000": 26.46396512, + "P10": "-48.16479931", + "P25": -40.15188127, + "P50": -33.33290468, + "P75": -28.2878116, + "P90": -25.17464378, + "Alpha": 2, + "T": 5 + }, + { + "ID_g": 311, + "ID_File": 16, + "LWD63": 39.16773118, + "LWD125": 56.75589782, + "LWD250": 66.48289349, + "LWD500": 62.42575839, + "LWD1000": 56.53368021, + "LWD2000": 48.0707058, + "LWD4000": 36.91260917, + "LWD8000": 25.57809736, + "P10": "-45.02213511", + "P25": -37.3613393, + "P50": -30.71803121, + "P75": -26.20491142, + "P90": -23.36630304, + "Alpha": 2.5, + "T": 6 + }, + { + "ID_g": 312, + "ID_File": 16, + "LWD63": 39.2596919, + "LWD125": 55.83125643, + "LWD250": 64.07977859, + "LWD500": 60.38251386, + "LWD1000": 58.51733351, + "LWD2000": 52.18026892, + "LWD4000": 37.55178298, + "LWD8000": 24.09455546, + "P10": "-46.55858428", + "P25": -38.57725261, + "P50": -32.24719896, + "P75": -27.61271129, + "P90": -24.63393103, + "Alpha": 3, + "T": 7 + }, + { + "ID_g": 313, + "ID_File": 16, + "LWD63": 46.71657593, + "LWD125": 57.44120288, + "LWD250": 63.23164536, + "LWD500": 60.6270737, + "LWD1000": 57.31544321, + "LWD2000": 50.85699294, + "LWD4000": 37.68159594, + "LWD8000": 23.47440468, + "P10": "-48.16479931", + "P25": -39.83406936, + "P50": -33.0425415, + "P75": -28.1512382, + "P90": -24.98436477, + "Alpha": 3.5, + "T": 8 + }, + { + "ID_g": 314, + "ID_File": 16, + "LWD63": 47.16337399, + "LWD125": 55.25170743, + "LWD250": 60.90062714, + "LWD500": 60.1084241, + "LWD1000": 54.33372725, + "LWD2000": 47.42156132, + "LWD4000": 34.23849817, + "LWD8000": 20.59423082, + "P10": "-49.32463825", + "P25": -41.06103874, + "P50": -34.87726152, + "P75": -30.15404314, + "P90": -27.11765483, + "Alpha": 4, + "T": 9 + }, + { + "ID_g": 315, + "ID_File": 16, + "LWD63": 48.69229583, + "LWD125": 55.13331228, + "LWD250": 61.34691169, + "LWD500": 59.44805118, + "LWD1000": 55.16280205, + "LWD2000": 50.0830293, + "LWD4000": 42.21479784, + "LWD8000": 28.73826834, + "P10": "-50.48447719", + "P25": -41.61762062, + "P50": -34.86256456, + "P75": -30.13699526, + "P90": -26.82198675, + "Alpha": 4.5, + "T": 10 + }, + { + "ID_g": 316, + "ID_File": 16, + "LWD63": 46.66432501, + "LWD125": 57.21134753, + "LWD250": 61.61745308, + "LWD500": 60.70582557, + "LWD1000": 62.78105573, + "LWD2000": 52.60923327, + "LWD4000": 39.98398499, + "LWD8000": 24.53579222, + "P10": "-47.51141697", + "P25": -39.37814543, + "P50": -32.62442331, + "P75": -27.63822053, + "P90": -24.25285983, + "Alpha": 5, + "T": 11 + }, + { + "ID_g": 317, + "ID_File": 16, + "LWD63": 51.11219922, + "LWD125": 56.34311127, + "LWD250": 60.17386824, + "LWD500": 57.77747691, + "LWD1000": 49.99163735, + "LWD2000": 40.38129502, + "LWD4000": 30.63507791, + "LWD8000": 21.66683829, + "P10": "-50.3089987", + "P25": -42.28098788, + "P50": -35.85632025, + "P75": -31.14728173, + "P90": -28.02879639, + "Alpha": 5.5, + "T": 12 + }, + { + "ID_g": 318, + "ID_File": 16, + "LWD63": 51.37546381, + "LWD125": 56.76774928, + "LWD250": 61.03950817, + "LWD500": 57.81080256, + "LWD1000": 54.60200043, + "LWD2000": 45.61064931, + "LWD4000": 31.68105602, + "LWD8000": 19.84905546, + "P10": "-49.32463825", + "P25": -41.61762062, + "P50": -34.95104638, + "P75": -30.00180359, + "P90": -27.02194158, + "Alpha": 6, + "T": 13 + }, + { + "ID_g": 319, + "ID_File": 16, + "LWD63": 48.66579553, + "LWD125": 56.77658111, + "LWD250": 61.29658911, + "LWD500": 58.23310791, + "LWD1000": 52.93983063, + "LWD2000": 45.42888868, + "LWD4000": 32.42004876, + "LWD8000": 17.7494097, + "P10": "-49.64052359", + "P25": -41.49081706, + "P50": -34.71706887, + "P75": -30.1882396, + "P90": -26.99817716, + "Alpha": 6.5, + "T": 14 + }, + { + "ID_g": 320, + "ID_File": 16, + "LWD63": 41.74498867, + "LWD125": 55.38293573, + "LWD250": 60.54518707, + "LWD500": 59.23028973, + "LWD1000": 52.44584316, + "LWD2000": 43.70290862, + "LWD4000": 31.98247596, + "LWD8000": 24.05709791, + "P10": "-49.80288139", + "P25": -41.68172342, + "P50": -35.19150159, + "P75": -30.71803121, + "P90": -27.63694413, + "Alpha": 7, + "T": 15 + }, + { + "ID_g": 321, + "ID_File": 16, + "LWD63": 42.09946377, + "LWD125": 56.9029948, + "LWD250": 63.06449499, + "LWD500": 60.40320225, + "LWD1000": 52.93068542, + "LWD2000": 42.8797664, + "LWD4000": 33.70798765, + "LWD8000": 20.56085526, + "P10": "-49.01983891", + "P25": -40.7665736, + "P50": -34.13128135, + "P75": -29.21673761, + "P90": -25.83388963, + "Alpha": 7.5, + "T": 16 + }, + { + "ID_g": 322, + "ID_File": 16, + "LWD63": 41.4347522, + "LWD125": 56.57451685, + "LWD250": 61.88868717, + "LWD500": 60.3657492, + "LWD1000": 52.97292805, + "LWD2000": 42.96402759, + "LWD4000": 31.78782748, + "LWD8000": 17.57591488, + "P10": "-49.01983891", + "P25": -41.12114894, + "P50": -34.57397026, + "P75": -29.73757365, + "P90": -26.28105621, + "Alpha": 8, + "T": 17 + }, + { + "ID_g": 323, + "ID_File": 16, + "LWD63": 41.45342517, + "LWD125": 59.24906099, + "LWD250": 62.15680084, + "LWD500": 60.96952381, + "LWD1000": 57.08045678, + "LWD2000": 47.33047455, + "LWD4000": 34.30358651, + "LWD8000": 22.74837381, + "P10": "-46.44650673", + "P25": -38.62237421, + "P50": -32.51176427, + "P75": -28.01677901, + "P90": -25.13625304, + "Alpha": 8.5, + "T": 18 + }, + { + "ID_g": 324, + "ID_File": 16, + "LWD63": 40.72168455, + "LWD125": 59.99192547, + "LWD250": 62.23764082, + "LWD500": 61.31165891, + "LWD1000": 52.97013901, + "LWD2000": 43.83634883, + "LWD4000": 32.47164851, + "LWD8000": 19.84027713, + "P10": "-47.51141697", + "P25": -39.73066469, + "P50": -33.33290468, + "P75": -28.45458581, + "P90": -25.0599769, + "Alpha": 9, + "T": 19 + }, + { + "ID_g": 325, + "ID_File": 16, + "LWD63": 41.55513714, + "LWD125": 61.93446276, + "LWD250": 63.34257966, + "LWD500": 59.40718247, + "LWD1000": 52.04714468, + "LWD2000": 44.06697075, + "LWD4000": 31.08694862, + "LWD8000": 18.34912815, + "P10": "-47.14174886", + "P25": -38.8052418, + "P50": -32.46710665, + "P75": -27.92388091, + "P90": -25.06947487, + "Alpha": 9.5, + "T": 20 + }, + { + "ID_g": 326, + "ID_File": 17, + "LWD63": 13.37361554, + "LWD125": 25.40657953, + "LWD250": 33.22046443, + "LWD500": 41.49123037, + "LWD1000": 37.58834777, + "LWD2000": 34.47083141, + "LWD4000": 24.5272123, + "LWD8000": 3.511128912, + "P10": "-84.28839879", + "P25": -74.74597369, + "P50": -65.70002027, + "P75": -58.05332156, + "P90": -30.35253708, + "Alpha": 0, + "T": 1 + }, + { + "ID_g": 327, + "ID_File": 17, + "LWD63": 21.24721193, + "LWD125": 35.33386518, + "LWD250": 42.35905895, + "LWD500": 48.75517027, + "LWD1000": 52.59717992, + "LWD2000": 52.99803944, + "LWD4000": 34.92540428, + "LWD8000": 14.77349664, + "P10": "-40.34278762", + "P25": -32.19308109, + "P50": -25.67960689, + "P75": -20.62585021, + "P90": -16.38536696, + "Alpha": 0.5, + "T": 2 + }, + { + "ID_g": 328, + "ID_File": 17, + "LWD63": 22.21957103, + "LWD125": 36.91304434, + "LWD250": 44.14944053, + "LWD500": 49.48715406, + "LWD1000": 50.70702174, + "LWD2000": 47.82176557, + "LWD4000": 33.41828195, + "LWD8000": 16.51083772, + "P10": "-41.77877347", + "P25": -33.55722993, + "P50": -26.95674524, + "P75": -21.98034958, + "P90": -18.12693342, + "Alpha": 1, + "T": 3 + }, + { + "ID_g": 329, + "ID_File": 17, + "LWD63": 22.01194822, + "LWD125": 36.13578606, + "LWD250": 46.25964385, + "LWD500": 53.40810264, + "LWD1000": 51.89271374, + "LWD2000": 48.65818211, + "LWD4000": 33.98467027, + "LWD8000": 12.42059023, + "P10": "-39.23133817", + "P25": -30.90206117, + "P50": -24.0760405, + "P75": -19.42515648, + "P90": -16.17413126, + "Alpha": 1.5, + "T": 4 + }, + { + "ID_g": 330, + "ID_File": 17, + "LWD63": 27.03179747, + "LWD125": 34.10341166, + "LWD250": 45.57958999, + "LWD500": 53.28171227, + "LWD1000": 53.96913508, + "LWD2000": 51.25482224, + "LWD4000": 35.17829166, + "LWD8000": 12.92225237, + "P10": "-38.35509498", + "P25": -29.92459592, + "P50": -23.07066633, + "P75": -18.39907426, + "P90": -15.11866351, + "Alpha": 2, + "T": 5 + }, + { + "ID_g": 331, + "ID_File": 17, + "LWD63": 26.47648668, + "LWD125": 36.85064386, + "LWD250": 43.56420826, + "LWD500": 53.04251181, + "LWD1000": 53.400571, + "LWD2000": 48.37489511, + "LWD4000": 32.81332992, + "LWD8000": 14.3899431, + "P10": "-38.58402967", + "P25": -30.61845243, + "P50": -23.96863668, + "P75": -19.04471838, + "P90": -15.81316283, + "Alpha": 2.5, + "T": 6 + }, + { + "ID_g": 332, + "ID_File": 17, + "LWD63": 24.24566977, + "LWD125": 34.02074138, + "LWD250": 42.82558094, + "LWD500": 53.78652939, + "LWD1000": 53.51794997, + "LWD2000": 49.8898105, + "LWD4000": 35.06332776, + "LWD8000": 15.74984373, + "P10": "-38.11711051", + "P25": -29.99552463, + "P50": -23.39760358, + "P75": -18.82374211, + "P90": -15.80547267, + "Alpha": 3, + "T": 7 + }, + { + "ID_g": 333, + "ID_File": 17, + "LWD63": 24.68555974, + "LWD125": 38.84079251, + "LWD250": 44.75063114, + "LWD500": 49.12834232, + "LWD1000": 51.13927437, + "LWD2000": 48.0983231, + "LWD4000": 34.15167009, + "LWD8000": 16.30765594, + "P10": "-41.94629444", + "P25": -33.74869741, + "P50": -26.98039642, + "P75": -22.12048133, + "P90": -18.52565089, + "Alpha": 3.5, + "T": 8 + }, + { + "ID_g": 334, + "ID_File": 17, + "LWD63": 23.12799637, + "LWD125": 33.77881265, + "LWD250": 41.45592744, + "LWD500": 49.36824677, + "LWD1000": 48.43603286, + "LWD2000": 44.60289407, + "LWD4000": 30.88064376, + "LWD8000": 11.49349733, + "P10": "-42.85075864", + "P25": -34.77497502, + "P50": -28.09047385, + "P75": -23.28080366, + "P90": -19.96508074, + "Alpha": 4, + "T": 9 + }, + { + "ID_g": 335, + "ID_File": 17, + "LWD63": 21.32741493, + "LWD125": 32.90574331, + "LWD250": 40.57491726, + "LWD500": 46.8998089, + "LWD1000": 45.5054693, + "LWD2000": 43.48158783, + "LWD4000": 29.67212177, + "LWD8000": 12.40857622, + "P10": "-45.39874534", + "P25": -37.20623, + "P50": -30.62745802, + "P75": -25.83388963, + "P90": -22.39897621, + "Alpha": 4.5, + "T": 10 + }, + { + "ID_g": 336, + "ID_File": 17, + "LWD63": 22.58470945, + "LWD125": 32.50269587, + "LWD250": 39.20011796, + "LWD500": 46.19136679, + "LWD1000": 47.87860123, + "LWD2000": 46.54365307, + "LWD4000": 35.80585962, + "LWD8000": 19.31206307, + "P10": "-44.46387727", + "P25": -36.277639, + "P50": -29.67679134, + "P75": -24.57537931, + "P90": -21.11210585, + "Alpha": 5, + "T": 11 + }, + { + "ID_g": 337, + "ID_File": 17, + "LWD63": 19.51619584, + "LWD125": 35.45479805, + "LWD250": 41.01470511, + "LWD500": 47.34389893, + "LWD1000": 42.8209082, + "LWD2000": 44.57844643, + "LWD4000": 31.89120958, + "LWD8000": 11.34022327, + "P10": "-46.22659905", + "P25": -38.11711051, + "P50": -31.56867655, + "P75": -26.51919243, + "P90": -22.77016356, + "Alpha": 5.5, + "T": 12 + }, + { + "ID_g": 338, + "ID_File": 17, + "LWD63": 26.818168, + "LWD125": 36.01996181, + "LWD250": 43.31976623, + "LWD500": 51.79782855, + "LWD1000": 47.88797842, + "LWD2000": 50.5306295, + "LWD4000": 36.66973779, + "LWD8000": 17.3521059, + "P10": "-40.70885984", + "P25": -32.70416318, + "P50": -26.16169795, + "P75": -21.45078453, + "P90": -18.0658298, + "Alpha": 6, + "T": 13 + }, + { + "ID_g": 339, + "ID_File": 17, + "LWD63": 26.49937158, + "LWD125": 37.34959518, + "LWD250": 43.00525402, + "LWD500": 53.41135435, + "LWD1000": 52.50690961, + "LWD2000": 51.14802099, + "LWD4000": 37.91423676, + "LWD8000": 20.54429726, + "P10": "-38.25263385", + "P25": -30.22257122, + "P50": -23.67640435, + "P75": -18.84460216, + "P90": -15.65951515, + "Alpha": 6.5, + "T": 14 + }, + { + "ID_g": 340, + "ID_File": 17, + "LWD63": 23.66837826, + "LWD125": 37.59025786, + "LWD250": 48.45624051, + "LWD500": 53.89700829, + "LWD1000": 52.19085873, + "LWD2000": 50.07125394, + "LWD4000": 37.83504031, + "LWD8000": 17.71584983, + "P10": "-38.31133726", + "P25": -30.08605148, + "P50": -23.73122005, + "P75": -18.67284904, + "P90": -15.25098218, + "Alpha": 7, + "T": 15 + }, + { + "ID_g": 341, + "ID_File": 17, + "LWD63": 24.81980974, + "LWD125": 38.12766451, + "LWD250": 46.56614669, + "LWD500": 54.08915606, + "LWD1000": 50.94691935, + "LWD2000": 50.55160964, + "LWD4000": 40.46004604, + "LWD8000": 20.22005193, + "P10": "-38.66773144", + "P25": -30.44909673, + "P50": -23.98959179, + "P75": -19.0346319, + "P90": -15.80040426, + "Alpha": 7.5, + "T": 16 + }, + { + "ID_g": 342, + "ID_File": 17, + "LWD63": 25.64295799, + "LWD125": 37.93964758, + "LWD250": 44.87959542, + "LWD500": 50.55164747, + "LWD1000": 49.90160643, + "LWD2000": 49.99009636, + "LWD4000": 39.59623338, + "LWD8000": 19.80487396, + "P10": "-40.56623119", + "P25": -32.36745864, + "P50": -25.94354163, + "P75": -20.94279081, + "P90": -17.66998217, + "Alpha": 8, + "T": 17 + }, + { + "ID_g": 343, + "ID_File": 17, + "LWD63": 21.06403599, + "LWD125": 35.73886295, + "LWD250": 44.45815507, + "LWD500": 52.54102737, + "LWD1000": 50.08841262, + "LWD2000": 51.51697148, + "LWD4000": 40.01904023, + "LWD8000": 18.37140789, + "P10": "-39.88623703", + "P25": -31.62913542, + "P50": -24.87216657, + "P75": -19.91243882, + "P90": -16.35918096, + "Alpha": 8.5, + "T": 18 + }, + { + "ID_g": 344, + "ID_File": 17, + "LWD63": 24.83150899, + "LWD125": 36.34728542, + "LWD250": 45.05412619, + "LWD500": 54.45092145, + "LWD1000": 54.79119459, + "LWD2000": 50.90842181, + "LWD4000": 36.6042385, + "LWD8000": 18.30151398, + "P10": "-37.68012332", + "P25": -29.37129488, + "P50": -22.66505449, + "P75": -17.99210104, + "P90": -14.57538964, + "Alpha": 9, + "T": 19 + }, + { + "ID_g": 345, + "ID_File": 17, + "LWD63": 26.79824692, + "LWD125": 37.79044511, + "LWD250": 44.7978292, + "LWD500": 52.49171004, + "LWD1000": 50.7067534, + "LWD2000": 51.93304537, + "LWD4000": 38.83463782, + "LWD8000": 17.66138978, + "P10": "-38.7821717", + "P25": -30.61845243, + "P50": -23.88531815, + "P75": -19.33875357, + "P90": -16.15929846, + "Alpha": 9.5, + "T": 20 + }, + { + "ID_g": 346, + "ID_File": 18, + "LWD63": 68.69805089, + "LWD125": 71.55304606, + "LWD250": 78.16132078, + "LWD500": 78.47348285, + "LWD1000": 77.32303109, + "LWD2000": 70.84719103, + "LWD4000": 60.78148412, + "LWD8000": 58.63576001, + "P10": "-78.14232344", + "P25": -69.46496667, + "P50": -61.55819866, + "P75": -55.35145065, + "P90": -51.02391662, + "Alpha": 0, + "T": 1 + }, + { + "ID_g": 347, + "ID_File": 18, + "LWD63": 70.13740048, + "LWD125": 74.63081569, + "LWD250": 79.04555542, + "LWD500": 84.35252758, + "LWD1000": 76.2766084, + "LWD2000": 67.77398086, + "LWD4000": 62.21864175, + "LWD8000": 56.36869917, + "P10": "-74.06640536", + "P25": -65.53200943, + "P50": -58.25508471, + "P75": -52.86564554, + "P90": -49.02531027, + "Alpha": 0.5, + "T": 2 + }, + { + "ID_g": 348, + "ID_File": 18, + "LWD63": 71.86270502, + "LWD125": 72.43210531, + "LWD250": 78.65806127, + "LWD500": 78.12842263, + "LWD1000": 72.15742904, + "LWD2000": 66.63390534, + "LWD4000": 63.55364445, + "LWD8000": 60.0720848, + "P10": "-73.62346649", + "P25": -65.52369364, + "P50": -58.73522981, + "P75": -53.9369043, + "P90": -51.03095592, + "Alpha": 1, + "T": 3 + }, + { + "ID_g": 349, + "ID_File": 18, + "LWD63": 72.38792008, + "LWD125": 74.32626353, + "LWD250": 78.5492892, + "LWD500": 79.37491622, + "LWD1000": 74.49268575, + "LWD2000": 66.49546418, + "LWD4000": 63.11321833, + "LWD8000": 62.34325366, + "P10": "-72.65975314", + "P25": -64.52528772, + "P50": -58.03596068, + "P75": -53.09183205, + "P90": -49.54122218, + "Alpha": 1.5, + "T": 4 + }, + { + "ID_g": 350, + "ID_File": 18, + "LWD63": 69.86872473, + "LWD125": 74.34610071, + "LWD250": 77.33540182, + "LWD500": 76.18474595, + "LWD1000": 70.46418255, + "LWD2000": 62.7906721, + "LWD4000": 58.86283198, + "LWD8000": 58.83990515, + "P10": "-74.54529988", + "P25": -66.68150719, + "P50": -59.91510443, + "P75": -55.17128662, + "P90": -51.95577108, + "Alpha": 2, + "T": 5 + }, + { + "ID_g": 351, + "ID_File": 18, + "LWD63": 88.70216106, + "LWD125": 82.33535629, + "LWD250": 86.01049675, + "LWD500": 81.99264514, + "LWD1000": 76.01260677, + "LWD2000": 74.42982367, + "LWD4000": 72.82701585, + "LWD8000": 68.86531155, + "P10": "-63.88256539", + "P25": -55.55558139, + "P50": -48.25593044, + "P75": -43.05223199, + "P90": -39.65306552, + "Alpha": 2.5, + "T": 6 + }, + { + "ID_g": 352, + "ID_File": 18, + "LWD63": 72.62287074, + "LWD125": 74.34961034, + "LWD250": 78.23737994, + "LWD500": 73.85525568, + "LWD1000": 67.92880605, + "LWD2000": 64.24602377, + "LWD4000": 60.07303648, + "LWD8000": 62.80526933, + "P10": "-74.21407431", + "P25": -65.73151179, + "P50": -58.75673953, + "P75": -54.1553655, + "P90": -51.10467589, + "Alpha": 3, + "T": 7 + }, + { + "ID_g": 353, + "ID_File": 18, + "LWD63": 66.38228147, + "LWD125": 73.58474583, + "LWD250": 79.97942346, + "LWD500": 77.76050855, + "LWD1000": 71.05954304, + "LWD2000": 65.219863, + "LWD4000": 60.72707381, + "LWD8000": 61.83797011, + "P10": "-74.91153296", + "P25": -66.9055986, + "P50": -60.22882534, + "P75": -55.36237115, + "P90": -52.09580203, + "Alpha": 3.5, + "T": 8 + }, + { + "ID_g": 354, + "ID_File": 18, + "LWD63": 69.05351628, + "LWD125": 74.07638786, + "LWD250": 79.06245084, + "LWD500": 80.64176436, + "LWD1000": 78.43168653, + "LWD2000": 68.13059073, + "LWD4000": 62.08848411, + "LWD8000": 60.01093463, + "P10": "-73.7581806", + "P25": -65.31882141, + "P50": -58.83154066, + "P75": -53.71902854, + "P90": -49.88421106, + "Alpha": 4, + "T": 9 + }, + { + "ID_g": 355, + "ID_File": 18, + "LWD63": 67.28762651, + "LWD125": 76.30343563, + "LWD250": 79.67180473, + "LWD500": 79.6063214, + "LWD1000": 79.48310097, + "LWD2000": 71.96967177, + "LWD4000": 64.23705741, + "LWD8000": 58.84133555, + "P10": "-72.79060002", + "P25": -64.36507707, + "P50": -57.67283321, + "P75": -52.94961867, + "P90": -49.73296837, + "Alpha": 4.5, + "T": 10 + }, + { + "ID_g": 356, + "ID_File": 18, + "LWD63": 68.33313118, + "LWD125": 75.88438702, + "LWD250": 81.40122244, + "LWD500": 80.49411151, + "LWD1000": 76.53030156, + "LWD2000": 72.82372609, + "LWD4000": 64.46796152, + "LWD8000": 57.4588985, + "P10": "-72.31147778", + "P25": -64.09380525, + "P50": -57.43146699, + "P75": -52.97921366, + "P90": -49.57779305, + "Alpha": 5, + "T": 11 + }, + { + "ID_g": 357, + "ID_File": 18, + "LWD63": 66.82091388, + "LWD125": 75.71172373, + "LWD250": 79.6983677, + "LWD500": 75.75422324, + "LWD1000": 75.25715934, + "LWD2000": 69.83032004, + "LWD4000": 64.12049814, + "LWD8000": 58.37250729, + "P10": "-73.63341083", + "P25": -65.88356732, + "P50": -59.66048056, + "P75": -54.58045917, + "P90": -50.94831921, + "Alpha": 5.5, + "T": 12 + }, + { + "ID_g": 358, + "ID_File": 18, + "LWD63": 65.84762273, + "LWD125": 75.00083163, + "LWD250": 79.68723138, + "LWD500": 79.7582177, + "LWD1000": 73.80328811, + "LWD2000": 68.43799017, + "LWD4000": 61.20523813, + "LWD8000": 58.4174718, + "P10": "-73.43616891", + "P25": -64.95410914, + "P50": -58.56065545, + "P75": -53.75843296, + "P90": -50.79889059, + "Alpha": 6, + "T": 13 + }, + { + "ID_g": 359, + "ID_File": 18, + "LWD63": 68.3954786, + "LWD125": 73.65209851, + "LWD250": 79.96742466, + "LWD500": 75.85128344, + "LWD1000": 72.37154578, + "LWD2000": 66.46091322, + "LWD4000": 60.62084723, + "LWD8000": 55.51954058, + "P10": "-74.611863", + "P25": -66.37146974, + "P50": -59.51092025, + "P75": -54.9434359, + "P90": -52.14432633, + "Alpha": 6.5, + "T": 14 + }, + { + "ID_g": 360, + "ID_File": 18, + "LWD63": 66.33579685, + "LWD125": 71.15028584, + "LWD250": 76.32667315, + "LWD500": 76.88105863, + "LWD1000": 73.51927359, + "LWD2000": 63.39714802, + "LWD4000": 60.32685315, + "LWD8000": 59.589834, + "P10": "-75.72038726", + "P25": -67.99042101, + "P50": -61.707523, + "P75": -57.11305081, + "P90": -53.64247005, + "Alpha": 7, + "T": 15 + }, + { + "ID_g": 361, + "ID_File": 18, + "LWD63": 66.44201893, + "LWD125": 78.03356205, + "LWD250": 82.96870483, + "LWD500": 88.28756697, + "LWD1000": 79.7914599, + "LWD2000": 69.23752248, + "LWD4000": 65.72200897, + "LWD8000": 58.49187796, + "P10": "-68.76874204", + "P25": -60.81420515, + "P50": -53.97330142, + "P75": -48.87200553, + "P90": -45.33802039, + "Alpha": 7.5, + "T": 16 + }, + { + "ID_g": 362, + "ID_File": 18, + "LWD63": 68.75163847, + "LWD125": 81.90968606, + "LWD250": 84.53349884, + "LWD500": 89.10047018, + "LWD1000": 83.6367687, + "LWD2000": 75.32696159, + "LWD4000": 67.70587008, + "LWD8000": 58.94744029, + "P10": "-66.07566069", + "P25": -57.89952695, + "P50": -51.28999403, + "P75": -46.72609009, + "P90": -43.52650974, + "Alpha": 8, + "T": 17 + }, + { + "ID_g": 363, + "ID_File": 18, + "LWD63": 78.70702, + "LWD125": 79.81447553, + "LWD250": 84.07951194, + "LWD500": 81.0438963, + "LWD1000": 77.82013249, + "LWD2000": 72.23659303, + "LWD4000": 65.2593884, + "LWD8000": 58.12404997, + "P10": "-69.50307249", + "P25": -61.15366638, + "P50": -54.36348555, + "P75": -49.65231258, + "P90": -46.23623187, + "Alpha": 8.5, + "T": 18 + }, + { + "ID_g": 364, + "ID_File": 18, + "LWD63": 69.11228583, + "LWD125": 76.99685504, + "LWD250": 81.59134565, + "LWD500": 82.13515681, + "LWD1000": 78.17220113, + "LWD2000": 69.27592867, + "LWD4000": 64.13271585, + "LWD8000": 56.81532705, + "P10": "-70.61985894", + "P25": -63.00940913, + "P50": -56.41038549, + "P75": -51.5054614, + "P90": -48.19280956, + "Alpha": 9, + "T": 19 + }, + { + "ID_g": 365, + "ID_File": 18, + "LWD63": 68.46557599, + "LWD125": 76.22120499, + "LWD250": 79.92491561, + "LWD500": 82.38330639, + "LWD1000": 75.15589913, + "LWD2000": 71.8379683, + "LWD4000": 66.43000609, + "LWD8000": 61.72168192, + "P10": "-72.8490389", + "P25": -64.62038402, + "P50": -57.73762834, + "P75": -52.29738934, + "P90": -48.51768498, + "Alpha": 9.5, + "T": 20 + }, + { + "ID_g": 366, + "ID_File": 19, + "LWD63": 22.17676309, + "LWD125": 16.85063145, + "LWD250": 26.69461755, + "LWD500": 26.27209446, + "LWD1000": 17.07297641, + "LWD2000": 7.388401859, + "LWD4000": 2.222257597, + "LWD8000": 3.849176468, + "P10": "-80.7665736", + "P25": -70.3089987, + "P50": -59.42763781, + "P75": -52.24719896, + "P90": -48.3015878, + "Alpha": 0, + "T": 1 + }, + { + "ID_g": 367, + "ID_File": 19, + "LWD63": 27.99583771, + "LWD125": 29.01006727, + "LWD250": 32.93994263, + "LWD500": 32.91953818, + "LWD1000": 26.0841365, + "LWD2000": 15.70105688, + "LWD4000": 8.130373933, + "LWD8000": 7.198474591, + "P10": "-63.8646128", + "P25": -56.5050771, + "P50": -50.05225421, + "P75": -45.49801373, + "P90": -41.87692016, + "Alpha": 0.5, + "T": 2 + }, + { + "ID_g": 368, + "ID_File": 19, + "LWD63": 35.13956669, + "LWD125": 33.51289248, + "LWD250": 40.19237152, + "LWD500": 42.09670142, + "LWD1000": 35.21333061, + "LWD2000": 28.70517063, + "LWD4000": 11.60026761, + "LWD8000": 8.376041152, + "P10": "-57.63962959", + "P25": -49.40253912, + "P50": -42.59687323, + "P75": -37.20623, + "P90": -33.58251639, + "Alpha": 1, + "T": 3 + }, + { + "ID_g": 369, + "ID_File": 19, + "LWD63": 38.9166478, + "LWD125": 38.01587553, + "LWD250": 44.40647437, + "LWD500": 44.15080001, + "LWD1000": 38.575373, + "LWD2000": 32.81074674, + "LWD4000": 16.45257486, + "LWD8000": 11.39377651, + "P10": "-54.18539922", + "P25": -45.54807664, + "P50": -38.96847138, + "P75": -33.68440482, + "P90": -30.38752561, + "Alpha": 1.5, + "T": 4 + }, + { + "ID_g": 370, + "ID_File": 19, + "LWD63": 39.86538205, + "LWD125": 40.84484994, + "LWD250": 48.06048488, + "LWD500": 44.73017265, + "LWD1000": 40.15915529, + "LWD2000": 30.7194239, + "LWD4000": 18.76818654, + "LWD8000": 12.73024843, + "P10": "-51.32119857", + "P25": -43.15030176, + "P50": -36.32959861, + "P75": -31.77186452, + "P90": -28.48973717, + "Alpha": 2, + "T": 5 + }, + { + "ID_g": 371, + "ID_File": 19, + "LWD63": 41.08921683, + "LWD125": 44.96937801, + "LWD250": 53.05463544, + "LWD500": 49.49932565, + "LWD1000": 41.52870472, + "LWD2000": 33.24632059, + "LWD4000": 21.011364, + "LWD8000": 18.19048575, + "P10": "-46.67212694", + "P25": -38.66773144, + "P50": -32.41160556, + "P75": -27.74747845, + "P90": -24.30578796, + "Alpha": 2.5, + "T": 6 + }, + { + "ID_g": 372, + "ID_File": 19, + "LWD63": 43.0260767, + "LWD125": 48.73674904, + "LWD250": 54.71286685, + "LWD500": 52.26456057, + "LWD1000": 44.28510401, + "LWD2000": 38.60655972, + "LWD4000": 25.07847671, + "LWD8000": 19.33789097, + "P10": "-44.82584171", + "P25": -36.71590268, + "P50": -29.91006507, + "P75": -25.08850202, + "P90": -21.82607397, + "Alpha": 3, + "T": 7 + }, + { + "ID_g": 373, + "ID_File": 19, + "LWD63": 42.22945773, + "LWD125": 47.44262841, + "LWD250": 55.48192329, + "LWD500": 58.19188838, + "LWD1000": 52.75338854, + "LWD2000": 46.67768699, + "LWD4000": 34.84656584, + "LWD8000": 28.4561838, + "P10": "-40.82467342", + "P25": -32.6017743, + "P50": -25.81833745, + "P75": -21.13322106, + "P90": -18.16633461, + "Alpha": 3.5, + "T": 8 + }, + { + "ID_g": 374, + "ID_File": 19, + "LWD63": 41.23426493, + "LWD125": 49.90636041, + "LWD250": 56.35162369, + "LWD500": 55.95151281, + "LWD1000": 49.67403287, + "LWD2000": 41.41721085, + "LWD4000": 30.61823482, + "LWD8000": 23.26618542, + "P10": "-42.35019853", + "P25": -34.03737893, + "P50": -27.25711714, + "P75": -22.57456289, + "P90": -19.34588014, + "Alpha": 4, + "T": 9 + }, + { + "ID_g": 375, + "ID_File": 19, + "LWD63": 44.20078513, + "LWD125": 50.97110343, + "LWD250": 57.32523754, + "LWD500": 56.1275978, + "LWD1000": 49.06634059, + "LWD2000": 43.59194459, + "LWD4000": 33.19056123, + "LWD8000": 23.25889242, + "P10": "-41.45940332", + "P25": -33.07831048, + "P50": -26.72658458, + "P75": -22.20292557, + "P90": -18.70418853, + "Alpha": 4.5, + "T": 10 + }, + { + "ID_g": 376, + "ID_File": 19, + "LWD63": 42.04719981, + "LWD125": 48.45375929, + "LWD250": 58.31896807, + "LWD500": 53.27810914, + "LWD1000": 48.37125334, + "LWD2000": 39.86472971, + "LWD4000": 27.58956712, + "LWD8000": 20.22549676, + "P10": "-42.35019853", + "P25": -34.22621005, + "P50": -27.69589172, + "P75": -22.9768069, + "P90": -19.4472653, + "Alpha": 5, + "T": 11 + }, + { + "ID_g": 377, + "ID_File": 19, + "LWD63": 43.49286106, + "LWD125": 46.97160489, + "LWD250": 55.63564226, + "LWD500": 55.59032306, + "LWD1000": 48.1127642, + "LWD2000": 38.71246099, + "LWD4000": 28.15142816, + "LWD8000": 19.08027578, + "P10": "-43.70072323", + "P25": -35.32974147, + "P50": -28.69286336, + "P75": -23.83158657, + "P90": -19.96455288, + "Alpha": 5.5, + "T": 12 + }, + { + "ID_g": 378, + "ID_File": 19, + "LWD63": 43.74625792, + "LWD125": 45.67623747, + "LWD250": 59.65835263, + "LWD500": 55.27161457, + "LWD1000": 49.84650847, + "LWD2000": 41.13293781, + "LWD4000": 30.92254595, + "LWD8000": 24.50862295, + "P10": "-40.82467342", + "P25": -32.73856279, + "P50": -26.25923236, + "P75": -21.50026338, + "P90": -18.2396155, + "Alpha": 6, + "T": 13 + }, + { + "ID_g": 379, + "ID_File": 19, + "LWD63": 44.57121243, + "LWD125": 47.73582525, + "LWD250": 55.7601825, + "LWD500": 56.32011199, + "LWD1000": 51.72772809, + "LWD2000": 44.97531237, + "LWD4000": 34.83774318, + "LWD8000": 25.82893973, + "P10": "-40.82467342", + "P25": -32.91263454, + "P50": -26.49676274, + "P75": -22.05978775, + "P90": -19.00503439, + "Alpha": 6.5, + "T": 14 + }, + { + "ID_g": 380, + "ID_File": 19, + "LWD63": 44.09958407, + "LWD125": 45.83176607, + "LWD250": 53.38847285, + "LWD500": 54.51380164, + "LWD1000": 50.62259791, + "LWD2000": 40.02928144, + "LWD4000": 29.61120336, + "LWD8000": 25.89559633, + "P10": "-43.42115323", + "P25": -35.4388034, + "P50": -28.98993909, + "P75": -24.24939996, + "P90": -21.05205798, + "Alpha": 7, + "T": 15 + }, + { + "ID_g": 381, + "ID_File": 19, + "LWD63": 45.00294759, + "LWD125": 45.32538133, + "LWD250": 54.42960304, + "LWD500": 54.36698173, + "LWD1000": 48.34018534, + "LWD2000": 37.2586079, + "LWD4000": 26.27356272, + "LWD8000": 26.16278931, + "P10": "-43.70072323", + "P25": -35.4388034, + "P50": -29.04608677, + "P75": -24.49495383, + "P90": -21.17257174, + "Alpha": 7.5, + "T": 16 + }, + { + "ID_g": 382, + "ID_File": 19, + "LWD63": 45.53866832, + "LWD125": 49.43601127, + "LWD250": 59.15739149, + "LWD500": 56.79890601, + "LWD1000": 49.89961096, + "LWD2000": 41.94465494, + "LWD4000": 32.46739884, + "LWD8000": 23.20537743, + "P10": "-40.27422186", + "P25": -32.42267745, + "P50": -25.56818287, + "P75": -20.94796287, + "P90": -17.87301422, + "Alpha": 8, + "T": 17 + }, + { + "ID_g": 383, + "ID_File": 19, + "LWD63": 44.17039607, + "LWD125": 49.97293338, + "LWD250": 58.84267528, + "LWD500": 63.47408247, + "LWD1000": 50.06254156, + "LWD2000": 42.57275235, + "LWD4000": 33.72500307, + "LWD8000": 26.47914541, + "P10": "-36.61209147", + "P25": -28.79076347, + "P50": -22.41646341, + "P75": -17.49142313, + "P90": -14.40948382, + "Alpha": 8.5, + "T": 18 + }, + { + "ID_g": 384, + "ID_File": 19, + "LWD63": 45.24102308, + "LWD125": 46.99036964, + "LWD250": 58.5960945, + "LWD500": 57.71446579, + "LWD1000": 50.97924288, + "LWD2000": 41.45716342, + "LWD4000": 31.78653665, + "LWD8000": 27.56227149, + "P10": "-41.2426319", + "P25": -33.32061042, + "P50": -26.44650673, + "P75": -21.34724537, + "P90": -17.958508, + "Alpha": 9, + "T": 19 + }, + { + "ID_g": 385, + "ID_File": 19, + "LWD63": 44.99220075, + "LWD125": 48.47632987, + "LWD250": 58.72299911, + "LWD500": 56.53953662, + "LWD1000": 51.43707113, + "LWD2000": 40.30364011, + "LWD4000": 31.11955999, + "LWD8000": 27.33865617, + "P10": "-40.2604563", + "P25": -32.53417949, + "P50": -26.24290719, + "P75": -21.23346151, + "P90": -18.03427587, + "Alpha": 9.5, + "T": 20 + }, + { + "ID_g": 386, + "ID_File": 20, + "LWD63": 4.637689684, + "LWD125": 22.80042185, + "LWD250": 26.18325336, + "LWD500": 32.16957068, + "LWD1000": 28.70162646, + "LWD2000": 25.13188718, + "LWD4000": 10.69655119, + "LWD8000": -2.014716784, + "P10": "#NAME?", + "P25": -90.3089987, + "P50": -84.28839879, + "P75": -78.26779887, + "P90": -70.3089987, + "Alpha": 0, + "T": 1 + }, + { + "ID_g": 387, + "ID_File": 20, + "LWD63": 16.52288137, + "LWD125": 41.66268522, + "LWD250": 48.35949318, + "LWD500": 61.41630708, + "LWD1000": 52.60376661, + "LWD2000": 47.48584926, + "LWD4000": 31.01524411, + "LWD8000": 11.27751548, + "P10": "-50.3089987", + "P25": -42.00953174, + "P50": -33.25939883, + "P75": -25.91861826, + "P90": -19.0917448, + "Alpha": 0.5, + "T": 2 + }, + { + "ID_g": 388, + "ID_File": 20, + "LWD63": 33.82652714, + "LWD125": 44.44051513, + "LWD250": 52.35007613, + "LWD500": 63.85653153, + "LWD1000": 54.07579686, + "LWD2000": 50.96697378, + "LWD4000": 34.65502311, + "LWD8000": 23.01110089, + "P10": "-39.91243882", + "P25": -31.6696764, + "P50": -25.19872444, + "P75": -20.58038912, + "P90": -16.87628677, + "Alpha": 1, + "T": 3 + }, + { + "ID_g": 389, + "ID_File": 20, + "LWD63": 20.66634468, + "LWD125": 43.10334848, + "LWD250": 49.19609518, + "LWD500": 56.72547074, + "LWD1000": 63.97311498, + "LWD2000": 58.15641368, + "LWD4000": 37.54247772, + "LWD8000": 15.5128576, + "P10": "-41.94297287", + "P25": -33.56986396, + "P50": -26.44372369, + "P75": -19.99417037, + "P90": -15.2434673, + "Alpha": 1.5, + "T": 4 + }, + { + "ID_g": 390, + "ID_File": 20, + "LWD63": 24.14920275, + "LWD125": 39.49313836, + "LWD250": 47.38667623, + "LWD500": 54.72459968, + "LWD1000": 50.82073955, + "LWD2000": 46.40650018, + "LWD4000": 27.38381882, + "LWD8000": 12.79300869, + "P10": "-52.46710665", + "P25": -44.33193717, + "P50": -37.20623, + "P75": -30.39629481, + "P90": -24.43732843, + "Alpha": 2, + "T": 5 + }, + { + "ID_g": 391, + "ID_File": 20, + "LWD63": 16.02586205, + "LWD125": 41.97252236, + "LWD250": 45.36902031, + "LWD500": 51.69874849, + "LWD1000": 56.67536896, + "LWD2000": 49.21915567, + "LWD4000": 34.20535186, + "LWD8000": 12.31281219, + "P10": "-51.41934526", + "P25": -43.07444198, + "P50": -35.80710828, + "P75": -28.71994736, + "P90": -22.42697266, + "Alpha": 2.5, + "T": 6 + }, + { + "ID_g": 392, + "ID_File": 20, + "LWD63": 18.35176797, + "LWD125": 40.60667673, + "LWD250": 50.11718509, + "LWD500": 57.1391082, + "LWD1000": 51.79233807, + "LWD2000": 47.73682552, + "LWD4000": 36.87173315, + "LWD8000": 17.26571158, + "P10": "-47.20227795", + "P25": -38.5547794, + "P50": -32.34546903, + "P75": -27.22051924, + "P90": -22.67514793, + "Alpha": 3, + "T": 7 + }, + { + "ID_g": 393, + "ID_File": 20, + "LWD63": 15.24126005, + "LWD125": 28.0336326, + "LWD250": 36.78670844, + "LWD500": 41.05358895, + "LWD1000": 40.40410723, + "LWD2000": 35.66918933, + "LWD4000": 24.02975014, + "LWD8000": 9.545310824, + "P10": "-63.8646128", + "P25": -55.34523816, + "P50": -47.83196588, + "P75": -41.36583807, + "P90": -36.36441184, + "Alpha": 3.5, + "T": 8 + }, + { + "ID_g": 394, + "ID_File": 20, + "LWD63": 12.46776793, + "LWD125": 34.10948683, + "LWD250": 43.45021048, + "LWD500": 50.33536857, + "LWD1000": 39.21171421, + "LWD2000": 42.6862255, + "LWD4000": 30.35975821, + "LWD8000": 9.43085759, + "P10": "-59.42763781", + "P25": -51.22414851, + "P50": -43.5001164, + "P75": -36.277639, + "P90": -29.73757365, + "Alpha": 4, + "T": 9 + }, + { + "ID_g": 395, + "ID_File": 20, + "LWD63": 13.60673793, + "LWD125": 31.15945777, + "LWD250": 43.19107133, + "LWD500": 48.46779507, + "LWD1000": 36.36958377, + "LWD2000": 36.59779166, + "LWD4000": 31.86276698, + "LWD8000": 13.26346671, + "P10": "-56.68417395", + "P25": -48.37079844, + "P50": -41.09104184, + "P75": -35.53338753, + "P90": -31.5086356, + "Alpha": 4.5, + "T": 10 + }, + { + "ID_g": 396, + "ID_File": 20, + "LWD63": 14.41276414, + "LWD125": 33.54329338, + "LWD250": 44.07851082, + "LWD500": 52.46043127, + "LWD1000": 41.40460887, + "LWD2000": 40.33794288, + "LWD4000": 28.51726897, + "LWD8000": 11.19353659, + "P10": "-58.48770656", + "P25": -50.22257122, + "P50": -42.85075864, + "P75": -36.32959861, + "P90": -30.19680979, + "Alpha": 5, + "T": 11 + }, + { + "ID_g": 397, + "ID_File": 20, + "LWD63": 15.45181492, + "LWD125": 32.37062655, + "LWD250": 38.76923911, + "LWD500": 47.96316781, + "LWD1000": 47.82502501, + "LWD2000": 42.62345942, + "LWD4000": 31.86215389, + "LWD8000": 15.64980292, + "P10": "-54.32218771", + "P25": -46.01212174, + "P50": -38.48770656, + "P75": -32.72995153, + "P90": -28.51796104, + "Alpha": 5.5, + "T": 12 + }, + { + "ID_g": 398, + "ID_File": 20, + "LWD63": 13.117115, + "LWD125": 32.01352373, + "LWD250": 44.39045099, + "LWD500": 48.58199711, + "LWD1000": 44.7470822, + "LWD2000": 45.95355796, + "LWD4000": 37.46160161, + "LWD8000": 15.84555625, + "P10": "-56.68417395", + "P25": -48.23292428, + "P50": -41.36583807, + "P75": -34.64522488, + "P90": -29.42604628, + "Alpha": 6, + "T": 13 + }, + { + "ID_g": 399, + "ID_File": 20, + "LWD63": 16.08560879, + "LWD125": 35.03958639, + "LWD250": 41.94107483, + "LWD500": 54.87530666, + "LWD1000": 56.28790937, + "LWD2000": 54.88294845, + "LWD4000": 41.20841286, + "LWD8000": 18.93867618, + "P10": "-47.20227795", + "P25": -38.57725261, + "P50": -30.89276648, + "P75": -24.27104436, + "P90": -19.82367332, + "Alpha": 6.5, + "T": 14 + }, + { + "ID_g": 400, + "ID_File": 20, + "LWD63": 24.51807893, + "LWD125": 43.51227755, + "LWD250": 51.22457375, + "LWD500": 61.48556216, + "LWD1000": 57.02936816, + "LWD2000": 53.45401556, + "LWD4000": 37.42148055, + "LWD8000": 19.07557241, + "P10": "-45.1554272", + "P25": -36.64805793, + "P50": -28.84930381, + "P75": -21.8555612, + "P90": -17.20219548, + "Alpha": 7, + "T": 15 + }, + { + "ID_g": 401, + "ID_File": 20, + "LWD63": 26.97559298, + "LWD125": 43.36472498, + "LWD250": 60.00092609, + "LWD500": 60.61193886, + "LWD1000": 53.12180609, + "LWD2000": 52.24897237, + "LWD4000": 37.04864616, + "LWD8000": 20.07102545, + "P10": "-44.24507755", + "P25": -35.80710828, + "P50": -27.82543759, + "P75": -21.06103874, + "P90": -16.82463979, + "Alpha": 7.5, + "T": 16 + }, + { + "ID_g": 402, + "ID_File": 20, + "LWD63": 19.76929616, + "LWD125": 43.08488695, + "LWD250": 58.70546347, + "LWD500": 59.7134502, + "LWD1000": 52.04979676, + "LWD2000": 50.04586614, + "LWD4000": 38.59189485, + "LWD8000": 16.25242032, + "P10": "-41.64961288", + "P25": -33.44434314, + "P50": -26.66070565, + "P75": -21.8449008, + "P90": -18.67205275, + "Alpha": 8, + "T": 17 + }, + { + "ID_g": 403, + "ID_File": 20, + "LWD63": 25.66254038, + "LWD125": 43.16041635, + "LWD250": 54.57128801, + "LWD500": 54.39842566, + "LWD1000": 48.46798932, + "LWD2000": 46.30836895, + "LWD4000": 34.91172358, + "LWD8000": 17.33009913, + "P10": "-46.06524661", + "P25": -38.44327736, + "P50": -31.79244721, + "P75": -26.97447759, + "P90": -23.43688854, + "Alpha": 8.5, + "T": 18 + }, + { + "ID_g": 404, + "ID_File": 20, + "LWD63": 19.03370641, + "LWD125": 38.62567948, + "LWD250": 47.47070283, + "LWD500": 59.18020214, + "LWD1000": 53.0531705, + "LWD2000": 50.6102012, + "LWD4000": 37.70275377, + "LWD8000": 17.15498462, + "P10": "-46.17248118", + "P25": -37.80274968, + "P50": -30.89276648, + "P75": -25.36918471, + "P90": -21.16044484, + "Alpha": 9, + "T": 19 + }, + { + "ID_g": 405, + "ID_File": 20, + "LWD63": 22.87428851, + "LWD125": 39.74086108, + "LWD250": 47.40973845, + "LWD500": 55.16308809, + "LWD1000": 55.57247056, + "LWD2000": 50.14419543, + "LWD4000": 34.540444, + "LWD8000": 13.49476421, + "P10": "-45.1554272", + "P25": -37.20623, + "P50": -30.5022216, + "P75": -25.57321671, + "P90": -21.82443729, + "Alpha": 9.5, + "T": 20 + } +] \ No newline at end of file diff --git a/wps_scripts/src/test/groovy/org/noise_planet/noisemodelling/wps/TestNoiseModelling.groovy b/wps_scripts/src/test/groovy/org/noise_planet/noisemodelling/wps/TestNoiseModelling.groovy index dd68cffc2..2e8e2e303 100644 --- a/wps_scripts/src/test/groovy/org/noise_planet/noisemodelling/wps/TestNoiseModelling.groovy +++ b/wps_scripts/src/test/groovy/org/noise_planet/noisemodelling/wps/TestNoiseModelling.groovy @@ -18,11 +18,16 @@ import org.h2gis.functions.io.shp.SHPRead import org.h2gis.utilities.JDBCUtilities import org.junit.Test import org.noise_planet.noisemodelling.wps.Acoustic_Tools.DynamicIndicators -import org.noise_planet.noisemodelling.wps.Experimental.Noise_Map_Difference -import org.noise_planet.noisemodelling.wps.Experimental_Matsim.Noise_From_Attenuation_Matrix_MatSim +import org.noise_planet.noisemodelling.wps.Geometric_Tools.Change_SRID +import org.noise_planet.noisemodelling.wps.Acoustic_Tools.ZerodB_Source +import org.noise_planet.noisemodelling.wps.Receivers.Building_Grid +import org.noise_planet.noisemodelling.wps.Source_Activity.PedestrianActivity +import org.noise_planet.noisemodelling.wps.NoiseModelling.Dynamic_Voices_Emission_from_PedestrianActivity import org.noise_planet.noisemodelling.wps.Geometric_Tools.Set_Height import org.noise_planet.noisemodelling.wps.Import_and_Export.Import_File import org.noise_planet.noisemodelling.wps.Import_and_Export.Export_Table +import org.noise_planet.noisemodelling.wps.Import_and_Export.Import_OSM +import org.noise_planet.noisemodelling.wps.Import_and_Export.Import_OSM_Pedestrian import org.noise_planet.noisemodelling.wps.NoiseModelling.Dynamic_Road_Emission_from_Traffic import org.noise_planet.noisemodelling.wps.NoiseModelling.Noise_From_Attenuation_Matrix import org.noise_planet.noisemodelling.wps.NoiseModelling.Noise_level_from_source @@ -65,6 +70,100 @@ class TestNoiseModelling extends JdbcTestCase { assertEquals("Calculation Done ! The table LW_DYNAMIC_GEOM has been created.", res) } + + @Test + void test_Pedestrian_Positioning() { + + new Import_OSM_Pedestrian().exec(connection, [ + "pathFile" : TestImportExport.getResource("map.osm.pbf").getPath(), + "targetSRID": 2154 + ]); + + + new Import_OSM().exec(connection, [ + "pathFile" : TestImportExport.getResource("map.osm.pbf").getPath(), + "targetSRID" : 2154, + "ignoreGround" : false, + "ignoreBuilding": false, + "ignoreRoads" : false, + "removeTunnels" : true + ]); + + new PedestrianActivity().exec(connection, [ + "walkableArea" : "PEDESTRIAN_AREA", + "cellSize" : 25, + "pointsOfInterests" : "PEDESTRIAN_POIS", + "coeffLeisure" : Math.pow(3.398, 8), + "coeffCulture" : Math.pow(5.44, 7), + "coeffFoodDrink" : 0, + "coeffEducation" : 0, + "coeffFootpath" : 0, + "coeffTourismSleep" : 0, + "coeffPublicTransport": 0, + "coeffReligion" : 0, + "coeffTourism" : Math.pow(-7.64, 8), + "coeffShop" : Math.pow(3.635, 8), + "coeffSport" : 0, + "coeffTrees" : 0, + "coeffIndTransport" : Math.pow(-3.858, 8) + + ]); + } + + @Test + void test_Pedestrian_Full_Chain() { + + new Import_OSM_Pedestrian().exec(connection, [ + "pathFile" : TestImportExport.getResource("map.osm.pbf").getPath(), + "targetSRID" : 2154 + ]); + + + new Import_OSM().exec(connection, [ + "pathFile" : TestImportExport.getResource("map.osm.pbf").getPath(), + "targetSRID" : 2154, + "ignoreGround" : false, + "ignoreBuilding": false, + "ignoreRoads" : false, + "removeTunnels" : true + ]); + + new PedestrianActivity().exec(connection, [ + "walkableArea" : "PEDESTRIAN_AREA", + "cellSize" : 25, + "pointsOfInterests" : "PEDESTRIAN_POIS", + "coeffLeisure" : Math.pow(3.398,8), + "coeffCulture" : Math.pow(5.44,7), + "coeffFoodDrink" : 0, + "coeffEducation" : 0, + "coeffFootpath" : 0, + "coeffTourismSleep" : 0, + "coeffPublicTransport" : 0, + "coeffReligion" : 0, + "coeffTourism" : Math.pow(-7.64,8), + "coeffShop" : Math.pow(3.635,8), + "coeffSport" : 0, + "coeffTrees" : 0, + "coeffIndTransport" : Math.pow(-3.858,8) + + ]); + + new Dynamic_Voices_Emission_from_PedestrianActivity().exec(connection, [ + "pathBDD" : System.getProperty("user.dir") +"/src/main/resources/VoiceModel/BDD_Info.json", + "pathSpectrums" : System.getProperty("user.dir") +"/src/main/resources/VoiceModel/Spectrums_500ms.json", + "tablePedestrian": "PEDESTRIANS"]); + + new Export_Table().exec(connection, + ["exportPath" : System.getProperty("user.dir") +"/target/output.geojson", + "tableToExport": "LW_PEDESTRIAN" + ]); + + + + } + + + @Test void testDynamicRoadEmissionPropagation() { @@ -79,6 +178,7 @@ class TestNoiseModelling extends JdbcTestCase { ["pathFile" : TestNoiseModelling.getResource("receivers.shp").getPath(), "inputSRID": "2154", "tableName": "receivers"]) + new Set_Height().exec(connection, [ "tableName":"RECEIVERS", "height": 1 @@ -96,7 +196,7 @@ class TestNoiseModelling extends JdbcTestCase { ["tableBuilding" : "BUILDINGS", "tableSources" : "ALL_VEH_POS_0DB", "tableReceivers": "RECEIVERS", - "confMaxSrcDist" : 100, + "confMaxSrcDist" : 150, "confDiffHorizontal" : false, "confExportSourceId": true, "confSkipLevening":true, @@ -128,7 +228,7 @@ class TestNoiseModelling extends JdbcTestCase { ["tableBuilding" : "BUILDINGS", "tableSources" : "ALL_VEH_POS_0DB", "tableReceivers": "RECEIVERS", - "confMaxSrcDist" : 100, + "confMaxSrcDist" : 150, "confDiffHorizontal" : false, "confExportSourceId": true, "confSkipLevening":true, @@ -148,9 +248,6 @@ class TestNoiseModelling extends JdbcTestCase { "columnName" : "LEQA" ]) - - - assertEquals("The columns LEQA and LEQ have been added to the table: LT_GEOM_VAL.", res) } From e34bdbcde645595de0c59ade5c29f9c8b1a21a0c Mon Sep 17 00:00:00 2001 From: Pierre Aumond Date: Fri, 13 Sep 2024 15:38:57 +0200 Subject: [PATCH 3/3] Fix error in CnossosVar and others dynamix things --- .../road/cnossos/RoadCnossosParameters.java | 2 +- .../cnossosvar/RoadVehicleCnossosvar.java | 10 +- ...Dynamic_Road_Emission_from_Vehicles.groovy | 730 ++++++++++++++++++ .../Noise_From_Attenuation_Matrix.groovy | 140 +++- .../Noise_level_from_source.groovy | 19 +- .../wps/TestNoiseModelling.groovy | 74 +- 6 files changed, 961 insertions(+), 14 deletions(-) create mode 100644 wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/NoiseModelling/Dynamic_Road_Emission_from_Vehicles.groovy diff --git a/noisemodelling-emission/src/main/java/org/noise_planet/noisemodelling/emission/road/cnossos/RoadCnossosParameters.java b/noisemodelling-emission/src/main/java/org/noise_planet/noisemodelling/emission/road/cnossos/RoadCnossosParameters.java index 72de0b8ba..777cfaa6d 100644 --- a/noisemodelling-emission/src/main/java/org/noise_planet/noisemodelling/emission/road/cnossos/RoadCnossosParameters.java +++ b/noisemodelling-emission/src/main/java/org/noise_planet/noisemodelling/emission/road/cnossos/RoadCnossosParameters.java @@ -75,7 +75,7 @@ public RoadCnossosParameters() { * @param wbvPerHour Average heavy vehicle per hour * @param frequency Studied Frequency (must be octave band) * @param Temperature Temperature (Celsius) - * @param roadSurface roadSurface empty default, NL01 FR01 .. (look at src/main/resources/org/noise_planet/noisemodelling/emission/RoadCnossos_2020.json) + * @param roadSurface roadSurface empty default, NL01 FR01 .. (look at src/main/resources/org/noise_planet/noisemodelling/emission/RoadCnossos_2020.jsonRoadCnossos_2020.json) * @param Ts_stud A limited period Ts (in months) over the year where a average proportion pm of light vehicles are equipped with studded tyres and during . * @param Pm_stud Average proportion of vehicles equipped with studded tyres * @param Junc_dist Distance to the junction (in m) near an intersection, the road segment should be cut into small parts of 10 m.. diff --git a/noisemodelling-emission/src/main/java/org/noise_planet/noisemodelling/emission/road/cnossosvar/RoadVehicleCnossosvar.java b/noisemodelling-emission/src/main/java/org/noise_planet/noisemodelling/emission/road/cnossosvar/RoadVehicleCnossosvar.java index 7878a8a82..5a7f6c93c 100644 --- a/noisemodelling-emission/src/main/java/org/noise_planet/noisemodelling/emission/road/cnossosvar/RoadVehicleCnossosvar.java +++ b/noisemodelling-emission/src/main/java/org/noise_planet/noisemodelling/emission/road/cnossosvar/RoadVehicleCnossosvar.java @@ -53,7 +53,7 @@ public static double evaluate(RoadVehicleCnossosvarParameters parameters) throws // Noise level // Noise level - RoadLvl = getNoiseLvl(getCoeff("ap", freqParam, veh_type, coeffVer), getCoeff("bp", freqParam, veh_type, coeffVer), speed, 70.); + RoadLvl = getNoiseLvl(getCoeff("ar", freqParam, veh_type, coeffVer), getCoeff("br", freqParam, veh_type, coeffVer), speed, 70.); // Correction by temperature p. 36 switch (veh_type) { @@ -61,6 +61,8 @@ public static double evaluate(RoadVehicleCnossosvarParameters parameters) throws RoadLvl = RoadLvl + 0.08 * (20 - Temperature); // K = 0.08 p. 36 break; case "2": + RoadLvl = RoadLvl + 0.04 * (20 - Temperature); // K = 0.04 p. 36 + break; case "3": RoadLvl = RoadLvl + 0.04 * (20 - Temperature); // K = 0.04 p. 36 break; @@ -70,8 +72,8 @@ public static double evaluate(RoadVehicleCnossosvarParameters parameters) throws // Rolling noise acceleration correction - double coefficientJunctionDistance = Math.max(1 - Math.abs(Junc_dist) / 100, 0); - RoadLvl = RoadLvl + getCr(veh_type, Junc_type, coeffVer) * coefficientJunctionDistance; + // double coefficientJunctionDistance = Math.max(1 - Math.abs(Junc_dist) / 100, 0); + // RoadLvl = RoadLvl + getCr(veh_type, Junc_type, coeffVer) * coefficientJunctionDistance; //Studied tyres @@ -102,7 +104,7 @@ public static double evaluate(RoadVehicleCnossosvarParameters parameters) throws switch (acc_type) { case 1: if (veh_type.equals("1") || veh_type.equals("2") || veh_type.equals("3")) { - MotorLvl = MotorLvl + getCp(veh_type, Junc_type, coeffVer) * coefficientJunctionDistance; + // MotorLvl = MotorLvl + getCp(veh_type, Junc_type, coeffVer) * coefficientJunctionDistance; } break; case 2: diff --git a/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/NoiseModelling/Dynamic_Road_Emission_from_Vehicles.groovy b/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/NoiseModelling/Dynamic_Road_Emission_from_Vehicles.groovy new file mode 100644 index 000000000..8f290474a --- /dev/null +++ b/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/NoiseModelling/Dynamic_Road_Emission_from_Vehicles.groovy @@ -0,0 +1,730 @@ +/** + * NoiseModelling is an open-source tool designed to produce environmental noise maps on very large urban areas. It can be used as a Java library or be controlled through a user friendly web interface. + * + * This version is developed by the DECIDE team from the Lab-STICC (CNRS) and by the Mixt Research Unit in Environmental Acoustics (Université Gustave Eiffel). + * + * + * NoiseModelling is distributed under GPL 3 license. You can read a copy of this License in the file LICENCE provided with this software. + * + * Contact: contact@noise-planet.org + * + */ + +/** + * @Author Pierre Aumond, Université Gustave Eiffel + * @Author Valetin Le Bescond, Université Gustave Eiffel, Ghent University + */ + +package org.noise_planet.noisemodelling.wps.NoiseModelling + +import geoserver.GeoServer +import geoserver.catalog.Store +import groovy.sql.Sql +import groovy.time.TimeCategory +import org.geotools.jdbc.JDBCDataStore +import org.h2gis.utilities.GeometryTableUtilities +import org.h2gis.utilities.SpatialResultSet +import org.h2gis.utilities.TableLocation +import org.h2gis.utilities.wrapper.ConnectionWrapper +import org.locationtech.jts.geom.* +import org.noise_planet.noisemodelling.emission.road.cnossosvar.RoadVehicleCnossosvar +import org.noise_planet.noisemodelling.emission.road.cnossosvar.RoadVehicleCnossosvarParameters + +import java.security.InvalidParameterException +import java.sql.Connection +import java.sql.ResultSet +import java.sql.SQLException +import java.util.stream.Collectors + +title = 'Dynamic Road Emission from vehicles' +description = 'Calculating dynamic road emissions based on vehicles trajectories.' + + '

    The output table is called : LW_DYNAMIC ' + + 'and contain :
    ' + + '- TIMESTAMP : The TIMESTAMP iteration (STRING).
    ' + + '- IDRECEIVER : an identifier (INTEGER, PRIMARY KEY).
    ' + + '- THE_GEOM : the 3D geometry of the receivers (POINT).
    ' + + '- HZ63, HZ125, HZ250, HZ500, HZ1000,HZ2000, HZ4000, HZ8000 : 8 columns giving the day emission sound level for each octave band (FLOAT).' + +inputs = [ + tableRoads : [name : 'Roads table name', title: 'Roads table name', description: "Name of the Roads table.
    " + + "
    The table shall contain :
    " + + "- PK : an identifier. It shall be a primary key (INTEGER, PRIMARY KEY)
    " + + "- TV_D : Hourly average light and heavy vehicle count (DOUBLE)
    " + + "- HV_D : Hourly average heavy vehicle count (DOUBLE)
    " + + "- LV_SPD_D : Hourly average light vehicle speed (DOUBLE)
    " + + "- HV_SPD_D : Hourly average heavy vehicle speed (DOUBLE)
    " + + "- PVMT : CNOSSOS road pavement identifier (ex: NL05) (VARCHAR)" + + "

    This table can be generated from the WPS Block 'Import_OSM'. .", type: String.class], + + tableVehicles : [name : 'tableVehicles', + title : "tableVehicles", + description : "timestep, geometry, speed, acceleration, veh_type...", + type: String.class], + + timestep : [name : 'timestep', + title : "timestep", + description : "Number of iterations. Timestep in sec.
    Default value : 1 ", + type: Integer.class], + + gridStep : [name : 'gridStep', + title : "gridStep", + description : "Distance between location of vehicle along the network in meters.
    Default value : 10 ", + type: Integer.class], + + duration : [name : 'duration', title: 'duration in sec.', + description: 'Number of the iterations to compute (INTEGER).

    Default value : 60 ', + type: Integer.class], +] + +outputs = [ + result: [ + name : 'Result output string', + title : 'Result output string', + description: 'This type of result does not allow the blocks to be linked together.', + type : String.class + ] +] + +// Open Connection to Geoserver +static Connection openGeoserverDataStoreConnection(String dbName) { + if (dbName == null || dbName.isEmpty()) { + dbName = new GeoServer().catalog.getStoreNames().get(0) + } + Store store = new GeoServer().catalog.getStore(dbName) + JDBCDataStore jdbcDataStore = (JDBCDataStore) store.getDataStoreInfo().getDataStore(null) + return jdbcDataStore.getDataSource().getConnection() +} + +// run the script +def run(input) { + + // Get name of the database + // by default an embedded h2gis database is created + // Advanced user can replace this database for a postGis or h2Gis server database. + String dbName = "h2gisdb" + + // Open connection + openGeoserverDataStoreConnection(dbName).withCloseable { + Connection connection -> + return [result: exec(connection, input)] + } +} + + +// main function of the script +def exec(Connection connection, input) { + + //Need to change the ConnectionWrapper to WpsConnectionWrapper to work under postGIS database + connection = new ConnectionWrapper(connection) + + // Open sql connection to communicate with the database + Sql sql = new Sql(connection) + + // output string, the information given back to the user + String resultString = null + + // print to command window + System.out.println('Start : Traffic Probabilistic Modelling') + def start = new Date() + + // ------------------- + // Get every inputs + // ------------------- + + double duration = 60 + if (input['duration']) { + duration = Double.valueOf(input['duration'] as String) + } + + int timestep = 1 + if (input['timestep']) { + timestep = Integer.valueOf(input['timestep'] as String) + } + + int gridStep = 10 + if (input['gridStep']) { + gridStep = Integer.valueOf(input['gridStep'] as String) + } + + int nIterations = (int) Math.round(duration/timestep); + + + + String sources_table_name = input['tableRoads'] + // do it case-insensitive + sources_table_name = sources_table_name.toUpperCase() + // Check if srid are in metric projection. + int sridSources = GeometryTableUtilities.getSRID(connection, TableLocation.parse(sources_table_name)) + if (sridSources == 3785 || sridSources == 4326) throw new IllegalArgumentException("Error : Please use a metric projection for "+sources_table_name+".") + if (sridSources == 0) throw new IllegalArgumentException("Error : The table "+sources_table_name+" does not have an associated SRID.") + + String vehicles_table_name = input['tableVehicles'] + // do it case-insensitive + vehicles_table_name = vehicles_table_name.toUpperCase() + // Check if srid are in metric projection. + sridSources = GeometryTableUtilities.getSRID(connection, TableLocation.parse(vehicles_table_name)) + if (sridSources == 3785 || sridSources == 4326) throw new IllegalArgumentException("Error : Please use a metric projection for "+vehicles_table_name+".") + if (sridSources == 0) throw new IllegalArgumentException("Error : The table "+vehicles_table_name+" does not have an associated SRID.") + + System.out.println('Start time : ' + TimeCategory.minus(new Date(), start)) + + sql.execute("DROP TABLE IF EXISTS ROAD_POINTS" ) + sql.execute("CREATE TABLE ROAD_POINTS(ROAD_ID serial, THE_GEOM geometry, LV int, LV_SPD real, HV int, HV_SPD real) AS SELECT r.PK, ST_Tomultipoint(ST_Densify(the_geom, "+gridStep+")), r.LV_D, r.LV_SPD_D, r.HGV_D, r.HGV_SPD_D FROM "+sources_table_name+" r WHERE NOT ST_IsEmpty(r.THE_GEOM) ;") + +/* sql.execute("DROP TABLE IF EXISTS ALL_VEH_POS_0DB") + sql.execute("CREATE TABLE ALL_VEH_POS_0DB(PK int NOT NULL PRIMARY KEY, ROAD_ID long, THE_GEOM geometry, LWD63 real, LWD125 real, LWD250 real, LWD500 real, LWD1000 real, LWD2000 real, LWD4000 real, LWD8000 real) AS SELECT r.PK, r.ROAD_ID, r.THE_GEOM, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 FROM VEHICLES AS r;") +*/ + + + VehicleEmissionProcessData vehicleEmissionProcessData = new VehicleEmissionProcessData(); + vehicleEmissionProcessData.setDynamicEmissionTable("VEHICLE", sql) + + // Drop table LDEN_GEOM if exists + + + sql.execute("CREATE SPATIAL INDEX ON ALL_VEH_POS_0DB(the_geom);") + sql.execute("CREATE SPATIAL INDEX ON LW_DYNAMIC(the_geom);") + + sql.execute("drop table if exists LW_DYNAMIC_GEOM;") + // Associate Geometry column to the table LDEN + sql.execute("create table LW_DYNAMIC_GEOM as SELECT b.IT as T ,b.Hz63, b.Hz125, b.Hz250, b.Hz500, b.Hz1000, b.Hz2000, b.Hz4000, b.Hz8000, (SELECT a.PK FROM ALL_VEH_POS_0DB a WHERE ST_EXPAND(b.the_geom,30,30) && a.the_geom ORDER BY ST_Distance(a.the_geom, b.the_geom) ASC LIMIT 1) PK FROM LW_DYNAMIC b ;") + + sql.execute("DROP TABLE IF EXISTS ROAD_POINTS") + sql.execute("DROP TABLE IF EXISTS VEHICLES") + sql.execute("drop table LW_DYNAMIC if exists;") + + + + System.out.println('Intermediate time : ' + TimeCategory.minus(new Date(), start)) + System.out.println("Export data to table") + + + resultString = "Calculation Done ! The table LW_DYNAMIC_GEOM has been created." + + // print to command window + System.out.println('Result : ' + resultString) + System.out.println('End : Traffic Probabilistic Modelling') + System.out.println('Duration : ' + TimeCategory.minus(new Date(), start)) + + // print to WPS Builder + return resultString +} + + + +/** + * + */ +/*class Road { + + long id + String type + LineString geom + int lv + double lv_spd + int hv + double hv_spd + double length + + public List source_points = new ArrayList() + + List line_segments = new ArrayList() + + List vehicles = new ArrayList() + + Map lw_corr_generators = new LinkedHashMap<>() + + int seed = 2528432 + + Road(){ + line_segments.clear() + vehicles.clear() + lw_corr_generators.clear() + source_points.clear() + } + + void setRoad(long id, String type, Geometry geom, int lv, double lv_spd, int hv, double hv_spd) { + if (geom.getGeometryType() == "MultiLineString") { + geom = geom.getGeometryN(0) + } + if (geom.getGeometryType() != "LineString") { + throw new InvalidParameterException("Only LineString Geometry is supported") + } + this.id = id + this.type = type + this.geom = (LineString) geom + this.lv = lv + this.lv_spd = lv_spd + this.hv = hv + this.hv_spd = hv_spd + this.length = geom.getLength() + + Coordinate[] coordinates = geom.getCoordinates() + for(int i = 1; i < coordinates.length; i++){ + line_segments.add(new LineSegment(coordinates[i-1], coordinates[i])); + } + + /*for (String vehicle_type: [ + Vehicle.LIGHT_VEHICLE_TYPE, Vehicle.MEDIUM_VEHICLE_TYPE, Vehicle.HEAVY_VEHICLE_TYPE, + Vehicle.MOPEDS_VEHICLE_TYPE, Vehicle.MOTORCYCLE_VEHICLE_TYPE + ]) { + lw_corr_generators.put(vehicle_type, new LwCorrectionGenerator(vehicle_type, 1.0, "meanEn")) + } + + double start + DisplacedNegativeExponentialDistribution distribution = new DisplacedNegativeExponentialDistribution(lv, 1, seed) + start = 0 + def samples = distribution.getSamples(lv) + for (int i = 0; i < lv; i++) { + start += samples[i] + vehicles.add(new Vehicle(lv_spd / 3.6, length, start, Vehicle.LIGHT_VEHICLE_TYPE, (i % 2 == 1), 0)) + } + distribution = new DisplacedNegativeExponentialDistribution(hv, 1, seed) + start = 0 + samples = distribution.getSamples(hv) + for (int i = 0; i < hv; i++) { + start += samples[i] + vehicles.add(new Vehicle(hv_spd / 3.6, length, start, Vehicle.HEAVY_VEHICLE_TYPE, (i % 2 == 1), 0)) + } + for (Vehicle vehicle: vehicles) { + vehicle.lw_correction = 2 //lw_corr_generators.get(vehicle.vehicle_type).generate() + } + } + + void move(double time, double max_time) { + resetSourceLevels() + for (Vehicle vehicle in vehicles) { + vehicle.move(time, max_time) + if (vehicle.exists) { + updateSourceLevels(vehicle) + } + } + } + + void updateSourceLevels(Vehicle vehicle) { + SourcePoint closest = null + SourcePoint secondary_closest = null + Coordinate vehicle_point = getPoint(vehicle.getPosition()) + double distance = -1 + double secondary_distance = -1 + for (SourcePoint source in source_points) { + double dist = vehicle_point.distance(source.geom.getCoordinate()) + if (distance == -1) { + closest = source + distance = dist + continue + } + if (dist < distance) { + secondary_closest = closest + secondary_distance = distance + closest = source + distance = dist + continue + } + if (dist < secondary_distance) { + secondary_closest = source + secondary_distance = dist + } + } + double[] vehicle_levels = vehicle.getLw() + double primary_weight = 1.0 + double secondary_weight = 0.0 + if (secondary_closest != null) { + primary_weight = 1 - distance / (distance + secondary_distance) + secondary_weight = 1 - secondary_distance / (distance + secondary_distance) + } + for (int freq = 0; freq < closest.levels.length; freq++) { + closest.levels[freq] = 10 * Math.log10(Math.pow(10, closest.levels[freq] / 10) + primary_weight * Math.pow(10, vehicle_levels[freq] / 10)) + if (secondary_closest != null) { + secondary_closest.levels[freq] = 10 * Math.log10(Math.pow(10, secondary_closest.levels[freq] / 10) + secondary_weight * Math.pow(10, vehicle_levels[freq] / 10)) + } + } + } + + void resetSourceLevels() { + for (SourcePoint source in source_points) { + for (int freq = 0; freq < source.levels.length; freq++) { + source.levels[freq] = -99.0 + } + } + } + + Coordinate getPoint(double position) { + double vh_pos = position % length + vh_pos = (vh_pos + length) % length // handle negative positions (backward vehicles) + double accum_length = 0.0 + Coordinate result = null + for (LineSegment line in line_segments) { + if ((line.getLength() + accum_length) < vh_pos) { + accum_length += line.getLength() + continue + } + double vh_pos_fraction = (vh_pos - accum_length) / line.getLength() + result = line.pointAlong(vh_pos_fraction) + break + } + return result + } + + int getCode() { + if (!type_codes.containsKey(type)) { + return 0 + } + return type_codes.get(type).toInteger() + } + + +} + + +class SourcePoint { + long id + Point geom + int[] freqs = [63, 125, 250, 500, 1000, 2000, 4000, 8000]; + double[] levels = new double[freqs.length]; + + SourcePoint(long id, Geometry geom) { + if (geom.getGeometryType() != "Point") { + throw new InvalidParameterException("Only Point Geometry is supported") + } + this.id = id + this.geom = (Point) geom + } +} +/* +class Vehicle { + + final static String LIGHT_VEHICLE_TYPE = "1" + final static String MEDIUM_VEHICLE_TYPE = "2" + final static String HEAVY_VEHICLE_TYPE = "3" + final static String MOPEDS_VEHICLE_TYPE = "4" + final static String MOTORCYCLE_VEHICLE_TYPE = "4" + + static int last_id = 0 + + static do_loop = false + static Random rand = new Random(681254665) + + String vehicle_type = LIGHT_VEHICLE_TYPE + int id = 0 + double position = 0.0 + double max_position = 0.0 + double speed = 0.0 // m/s + double time_offset = 10.0 // shift everything by X seconds to ensure enough traffic exists + double time = 0.0 + double start_time = 0 + boolean exists = false + boolean backward = false + + double lw_correction = 0.0 + + static int getNextId() { + last_id++ + return last_id + } + + Vehicle(double speed, double length, double start, String type, boolean is_back, int road_type) { + max_position = length + vehicle_type = type + start_time = start + backward = is_back + id = getNextId() + + if (road_type == 0 ) { + this.speed = (3 * speed / 4) + (rand.nextGaussian() + 1) * (speed / 4) + } + if (this.vehicle_type == HEAVY_VEHICLE_TYPE || this.vehicle_type == MEDIUM_VEHICLE_TYPE) { + this.speed = Math.min(this.speed, 90 / 3.6) // max 90km/h for heavy vehicles + } + } + + Vehicle(double speed, double length, double start) { + this(speed, length, start, LIGHT_VEHICLE_TYPE, false, 5113) + } + + Vehicle(double speed, double length) { + this(speed, length, 0.0, LIGHT_VEHICLE_TYPE, false, 5113) + } + + void move(double input_time, double max_time) { + time = (input_time + time_offset) % max_time + double real_speed = (backward ? (-1 * speed) : speed) + if (do_loop) { + exists = true + position = ((time + max_time + start_time) % max_time) * real_speed + } + else { + if (time >= start_time) { + exists = true + position = ((time - start_time) % max_time) * real_speed + } else { + exists = false + } + if (position > max_position || position < -max_position) { + exists = false + } + } + } + + double getPosition() { + return position % max_position; + } + + double[] getLw() { + int[] freqs = [63, 125, 250, 500, 1000, 2000, 4000, 8000]; + double[] result = new double[freqs.length]; + if (!exists) { + for (int i = 0; i < freqs.length; i++) { + result[i] = -99.0; + } + return result; + } + for (int i = 0; i < freqs.length; i++) { + + RoadVehicleCnossosvarParameters rsParametersDynamic = new RoadVehicleCnossosvarParameters( + speed * 3.6, 0, vehicle_type, 0, true, 1, id ) + rsParametersDynamic.setRoadSurface("DEF") + // remove lw_correction + result[i] = RoadVehicleCnossosvar.evaluate(rsParametersDynamic) + lw_correction; + } + return result; + } +} +*/ + +/*class LwCorrectionGenerator { + + static Random rand = new Random(546656812) + + + final private static LinkedHashMap > distributions = [ + (Vehicle.LIGHT_VEHICLE_TYPE) : [0], + (Vehicle.MEDIUM_VEHICLE_TYPE) : [0], + (Vehicle.HEAVY_VEHICLE_TYPE) : [0], + (Vehicle.MOPEDS_VEHICLE_TYPE) : [0], + (Vehicle.MOTORCYCLE_VEHICLE_TYPE) : [0] + ]; + + List xy_values; + List partition; + double dx = 1.0 + + + LwCorrectionGenerator(String type, double dx, String zero_point) { + List values = new ArrayList(distributions.get(type)) + int n = values.size() + this.dx = dx + List cum_dist = cumDist(values) + partition = new ArrayList(cum_dist) + partition.remove(n-1) + xy_values = new ArrayList() + double median = 0 + double meandB = 0 + double meanEn = 0 + for (double i = 0; i < n; i +=dx) { + xy_values.add(i) + if (median <= 0 && cum_dist[(int) i] >= 50) { + median = i + } + } + List xy_values_en = new ArrayList() + for (int i = 0; i < xy_values.size(); i++) { + xy_values_en.add(Math.pow(10, xy_values[i] / 10)) + } + meandB = multiplyAndSum(values, xy_values) / sum(values) + meanEn = 10 * Math.log10(multiplyAndSum(values, xy_values_en) / sum(values)) + if (zero_point == "median") { + xy_values = xy_values.stream().map({ e -> e - median}).collect(Collectors.toList()) + } + else if (zero_point == "meandB") { + xy_values = xy_values.stream().map({ e -> e - meandB}).collect(Collectors.toList()) + } + else { + xy_values = xy_values.stream().map({ e -> e - meanEn}).collect(Collectors.toList()) + } + } + + double generate() { + def result = xy_values[rouletteRand(partition)] + result += uniRand(-dx/2.0,dx/2.0) + return result + } + + static List cumDist(List array) { + List input = new ArrayList(array) + double divide = sum(input) + input = input.stream().map({ e -> e / divide }).collect(Collectors.toList()) + List out = new ArrayList() + out.add(input[0]) + for (int i = 1; i < input.size(); i++) + out.add(out.last() + input[i]) + out = out.stream().map({ e -> e * 100.0}).collect(Collectors.toList()) + return out + } + static double sum(List list) { + double sum = 0; + for (double i : list) + sum = sum + i; + return sum; + } + static double multiplyAndSum(List list1, List list2) { + int max = Math.min(list1.size(), list2.size()); + double sum = 0; + for (int i = 0; i < max; i++) { + sum += list1[i] * list2[i]; + } + return sum; + } + + static double uniRand(double left, double right) { + return left + rand.nextDouble() * (right - left) + } + static double rouletteRand(List partition) { + double r = rand.nextDouble() * 100.0 + double v = 0 + for (i in 0.. partition[i]) { + v = i + 1 + } + } + return v + } + +} + +*/ +/* +abstract class HeadwayDistribution { + + protected static int seed; + Random random; + + HeadwayDistribution(int seed) { + this.seed = seed; + random = new Random(seed); + } + + HeadwayDistribution() { + this(1234) + } + + abstract double inverseCumulativeProbability(double p); + + double getNext() { + return inverseCumulativeProbability(random.nextDouble()) + } + + double[] getSamples(int n) { + double[] result = new double[n]; + for (i in 0.. SPEED_LV = new HashMap<>() + Map SPEED_HV = new HashMap<>() + Map LV = new HashMap<>() + Map HV = new HashMap<>() + int nCars = 0 + double speed = 0 + String id_veh = "" + + double[] getCarsLevel(speed, id_veh) throws SQLException { + double[] res_d = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0] + double[] res_LV = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0] + double[] res_HV = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0] + def list = [63, 125, 250, 500, 1000, 2000, 4000, 8000] + + int kk = 0 + for (f in list) { + int acc = 0 + int FreqParam = f + double Temperature = 20 + String RoadSurface = "DEF" + boolean Stud = false + double Junc_dist = 200 + int Junc_type = 1 + String veh_type = "1" + int acc_type = 1 + double LwStd = 1 + int VehId = 10 + + RoadVehicleCnossosvarParameters rsParameters = new RoadVehicleCnossosvarParameters(speed, acc, veh_type, acc_type, Stud, LwStd, VehId) + rsParameters.setRoadSurface(RoadSurface) + rsParameters.setSlopePercentage(0) + + res_LV[kk] = RoadVehicleCnossosvar.evaluate(rsParameters) + kk++ + } + + return res_LV + } + + int getCarsPositions(){ + nCars = SPEED_LV.size() + return nCars + } + void setDynamicEmissionTable(String tablename, Sql sql) { + ////////////////////// + // Import file text + ////////////////////// + + sql.execute("drop table if exists LW_DYNAMIC;") + sql.execute("create table LW_DYNAMIC(IT integer, THE_GEOM geometry, Hz63 double precision, Hz125 double precision, Hz250 double precision, Hz500 double precision, Hz1000 double precision, Hz2000 double precision, Hz4000 double precision, Hz8000 double precision);") + def qry = 'INSERT INTO LW_DYNAMIC(IT , THE_GEOM,Hz63, Hz125, Hz250, Hz500, Hz1000,Hz2000, Hz4000, Hz8000) VALUES (?,?,?,?,?,?,?,?,?,?);' + + + // Remplissage des variables avec le contenu du fichier plan d'exp + sql.eachRow('SELECT THE_GEOM, SPEED, ID, TIMESTEP FROM ' + tablename + ';') { row -> + + Geometry the_geom = (Geometry) row[0] + double speed = (double) row[1] + String id_veh = (String) row[2] + int timestep = (int) row[3] + + + double[] carLevel = getCarsLevel(speed*3.6, id_veh) + + sql.withBatch(100, qry) { ps -> + ps.addBatch(timestep as Integer, the_geom as Geometry, + carLevel[0] as Double, carLevel[1] as Double, carLevel[2] as Double, + carLevel[3] as Double, carLevel[4] as Double, carLevel[5] as Double, + carLevel[6] as Double, carLevel[7] as Double) + } + + } + + } + +} diff --git a/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/NoiseModelling/Noise_From_Attenuation_Matrix.groovy b/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/NoiseModelling/Noise_From_Attenuation_Matrix.groovy index 16a4a1725..7348d6380 100644 --- a/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/NoiseModelling/Noise_From_Attenuation_Matrix.groovy +++ b/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/NoiseModelling/Noise_From_Attenuation_Matrix.groovy @@ -18,8 +18,10 @@ package org.noise_planet.noisemodelling.wps.NoiseModelling import geoserver.GeoServer import geoserver.catalog.Store +import groovy.sql.GroovyRowResult import org.geotools.jdbc.JDBCDataStore import org.h2gis.utilities.wrapper.ConnectionWrapper +import org.locationtech.jts.geom.Geometry import org.slf4j.Logger import org.slf4j.LoggerFactory @@ -179,19 +181,129 @@ def exec(Connection connection, input) { GROUP BY lg.IDRECEIVER, lg.THE_GEOM, mr.T; ''' - long start = System.currentTimeMillis(); + + long start = System.currentTimeMillis(); + + /* int timeBinSize = 3600 + if (input["timeBinSize"]) { + timeBinSize = input["timeBinSize"] as int; + } + + + sql.execute(String.format("DROP TABLE %s IF EXISTS", outputTable)) + String query3 = "CREATE TABLE " + outputTable + '''( + PK integer PRIMARY KEY AUTO_INCREMENT, + IDRECEIVER integer, + THE_GEOM geometry, + HZ63 double precision, + HZ125 double precision, + HZ250 double precision, + HZ500 double precision, + HZ1000 double precision, + HZ2000 double precision, + HZ4000 double precision, + HZ8000 double precision, + TIME int + ) + ''' + sql.execute(query3) + PreparedStatement insert_stmt = connection.prepareStatement( + "INSERT INTO " + outputTable + " VALUES(DEFAULT, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", + ) + + logger.info("searching indexes on attenuation matrix ... ") + ensureIndex(connection, attenuationTable, "IDSOURCE", false) + ensureIndex(connection, attenuationTable, "IDRECEIVER", false) + logger.info("searching indexes on traffic tables ... ") + ensureIndex(connection, "LW_DYNAMIC_GEOM", "PK", false) + + List mrs_freqs = ["HZ63", "HZ125", "HZ250", "HZ500", "HZ1000", "HZ2000", "HZ4000", "HZ8000"] + + long count = 0, do_print = 1 + List receivers_res = sql.rows("SELECT * FROM RECEIVERS;" ); + long nb_receivers = receivers_res.size() + + for (GroovyRowResult receiver: receivers_res) { + long receiver_id = receiver["PK"] as long; + Geometry receiver_geom = receiver["THE_GEOM"] as Geometry; + Map> levels = new HashMap>(); + List sources_att_res = sql.rows(String.format("SELECT lg.* FROM %s lg WHERE lg.IDRECEIVER = %d", attenuationTable, receiver_id)); + long nb_sources = sources_att_res.size(); + if (nb_sources == 0) { + count++ + continue + } + for (GroovyRowResult sources_att: sources_att_res) { + long source_id = sources_att["IDSOURCE"] as long; + List attenuation = [ + sources_att["HZ63"] as double, + sources_att["HZ125"] as double, + sources_att["HZ250"] as double, + sources_att["HZ500"] as double, + sources_att["HZ1000"] as double, + sources_att["HZ2000"] as double, + sources_att["HZ4000"] as double, + sources_att["HZ8000"] as double, + ]; + List roads_stats_res = sql.rows(String.format("SELECT * FROM LW_DYNAMIC_GEOM")); + for (GroovyRowResult roads_stats: roads_stats_res) { + int timeBin = roads_stats["T"] as int + if (!levels.containsKey(timeBin)) { + levels[timeBin] = [-99.0, -99.0, -99.0, -99.0, -99.0, -99.0, -99.0, -99.0] as List + } + for (i in 0..<8) { + double new_level = (roads_stats[mrs_freqs[i]] as double) + attenuation[i]; + levels[timeBin][i] = 10 * Math.log10( Math.pow(10, levels[timeBin][i] / 10) + Math.pow(10, new_level / 10)) + } + } + } + + for (int timeBin = 0; timeBin < 86400; timeBin += timeBinSize) { + if (!levels.containsKey(timeBin)) { + levels[timeBin] = [-99.0, -99.0, -99.0, -99.0, -99.0, -99.0, -99.0, -99.0] as List + } + List ts_levels = levels[timeBin] + insert_stmt.setLong(1, receiver_id) + insert_stmt.setString(2, receiver_geom.toText()) + for (i in 0..<8) { + insert_stmt.setDouble(i+3, ts_levels[i]) + } + insert_stmt.setInt(11, timeBin) + insert_stmt.execute() + } + if (count >= do_print) { + double elapsed = (System.currentTimeMillis() - start + 1) / 1000 + logger.info(String.format("Processing Receiver %d (max:%d) - elapsed : %ss (%.1fit/s)", + count, nb_receivers, elapsed, count/elapsed)) + do_print *= 2 + } + count ++ + } +*/ + + long stop = System.currentTimeMillis(); + + println(stop-start) + + + + start = System.currentTimeMillis(); sql.execute(String.format("DROP TABLE IF EXISTS "+outputTable+"")) //logger.info(query) sql.execute(query) - long stop = System.currentTimeMillis(); + stop = System.currentTimeMillis(); println(stop-start) - start = System.currentTimeMillis(); + start = System.currentTimeMillis(); sql.execute(String.format("DROP TABLE IF EXISTS "+outputTable+";")) //logger.info(query2) sql.execute(query2) - stop = System.currentTimeMillis(); + stop = System.currentTimeMillis(); println(stop-start) + + + + String prefix = "HZ" sql.execute("ALTER TABLE "+outputTable+" ADD COLUMN LEQA float as 10*log10((power(10,(" + prefix + "63-26.2)/10)+power(10,(" + prefix + "125-16.1)/10)+power(10,(" + prefix + "250-8.6)/10)+power(10,(" + prefix + "500-3.2)/10)+power(10,(" + prefix + "1000)/10)+power(10,(" + prefix + "2000+1.2)/10)+power(10,(" + prefix + "4000+1)/10)+power(10,(" + prefix + "8000-1.1)/10)))") sql.execute("ALTER TABLE "+outputTable+" ADD COLUMN LEQ float as 10*log10((power(10,(" + prefix + "63)/10)+power(10,(" + prefix + "125)/10)+power(10,(" + prefix + "250)/10)+power(10,(" + prefix + "500)/10)+power(10,(" + prefix + "1000)/10)+power(10,(" + prefix + "2000)/10)+power(10,(" + prefix + "4000)/10)+power(10,(" + prefix + "8000)/10)))") @@ -202,3 +314,23 @@ def exec(Connection connection, input) { return resultString } + +static boolean indexExists(Connection connection, String table, String column_name) { + DatabaseMetaData dbMeta = connection.getMetaData(); + ResultSet rs = dbMeta.getIndexInfo(null, null, table, false, false); + boolean index_found = false; + while (rs.next()) { + String column = rs.getString("COLUMN_NAME"); + String pos = rs.getString("ORDINAL_POSITION"); + if (column == column_name && pos == "1") { + index_found = true; + } + } + return index_found +} +static void ensureIndex(Connection connection, String table, String column_name, boolean spatial) { + if (!indexExists(connection, table, column_name)) { + Sql sql = new Sql(connection) + sql.execute("CREATE " + (spatial ? "SPATIAL " : "") + "INDEX ON " + table + " (" + column_name + ")"); + } +} diff --git a/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/NoiseModelling/Noise_level_from_source.groovy b/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/NoiseModelling/Noise_level_from_source.groovy index e3a4b7d8c..908bad98a 100644 --- a/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/NoiseModelling/Noise_level_from_source.groovy +++ b/wps_scripts/src/main/groovy/org/noise_planet/noisemodelling/wps/NoiseModelling/Noise_level_from_source.groovy @@ -271,6 +271,14 @@ inputs = [ min : 0, max: 1, type : String.class ], + maxError : [ + name : 'maxError', + title : 'maxError', + description: 'maxError', + min : 0, max: 1, type: Double.class + ], + + confRaysName : [ name : '', title : 'Export scene', @@ -407,6 +415,8 @@ def exec(Connection connection, input) { // Get every inputs // ------------------- + + String sources_table_name = input['tableSources'] // do it case-insensitive sources_table_name = sources_table_name.toUpperCase() @@ -501,12 +511,16 @@ def exec(Connection connection, input) { tableSourceDirectivity = tableSourceDirectivity.toUpperCase() } - int reflexion_order = 0 if (input['confReflOrder']) { reflexion_order = Integer.valueOf(input['confReflOrder']) } + double maxError = 0.1 + if (input['maxError']) { + maxError = Double.valueOf(input['maxError']) + } + double max_src_dist = 150 if (input['confMaxSrcDist']) { max_src_dist = Double.valueOf(input['confMaxSrcDist']) @@ -690,7 +704,8 @@ def exec(Connection connection, input) { // Do not propagate for low emission or far away sources // Maximum error in dB - pointNoiseMap.setMaximumError(0.1d) + + pointNoiseMap.setMaximumError(maxError) // Init Map pointNoiseMap.initialize(connection, new EmptyProgressVisitor()) diff --git a/wps_scripts/src/test/groovy/org/noise_planet/noisemodelling/wps/TestNoiseModelling.groovy b/wps_scripts/src/test/groovy/org/noise_planet/noisemodelling/wps/TestNoiseModelling.groovy index 2e8e2e303..e45c9dc88 100644 --- a/wps_scripts/src/test/groovy/org/noise_planet/noisemodelling/wps/TestNoiseModelling.groovy +++ b/wps_scripts/src/test/groovy/org/noise_planet/noisemodelling/wps/TestNoiseModelling.groovy @@ -20,6 +20,7 @@ import org.junit.Test import org.noise_planet.noisemodelling.wps.Acoustic_Tools.DynamicIndicators import org.noise_planet.noisemodelling.wps.Geometric_Tools.Change_SRID import org.noise_planet.noisemodelling.wps.Acoustic_Tools.ZerodB_Source +import org.noise_planet.noisemodelling.wps.NoiseModelling.Dynamic_Road_Emission_from_Vehicles import org.noise_planet.noisemodelling.wps.Receivers.Building_Grid import org.noise_planet.noisemodelling.wps.Source_Activity.PedestrianActivity import org.noise_planet.noisemodelling.wps.NoiseModelling.Dynamic_Voices_Emission_from_PedestrianActivity @@ -163,6 +164,74 @@ class TestNoiseModelling extends JdbcTestCase { } + @Test + void testDynamicRoadEmissionPropagationVehicles() { + + SHPRead.importTable(connection, TestDatabaseManager.getResource("ROADS2.shp").getPath()) + + + new Import_File().exec(connection, + ["pathFile" : "/home/aumond/Documents/Projets/2024_XX Invit_Sacha/comparison NoiseModelling-attenuation/buildings_nm_ready_pop_heights.shp", + "inputSRID": "32635", + "tableName": "buildings"]) + + new Import_File().exec(connection, + ["pathFile" : "/home/aumond/Documents/Projets/2024_XX Invit_Sacha/comparison NoiseModelling-attenuation/lw_discrete_roads_zero.shp", + "inputSRID": "32635", + "tableName": "ALL_VEH_POS_0DB"]) + + new Import_File().exec(connection, + ["pathFile" : "/home/aumond/Documents/Projets/2024_XX Invit_Sacha/comparison NoiseModelling-attenuation/receivers_python_method0_50m_pop.shp", + "inputSRID": "32635", + "tableName": "receivers"]) + + new Set_Height().exec(connection, + [ "tableName":"RECEIVERS", + "height": 1.5 + ] + ) + + new Import_File().exec(connection, + ["pathFile" : "/home/aumond/Documents/Projets/2024_XX Invit_Sacha/comparison NoiseModelling-attenuation/SUMO.geojson", + "inputSRID": "32635", + "tableName": "vehicle"]) + + String res = new Dynamic_Road_Emission_from_Vehicles().exec(connection, + ["tableRoads": "ROADS2", + "tableVehicles" : "vehicle", + "timestep" : 1, + "gridStep":20, + "duration":100]) + + res = new Noise_level_from_source().exec(connection, + ["tableBuilding" : "BUILDINGS", + "tableSources" : "ALL_VEH_POS_0DB", + "tableReceivers": "RECEIVERS", + "maxError" : 0.0, + "confMaxSrcDist" : 150, + "confDiffHorizontal" : false, + "confExportSourceId": true, + "confSkipLevening":true, + "confSkipLnight":true, + "confSkipLden":true + ]) + + res = new Noise_From_Attenuation_Matrix().exec(connection, + ["lwTable" : "LW_DYNAMIC_GEOM", + "attenuationTable" : "LDAY_GEOM", + "outputTable" : "LT_GEOM_PROBA" + ]) + + + res = new DynamicIndicators().exec(connection, + ["tableName" : "LT_GEOM_PROBA", + "columnName" : "LEQA" + ]) + + assertEquals("The columns LEQA and LEQ have been added to the table: LT_GEOM_VAL.", res) + } + + @Test void testDynamicRoadEmissionPropagation() { @@ -178,7 +247,6 @@ class TestNoiseModelling extends JdbcTestCase { ["pathFile" : TestNoiseModelling.getResource("receivers.shp").getPath(), "inputSRID": "2154", "tableName": "receivers"]) - new Set_Height().exec(connection, [ "tableName":"RECEIVERS", "height": 1 @@ -196,7 +264,7 @@ class TestNoiseModelling extends JdbcTestCase { ["tableBuilding" : "BUILDINGS", "tableSources" : "ALL_VEH_POS_0DB", "tableReceivers": "RECEIVERS", - "confMaxSrcDist" : 150, + "confMaxSrcDist" : 100, "confDiffHorizontal" : false, "confExportSourceId": true, "confSkipLevening":true, @@ -228,7 +296,7 @@ class TestNoiseModelling extends JdbcTestCase { ["tableBuilding" : "BUILDINGS", "tableSources" : "ALL_VEH_POS_0DB", "tableReceivers": "RECEIVERS", - "confMaxSrcDist" : 150, + "confMaxSrcDist" : 100, "confDiffHorizontal" : false, "confExportSourceId": true, "confSkipLevening":true,