NPM/numass-framework
4
0
Fork 1
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Minor fixes

Browse Source
This commit is contained in:
Alexander Nozik 2017-10-09 16:52:44 +03:00
parent 23b4fc0246
commit 262d5f44d6
5 changed files with 81 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
numass-core/src/main/java/inr/numass/data/NumassDataUtils.java
View File

@ -31,7 +31,7 @@ public class NumassDataUtils {
return new NumassSet() {
@Override
public Stream<NumassPoint> getPoints() {
return sets.stream().flatMap(set -> getPoints());
return sets.stream().flatMap(NumassSet::getPoints);
}
@Override

14
numass-core/src/main/java/inr/numass/data/api/SimpleNumassPoint.java
View File

@ -4,6 +4,8 @@ import hep.dataforge.meta.Meta;
import hep.dataforge.meta.MetaBuilder;
import hep.dataforge.utils.MetaHolder;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Stream;
@ -20,16 +22,16 @@ public class SimpleNumassPoint extends MetaHolder implements NumassPoint {
* @param voltage
* @param blocks
*/
public SimpleNumassPoint(double voltage, List<NumassBlock> blocks) {
this.blocks = blocks;
blocks.sort(Comparator.comparing(NumassBlock::getStartTime));
public SimpleNumassPoint(double voltage, Collection<NumassBlock> blocks) {
this.blocks = new ArrayList<>(blocks);
this.blocks.sort(Comparator.comparing(NumassBlock::getStartTime));
super.setMeta(new MetaBuilder("point").setValue(HV_KEY, voltage));
}
public SimpleNumassPoint(Meta meta, List<NumassBlock> blocks) {
public SimpleNumassPoint(Meta meta, Collection<NumassBlock> blocks) {
super(meta);
blocks.sort(Comparator.comparing(NumassBlock::getStartTime));
this.blocks = blocks;
this.blocks = new ArrayList<>(blocks);
this.blocks.sort(Comparator.comparing(NumassBlock::getStartTime));
}
@Override

3
numass-main/build.gradle
View File

@ -23,6 +23,9 @@ compileTestKotlin {
}
}
compileGroovy.dependsOn(compileKotlin)
compileGroovy.classpath += files(compileKotlin.destinationDir)
dependencies {
compile group: 'commons-cli', name: 'commons-cli', version: '1.+'
compile group: 'commons-io', name: 'commons-io', version: '2.+'

45
numass-main/src/main/groovy/inr/numass/scripts/times/TestPointAnalyzer.groovy
View File

@ -7,11 +7,12 @@ import hep.dataforge.grind.Grind
import hep.dataforge.grind.GrindShell
import hep.dataforge.meta.Meta
import hep.dataforge.plots.fx.FXPlotManager
import hep.dataforge.storage.commons.StorageUtils
import inr.numass.NumassPlugin
import inr.numass.actions.TimeAnalyzedAction
import inr.numass.data.NumassDataUtils
import inr.numass.data.api.NumassPoint
import inr.numass.data.api.NumassSet
import inr.numass.data.api.SimpleNumassPoint
import inr.numass.data.storage.NumassStorage
import inr.numass.data.storage.NumassStorageFactory
@ -31,26 +32,40 @@ new GrindShell(ctx).eval {
Meta meta = Grind.buildMeta(binNum: 200) {
window(lo: 500, up: 1800)
plot(showErrors: false)
}
// def set = "set_43"
// def loader = storage.provide("loader::$set", NumassSet.class).get();
// def data = NumassUtils.pointsToNode(loader).filter { name, data ->
// return data.meta().getDouble("voltage",0) < 15000
// };
def sets = (20..31).collect { "set_$it" }
def loaders = sets.collect { set ->
storage.provide("loader::$set", NumassSet.class).orElse(null)
}.findAll { it != null }
def hv = 14000;
def dataBuilder = DataSet.builder(NumassPoint)
def hvs = [14000d, 14200d, 14600d, 14800d, 15000d, 15200d, 15400d, 15600d, 15800d, 16000d]
StorageUtils.loaderStream(storage, false)
.filter { it.value instanceof NumassSet }
.forEach { pair ->
(pair.value as NumassSet).optPoint(hv).ifPresent {
dataBuilder.putData(pair.key, it, it.meta);
}
def all = NumassDataUtils.join("sum", loaders)
def builder = DataSet.builder(NumassPoint)
hvs.each { hv ->
builder.putStatic("point_${hv as int}", new SimpleNumassPoint(hv, all.points.filter {
it.voltage == hv
}.collect()));
}
def data = dataBuilder.build()
def data = builder.build()
// def hv = 14000;
// def dataBuilder = DataSet.builder(NumassPoint)
//
// StorageUtils.loaderStream(storage, false)
// .filter { it.value instanceof NumassSet }
// .forEach { pair ->
// (pair.value as NumassSet).optPoint(hv).ifPresent {
// dataBuilder.putData(pair.key, it, it.meta);
// }
// }
// def data = dataBuilder.build()
def result = new TimeAnalyzedAction().run(ctx, data, meta);

50
numass-main/src/main/kotlin/inr/numass/actions/TimeAnalyzedAction.kt
View File

@ -2,7 +2,7 @@ package inr.numass.actions
import hep.dataforge.actions.OneToOneAction
import hep.dataforge.context.Context
import hep.dataforge.description.TypedActionDef
import hep.dataforge.description.*
import hep.dataforge.kodex.buildMeta
import hep.dataforge.kodex.configure
import hep.dataforge.maths.histogram.UnivariateHistogram
@ -11,6 +11,7 @@ import hep.dataforge.plots.PlotManager
import hep.dataforge.plots.data.PlottableData
import hep.dataforge.tables.Table
import hep.dataforge.tables.ValueMap
import hep.dataforge.values.ValueType
import inr.numass.data.analyzers.TimeAnalyzer
import inr.numass.data.api.NumassAnalyzer
import inr.numass.data.api.NumassPoint
@ -18,6 +19,18 @@ import inr.numass.data.api.NumassPoint
/**
* Plot time analysis graphics
*/
@ValueDefs(
ValueDef(name = "normalize", type = arrayOf(ValueType.BOOLEAN), def = "true", info = "Normalize t0 dependencies"),
ValueDef(name = "t0", type = arrayOf(ValueType.NUMBER), def = "30e3", info = "The default t0 in nanoseconds"),
ValueDef(name = "window.lo", type = arrayOf(ValueType.NUMBER), def = "500", info = "Lower boundary for amplitude window"),
ValueDef(name = "window.up", type = arrayOf(ValueType.NUMBER), def = "10000", info = "Upper boundary for amplitude window"),
ValueDef(name = "binNum", type = arrayOf(ValueType.NUMBER), def = "1000", info = "Number of bins for time histogram"),
ValueDef(name = "binSize", type = arrayOf(ValueType.NUMBER), info = "Size of bin for time histogram. By default is defined automatically")
)
@NodeDefs(
NodeDef(name = "histogram", info = "Configuration for histogram plots"),
NodeDef(name = "plot", info = "Configuration for stat plots")
)
@TypedActionDef(name = "timeSpectrum", inputType = NumassPoint::class, outputType = Table::class)
class TimeAnalyzedAction : OneToOneAction<NumassPoint, Table>() {
private val analyzer = TimeAnalyzer();
@ -25,20 +38,21 @@ class TimeAnalyzedAction : OneToOneAction<NumassPoint, Table>() {
override fun execute(context: Context, name: String, input: NumassPoint, inputMeta: Laminate): Table {
val log = getLog(context, name);
val t0 = inputMeta.getDouble("t0", 30e3);
val loChannel = inputMeta.getInt("window.lo", 500);
val upChannel = inputMeta.getInt("window.up", 10000);
val pm = context.getFeature(PlotManager::class.java);
//TODO use meta parameters
val trueCR = analyzer.analyze(input, buildMeta {
"t0" to 30e3
"t0" to t0
"window.lo" to loChannel
"window.up" to upChannel
}).getDouble("cr")
val binNum = inputMeta.getInt("binNum", 1000);
val binSize = inputMeta.getDouble("binSize", 1.0 / trueCR * 10 / binNum)
val binSize = inputMeta.getDouble("binSize", 1.0 / trueCR * 10 / binNum * 1e6)
val histogram = UnivariateHistogram.buildUniform(0.0, binSize * binNum, binSize)
.fill(analyzer
@ -56,7 +70,7 @@ class TimeAnalyzedAction : OneToOneAction<NumassPoint, Table>() {
"axisTitle" to "delay"
"axisUnits" to "us"
}
node("xAxis") {
node("yAxis") {
"type" to "log"
}
}
@ -70,22 +84,33 @@ class TimeAnalyzedAction : OneToOneAction<NumassPoint, Table>() {
node("adapter") {
"y.value" to "count"
}
}.fillData(histogram)
}.apply {
configure(inputMeta.getMetaOrEmpty("histogram"))
}
.fillData(histogram)
)
log.report("The expected count rate for 30 us delay is $trueCR")
val statPlotPoints = (1..150).map { 1000 * it }.map { t0 ->
val statPlotPoints = (1..150).map { 1000 * it }.map { t ->
val result = analyzer.analyze(input, buildMeta {
"t0" to t0
"t0" to t
"window.lo" to loChannel
"window.up" to upChannel
})
val norm = if (inputMeta.getBoolean("normalize", true)) {
trueCR
} else {
1.0
}
ValueMap.ofMap(
mapOf(
"x" to t0 / 1000,
"y" to result.getDouble("cr"),
"y.err" to result.getDouble(NumassAnalyzer.COUNT_RATE_ERROR_KEY)
"x" to t / 1000,
"y" to result.getDouble("cr") / norm,
"y.err" to result.getDouble(NumassAnalyzer.COUNT_RATE_ERROR_KEY) / norm
)
);
}
@ -94,6 +119,9 @@ class TimeAnalyzedAction : OneToOneAction<NumassPoint, Table>() {
PlottableData(name).configure {
"showLine" to true
"thickness" to 4
"title" to "${name}_${input.voltage}"
}.apply {
configure(inputMeta.getMetaOrEmpty("plot"))
}.fillData(statPlotPoints)
)
return histogram;