def test_typeclass_ndim_v03():
objects = [
C.Histogram(np.arange(6), np.arange(5)),
C.Points(np.arange(5)),
C.Histogram2d(np.arange(6), np.arange(7)),
C.Points(np.arange(12).reshape(3, 4))
]
outputs = [p.single() for p in objects]
obj = C.DummyType()
list(map(obj.add_input, outputs))
dt = R.TypeClasses.CheckNdimT(context.current_precision())(1, (0, 1))
R.SetOwnership(dt, False)
dt.dump()
print()
obj.add_typeclass(dt)
res = obj.process_types()
assert res
dt1 = R.TypeClasses.CheckNdimT(context.current_precision())(2, (-2, -1))
R.SetOwnership(dt1, False)
dt1.dump()
print()
obj.add_typeclass(dt1)
res = obj.process_types()
assert res
def test_typeclass_passtype():
"""Last input has another edges"""
objects = [
C.Histogram2d(np.arange(4), np.arange(5)),
C.Histogram(np.arange(4)),
C.Points(np.arange(12).reshape(3,4))
]
outputs = [p.single() for p in objects]
obj = C.DummyType()
k = list(map(obj.add_input, outputs))
for i in range(5):
obj.add_output()
dt1 = R.TypeClasses.PassTypeT(context.current_precision())((0,), (0,1))
dt2 = R.TypeClasses.PassTypeT(context.current_precision())((1,), (2,-1))
R.SetOwnership(dt1, False)
R.SetOwnership(dt2, False)
dt1.dump(); print()
dt2.dump(); print()
obj.add_typeclass(dt1)
obj.add_typeclass(dt2)
res = obj.process_types();
assert res
obj.print()
dta = outputs[0].datatype()
dtb = outputs[1].datatype()
doutputs = obj.transformations.back().outputs
assert doutputs[0].datatype()==dta
assert doutputs[1].datatype()==dta
assert doutputs[2].datatype()==dtb
assert doutputs[3].datatype()==dtb
assert doutputs[4].datatype()==dtb
def test_typeclass_kind_v01():
objects = [
C.Histogram(np.arange(6), np.arange(5)),
C.Histogram2d(np.arange(6), np.arange(7))
]
outputs = [p.single() for p in objects]
obj = C.DummyType()
list(map(obj.add_input, outputs))
dt_points = R.TypeClasses.CheckKindT(context.current_precision())(1)
R.SetOwnership(dt_points, False)
dt_points.dump()
print()
dt_hist = R.TypeClasses.CheckKindT(context.current_precision())(2)
R.SetOwnership(dt_hist, False)
dt_hist.dump()
print()
obj.add_typeclass(dt_hist)
res = obj.process_types()
assert res
obj.add_typeclass(dt_points)
print('Exception expected: ', end='')
res = obj.process_types()
assert not res
def test_typeclass_same_v02():
"""Last input has another shape"""
arrays = [np.arange(12, dtype='d').reshape(3,4) for i in range(5)]
arrays[-1]=arrays[-1].reshape(4,3)
points = [C.Points(a) for a in arrays]
outputs = [p.points.points for p in points]
print(outputs)
obj = C.DummyType()
list(map(obj.add_input, outputs))
dt = R.TypeClasses.CheckSameTypesT(context.current_precision())((1,-2))
R.SetOwnership(dt, False)
dt.dump(); print()
obj.add_typeclass(dt)
res = obj.process_types();
assert res
dt1 = R.TypeClasses.CheckSameTypesT(context.current_precision())((-2,-1))
R.SetOwnership(dt1, False)
dt1.dump(); print()
obj.add_typeclass(dt1)
print('Exception expected: ',end='')
res = obj.process_types();
assert not res
def Dummy(shape, name, varnames=None, *args, **kwargs):
if varnames:
return R.GNA.GNAObjectTemplates.DummyT(context.current_precision())(
shape, name, stdvector(varnames), *args, **kwargs)
return R.GNA.GNAObjectTemplates.DummyT(context.current_precision())(
shape, name, *args, **kwargs)
def Identity(outputs=None, **kwargs):
if outputs is None:
return R.GNA.GNAObjectTemplates.IdentityT(
context.current_precision())(**kwargs)
return R.GNA.GNAObjectTemplates.IdentityT(context.current_precision())(
OutputDescriptors(outputs), **kwargs)
def get_cpp_type( array ):
"""Guess appropriate C++ type to store data based on array.dtype or type"""
if len(array)==0:
raise Exception('Unable to determine type of the elements of the empty array')
if hasattr( array, 'dtype' ):
typemap = {
'int32': 'int',
'float64': 'double',
'float32': 'float',
# 'uint64': 'size_t',
}
atype = array.dtype.name
else:
typemap = {
int: 'int',
float: context.current_precision(),
str: 'std::string',
'int': 'int',
'float': context.current_precision(),
'str': 'std::string',
'variable<double>': 'variable<double>',
'variable<float>': 'variable<float>',
}
atype = type( array[0] ).__name__
ret = typemap.get( atype )
if not ret:
raise Exception( 'Do not know how to convert type '+str(atype) )
return ret
def test_arrayview_allocation():
nitems, ndata = 6, 15
allocator = R.arrayviewAllocatorSimple(context.current_precision())(ndata)
arrays = []
for i in range(1, nitems):
array = R.arrayview(context.current_precision())(i, allocator)
for j in range(i):
array[j] = j
print(i, array.view())
arrays.append(array)
print('Arrays:', [array.view() for array in arrays])
print('Data (filled):', allocator.view())
print('Data (all):', allocator.viewall())
def test_typeclass_passeach_02():
"""Pass with step 2"""
objects = [
C.Histogram2d(np.arange(4), np.arange(5)),
C.Histogram(np.arange(4)),
C.Points(np.arange(20).reshape(4,5))
]
outputs = [p.single() for p in objects]
obj = C.DummyType()
i = list(map(obj.add_input, outputs))
i1 = list(map(obj.add_input, outputs))
for i in range(3):
obj.add_output()
dt1 = R.TypeClasses.PassEachTypeT(context.current_precision())((0,-1,2), (0,-1))
R.SetOwnership(dt1, False)
dt1.dump(); print()
obj.add_typeclass(dt1)
res = obj.process_types();
assert res
obj.print()
dta = outputs[0].datatype()
dtb = outputs[1].datatype()
dtc = outputs[2].datatype()
doutputs = obj.transformations.back().outputs
assert doutputs[0].datatype()==dta
assert doutputs[1].datatype()==dtc
assert doutputs[2].datatype()==dtb
def test_variable_allocation(function_name):
from gna.env import env
ns = env.globalns(function_name)
ndata = 10
allocator = R.arrayviewAllocatorSimple(context.current_precision())(ndata)
with context.allocator(allocator):
ns.defparameter('float1',
central=1,
fixed=True,
label='Float variable 1')
ns.defparameter('float2',
central=2,
fixed=True,
label='Float variable 2')
ns.defparameter('angle',
central=3,
label='Angle parameter',
type='uniformangle')
ns.defparameter('discrete',
default='a',
label='Discrete parameter',
type='discrete',
variants=OrderedDict([('a', 10.0), ('b', 20.0),
('c', 30.0)]))
ns.printparameters(labels=True)
print('Data (filled):', allocator.view())
print('Data (all):', allocator.viewall())
def test_arrayview_complex():
a1 = R.arrayview(context.current_precision())(2)
a1[0] = 2
a1[1] = 3
c1 = a1.complex()
assert c1.real == 2.0
assert c1.imag == 3.0
def Product(outputs=None, **kwargs):
if outputs is None:
args = ()
else:
args = OutputDescriptors(outputs),
return R.GNA.GNAObjectTemplates.ProductT(context.current_precision())(
*args, **kwargs)
def test_arrayview_vector():
size = 5
from gna.constructors import stdvector
a1 = N.arange(size, dtype=context.current_precision_short())
v1 = stdvector(a1)
view1 = R.arrayview(context.current_precision())(a1, size)
assert view1 == v1
assert not view1 != v1
def test_arrayview_constructor():
size = 5
import ctypes
san_size = ctypes.c_int(5)
a = N.arange(size, dtype=context.current_precision_short())
print("in failing test! Precision is {}".format(
context.current_precision()))
view = R.arrayview[context.current_precision()](size)
assert view.size() == size
assert view.isOwner()
for i, v in enumerate(a):
view[i] = v
vview = view.view()
print('C++', vview)
assert (a == vview).all()
def WeightedSumSq(weights, inputs=None, *args, **kwargs):
weights = stdvector(weights)
if inputs is None:
inputs = weights
elif isinstance(inputs[0], str):
inputs = stdvector(inputs)
else:
inputs = OutputDescriptors(inputs)
return R.GNA.GNAObjectTemplates.WeightedSumSqT(
context.current_precision())(weights, inputs, *args, **kwargs)
def test_arrayview_comparison():
size = 5
a1 = N.arange(size, dtype=context.current_precision_short())
a2 = N.ascontiguousarray(a1[::-1])
a3 = N.arange(size + 1, dtype=context.current_precision_short())
view1a = R.arrayview(context.current_precision())(a1, a1.size)
view1b = R.arrayview(context.current_precision())(a1, a1.size)
view2 = R.arrayview(context.current_precision())(a2, a2.size)
view3 = R.arrayview(context.current_precision())(a3, a3.size)
assert view1a == view1b
assert not view1a != view1b
assert view1a != view2
assert not view1a == view2
assert view1a != view3
assert not view1a == view3
view4 = R.arrayview(context.current_precision())(view3.size())
view4 = view3
assert view3 == view4
assert not view3 != view4
view5 = R.arrayview(context.current_precision())(view3)
assert view3 == view5
assert not view3 != view5
def test_vararray_preallocated_v01(function_name):
ns = env.globalns(function_name)
names = ['zero', 'one', 'two', 'three', 'four', 'five']
values = N.arange(len(names), dtype=context.current_precision_short())
variables = R.vector('variable<%s>' % context.current_precision())()
with context.allocator(100) as allocator:
for name, value in zip(names, values):
par = ns.defparameter(name, central=value, relsigma=0.1)
variables.push_back(par.getVariable())
with ns:
vsum = C.VarSum(names, 'sum', ns=ns)
vsum_var = ns['sum'].get()
variables.push_back(vsum_var.getVariable())
vprod = C.VarProduct(names, 'product', ns=ns)
vprod_var = ns['product'].get()
variables.push_back(vprod_var.getVariable())
va = C.VarArrayPreallocated(variables)
pool = allocator.view()
res = va.vararray.points.data()
values_all = N.zeros(shape=values.size + 2, dtype=values.dtype)
values_all[:-2] = values
values_all[-2] = values_all[:-2].sum()
values_all[-1] = values_all[:-2].prod()
print('Python array:', values_all)
print('VarArray (preallocated):', res)
print('Pool:', pool)
assert (values_all == res).all()
assert (values_all == pool).all()
assert (res == pool).all()
for i, (val, name) in enumerate(enumerate(names, 2)):
ns[name].set(val)
values_all[i] = val
values_all[-2] = values_all[:-2].sum()
values_all[-1] = values_all[:-2].prod()
res = va.vararray.points.data()
print('Iteration', i)
print(' Python array:', values_all)
print(' VarArray (preallocated):', res)
assert (values_all == res).all()
assert (values_all == pool).all()
assert (res == pool).all()
def test_arrayview_constructor_view():
a = N.arange(5, dtype=context.current_precision_short())
view = R.arrayview(context.current_precision())(a, a.size)
assert view.size() == a.size
assert not view.isOwner()
vview = view.view()
print('Python/C++', a, vview)
assert (a == vview).all()
assert view == view
assert not view != view
def test_typeclass_same_v04():
"""Last input has another edges"""
objects=[C.Histogram2d(np.arange(4), np.arange(5)) for i in range(5)]
objects.append(C.Histogram2d(np.arange(1,5), np.arange(5)))
outputs = [p.single() for p in objects]
obj = C.DummyType()
list(map(obj.add_input, outputs))
dt = R.TypeClasses.CheckSameTypesT(context.current_precision())((1,-1), 'shape')
R.SetOwnership(dt, False)
dt.dump(); print()
obj.add_typeclass(dt)
res = obj.process_types();
assert res
dt1 = R.TypeClasses.CheckSameTypesT(context.current_precision())((1,-1),)
R.SetOwnership(dt1, False)
dt1.dump(); print()
obj.add_typeclass(dt1)
print('Exception expected: ',end='')
res = obj.process_types();
assert not res
def test_typeclass_same_v01():
"""All inputs have same types"""
arrays = [np.arange(12, dtype='d').reshape(3,4) for i in range(5)]
points = [C.Points(a) for a in arrays]
outputs = [p.points.points for p in points]
obj = C.DummyType()
list(map(obj.add_input, outputs))
dt = R.TypeClasses.CheckSameTypesT(context.current_precision())((0,-1))
R.SetOwnership(dt, False)
dt.dump(); print()
obj.add_typeclass(dt)
res = obj.process_types();
assert res
def OscProb3(*args, **kwargs):
"""OscProb3 wrapper
Aguments:
Neutrino from,
Neutrino to,
std::string l_name="L",
bool modecos=true,
std::vector<std::string> dmnames={}
"""
if len(args) >= 5:
args = list(args)
args[4] = stdvector(args[4])
return R.GNA.GNAObjectTemplates.OscProb3T(context.current_precision())(
*args, **kwargs)
def test_typeclass_setpoints_v01():
sizes = (1, 2, 3)
for size in sizes:
obj = C.DummyType()
obj.add_output('out')
dt = R.TypeClasses.SetPointsT(context.current_precision())(size)
R.SetOwnership(dt, False)
dt.dump(); print()
obj.add_typeclass(dt)
res = obj.process_types();
assert res
dtype = obj.dummytype.out.datatype()
assert dtype.kind==1
assert dtype.shape.size()==1
assert dtype.shape[0]==size
def Points(array, *args, **kwargs):
"""Convert array/TH1/TH2 to Points"""
if isinstance(array, R.TObject):
if not hasattr(array, 'get_buffer'):
raise Exception(
'Only TH1D/TH2D/TH1F/TH2F/TMatrixD/TMatrixF may be converted to Points'
)
if isinstance(array, R.TH2):
array = array.get_buffer().T
else:
array = array.get_buffer()
array = np.ascontiguousarray(array,
dtype=context.current_precision_short())
if len(array.shape) > 2:
raise Exception('Can convert only 1- and 2- dimensional arrays')
s = array_to_stdvector_size_t(array.shape)
return R.GNA.GNAObjectTemplates.PointsT(context.current_precision())(
array.ravel(order='F'), s, *args, **kwargs)
def test_vararray_v02(function_name):
ns = env.globalns(function_name)
names = ['zero', 'one', 'two', 'three', 'four', 'five']
values = N.arange(len(names), dtype=context.current_precision_short())
variables = R.vector('variable<%s>' % context.current_precision())()
for name, value in zip(names, values):
par = ns.defparameter(name, central=value, relsigma=0.1)
variables.push_back(par.getVariable())
va = C.VarArray(variables)
res = va.vararray.points.data()
print('Python array:', values)
print('Array:', res)
assert N.allclose(values, res)
for i, (val, name) in enumerate(enumerate(names, 2)):
ns[name].set(val)
values[i] = val
res = va.vararray.points.data()
assert N.allclose(values, res)
def OutputDescriptors(outputs):
descriptors = []
odescr = R.OutputDescriptorT(context.current_precision(),
context.current_precision())
ohandle = R.TransformationTypes.OutputHandleT(context.current_precision())
singleoutput = R.SingleOutputT(context.current_precision())
for output in outputs:
if isinstance(output, odescr):
append = output
elif isinstance(output, ohandle):
append = odescr(output)
elif isinstance(output, singleoutput):
append = odescr(output.single())
else:
raise Exception('Expect OutputHandle or SingleOutput object')
descriptors.append(append)
return stdvector(
descriptors, 'OutputDescriptorT<%s,%s>' %
(context.current_precision(), context.current_precision()))
def PolyRatio(nominator=[], denominator=[], *args, **kwargs):
nominator = stdvector(nominator, 'string')
denominator = stdvector(denominator, 'string')
return R.GNA.GNAObjectTemplates.PolyRatioT(context.current_precision())(
nominator, denominator, *args, **kwargs)
def newfcn(*args, **kwargs):
template = getattr(R, classname)
return template(context.current_precision())(*args, **kwargs)
def VarArray(vars, *args, **kwargs):
cls = R.GNA.GNAObjectTemplates.VarArrayT(context.current_precision())
ret = cls(stdvector(vars), *args, **kwargs)
ret.transformations.front().updateTypes()
return ret
def VarArrayPreallocated(vars, *args, **kwargs):
cls = R.GNA.GNAObjectTemplates.VarArrayPreallocatedT(
context.current_precision())
ret = cls(stdvector(vars), *args, **kwargs)
return ret
def VarProduct(varnames, *args, **kwargs):
return R.GNA.GNAObjectTemplates.VarProductT(context.current_precision())(
stdvector(varnames), *args, **kwargs)
