Exemple #1
0
    def get_StartTime(self):
        """
        Uses SWMM5 Conversion Functions to Pull DateTime String.

        This converts to Python datetime format.

        :return: Simulation start time.
        :rtype: datetime

        Examples:

        >>> OutputFile = SWMMBinReader()
        >>> OutputFile.OpenBinFile("outputfile.out")
        >>> OutputFile.get_StartTime()
        >>> datetime.datetime(2016,10,4,12,4,0)
        """
        _StartTime = self._get_StartTimeSWMM()
        _date = int(_StartTime)
        _time = _StartTime - _date

        # Pull Date String
        DateStr = ctypes.create_string_buffer(50)
        self.SWMMdateToStr(ctypes.c_double(_date), ctypes.byref(DateStr))
        DATE = DateStr.value

        # Pull Time String
        TimeStr = ctypes.create_string_buffer(50)
        self.SWMMtimeToStr(ctypes.c_double(_time), ctypes.byref(TimeStr))
        TIME = TimeStr.value
        DTime = datetime.strptime(DATE + ' ' + TIME, '%Y-%b-%d %H:%M:%S')
        return DTime
Exemple #2
0
    def getNodePos(self , i , j , k):
        """Will return the (x,y,z) for the node given by (i,j,k).

        Observe that this method does not consider cells, but the
        nodes in the grid. This means that the valid input range for
        i,j and k are are upper end inclusive. To get the four
        bounding points of the lower layer of the grid:

           p0 = grid.getNodePos(0 , 0 , 0)
           p1 = grid.getNodePos(grid.getNX() , 0 , 0)
           p2 = grid.getNodePos(0 , grid.getNY() , 0)
           p3 = grid.getNodePos(grid.getNX() , grid.getNY() , 0)

        """
        if not 0 <= i <= self.getNX():
            raise IndexError("Invalid I value:%d - valid range: [0,%d]" % (i , self.getNX()))

        if not 0 <= j <= self.getNY():
            raise IndexError("Invalid J value:%d - valid range: [0,%d]" % (j , self.getNY()))

        if not 0 <= k <= self.getNZ():
            raise IndexError("Invalid K value:%d - valid range: [0,%d]" % (k , self.getNZ()))
            
        x = ctypes.c_double()
        y = ctypes.c_double()
        z = ctypes.c_double()
        cfunc.get_corner_xyz( self , i,j,k , ctypes.byref(x) , ctypes.byref(y) , ctypes.byref(z))
        return (x.value , y.value , z.value)
Exemple #3
0
 def create_yamr(self, stor_file, port, info_filename, 
                 n_fail_max, overdue_resched_fac, overdue_giveup_fac):
     func = self.runlib.rmic_create_yamr
     func.restype = ctypes.c_void_p
     self.obj = func( ctypes.c_char_p(stor_file), 
           ctypes.c_char_p(port), ctypes.c_char_p(info_filename), 
           n_fail_max, ctypes.c_double(overdue_resched_fac), ctypes.c_double(overdue_giveup_fac))
Exemple #4
0
def gamma3(pulsar, tobs, harmonic):
    """S/N ratio decrease in an accel & jerk pulsar search"""

    gamma = C.c_double(0.)

    harm = float(harmonic)
    m1 = pulsar.pulsar_mass_msolar
    m2 = pulsar.companion_mass_msolar
    period_s = pulsar.period / 1000.
    long_peri = pulsar.long_peri_degrees
    inc_deg = pulsar.inclination_degrees
    ecc = pulsar.ecc
    orb_p = pulsar.orbital_period_days

    gammalib.gamma3_(
                     C.byref(C.c_double(harm)),
                     C.byref(C.c_double(tobs)),
                     C.byref(C.c_double(m1)),
                     C.byref(C.c_double(m2)),
                     C.byref(C.c_double(period_s)),
                     C.byref(C.c_double(long_peri)),
                     C.byref(C.c_double(inc_deg)),
                     C.byref(C.c_double(ecc)),
                     C.byref(C.c_double(orb_p)),
                     C.byref(gamma)
                     )

    return gamma.value
def call_forward_cic(nx1,nx2,boxsize,yif1,yif2):
    img_in = np.array(np.ones(len(yif1)),dtype=ct.c_double)
    yif1 = np.array(yif1,dtype=ct.c_double)
    yif2 = np.array(yif2,dtype=ct.c_double)
    img_out = np.zeros((nx1,nx2))
    fcic.forward_cic(img_in,yif1,yif2,ct.c_double(boxsize),ct.c_double(boxsize),ct.c_int(nx1),ct.c_int(nx2),ct.c_int(len(yif1)),img_out)
    return img_out.T
Exemple #6
0
    def mul(self, a, b, out, alpha=1.0, beta=0.0):
        w = self._wrappers

        # Ensure the matrices are compatible
        if a.nrow != out.nrow or a.ncol != b.nrow or b.ncol != out.ncol:
            raise ValueError('Incompatible matrices for out = a*b')

        # CUBLAS expects inputs to be column-major (or Fortran order in
        # numpy parlance).  However as C = A*B => C^T = (A*B)^T
        # = (B^T)*(A^T) with a little trickery we can multiply our
        # row-major matrices directly.
        m, n, k = b.ncol, a.nrow, a.ncol
        A, B, C = b, a, out

        # Do not transpose either A or B
        opA = opB = w.CUBLAS_OP_N

        # α and β factors for C = α*(A*op(B)) + β*C
        if a.dtype == np.float64:
            cublasgemm = w.cublasDgemm
            alpha_ct, beta_ct = c_double(alpha), c_double(beta)
        else:
            cublasgemm = w.cublasSgemm
            alpha_ct, beta_ct = c_float(alpha), c_float(beta)

        class MulKernel(ComputeKernel):
            def run(iself, queue):
                w.cublasSetStream(self._handle, queue.cuda_stream_comp.handle)
                cublasgemm(self._handle, opA, opB, m, n, k,
                           alpha_ct, A, A.leaddim, B, B.leaddim,
                           beta_ct, C, C.leaddim)

        return MulKernel()
Exemple #7
0
def _dgemm(trans_a, trans_b, m, n, k, a, b, c, alpha=1, beta=0,
           offseta=0, offsetb=0, offsetc=0):
    if a.size == 0 or b.size == 0:
        if beta == 0:
            c[:] = 0
        else:
            c[:] *= beta
        return c

    assert(a.flags.c_contiguous)
    assert(b.flags.c_contiguous)
    assert(c.flags.c_contiguous)

    _np_helper.NPdgemm(ctypes.c_char(trans_b.encode('ascii')),
                       ctypes.c_char(trans_a.encode('ascii')),
                       ctypes.c_int(n), ctypes.c_int(m), ctypes.c_int(k),
                       ctypes.c_int(b.shape[1]), ctypes.c_int(a.shape[1]),
                       ctypes.c_int(c.shape[1]),
                       ctypes.c_int(offsetb), ctypes.c_int(offseta),
                       ctypes.c_int(offsetc),
                       b.ctypes.data_as(ctypes.c_void_p),
                       a.ctypes.data_as(ctypes.c_void_p),
                       c.ctypes.data_as(ctypes.c_void_p),
                       ctypes.c_double(alpha), ctypes.c_double(beta))
    return c
Exemple #8
0
def goMapping(freq=30):
    global myMap,q

    # Parameters
    RED_BALL = 4
    GREEN_BALL = 5

    YELLOW_WALL = 2

    myMap.initMapping()
    while not q:
        start = time.time()
        sensorPoints = ct.getSensorPoints()
        pose = ct.getPose()

        balls = getBalls()
        knownBalls = [v.getBallCoords(b,pose) for b in getKnownBalls(balls)]
        specialWallPoints = [getPoint(pose,v.getAreaAngle(a,pose),640) for a in getWalls()]

        # Mapping update
        myMap.robotPositioned(ctypes.c_double(pose[0]), ctypes.c_double(pose[1]))

        for a in knownBalls:
            myMap.ballDetected(ctypes.c_double(a[0]),ctypes.c_double(a[1]),ctypes.c_int(RED_BALL))

        for wp in specialWallPoints:
            myMap.specialWall(ctypes.c_double(wp[0]),ctypes.c_double(wp[1]),ctypes.c_int(YELLOW_WALL))

        for s in sensorPoints:
            if(s[2]):
                myMap.wallDetected(ctypes.c_double(s[0]), ctypes.c_double(s[1]))
            else:
                myMap.wallNotDetected(ctypes.c_double(s[0]), ctypes.c_double(s[1]))

        time.sleep(max(0,1.0/float(freq) - (time.time()-start)))
Exemple #9
0
 def __getitem__(self, key):
     self._update()
     dx = c_double()
     dy = c_double()
     dz = c_double()
     m = self.__len__()
     has_z = self._ndim == 3
     if isinstance(key, int):
         if key + m < 0 or key >= m:
             raise IndexError("index out of range")
         if key < 0:
             i = m + key
         else:
             i = key
         lgeos.GEOSCoordSeq_getX(self._cseq, i, byref(dx))
         lgeos.GEOSCoordSeq_getY(self._cseq, i, byref(dy))
         if has_z:
             lgeos.GEOSCoordSeq_getZ(self._cseq, i, byref(dz))
             return (dx.value, dy.value, dz.value)
         else:
             return (dx.value, dy.value)
     elif isinstance(key, slice):
         res = []
         start, stop, stride = key.indices(m)
         for i in range(start, stop, stride):
             lgeos.GEOSCoordSeq_getX(self._cseq, i, byref(dx))
             lgeos.GEOSCoordSeq_getY(self._cseq, i, byref(dy))
             if has_z:
                 lgeos.GEOSCoordSeq_getZ(self._cseq, i, byref(dz))
                 res.append((dx.value, dy.value, dz.value))
             else:
                 res.append((dx.value, dy.value))
         return res
     else:
         raise TypeError("key must be an index or slice")
def _get_bounds(handle, bounds_fn, interleaved):
    pp_mins = ctypes.pointer(ctypes.c_double())
    pp_maxs = ctypes.pointer(ctypes.c_double())
    dimension = ctypes.c_uint32(0)

    bounds_fn(handle,
            ctypes.byref(pp_mins),
            ctypes.byref(pp_maxs),
            ctypes.byref(dimension))
    if (dimension.value == 0): return None

    mins = ctypes.cast(pp_mins,ctypes.POINTER(ctypes.c_double \
                                                      * dimension.value))
    maxs = ctypes.cast(pp_maxs,ctypes.POINTER(ctypes.c_double \
                                                      * dimension.value))

    results = [mins.contents[i] for i in range(dimension.value)]
    results += [maxs.contents[i] for i in range(dimension.value)]

    p_mins = ctypes.cast(mins,ctypes.POINTER(ctypes.c_double))
    p_maxs = ctypes.cast(maxs,ctypes.POINTER(ctypes.c_double))
    core.rt.Index_Free(ctypes.cast(p_mins, ctypes.POINTER(ctypes.c_void_p)))
    core.rt.Index_Free(ctypes.cast(p_maxs, ctypes.POINTER(ctypes.c_void_p)))
    if interleaved: # they want bbox order.
        return results
    return Index.deinterleave(results)
Exemple #11
0
def calc_fdtd(ey, hz, dx, dt, hist_ey):
  """ FDTDメインルーチン"""
  last_step = int(Const.STOP_TIME / dt)

  fp1 = open('fdtd_point.csv', 'w')
  print_point_value_header(fp1)
  fp2 = open('fdtd_line.csv', 'w')

  resource = ctypes.CDLL('./utility.so')

  tstart = ctypes.c_double()
  resource.get_current_time_by_sec(ctypes.byref(tstart))

  # メインループ
  step = 0
  while step <= last_step:
    if step % 100 == 0:
      print "%d / %d (%.2f %%)" % (step, last_step, float(step)/last_step * 100)

    # 磁流源の設定
    stimulus = calc_stimulus(step, dt)
    # 波源を(0.01mm, 0.05mm)に設定
    hz[500] += stimulus * dt

    # Eyの計算
    calc_ey(ey, hz, dx, dt)

    # 境界条件
    ey_boundary(ey, hist_ey, dt)
    hist_update(ey, hist_ey)

    # Hzの計算
    calc_hz(hz, ey, dx, dt)

    # 波形出力
    # print_point_value(fp1, hz, step * dt, stimulus)
    # if step % 100 == 0:
    #   print_line_value(fp2, hz, step)

    step += 1

  tend = ctypes.c_double()
  resource.get_current_time_by_sec(ctypes.byref(tend))
  memsize = ctypes.c_long()
  resource.get_use_memory_size_from_mac(ctypes.byref(memsize))

  fp1.close()
  fp2.close()

  print "All User Time: %.2f [sec], %.2f [min], %.2f [hour]" % \
      (tend.value-tstart.value, (tend.value-tstart.value)/60, (tend.value-tstart.value)/3600);

  if 0 <= memsize.value and memsize.value < 1024:
    print "Memory       : %.2f [B]" % (float(memsize.value))
  elif 1024 <= memsize.value and memsize.value/1024 < 1024:
    print "Memory       : %.2f [KB]" % (float(memsize.value)/1024)
  elif 1024 <= memsize.value/1024 and memsize.value/1024/1024 < 1024:
    print "Memory       : %.2f [MB]" % (float(memsize.value)/1024/1024)
  elif 1024 <= memsize.value/1024/1024:
    print "Memory       : %.2f [GB]" % (float(memsize.value)/1024/1024/1024)
Exemple #12
0
 def goRelative(self, dx, dy):
     if self.good:
         self.jog(0.0,0.0)
         dX = ctypes.c_double(dx * self.um_to_unit)
         dY = ctypes.c_double(dy * self.um_to_unit)
         dZA = ctypes.c_double(0.0)
         tango.LSX_MoveRel(self.LSID, dX, dY, dZA, dZA, self.wait)
    def get_coordinate_pointers(self, coordinates):

        try:
            iter(coordinates)
        except TypeError:
            raise TypeError('Bounds must be a sequence')
        dimension = self.properties.dimension

        mins = ctypes.c_double * dimension
        maxs = ctypes.c_double * dimension

        if not self.interleaved:
            coordinates = Index.interleave(coordinates)

        # it's a point make it into a bbox. [x, y] => [x, y, x, y]
        if len(coordinates) == dimension:
            coordinates += coordinates

        if len(coordinates) != dimension * 2:
            raise core.RTreeError("Coordinates must be in the form "
                                    "(minx, miny, maxx, maxy) or (x, y) for 2D indexes")

        # so here all coords are in the form:
        # [xmin, ymin, zmin, xmax, ymax, zmax]
        for i in range(dimension):
            if not coordinates[i] <= coordinates[i + dimension]:
                raise core.RTreeError("Coordinates must not have minimums more than maximums")

        p_mins = mins(*[ctypes.c_double(\
                            coordinates[i]) for i in range(dimension)])
        p_maxs = maxs(*[ctypes.c_double(\
                        coordinates[i + dimension]) for i in range(dimension)])

        return (p_mins, p_maxs)
Exemple #14
0
	def setFrom(self, val, name=None):
		"""Create an argument using a value as input.
		
		Arguments:
		Value -- an OpenSCAD value
		string -- the name of the value
		"""
		if name:
			self.name = ctypes.c_char_p(name)
		else:
			self.name = ctypes.c_char_p(0)
			
		if isinstance(val, bool):
			self.type = 'b'
			self.boolValue = ctypes.c_bool(val)
		elif isinstance(val, int) or isinstance(val, float):
			self.type = 'd'
			self.dblValue = ctypes.c_double(val)
		elif isinstance(val, str):
			self.type = 's'
			self.strValue = ctypes.c_char_p(val)
		elif isinstance(val, list) or isinstance(val, tuple):
			self.type = 'v'
			self.vecLen = ctypes.c_int(len(val))
			arr = (ctypes.c_double * len(val))()
			for i, v in enumerate(val):
				arr[i] = ctypes.c_double(v)
			self.vecValue = arr
 def trigger_IQ_bandwidth_set(self, dBandWidth, iOption=0):
     afDigitizerDll_Trigger_SetIntIQTriggerDigitalBandwidth = getDllObject('afDigitizerDll_Trigger_SetIntIQTriggerDigitalBandwidth', 
                                                                    argtypes = [afDigitizerInstance_t, c_double, c_int, POINTER(c_double)])
     dValue=c_double()
     error = afDigitizerDll_Trigger_SetIntIQTriggerDigitalBandwidth(self.session, c_double(dBandWidth), c_int(iOption), byref(dValue))
     self.check_error(error)
     return dValue.value
Exemple #16
0
def util_lon_lat(orig_lon, orig_lat, x, y):
    """
    Transform x, y [km] to decimal degree in reference to orig_lon and orig_lat

    >>> util_lon_lat(12.0, 48.0, 0.0, 0.0)
    (12.0, 48.0)
    >>> lon, lat = util_lon_lat(12.0, 48.0, 73.9041, 111.1908)
    >>> print("%.4f, %.4f" % (lon, lat))
    13.0000, 49.0000

    :param orig_lon: Longitude of reference origin
    :param orig_lat: Latitude of reference origin
    :param x: value [km] to calculate relative coordinate in degree
    :param y: value [km] to calculate relative coordinate in degree
    :return: lon, lat coordinate in degree (absolute)
    """
    # 2009-10-11 Moritz

    clibsignal.utl_lonlat.argtypes = [C.c_double, C.c_double, C.c_double,
                                      C.c_double, C.POINTER(C.c_double),
                                      C.POINTER(C.c_double)]
    clibsignal.utl_lonlat.restype = C.c_void_p

    lon = C.c_double()
    lat = C.c_double()

    clibsignal.utl_lonlat(orig_lon, orig_lat, x, y, C.byref(lon), C.byref(lat))
    return lon.value, lat.value
def callback(x, comm):
    """
    Callback that calculates the Black Scholes Option Price for a given Volatility
    """

    fail = NagError()

    p_userdata = cast(comm[0].p, py_object)
    userdata = p_userdata.value

    time = c_double(userdata[0])
    callput = userdata[1]
    strike = c_double(userdata[2])
    underlying = userdata[3]
    current_price = userdata[4]
    out = c_double(0.0)
  
    # NAG function call 
    # Update input with risk free (r) and dividend (q) rate if any:
    # (Nag_RowMajor, callput, 1, 1, strike, underlying, time, x, r, q, out, fail)
    s30aac(Nag_RowMajor, callput, 1, 1, strike, underlying, time, x, 0.0, 0.0, out, fail)
    if(fail.code == 0):
        return out.value - current_price
    print fail.message
    return 0.0
	def __init__(self, machine, name, **keys):

		super(self.__class__, self).__init__( machine, name )


		self.AddInput("signal")
		self.AddOutput("out")


		self.Gain=math.pi*0.5
		if 'gain' in keys.keys():
			self.Gain = keys['gain']
		else:
			print "WARNING! No gain given, using default gain = "+str(self.Gain)


		self.Q=math.sqrt(2.0)*0.5
		if 'Q' in keys.keys():
			self.Q = keys['Q']
		else:
			print "WARNING! No Q give, using default Q = "+str(self.Q)


		self.fc=0
		if 'fc' in keys.keys():
			self.fc = keys['fc']
		else:
			raise NameError("Missing fc!")



		self.cCoreID = Circuit.cCore.Add_SKLP(self.machine.cCoreID,
			c_double(self.fc), c_double(self.Q), c_double(self.Gain))

		self.SetInputs(**keys)
def d_line_setter(d_line, model, packet):
    packet.mu = c_double(0.0)
    scale = d_line * 1e1
    model.time_explosion = c_double(INVERSE_C * scale)
    packet.nu = c_double(1.0)
    nu_line = (1. - d_line/scale)
    packet.nu_line = c_double(nu_line)
Exemple #20
0
 def configure(self, n_samples, seconds_per_point):
     """
     Configures the sampling length and rate.
     
         n==0:    single point
         0<n<Inf: single waveform
     """
     if n_samples == 0:
         CHK( dll.DAQmxSetSampTimingType(self.ao_task, DAQmx_Val_OnDemand) )
     elif n_samples < numpy.inf:
         f = 1./seconds_per_point
         CHK( dll.DAQmxSetSampTimingType(self.ao_task, DAQmx_Val_SampClk) )
         CHK( dll.DAQmxCfgSampClkTiming(self.ao_task,
                                        self.co_dev+'InternalOutput',
                                        ctypes.c_double(f),
                                        DAQmx_Val_Falling,
                                        DAQmx_Val_FiniteSamps,
                                        ctypes.c_ulonglong(n_samples)) )
         CHK( dll.DAQmxSetCOPulseFreq(self.co_task,
                                      self.co_dev,
                                      ctypes.c_double(f)
                                      ))
         CHK( dll.DAQmxCfgImplicitTiming(self.co_task,
                                         DAQmx_Val_ContSamps,
                                         ctypes.c_ulonglong(n_samples+1)
                                         ))
         CHK( dll.DAQmxCfgImplicitTiming(self.ci_task,
                                         DAQmx_Val_FiniteSamps,
                                         ctypes.c_ulonglong(n_samples+1)
                                         ))
         self.ci_data = numpy.empty((n_samples+1,), dtype=numpy.uint32)
	def __init__(self, machine, name, **keys):

		super(self.__class__, self).__init__( machine, name )


		self.AddInput("signal")
		self.AddOutput("out")


		self.Gain=math.pi*0.5
		if 'gain' in keys.keys():
			self.Gain = keys['gain']
		else:
			print "WARNING! No gain given, using default gain = "+str(self.Gain)

		self.fc=0
		if 'fcut' in keys.keys():
			self.fc = keys['fcut']
		else:
			raise NameError("Missing fcut!")

		self.band=0
		if 'band' in keys.keys():
			self.band = keys['band']
		else:
			raise NameError("Missing band!")

		self.cCoreID = Circuit.cCore.Add_SKBP(self.machine.cCoreID,
			c_double(self.fc), c_double(self.band), c_double(self.Gain))
def hscryptkdf(password, dklen, maxmem, maxmemfrac, maxtime, params = None, saltsz = 32, nocheck = False):
    dk = create_string_buffer(dklen)

    # get lib's param size
    psz = _hgetparamsize()
    # check length of params
    if params is not None and len(params) < (psz + saltsz):
        raise Exception('For this build of the scrypt lib the params are %s/%s bytes! The salt size is %s.' % (len(params), psz + saltsz, saltsz))
    if params is None:
        print('creating param bytes')
        params = create_string_buffer(psz + saltsz)
        recover = 0
    else:
        print('using param bytes')
        params = c_char_p(params)
        recover = 1

    if nocheck:
        nocheck = 1
    else:
        nocheck = 0

    rcode = _hscryptkdf(
        c_char_p(password), c_size_t(len(password)), dk, c_size_t(dklen),
        c_size_t(saltsz),
        c_double(maxmem), c_double(maxmemfrac), c_double(maxtime), params,
        c_uint8(recover), c_uint8(nocheck)
    )

    if recover == 0:
        # convert from string buffer into bytes object
        params = bytes(params)

    return (rcode, bytes(dk), params)
Exemple #23
0
    def __init__(self,uid,timebase=None):
        if timebase == None:
            logger.debug("Capture will run with default system timebase")
            self.timebase = c_double(0)
        elif hasattr(timebase,'value'):
            logger.debug("Capture will run with app wide adjustable timebase")
            self.timebase = timebase
        else:
            logger.error("Invalid timebase variable type. Will use default system timebase")
            self.timebase = c_double(0)

        # self.use_hw_ts = self.check_hw_ts_support()
        self.use_hw_ts = False
        self._last_timestamp = self.get_now()


        self.capture = uvc.Capture(uid)
        self.uid = uid

        logger.debug('avaible modes %s'%self.capture.avaible_modes)

        controls_dict = dict([(c.display_name,c) for c in self.capture.controls])
        try:
            controls_dict['Auto Focus'].value = 0
        except KeyError:
            pass
        try:
            # Auto Exposure Priority = 1 leads to reduced framerates under low light and corrupt timestamps.
            controls_dict['Auto Exposure Priority'].value = 0
        except KeyError:
            pass

        self.sidebar = None
        self.menu = None
Exemple #24
0
def Vegas(integrand, ndim, userdata=NULL, 
    epsrel=EPSREL, epsabs=EPSABS, verbose=0, ncomp=1, seed=None,
    mineval=MINEVAL, maxeval=MAXEVAL, nstart=NSTART, 
    nincrease=NINCREASE, nbatch=NBATCH,
    gridno=GRIDNO, statefile=NULL):
  
  neval = c_int()
  fail = c_int()
  comp = c_int()
  ARR = c_double * ncomp
  integral = ARR()
  error = ARR()
  prob  = ARR()
  
  if seed is None:
    seed = 0
  
  lib.Vegas(ndim, ncomp, integrand_type(integrand), userdata,
    c_double(epsrel), c_double(epsabs), verbose, seed,
    mineval, maxeval, nstart, nincrease, nbatch,
    gridno, statefile,
    byref(neval), byref(fail), integral, error, prob)
  
  return dict(neval=neval.value, fail=fail.value, comp=comp.value,
    results=[{
      'integral':integral[comp], 
      'error':error[comp], 
      'prob':prob[comp]
      } for comp in range(ncomp)])
Exemple #25
0
def Suave(integrand, ndim, nnew=1000, flatness=25., userdata=NULL, 
    epsrel=EPSREL, epsabs=EPSABS, verbose=0, ncomp=1, seed=None,
    mineval=MINEVAL, maxeval=MAXEVAL):
  
  neval = c_int()
  fail = c_int()
  comp = c_int()
  nregions = c_int()
  ARR = c_double * ncomp
  integral = ARR()
  error = ARR()
  prob  = ARR()
    
  if seed is None:
    seed = 0
  
  lib.Suave(ndim, ncomp, integrand_type(integrand), userdata,
    c_double(epsrel), c_double(epsabs), verbose, seed,
    mineval, maxeval, nnew, c_double(flatness),
    byref(nregions), byref(neval), byref(fail), integral, error, prob)
  
  return dict(neval=neval.value, fail=fail.value, comp=comp.value, nregions=nregions.value,
    results=[{
      'integral':integral[comp], 
      'error':error[comp], 
      'prob':prob[comp]
      } for comp in range(ncomp)])
Exemple #26
0
def computeEigenVectorsOfHessianImage( imgStack, zAnisotropyFactor, sigma=3.5 ):
    """
    Computes an orientation matrix (3x3) per pixel.
    """
    if imgStack.dtype != np.dtype("uint8"):
        raise RuntimeError("image must be of uint8 type")

    if not imgStack.flags["C_CONTIGUOUS"]:
        raise RuntimeError("image must be C_CONTIGUOUS, and must be provided in z-y-x order.")

    if imgStack.ndim != 3:
        raise RuntimeError("image must be 3D.")
    
    # Data is C-style memory layout (z-y-x)
    width = imgStack.shape[2]
    height = imgStack.shape[1]
    depth = imgStack.shape[0]

    ptr_address = libPtr.computeEigenVectorsOfHessianImage( 
                    ctypes.c_void_p(imgStack.ctypes.data),
                    ctypes.c_int(width), ctypes.c_int(height), ctypes.c_int(depth),
                    ctypes.c_double(zAnisotropyFactor),
                    ctypes.c_double(sigma) )

    return EigenVectorsOfHessianImage(ptr_address, imgStack.shape + (3,3))
def generate_photo_current(mesh,e_field,problem):
	current = 0
	accumulated_charge = 0.
	total_photons = len(mesh.coordinates())
	particles = mpc.CParticles(2000,mesh.c_mesh,mesh.dim)
	e_field = np.array(mc.pre_compute_field(mesh,e_field))
	nextDensity = problem.density_funcs.combined_density.vector().array().astype('int')

	for point in xrange(len(mesh.coordinates())):
		new_particle(point,particles,problem,-1,mesh)
		new_particle(point,particles,problem,+1,mesh)
	for rep in xrange(300):
		accumulated_charge+=mpc.lib.photocurrentC(particles.ptr,
				nextDensity.ctypes.data,
				e_field.ctypes.data,
				mesh.c_mesh,
				ctypes.c_double(mesh.dt),
				ctypes.c_double(mesh.length_scale))

	print "accumulated_charge",accumulated_charge,total_photons
	charge_per_photon = constants.eC*accumulated_charge/total_photons
	power = 1000. #per meter squared
	photons_sec = power*photons_per_watt(400*10**-9)
	current = charge_per_photon*photons_sec
	print "photocurrent:",current
	return current
Exemple #28
0
def lagrange_interpol_2D_td(points1, points2, coefficients, x1, x2):
    points1 = np.require(points1, dtype=np.float64,
                         requirements=["F_CONTIGUOUS"])
    points2 = np.require(points2, dtype=np.float64,
                         requirements=["F_CONTIGUOUS"])
    coefficients = np.require(coefficients, dtype=np.float64,
                              requirements=["F_CONTIGUOUS"])

    # Should be safe enough. This was never raised while extracting a lot of
    # seismograms.
    assert len(points1) == len(points2)

    N = len(points1) - 1
    nsamp = coefficients.shape[0]

    interpolant = np.zeros(nsamp, dtype="float64", order="F")

    lib.lagrange_interpol_2D_td(
        C.c_int(N),
        C.c_int(nsamp),
        points1.ctypes.data_as(C.POINTER(C.c_double)),
        points2.ctypes.data_as(C.POINTER(C.c_double)),
        coefficients.ctypes.data_as(C.POINTER(C.c_double)),
        C.c_double(x1),
        C.c_double(x2),
        interpolant.ctypes.data_as(C.POINTER(C.c_double)))
    return interpolant
def Cuhre(integrand, ndim, 
    key=0, mineval=MINEVAL, maxeval=MAXEVAL, ncomp=1,
    userdata=NULL, seed=None,
    epsrel=EPSREL, epsabs=EPSABS, verbose=0, statefile=NULL, nvec=1):
  """
  *key* chooses the basic integration rule:
    key = 7, 9, 11, 13 selects the cubature rule of degree key. Note that the degree-11
    rule is available only in 3 dimensions, the degree-13 rule only in 2 dimensions.
    For other values, the default rule is taken, which is the degree-13 rule in 2 dimensions,
    the degree-11 rule in 3 dimensions, and the degree-9 rule otherwise.
  """
  
  neval = c_int()
  fail = c_int()
  comp = c_int()
  nregions = c_int()
  ARR = c_double * ncomp
  integral = ARR()
  error = ARR()
  prob  = ARR()
  
  if seed is None:
    seed = 0

  lib.Cuhre(ndim, ncomp, wrap_integrand(integrand), userdata,
    c_int(nvec), c_double(epsrel), c_double(epsabs), verbose,
    mineval, maxeval, key, statefile, spin,
    byref(nregions), byref(neval), byref(fail), integral, error, prob)
  
  return dict(neval=neval.value, fail=fail.value, comp=comp.value, nregions=nregions.value,
    results=[{
      'integral':integral[comp], 
      'error':error[comp], 
      'prob':prob[comp]
      } for comp in range(ncomp)])
 def __init__(self, rf_freq, rf_dur):
     # Constants corresponding to various NI options, defined with c_types
     vi = c_int(1)
     o1 = c_int(1)
     o2 = c_int(101)
     o3 = c_int(1000000 + 150000 + 219)
     o4 = c_double(0)
     length = len(rf_freq)
     # Loading the driver to call niFgen functions
     try:
         self.nfg = windll.LoadLibrary("niFgen_32.dll")
     except OSError:
         self.nfg = windll.LoadLibrary("niFgen_64.dll")
     # The way to initialize niFgen can be found in NI examples
     # It is copy/past from that, only translated into c_types
     self.nfg.niFgen_init(b'Dev3', c_bool(1), c_bool(1), byref(vi))
     self.nfg.niFgen_ConfigureChannels(vi, b"0")
     self.nfg.niFgen_ConfigureOutputMode(vi, o2)
     # This is the way to convert numpy array into C array
     rff = rf_freq.ctypes.data
     rfd = rf_dur.ctypes.data
     rf = c_int(0)
     self.nfg.niFgen_CreateFreqList(vi, o1, length, rff, rfd, byref(rf))
     self.nfg.niFgen_ConfigureFreqList(vi, b"0", rf, c_double(4), o4,  o4)
     self.nfg.niFgen_ConfigureDigitalEdgeStartTrigger(vi, b"PFI1", o2)
     self.nfg.niFgen_ConfigureTriggerMode(vi, b"0", c_int(2))
     self.nfg.niFgen_ConfigureOutputEnabled(vi, b"0", c_bool(1))
     # These two lines export the internal clock of the niFgen (100 MHz)
     # divided by 400 (250 kHz) on the RTSI1 channel. It's the only way
     # to be sure that all cards are synchronized on the same clock
     self.nfg.niFgen_SetAttributeViInt32(vi, b"", o3, c_long(400))
     self.nfg.niFgen_ExportSignal(vi, o2, b"", b"RTSI1")
     # self.niFgen.niFgen_ExportSignal(vi, c_int(1000 + 4), b"", b"RTSI2")
     self.nfg.niFgen_Commit(vi)
     self.vi = vi
Exemple #31
0
def get_parameter_double(key):
    val_c = c_double()
    getparameter_double_c(c_char_p(key.encode()), byref(val_c))
    return val_c.value
Exemple #32
0
 def _get_y(self, index):
     return capi.cs_gety(self.ptr, index, byref(c_double()))
Exemple #33
0
    def set_cosmology(self, H0=67.0, cosmomc_theta=None, ombh2=0.022, omch2=0.12, omk=0.0, Num_drf=0.2,                   
                      neutrino_hierarchy='degenerate', num_massive_neutrinos=1,
                      mnu=0.06, nnu=3.046, YHe=None, meffsterile=0.0, standard_neutrino_neff=3.046,
                      TCMB=constants.COBE_CMBTemp, tau=None, deltazrei=None, bbn_predictor=None,
                      theta_H0_range=[10, 100]):                                                       #ZP drf
        """
        Sets cosmological parameters in terms of physical densities and parameters used in Planck 2015 analysis.
        Default settings give a single distinct neutrino mass eigenstate, by default one neutrino with mnu = 0.06eV.
        Set the neutrino_hierarchy parameter to normal or inverted to use a two-eigenstate model that is a good
        approximation to the known mass splittings seen in oscillation measurements.
        If you require more fine-grained control you can set the neutrino parameters directly rather than using this function.

        :param H0: Hubble parameter (in km/s/Mpc)
        :param cosmomc_theta: The CosmoMC theta parameter. You must set H0=None to solve for H0 given cosmomc_theta
        :param ombh2: physical density in baryons
        :param omch2:  physical density in cold dark matter
        :param omk: Omega_K curvature parameter
        :param neutrino_hierarchy: 'degenerate', 'normal', or 'inverted' (1 or 2 eigenstate approximation)
        :param num_massive_neutrinos:  number of massive neutrinos (ignored unless hierarchy == 'degenerate')
        :param mnu: sum of neutrino masses (in eV)
        :param nnu: N_eff, effective relativistic degrees of freedom
        :param YHe: Helium mass fraction. If None, set from BBN consistency.
        :param meffsterile: effective mass of sterile neutrinos
        :param standard_neutrino_neff:  default value for N_eff in standard cosmology (non-integer to allow for partial
                heating of neutrinos at electron-positron annihilation and QED effects)
        :param TCMB: CMB temperature (in Kelvin)
        :param tau: optical depth; if None, current Reion settings are not changed
        :param deltazrei: redshift width of reionization; if None, uses default
        :param bbn_predictor: :class:`.bbn.BBNPredictor` instance used to get YHe from BBN consistency if YHe is None
        :param theta_H0_range: if cosmomc_theta is specified, the min, max interval of H0 values to map to; outside this range
                 it will raise an exception.

        """

        if YHe is None:
            # use BBN prediction
            bbn_predictor = bbn_predictor or bbn.get_default_predictor()
            YHe = bbn_predictor.Y_He(ombh2, nnu - standard_neutrino_neff)
        self.YHe = YHe

        if cosmomc_theta is not None:
            if not (0.001 < cosmomc_theta < 0.1):
                raise CAMBParamRangeError('cosmomc_theta looks wrong (parameter is just theta, not 100*theta)')

            kw = locals();
            [kw.pop(x) for x in ['self', 'H0', 'cosmomc_theta']]

            if H0 is not None:
                raise CAMBError('Set H0=None when setting cosmomc_theta.')

            try:
                from scipy.optimize import brentq
            except ImportError:
                raise CAMBError('You need SciPy to set cosmomc_theta.')

            from . import camb

            def f(H0):
                self.set_cosmology(H0=H0, **kw)
                return camb.get_background(self, no_thermo=True).cosmomc_theta() - cosmomc_theta

            try:
                self.H0 = brentq(f, theta_H0_range[0], theta_H0_range[1], rtol=1e-4)
            except ValueError:
                raise CAMBParamRangeError('No solution for H0 inside of theta_H0_range')
        else:
            self.H0 = H0

        self.TCMB = TCMB
        fac = (self.H0 / 100.0) ** 2
        self.omegab = ombh2 / fac
        self.omegac = omch2 / fac

        self.Num_drf = Num_drf       #ZP drf

        neutrino_mass_fac = 94.07
        # conversion factor for thermal with Neff=3 TCMB=2.7255

        omnuh2 = mnu / neutrino_mass_fac * (standard_neutrino_neff / 3.0) ** 0.75
        omnuh2_sterile = meffsterile / neutrino_mass_fac
        if omnuh2_sterile > 0 and nnu < standard_neutrino_neff:
            raise CAMBError('sterile neutrino mass required Neff>3.046')
        if omnuh2 and not num_massive_neutrinos:
            raise CAMBError('non-zero mnu with zero num_massive_neutrinos')

        if isinstance(neutrino_hierarchy, six.string_types):
            if not neutrino_hierarchy in neutrino_hierarchies:
                raise CAMBError('Unknown neutrino_hierarchy {0:s}'.format(neutrino_hierarchy))
            neutrino_hierarchy = neutrino_hierarchies.index(neutrino_hierarchy) + 1

        omnuh2 = omnuh2 + omnuh2_sterile
        self.omegan = omnuh2 / fac
        self.omegav = 1 - omk - self.omegab - self.omegac - self.omegan
        # self.share_delta_neff = False
        # self.nu_mass_eigenstates = 0
        # self.num_nu_massless = nnu
        # self.nu_mass_numbers[0] = 0
        # self.num_nu_massive = 0
        # if omnuh2 > omnuh2_sterile:
        #     neff_massive_standard = num_massive_neutrinos * standard_neutrino_neff / 3.0
        #     self.num_nu_massive = num_massive_neutrinos
        #     self.nu_mass_eigenstates = self.nu_mass_eigenstates + 1
        #     if nnu > neff_massive_standard:
        #         self.num_nu_massless = nnu - neff_massive_standard
        #     else:
        #         self.num_nu_massless = 0
        #         neff_massive_standard = nnu
        #
        #     self.nu_mass_numbers[self.nu_mass_eigenstates - 1] = num_massive_neutrinos
        #     self.nu_mass_degeneracies[self.nu_mass_eigenstates - 1] = neff_massive_standard
        #     self.nu_mass_fractions[self.nu_mass_eigenstates - 1] = (omnuh2 - omnuh2_sterile) / omnuh2
        # else:
        #     neff_massive_standard = 0
        if omnuh2_sterile > 0:
            if nnu < standard_neutrino_neff:
                raise CAMBError('nnu < 3.046 with massive sterile')
        # self.num_nu_massless = standard_neutrino_neff - neff_massive_standard
        #     self.num_nu_massive = self.num_nu_massive + 1
        #     self.nu_mass_eigenstates = self.nu_mass_eigenstates + 1
        #     self.nu_mass_numbers[self.nu_mass_eigenstates - 1] = 1
        #     self.nu_mass_degeneracies[self.nu_mass_eigenstates - 1] = max(1e-6, nnu - standard_neutrino_neff)
        #     self.nu_mass_fractions[self.nu_mass_eigenstates - 1] = omnuh2_sterile / omnuh2

        CAMB_SetNeutrinoHierarchy(byref(self), byref(c_double(omnuh2)), byref(c_double(omnuh2_sterile)),
                                  byref(c_double(nnu)), byref(c_int(neutrino_hierarchy)),
                                  byref(c_int(num_massive_neutrinos)))

        if tau is not None:
            self.Reion.set_tau(tau, delta_redshift=deltazrei)
        elif deltazrei:
            raise CAMBError('must set tau if setting deltazrei')

        return self
Exemple #34
0
def checkFWver():
	FWver = c_double()
	lib.nScope_check_FW_version(byref(FWver))
	return FWver.value
Exemple #35
0
def checkAPIver():
	APIver = c_double()
	lib.nScope_check_API_version(byref(APIver))
	return APIver.value
Exemple #36
0
    def test_DynTipDispRot_2v3noded(self):
        """@brief Check free vibration frequencies of goland wing."""

        import NonlinearDynamic  # imported after clean/make process

        Settings.OutputFileRoot = 'PyBeamGolandFree2noded'

        "beam options"
        XBOPTS = DerivedTypes.Xbopts(FollowerForce = ct.c_bool(False),\
                                     MaxIterations = ct.c_int(99),\
                                     PrintInfo = ct.c_bool(True),\
                                     NumLoadSteps = ct.c_int(25),\
                                     Solution = ct.c_int(312),\
                                     MinDelta = ct.c_double(1e-4),\
                                     NewmarkDamp = ct.c_double(1e-2))

        "beam inputs"
        XBINPUT = DerivedTypes.Xbinput(2, 24)
        XBINPUT.BeamLength = 6.096
        XBINPUT.BeamStiffness[0, 0] = 1.0e+09
        XBINPUT.BeamStiffness[1, 1] = 1.0e+09
        XBINPUT.BeamStiffness[2, 2] = 1.0e+09
        XBINPUT.BeamStiffness[3, 3] = 0.9875e+06
        XBINPUT.BeamStiffness[4, 4] = 9.77e+06
        XBINPUT.BeamStiffness[5, 5] = 9.77e+08

        XBINPUT.BeamStiffness[:, :] = 1.0 * XBINPUT.BeamStiffness[:, :]

        XBINPUT.BeamMass[0, 0] = 35.709121
        XBINPUT.BeamMass[1, 1] = 35.709121
        XBINPUT.BeamMass[2, 2] = 35.709121
        XBINPUT.BeamMass[3, 3] = 8.6405832
        XBINPUT.BeamMass[4, 4] = 0.001
        XBINPUT.BeamMass[5, 5] = 0.001

        "pitch-plunge coupling term"
        "b-frame coordinates"
        c = 1.8288

        "using skew-symmetric operator"
        cg = np.array([0.0, -0.1, 0.0]) * c
        cgSkew = np.array([[   0.0, -cg[2], cg[1] ],\
                           [ cg[2],    0.0, -cg[0]],\
                           [-cg[1],  cg[0],   0.0] ])

        XBINPUT.BeamMass[:3, 3:] = -XBINPUT.BeamMass[0, 0] * cgSkew
        XBINPUT.BeamMass[3:, :3] = XBINPUT.BeamMass[:3, 3:].T

        "set (0,5) and (5,0) to zero"
        XBINPUT.BeamMass[0, 5] = 0.0
        XBINPUT.BeamMass[5, 0] = 0.0

        "Dynamic parameters"
        XBINPUT.t0 = 0.0
        XBINPUT.tfin = 1.0
        XBINPUT.dt = 0.01
        XBINPUT.Omega = 0.0
        XBINPUT.ForceDyn[-1, 2] = 6e03
        XBINPUT.ForcingType = '1-cos'

        NonlinearDynamic.Solve_Py(XBINPUT, XBOPTS)

        "Read from file"
        Dyn2noded = np.loadtxt(Settings.OutputDir + Settings.OutputFileRoot+'_SOL'+str(XBOPTS.Solution.value) + '_dyn.dat', \
                               skiprows=3)

        "run with 3-noded"
        Settings.OutputFileRoot = 'PyBeamGolandFree2noded'
        "beam inputs"
        XBINPUT = DerivedTypes.Xbinput(3, 12)
        XBINPUT.BeamLength = 6.096
        XBINPUT.BeamStiffness[0, 0] = 1.0e+09
        XBINPUT.BeamStiffness[1, 1] = 1.0e+09
        XBINPUT.BeamStiffness[2, 2] = 1.0e+09
        XBINPUT.BeamStiffness[3, 3] = 0.9875e+06
        XBINPUT.BeamStiffness[4, 4] = 9.77e+06
        XBINPUT.BeamStiffness[5, 5] = 9.77e+08

        XBINPUT.BeamStiffness[:, :] = 1.0 * XBINPUT.BeamStiffness[:, :]

        XBINPUT.BeamMass[0, 0] = 35.709121
        XBINPUT.BeamMass[1, 1] = 35.709121
        XBINPUT.BeamMass[2, 2] = 35.709121
        XBINPUT.BeamMass[3, 3] = 8.6405832
        XBINPUT.BeamMass[4, 4] = 0.001
        XBINPUT.BeamMass[5, 5] = 0.001

        "pitch-plunge coupling term"
        "b-frame coordinates"
        c = 1.8288

        "using skew-symmetric operator"
        cg = np.array([0.0, -0.1, 0.0]) * c
        cgSkew = np.array([[   0.0, -cg[2], cg[1] ],\
                           [ cg[2],    0.0, -cg[0]],\
                           [-cg[1],  cg[0],   0.0] ])

        XBINPUT.BeamMass[:3, 3:] = -XBINPUT.BeamMass[0, 0] * cgSkew
        XBINPUT.BeamMass[3:, :3] = XBINPUT.BeamMass[:3, 3:].T

        "set (0,5) and (5,0) to zero"
        XBINPUT.BeamMass[0, 5] = 0.0
        XBINPUT.BeamMass[5, 0] = 0.0

        "Dynamic parameters"
        XBINPUT.t0 = 0.0
        XBINPUT.tfin = 1.0
        XBINPUT.dt = 0.001
        XBINPUT.Omega = 0.0
        XBINPUT.ForceDyn[-1, 2] = 6e03
        XBINPUT.ForcingType = '1-cos'

        NonlinearDynamic.Solve_Py(XBINPUT, XBOPTS)

        "Read from file"
        Dyn3noded = np.loadtxt(Settings.OutputDir + Settings.OutputFileRoot + '_SOL' + str(XBOPTS.Solution.value) + '_dyn.dat', \
                               skiprows=3)

        PlotThings = False
        if PlotThings == True:
            "plot displacements"
            "plot displacements"
            plt.figure(1)
            plt.subplot(311)
            plt.plot(Dyn3noded[:, 0], Dyn3noded[:, 1])
            plt.plot(Dyn2noded[:, 0], Dyn2noded[:, 1])
            plt.grid()
            plt.ylabel('R_1')
            #plt.ylim(4.95,5.05)
            plt.subplot(312)
            plt.plot(Dyn3noded[:, 0], Dyn3noded[:, 2])
            plt.plot(Dyn2noded[:, 0], Dyn2noded[:, 2])
            plt.grid()
            plt.ylabel('R_2')
            plt.subplot(313)
            plt.plot(Dyn3noded[:, 0], Dyn3noded[:, 3])
            plt.plot(Dyn2noded[:, 0], Dyn2noded[:, 3])
            plt.grid()
            plt.ylabel('R_3')
            plt.xlabel('time')
            plt.legend(("3-noded","2-noded")\
                       ,'lower left',\
                       shadow=True,\
                       prop={'size':12})
            plt.figure(2)
            plt.subplot(311)
            plt.plot(Dyn3noded[:, 0], Dyn3noded[:, 4])
            plt.plot(Dyn2noded[:, 0], Dyn2noded[:, 4])
            plt.grid()
            plt.ylabel('Psi_1')
            #plt.ylim(4.95,5.05)
            plt.subplot(312)
            plt.plot(Dyn3noded[:, 0], Dyn3noded[:, 5])
            plt.plot(Dyn2noded[:, 0], Dyn2noded[:, 5])
            plt.grid()
            plt.ylabel('Psi_2')
            plt.subplot(313)
            plt.plot(Dyn3noded[:, 0], Dyn3noded[:, 6])
            plt.plot(Dyn2noded[:, 0], Dyn2noded[:, 6])
            plt.grid()
            plt.ylabel('Psi_3')
            plt.xlabel('time')
            plt.legend(("3-noded","2-noded")\
                       ,'lower left',\
                       shadow=True,\
                       prop={'size':12})
            plt.show()

        for iTime in range(Dyn3noded.shape[0]):
            "Assert z-displacement"
            Delz = 0.001 * np.max(Dyn3noded[:, 3])
            self.assertAlmostEqual(Dyn2noded[iTime,3],Dyn3noded[iTime,3],\
                                   places = None,\
                                   msg = 'z-displacement does not match',\
                                   delta=Delz)
Exemple #37
0
class Process(object):

    _tree_buf = c_double()
    _ewcc_buf = c_double()
    _ct_buf = c_double()
    _pt_buf = c_double()
    _ptloop_buf = c_double()
    _loop_buf = (3 * c_double)()
    _ir1_buf = (3 * c_double)()
    _loop2_buf = (5 * c_double)()
    _ir2_buf = (5 * c_double)()
    _acc_buf = c_double()

    def __init__(self, process, amptype=default_amptype, qcd=-1, ew=-1):
        """Register a process with given amptype (default=LOOP).
        Use 'qcd' rsp. 'ew' to request a process in a certain order
        in alpha_s rsp. alpha.

        public members:
        * process -- the process name as registered
        * id (int) -- process id
        * amptype (int) -- amptype
        * contains -- LibraryContent() instance
        * n -- number of external particles
        Process instances can be passed to C functions as id.
        """
        typearg = amptype
        needs_tree = False
        needs_pt = False
        if isinstance(amptype, strtype):
            try:
                amptype = AMPTYPES[amptype.lower()]
            except KeyError:
                pass
        if isinstance(amptype, strtype):
            if not set(typearg) - set(loopspec_flags):
                if 's' in typearg and 'l' in typearg:
                    amptype = LOOP2
                elif 'l' in amptype:
                    amptype = LOOP
                elif 't' in amptype:
                    amptype = TREE
            if 't' in typearg:
                needs_tree = True
            if 'p' in typearg:
                needs_pt = True
        if not amptype in AMPTYPES.values():
            raise RegisterProcessError(
                'Process(): illegal amptype \'{}\''.format(typearg))
        if qcd >= 0:
            set_parameter('order_qcd', qcd)
        if ew >= 0:
            set_parameter('order_ew', ew)
        self.id = register_process(process, amptype)
        if self.id <= 0:
            raise RegisterProcessError(
                'Failed to load process \'{}\' with amptype {}'.format(
                    process, typearg))
        self.contains = library_content(self.id)
        if needs_tree and not self.contains.tree:
            raise RegisterProcessError(
                ('Dedicated tree matrix elements are not available ' +
                 'in process {}.').format(process))
        if needs_pt and not self.contains.pt:
            raise RegisterProcessError(
                ('Pseudo-tree matrix elements are not available ' +
                 'in process {}.').format(process))
        self.process = process
        self.amptype = amptype
        self.n = n_external(self.id)
        self._as_parameter_ = self.id
        self._pp_buf = ((5 * self.n) * c_double)()
        if amptype == CC:
            self._cc_buf = (((self.n * (self.n - 1)) / 2) * c_double)()
        if amptype == SC:
            self._sc_buf = ((2 * self.n**2) * c_double)()
        if amptype == SCPV:
            self._sc_polvect_buf = ((self.n) * c_double)()

    def psp(self, sqrt_s=default_energy):
        """Generate a random phase space point for the process."""
        phase_space_point_c(self.id, sqrt_s, self._pp_buf)
        return PhaseSpacePoint(self._pp_buf, self.n)

    def evaluate(self, pp_or_sqrt_s=default_energy, amptype=None):
        """Calculate matrix elements either for a given phase space point
        or for a random phase space point of given or default energy.

        'amptype' overrides the amptype of the process -- if you use this,
                  it's up to you to figure out if what you do makes sense.
                  'ct' calculates the counterterms only."""
        ct_only = False
        r2_only = False
        if amptype == 'ct':
            ct_only = True
            amptype = None
        elif amptype == 'r2':
            r2_only = True
            amptype = None
        if not amptype:
            amptype = self.amptype
        if not start.started:
            start()
            start.started = True
        if isinstance(pp_or_sqrt_s, (int, float)):
            psp = self.psp(pp_or_sqrt_s)
        elif isinstance(pp_or_sqrt_s, PhaseSpacePoint):
            psp = pp_or_sqrt_s
        else:
            psp = PhaseSpacePoint(pp_or_sqrt_s, self.n)

        if amptype in (LOOP, LOOP2):
            if ct_only:
                evaluate_ct_c(self.id, psp, Process._tree_buf, Process._ct_buf)
                me = MatrixElement('ct',
                                   psp,
                                   tree=Process._tree_buf.value,
                                   ct=Process._ct_buf.value)
            elif r2_only:
                evaluate_r2_c(self.id, psp, Process._tree_buf, Process._ct_buf)
                me = MatrixElement('r2',
                                   psp,
                                   tree=Process._tree_buf.value,
                                   r2=Process._ct_buf.value)
            else:
                evaluate_full_c(self.id, psp, Process._tree_buf,
                                Process._loop_buf, Process._ir1_buf,
                                Process._loop2_buf, Process._ir2_buf,
                                Process._acc_buf)
                me = MatrixElement(amptype,
                                   psp,
                                   tree=Process._tree_buf.value,
                                   loop=LoopME(*Process._loop_buf),
                                   iop=IOperator(*Process._ir1_buf),
                                   loop2=Loop2ME(*Process._loop2_buf),
                                   acc=Process._acc_buf.value)
        elif amptype == TREE:
            evaluate_tree_c(self.id, psp, Process._tree_buf)
            me = MatrixElement(amptype, psp, tree=Process._tree_buf.value)
        else:
            raise OpenLoopsError(
                'Process() amptype {} not implemented yet'.format(amptype))
        return me
Exemple #38
0
'''
DATA TYPE
'''

data_integer = 1234567890  #numbers
data_float = 13.7  #numbers with coma
data_string = "*****@*****.**"
data_boolean = True  #value true and false (boolean)
data_complex = complex(5, 6)  #complex number

#import data type from C to use data type from C like c_double
from ctypes import c_double
data_c_double = c_double(10.8)
print("Data type introduction")
print("data :", data_integer, "data type", type(data_integer))
print("data :", data_float, "data type", type(data_float))
print("data :", data_string, "data type", type(data_string))
print("data :", data_boolean, "data type", type(data_boolean))
print("data :", data_complex, "data type", type(data_complex))
print("data :", data_c_double, "data type", type(data_c_double))
Exemple #39
0
    def mainLoopViaCLib_On(self,
                           nsweep=1000,
                           nthermal=5000,
                           ninterval=-1,
                           algo='Metroplis',
                           On=3,
                           flunc=0.0,
                           h=0.,
                           binGraph=False):
        self.nsweep = nsweep
        self.nthermal = nthermal
        ninterval = self.totOrbs if ninterval <= 0 else ninterval

        # initial spin, single ion anisotropy and number of linking
        initSpin = (c_double * self.totOrbs)()
        initD = (c_double * (3 * self.totOrbs))()
        nlinking = (c_int * self.totOrbs)()
        nlinking_list = []
        for iorb, orb in enumerate(self.lattice):
            #print(orb.spin)
            initSpin[iorb] = c_double(orb.spin)
            initD[iorb * 3] = c_double(orb.D[0])
            initD[iorb * 3 + 1] = c_double(orb.D[1])
            initD[iorb * 3 + 2] = c_double(orb.D[2])

            nlinking[iorb] = c_int(len(orb.linkedOrb))
            nlinking_list.append(len(orb.linkedOrb))

        # link strength
        ignoreNonDiagonalJ = 1
        maxNLinking = np.max(nlinking_list)
        #print("maxNLinking=%d"%maxNLinking)
        linkStrength = (c_double * (self.totOrbs * maxNLinking * 9)
                        )()  # thus the nlinking of every orbs are the same
        cnt = 0
        for iorb, orb in enumerate(self.lattice):
            #print("orb%d"%orb.id)
            for ilinking in range(maxNLinking):
                if ilinking >= nlinking_list[iorb]:
                    for i in range(9):
                        linkStrength[cnt] = c_double(0.)
                        cnt += 1
                else:
                    #print("link %d :"%ilinking,orb.linkStrength[ilinking])
                    for i in range(9):
                        linkStrength[cnt] = c_double(
                            orb.linkStrength[ilinking][i])
                        if abs(orb.linkStrength[ilinking]
                               [i]) > 1e-6 and i >= 3:
                            ignoreNonDiagonalJ = 0
                        cnt += 1
        ignoreNonDiagonalJ = c_int(ignoreNonDiagonalJ)
        # linking info.
        linkData = (c_int * (self.totOrbs * maxNLinking))()

        #-------------------------------------------------------------------------------#
        # linking info. for renormalized lattice
        # count total sites in shrinked lat.
        totOrb_rnorm = 0
        for orb in self.lattice:
            if orb.chosen:
                totOrb_rnorm += 1
                norbInCluster = len(orb.orb_cluster)
        #print("total %d orbs in renormalized lattice"%totOrb_rnorm)
        rOrb = (c_int * totOrb_rnorm)()  # store id of renormalized orbs
        rOrbCluster = (c_int * (totOrb_rnorm * norbInCluster)
                       )()  # store id of renormalized orbs in cluster
        cnt = 0
        for orb in self.lattice:
            if orb.chosen:
                rOrb[cnt] = orb.id
                cnt += 1

        cnt = 0
        #print("checking while preparing info.>>>>")
        for orb in self.lattice:
            if orb.chosen:
                #print("orb%d is chosen"%orb.id)
                for orbInCluster in orb.orb_cluster:
                    rOrbCluster[cnt] = orbInCluster.id
                    #print("    orb%d"%orbInCluster.id)
                    cnt += 1
        #print("<<<<")

        linkData_rnorm = (
            c_int * (totOrb_rnorm * maxNLinking))()  # store their link info
        cnt = 0
        for orb in self.lattice:
            if orb.chosen:
                for iorb in range(maxNLinking):
                    linkData_rnorm[cnt] = c_int(
                        orb.linkedOrb_rnorm[iorb].id) if iorb < len(
                            orb.linkedOrb_rnorm) else c_int(-1)
                    #print("orb%d ~ orb%d, linkeData_rnorm[%d]= %d"%(orb.id,orb.linkedOrb_rnorm[iorb].id,cnt,linkData_rnorm[cnt]))
                    cnt += 1
        #for cnt in range(totOrb_rnorm*maxNLinking):
        #    print(linkData_rnorm[cnt])
        #-------------------------------------------------------------------------------#

        # field
        h = c_double(self.h)

        cnt = 0
        for iorb, orb in enumerate(self.lattice):
            for ilinking in range(maxNLinking):
                if ilinking >= nlinking_list[iorb]:
                    linkData[cnt] = -1
                    cnt += 1
                else:
                    linkData[cnt] = orb.linkedOrb[ilinking].id
                    cnt += 1

        maxNLinking_ = c_int(maxNLinking)

        # correlated info.
        nLat = len(self.correlatedOrbitalPair)
        corrOrbitalPair = (c_int * (nLat * 2))()
        for ipair, pair in enumerate(self.correlatedOrbitalPair):
            corrOrbitalPair[ipair * 2] = pair[0]
            corrOrbitalPair[ipair * 2 + 1] = pair[1]
            #print(pair[0],pair[1])

        # orb group
        nOrbGroup = len(self.orbGroup)
        maxOrbGroupSize = 1
        if nOrbGroup > 0:
            maxOrbGroupSize = len(self.orbGroup[0])
        if nOrbGroup > 1:
            maxOrbGroupSize = np.max(
                [len(subGroup) for subGroup in self.orbGroup])
        orbGroupList = (c_int * (nOrbGroup * maxOrbGroupSize))()
        cnt = 0
        for subGroup in self.orbGroup:
            for iorb in range(maxOrbGroupSize):
                if iorb < len(subGroup):
                    orbGroupList[cnt] = subGroup[iorb].id
                else:
                    orbGroupList[cnt] = -1
                cnt += 1
        nOrbGroup = c_int(nOrbGroup)
        maxOrbGroupSize = c_int(maxOrbGroupSize)

        flunc_ = c_double(flunc)

        if win.libPool[1] != None:
            dll_path = win.libPool[1] if On == 2 else win.libPool[2]
        else:
            dll_name = "xylib.so" if On == 2 else "heisenberglib.so"
            if getattr(sys, 'frozen', False):
                application_path = os.path.dirname(sys.executable)
            elif __file__:
                application_path = os.path.dirname(__file__)
            dll_path = os.path.join(application_path, dll_name)
        print('loading dynamic library in %s' % (dll_path))
        #print(os.listdir(application_path))
        #exit()

        mylib = CDLL(dll_path)

        spinFrame = c_int(int(self.spinFrame))

        updateAlgorithm = 0  # default Metropolis algorithm
        if algo == 'Wolff': updateAlgorithm = 1
        updateAlgorithm = c_int(updateAlgorithm)

        cMC = mylib.MCMainFunction
        cMC.restype = py_object
        data = cMC(updateAlgorithm, self.totOrbs, initSpin, initD, nthermal,
                   nsweep, maxNLinking_, nlinking, linkStrength, linkData,
                   ninterval, nLat, corrOrbitalPair, nOrbGroup,
                   maxOrbGroupSize, orbGroupList, flunc_, h, totOrb_rnorm,
                   norbInCluster, rOrb, rOrbCluster, linkData_rnorm, spinFrame,
                   ignoreNonDiagonalJ)
        spin_i_x, spin_i_y, spin_i_z, spin_j_x, spin_j_y, spin_j_z, spin_ij, autoCorr, E, E2, U4, spin_i_r_x, spin_i_r_y, spin_i_r_z, spin_j_r_x, spin_j_r_y, spin_j_r_z, spin_ij_r, E_r, E2_r, spin_i_tot_z, spin_j_tot_z, spin_tot_z, spin_i_h, spin_j_h, spin_tot_h, spinDistributionList, spinDotSpinBetweenGroups = data
        E *= self.T
        E2 *= self.T**2
        E_r *= self.T
        E2_r *= self.T**2  # recover the real energies
        C = E2 - E * E
        C_r = E2_r - E_r * E_r
        spin_i = np.array([spin_i_x, spin_i_y, spin_i_z])
        spin_j = np.array([spin_j_x, spin_j_y, spin_j_z])
        spin_i_len = np.sqrt(np.dot(spin_i, spin_i))
        spin_j_len = np.sqrt(np.dot(spin_j, spin_j))
        spin_i_r = np.array([spin_i_r_x, spin_i_r_y, spin_i_r_z])
        spin_j_r = np.array([spin_j_r_x, spin_j_r_y, spin_j_r_z])
        #      T       <i><j>     <ij>      <autoCorr>      <E>      <E2>      <U4>      <E_r>      <E2_r>  C  C_v
        print(
            '%.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.6f %.3f %.3f %.3f %.3f %.3f %.3f %.3f'
            % (self.T, self.h, spin_i_tot_z, spin_j_tot_z, spin_tot_z,
               spin_i_h, spin_j_h, spin_tot_h, spin_i_len, spin_j_len, spin_ij,
               np.dot(spin_i, spin_j), E, E2, U4, spin_ij_r,
               np.dot(spin_i_r, spin_j_r), E_r, E2_r))
        with open('./out', 'a') as fout:
            fout.write(
                '%.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.6f %.3f %.3f %.3f %.3f %.3f %.3f %.3f\n'
                % (self.T, self.h, spin_i_tot_z, spin_j_tot_z, spin_tot_z,
                   spin_i_h, spin_j_h, spin_tot_h, spin_i_len, spin_j_len,
                   spin_ij, np.dot(spin_i, spin_j), E, E2, U4, spin_ij_r,
                   np.dot(spin_i_r, spin_j_r), E_r, E2_r))
        if self.spinFrame == nsweep:
            self.outputSpinWaveSpetra(spinDistributionList)

        if self.spinFrame > 0:
            self.outputSpinDistributionForOn(spinDistributionList)

        if len(self.orbGroup) > 0:
            self.outputSpinGroup(spinDotSpinBetweenGroups)
        return spin_i, spin_j, spin_ij, autoCorr, E, E2, U4
 def Plan(self, sx, sy, sphi, ex, ey, ephi, XYbounds):
     return lib.Plan(self.planner, self.obstacles, self.result, c_double(sx),
                     c_double(sy), c_double(sphi), c_double(ex), c_double(ey), c_double(ephi), POINTER(c_double)(XYbounds))
Exemple #41
0
def train(arg1, arg2=None, arg3=None):
    """
	train(y, x [, options]) -> model | ACC

	y: a list/tuple/ndarray of l true labels (type must be int/double).

	x: 1. a list/tuple of l training instances. Feature vector of
	      each training instance is a list/tuple or dictionary.

	   2. an l * n numpy ndarray or scipy spmatrix (n: number of features).

	train(prob [, options]) -> model | ACC
	train(prob, param) -> model | ACC

	Train a model from data (y, x) or a problem prob using
	'options' or a parameter param.

	If '-v' is specified in 'options' (i.e., cross validation)
	either accuracy (ACC) or mean-squared error (MSE) is returned.

	options:
		-s type : set type of solver (default 1)
		  for multi-class classification
			 0 -- L2-regularized logistic regression (primal)
			 1 -- L2-regularized L2-loss support vector classification (dual)
			 2 -- L2-regularized L2-loss support vector classification (primal)
			 3 -- L2-regularized L1-loss support vector classification (dual)
			 4 -- support vector classification by Crammer and Singer
			 5 -- L1-regularized L2-loss support vector classification
			 6 -- L1-regularized logistic regression
			 7 -- L2-regularized logistic regression (dual)
		  for regression
			11 -- L2-regularized L2-loss support vector regression (primal)
			12 -- L2-regularized L2-loss support vector regression (dual)
			13 -- L2-regularized L1-loss support vector regression (dual)
		-c cost : set the parameter C (default 1)
		-p epsilon : set the epsilon in loss function of SVR (default 0.1)
		-e epsilon : set tolerance of termination criterion
			-s 0 and 2
				|f'(w)|_2 <= eps*min(pos,neg)/l*|f'(w0)|_2,
				where f is the primal function, (default 0.01)
			-s 11
				|f'(w)|_2 <= eps*|f'(w0)|_2 (default 0.001)
			-s 1, 3, 4, and 7
				Dual maximal violation <= eps; similar to liblinear (default 0.)
			-s 5 and 6
				|f'(w)|_inf <= eps*min(pos,neg)/l*|f'(w0)|_inf,
				where f is the primal function (default 0.01)
			-s 12 and 13
				|f'(alpha)|_1 <= eps |f'(alpha0)|,
				where f is the dual function (default 0.1)
		-B bias : if bias >= 0, instance x becomes [x; bias]; if < 0, no bias term added (default -1)
		-wi weight: weights adjust the parameter C of different classes (see README for details)
		-v n: n-fold cross validation mode
		-q : quiet mode (no outputs)
	"""
    prob, param = None, None
    if isinstance(arg1,
                  (list, tuple)) or (scipy
                                     and isinstance(arg1, scipy.ndarray)):
        assert isinstance(arg2, (list, tuple)) or (scipy and isinstance(
            arg2, (scipy.ndarray, sparse.spmatrix)))
        y, x, options = arg1, arg2, arg3
        prob = problem(y, x)
        param = parameter(options)
    elif isinstance(arg1, problem):
        prob = arg1
        if isinstance(arg2, parameter):
            param = arg2
        else:
            param = parameter(arg2)
    if prob == None or param == None:
        raise TypeError("Wrong types for the arguments")

    prob.set_bias(param.bias)
    liblinear.set_print_string_function(param.print_func)
    err_msg = liblinear.check_parameter(prob, param)
    if err_msg:
        raise ValueError('Error: %s' % err_msg)

    if param.flag_find_C:
        nr_fold = param.nr_fold
        best_C = c_double()
        best_rate = c_double()
        max_C = 1024
        if param.flag_C_specified:
            start_C = param.C
        else:
            start_C = -1.0
        liblinear.find_parameter_C(prob, param, nr_fold, start_C, max_C,
                                   best_C, best_rate)
        print("Best C = %lf  CV accuracy = %g%%\n" %
              (best_C.value, 100.0 * best_rate.value))
        return best_C.value, best_rate.value

    elif param.flag_cross_validation:
        l, nr_fold = prob.l, param.nr_fold
        target = (c_double * l)()
        liblinear.cross_validation(prob, param, nr_fold, target)
        ACC, MSE, SCC = evaluations(prob.y[:l], target[:l])
        if param.solver_type in [
                L2R_L2LOSS_SVR, L2R_L2LOSS_SVR_DUAL, L2R_L1LOSS_SVR_DUAL
        ]:
            print("Cross Validation Mean squared error = %g" % MSE)
            print("Cross Validation Squared correlation coefficient = %g" %
                  SCC)
            return MSE
        else:
            print("Cross Validation Accuracy = %g%%" % ACC)
            return ACC
    else:
        m = liblinear.train(prob, param)
        m = toPyModel(m)

        return m
Exemple #42
0
    def mainLoopViaCLib(self,
                        nsweep=1000,
                        nthermal=500,
                        ninterval=-1,
                        algo='Wolff'):
        self.nsweep = nsweep
        self.nthermal = nthermal
        ninterval = self.totOrbs if ninterval <= 0 else ninterval

        # initial spin
        initSpin = (c_double * self.totOrbs)()
        nlinking = (c_int * self.totOrbs)()
        nlinking_list = []
        for iorb, orb in enumerate(self.lattice):
            initSpin[iorb] = c_double(orb.spin)
            nlinking[iorb] = c_int(len(orb.linkedOrb))
            nlinking_list.append(len(orb.linkedOrb))

        # link strength
        maxNLinking = np.max(nlinking_list)
        #nlinking=len(orb.linkedOrb)
        linkStrength = (c_double * (self.totOrbs * maxNLinking))()
        #linkStrength_rnorm=(c_double*(self.totOrbs*maxNLinking))() # linking for renormalization
        cnt = 0
        for iorb, orb in enumerate(self.lattice):
            for ilinking in range(maxNLinking):
                if ilinking >= nlinking_list[iorb]:
                    linkStrength[cnt] = c_double(0.)
                    #linkStrength_rnorm[cnt]=c_double(0.)
                    cnt += 1
                else:
                    linkStrength[cnt] = c_double(orb.linkStrength[ilinking])
                    #linkStrength_rnorm[cnt]==c_double(orb.linkStrength[ilinking]) if orb.chosen else c_double(0.)
                    cnt += 1
        #for istrength, strength in enumerate(orb.linkStrength):
        #    linkStrength[istrength]=c_double(strength)

        # linking info.
        linkData = (c_int * (self.totOrbs * maxNLinking))()
        cnt = 0
        for orb in self.lattice:
            for iorb in range(maxNLinking):  #orb.linkedOrb:
                linkData[cnt] = orb.linkedOrb[iorb].id if iorb < len(
                    orb.linkedOrb) else -1
                cnt += 1

        #-------------------------------------------------------------------------------#
        # linking info. for renormalized lattice
        # count total sites in shrinked lat.
        totOrb_rnorm = 0
        norbInCluster = -1
        for orb in self.lattice:
            if orb.chosen:
                totOrb_rnorm += 1
                norbInCluster = len(orb.orb_cluster)
        #print("total %d orbs in renormalized lattice"%totOrb_rnorm)
        rOrb = (c_int * totOrb_rnorm)()  # store id of renormalized orb cores
        rOrbCluster = (c_int * (totOrb_rnorm * norbInCluster)
                       )()  # store id of renormalized orbs in cluster
        cnt = 0
        for orb in self.lattice:
            if orb.chosen:
                rOrb[cnt] = orb.id
                cnt += 1
        cnt = 0
        #print("checking while preparing info.>>>>")
        for orb in self.lattice:
            if orb.chosen:
                #print("orb%d is chosen"%orb.id)
                for orbInCluster in orb.orb_cluster:
                    rOrbCluster[cnt] = orbInCluster.id
                    #print("    orb%d"%orbInCluster.id)
                    cnt += 1
        #print("<<<<")

        linkData_rnorm = (
            c_int * (totOrb_rnorm * maxNLinking))()  # store their link info
        cnt = 0
        for orb in self.lattice:
            if orb.chosen:
                for iorb in range(maxNLinking):
                    linkData_rnorm[cnt] = c_int(
                        orb.linkedOrb_rnorm[iorb].id) if iorb < len(
                            orb.linkedOrb_rnorm) else c_int(-1)
                    #print("orb%d ~ orb%d, linkeData_rnorm[%d]= %d"%(orb.id,orb.linkedOrb_rnorm[iorb].id,cnt,linkData_rnorm[cnt]))
                    cnt += 1
        #for cnt in range(totOrb_rnorm*maxNLinking):
        #    print(linkData_rnorm[cnt])
        #-------------------------------------------------------------------------------#
        maxNLinking = c_int(maxNLinking)

        # field info.
        h = c_double(self.h)
        # correlated info.
        nLat = len(self.correlatedOrbitalPair)
        corrOrbitalPair = (c_int * (nLat * 2))()
        for ipair, pair in enumerate(self.correlatedOrbitalPair):
            corrOrbitalPair[ipair * 2] = pair[0]
            corrOrbitalPair[ipair * 2 + 1] = pair[1]

        # renormalization calc. switch
        renormOn = c_int(0) if self.dipoleCorrection else c_int(1)

        # num. of returned spin frame
        spinFrame = c_int(int(self.spinFrame))

        if win.libPool[0] != None:
            dll_path = win.libPool[0]
        else:
            dll_name = "isinglib.so"
            if getattr(sys, 'frozen', False):
                application_path = os.path.dirname(sys.executable)
            elif __file__:
                application_path = os.path.dirname(__file__)
            dll_path = os.path.join(application_path, dll_name)
            print('loading dynamic library in %s' % (dll_path))

        mylib = CDLL(dll_path)
        cMC = mylib.localUpdateMC  # default Ising solver
        if algo == 'Wolff':  # Other choices
            if abs(self.h) > 1e-5:
                print(
                    "WARNING: external field has not been developed in Wolff algorithm (not effiecient), now the job continues but field is skipped, please switch to Metropolis algorithm to include field effects"
                )
            cMC = mylib.blockUpdateMC
        # uncode returned Data
        cMC.restype = py_object
        data = cMC(self.totOrbs, initSpin, nthermal, nsweep, maxNLinking,
                   nlinking, linkStrength, linkData, ninterval, nLat,
                   corrOrbitalPair, h, renormOn, totOrb_rnorm, norbInCluster,
                   rOrb, rOrbCluster, linkData_rnorm, spinFrame)
        #print('data has been returned successfully, dim=%d'%len(data))
        spin_i, spin_j, spin_ij, autoCorr, E, E2, E_rnorm, E2_rnorm, U4, spin_tot, spinDistributionList = data
        E *= self.T
        E2 *= self.T**2
        E_rnorm *= self.T
        E2_rnorm *= self.T**2  # recover the real energies
        print(
            "%.3f %.3f %.3f %.3f %.3f %.3f %.6f %.3f %.3f %.3f %.3f %.6f %.6f %.6f"
            % (self.T, self.h, spin_i, spin_j, spin_tot, spin_ij, autoCorr, E,
               E2, E_rnorm, E2_rnorm, E2 - E**2, E2_rnorm - E_rnorm**2, U4))
        with open('./out', 'a') as fout:
            fout.write(
                "%.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.6f\n" %
                (self.T, self.h, spin_i, spin_j, spin_tot, spin_ij, E, E2,
                 E_rnorm, E2_rnorm, U4))
        if self.spinFrame > 0:
            self.outputSpinDistributionForIsing(spinDistributionList)
        return spin_i, spin_j, spin_ij, autoCorr, E, E2, U4
Exemple #43
0
 def Set_FPar_Double(self, Index, Value):
     '''Set_FPar_Double sets a global double variable to a specified value.'''
     _val = ctypes.c_double(Value)
     self.dll.e_Set_ADBFPar_Double(Index, _val, self.DeviceNo,
                                   self.__errPointer)
     self.__checkError('Set_FPar_Double')
Exemple #44
0
    def write(self,
              byte_array: bytes,
              lsb_tx_first=False,
              lsb_rx_first=False,
              err_clks=0) -> bytes:
        '''write an integer word and return the read back value'''
        sts = c_byte()
        dwf = self.dwf
        hdwf = self.hdwf
        byte_count = len(byte_array)
        #maximum effective byte length is 63
        #(1024 samples/2 = 512 bits = 64 bytes
        #2 samples consumed => 63 bytes (12 words)
        assert byte_count <= 63
        bit_count = byte_count * 8 + err_clks
        sample_count = bit_count * 2 + 2  #sample at clock freq to cater for cpha
        assert sample_count < self.max_output_samples, \
                "Attempted write would exceed the output buffer length"
        #logger.info('bit_count: {}'.format(bit_count))
        # serialization time length
        logger.debug("Bit count: {}".format(bit_count))
        #runset = (bit_count+0.5*self.CPHA)*self.bit_period
        #add just slightly less than a half a bit so we don't get an extra
        #active clock edge but still allow enough time before CS going high
        runset = (bit_count + 0.49) * self.bit_period
        logger.debug("Runset: {}".format(runset))
        dwf.FDwfDigitalOutRunSet(hdwf, c_double(runset))
        #read_back_runset = c_double()
        #dwf.FDwfDigitalOutRunGet(hdwf, byref(read_back_runset))
        #print("Read back run set: {}".format(read_back_runset.value))

        # set number of sample to acquire
        dwf.FDwfDigitalInBufferSizeSet(hdwf, sample_count)
        # number of samples after trigger
        dwf.FDwfDigitalInTriggerPositionSet(hdwf, sample_count)

        if lsb_tx_first:
            data = (c_byte * byte_count)(*byte_array)
        else:
            new_bytes = []
            for i, b in enumerate(byte_array):
                new_byte = 0
                for bit_pos in range(8):
                    new_byte |= (
                        (b >> bit_pos) & 1) << (7 - bit_pos)  #reorder bits
                new_bytes.append(new_byte)
            data = (c_byte * byte_count)(*new_bytes)

        #data = bs
        dwf.FDwfDigitalOutDataSet(hdwf, self.pin_cfg.MOSI, byref(data),
                                  bit_count)
        # begin acquisition
        dwf.FDwfDigitalInConfigure(hdwf, 0, 1)  #reconfigure, start acquisition
        #dwf.FDwfDigitalInStatus(hdwf, 1, byref(sts))
        ##logger.info("STS VAL: {}".format(sts.value))
        #assert sts.value == stsArm.value

        dwf.FDwfDigitalOutConfigure(hdwf, 1)

        while True:
            dwf.FDwfDigitalInStatus(hdwf, 1, byref(sts))
            #logger.info("STS VAL: {}".format(sts.value))
            if sts.value == stsDone.value:
                break
            time.sleep(0.001)
        #logger.info("Acquisition finished")

        # get samples, byte size
        rgwSamples = (c_uint16 * sample_count)()
        dwf.FDwfDigitalInStatusData(hdwf, byref(rgwSamples), 2 * sample_count)

        byte_array = bytearray()

        b = 0
        logger.debug("Number of samples collected: {}".format(len(rgwSamples)))
        for i, sample in enumerate(rgwSamples):
            rx_bit = (sample >> self.pin_cfg.MISO) & 1
            logger.debug("Sample {:2}: {:2}, mosi: {}, miso: {}".format(
                i, sample, (sample >> self.pin_cfg.MOSI) & 1, rx_bit))

        Slice = rgwSamples[:bit_count * 2:2]
        for i, sample in enumerate(Slice):
            i_mod_8 = i % 8
            if i_mod_8 == 0 and i != 0:  #new byte is ready
                byte_array.append(b)
                b = 0
            rx_bit = (sample >> self.pin_cfg.MISO) & 1
            if lsb_rx_first:
                b |= rx_bit << i_mod_8
            else:
                b <<= 1
                b |= rx_bit
        #    logger.info("Sample {:2}: {:2}, mosi: {}, miso: {}".format(i, sample,
        #        (sample>>self.pin_cfg.MOSI)&1,
        #        rx_bit))
        byte_array.append(b)
        #logger.info("Returning: {}".format(byte_array))
        return byte_array
Exemple #45
0
syncDivider = 4 # you can change this, observe mode! READ MANUAL!
CFDZeroCross0 = 10 # you can change this (in mV)
CFDLevel0 = 50 # you can change this (in mV)
CFDZeroCross1 = 10 # you can change this (in mV)
CFDLevel1 = 150 # you can change this (in mV)

# Variables to store information read from DLLs
buffer = (ctypes.c_uint * TTREADMAX)()
dev = []
libVersion = ctypes.create_string_buffer(b"", 8)
hwSerial = ctypes.create_string_buffer(b"", 8)
hwPartno = ctypes.create_string_buffer(b"", 8)
hwVersion = ctypes.create_string_buffer(b"", 8)
hwModel = ctypes.create_string_buffer(b"", 16)
errorString = ctypes.create_string_buffer(b"", 40)
resolution = ctypes.c_double()
countRate0 = ctypes.c_int()
countRate1 = ctypes.c_int()
flags = ctypes.c_int()
nactual = ctypes.c_int()
ctcDone = ctypes.c_int()
warnings = ctypes.c_int()
warningstext = ctypes.create_string_buffer(b"", 16384)

phlib = ctypes.CDLL("phlib64.dll")

def closeDevices():
    for i in range(0, MAXDEVNUM):
        phlib.PH_CloseDevice(ctypes.c_int(i))
    exit(0)
Exemple #46
0
def geos_linearring_from_py(ob, update_geom=None, update_ndim=0):
    try:
        # From array protocol
        array = ob.__array_interface__
        assert len(array['shape']) == 2
        m = array['shape'][0]
        n = array['shape'][1]
        if m < 3:
            raise ValueError(
                "A LinearRing must have at least 3 coordinate tuples")
        assert n == 2 or n == 3

        # Make pointer to the coordinate array
        try:
            cp = cast(array['data'][0], POINTER(c_double))
        except ArgumentError:
            cp = array['data']

        # Add closing coordinates to sequence?
        if cp[0] != cp[m * n - n] or cp[1] != cp[m * n - n + 1]:
            M = m + 1
        else:
            M = m

        # Create a coordinate sequence
        if update_geom is not None:
            cs = lgeos.GEOSGeom_getCoordSeq(update_geom)
            if n != update_ndim:
                raise ValueError(
                "Wrong coordinate dimensions; this geometry has dimensions: %d" \
                % update_ndim)
        else:
            cs = lgeos.GEOSCoordSeq_create(M, n)

        # add to coordinate sequence
        for i in xrange(m):
            dx = c_double(cp[n * i])
            dy = c_double(cp[n * i + 1])
            dz = None
            if n == 3:
                dz = c_double(cp[n * i + 2])

            # Because of a bug in the GEOS C API,
            # always set X before Y
            lgeos.GEOSCoordSeq_setX(cs, i, dx)
            lgeos.GEOSCoordSeq_setY(cs, i, dy)
            if n == 3:
                lgeos.GEOSCoordSeq_setZ(cs, i, dz)

        # Add closing coordinates to sequence?
        if M > m:
            dx = c_double(cp[0])
            dy = c_double(cp[1])
            dz = None
            if n == 3:
                dz = c_double(cp[2])

            # Because of a bug in the GEOS C API,
            # always set X before Y
            lgeos.GEOSCoordSeq_setX(cs, M - 1, dx)
            lgeos.GEOSCoordSeq_setY(cs, M - 1, dy)
            if n == 3:
                lgeos.GEOSCoordSeq_setZ(cs, M - 1, dz)

    except AttributeError:
        # Fall back on list
        m = len(ob)
        n = len(ob[0])
        if m < 3:
            raise ValueError(
                "A LinearRing must have at least 3 coordinate tuples")
        assert (n == 2 or n == 3)

        # Add closing coordinates if not provided
        if m == 3 or ob[0][0] != ob[-1][0] or ob[0][1] != ob[-1][1]:
            M = m + 1
        else:
            M = m

        # Create a coordinate sequence
        if update_geom is not None:
            cs = lgeos.GEOSGeom_getCoordSeq(update_geom)
            if n != update_ndim:
                raise ValueError(
                "Wrong coordinate dimensions; this geometry has dimensions: %d" \
                % update_ndim)
        else:
            cs = lgeos.GEOSCoordSeq_create(M, n)

        # add to coordinate sequence
        for i in xrange(m):
            coords = ob[i]
            dx = c_double(coords[0])
            dy = c_double(coords[1])
            dz = None
            if n == 3:
                dz = c_double(coords[2])

            # Because of a bug in the GEOS C API,
            # always set X before Y
            lgeos.GEOSCoordSeq_setX(cs, i, dx)
            lgeos.GEOSCoordSeq_setY(cs, i, dy)
            if n == 3:
                lgeos.GEOSCoordSeq_setZ(cs, i, dz)

        # Add closing coordinates to sequence?
        if M > m:
            coords = ob[0]
            dx = c_double(coords[0])
            dy = c_double(coords[1])
            dz = None
            if n == 3:
                dz = c_double(coords[2])

            # Because of a bug in the GEOS C API,
            # always set X before Y
            lgeos.GEOSCoordSeq_setX(cs, M - 1, dx)
            lgeos.GEOSCoordSeq_setY(cs, M - 1, dy)
            if n == 3:
                lgeos.GEOSCoordSeq_setZ(cs, M - 1, dz)

    if update_geom is not None:
        return None
    else:
        return lgeos.GEOSGeom_createLinearRing(cs), n
Exemple #47
0
    def read_segment(self, import_neuroshare_segment=True, lazy=False):
        """
        Arguments:
            import_neuroshare_segment: import neuroshare segment as SpikeTrain
            with associated waveforms or not imported at all.
        """
        assert not lazy, 'Do not support lazy'

        seg = Segment(file_origin=os.path.basename(self.filename), )

        if sys.platform.startswith('win'):
            neuroshare = ctypes.windll.LoadLibrary(self.dllname)
        elif sys.platform.startswith('linux'):
            neuroshare = ctypes.cdll.LoadLibrary(self.dllname)
        neuroshare = DllWithError(neuroshare)

        # elif sys.platform.startswith('darwin'):

        # API version
        info = ns_LIBRARYINFO()
        neuroshare.ns_GetLibraryInfo(ctypes.byref(info), ctypes.sizeof(info))
        seg.annotate(neuroshare_version=str(info.dwAPIVersionMaj) + '.' +
                     str(info.dwAPIVersionMin))

        # open file
        hFile = ctypes.c_uint32(0)
        neuroshare.ns_OpenFile(ctypes.c_char_p(self.filename),
                               ctypes.byref(hFile))
        fileinfo = ns_FILEINFO()
        neuroshare.ns_GetFileInfo(hFile, ctypes.byref(fileinfo),
                                  ctypes.sizeof(fileinfo))

        # read all entities
        for dwEntityID in range(fileinfo.dwEntityCount):
            entityInfo = ns_ENTITYINFO()
            neuroshare.ns_GetEntityInfo(hFile, dwEntityID,
                                        ctypes.byref(entityInfo),
                                        ctypes.sizeof(entityInfo))

            # EVENT
            if entity_types[entityInfo.dwEntityType] == 'ns_ENTITY_EVENT':
                pEventInfo = ns_EVENTINFO()
                neuroshare.ns_GetEventInfo(hFile, dwEntityID,
                                           ctypes.byref(pEventInfo),
                                           ctypes.sizeof(pEventInfo))

                if pEventInfo.dwEventType == 0:  # TEXT
                    pData = ctypes.create_string_buffer(
                        pEventInfo.dwMaxDataLength)
                elif pEventInfo.dwEventType == 1:  # CVS
                    pData = ctypes.create_string_buffer(
                        pEventInfo.dwMaxDataLength)
                elif pEventInfo.dwEventType == 2:  # 8bit
                    pData = ctypes.c_byte(0)
                elif pEventInfo.dwEventType == 3:  # 16bit
                    pData = ctypes.c_int16(0)
                elif pEventInfo.dwEventType == 4:  # 32bit
                    pData = ctypes.c_int32(0)
                pdTimeStamp = ctypes.c_double(0.)
                pdwDataRetSize = ctypes.c_uint32(0)

                ea = Event(name=str(entityInfo.szEntityLabel), )

                times = []
                labels = []
                for dwIndex in range(entityInfo.dwItemCount):
                    neuroshare.ns_GetEventData(hFile, dwEntityID, dwIndex,
                                               ctypes.byref(pdTimeStamp),
                                               ctypes.byref(pData),
                                               ctypes.sizeof(pData),
                                               ctypes.byref(pdwDataRetSize))
                    times.append(pdTimeStamp.value)
                    labels.append(str(pData.value))
                ea.times = times * pq.s
                ea.labels = np.array(labels, dtype='U')

                seg.events.append(ea)

            # analog
            if entity_types[entityInfo.dwEntityType] == 'ns_ENTITY_ANALOG':
                pAnalogInfo = ns_ANALOGINFO()

                neuroshare.ns_GetAnalogInfo(hFile, dwEntityID,
                                            ctypes.byref(pAnalogInfo),
                                            ctypes.sizeof(pAnalogInfo))
                dwIndexCount = entityInfo.dwItemCount

                pdwContCount = ctypes.c_uint32(0)
                pData = np.zeros((entityInfo.dwItemCount, ), dtype='float64')
                total_read = 0
                while total_read < entityInfo.dwItemCount:
                    dwStartIndex = ctypes.c_uint32(total_read)
                    dwStopIndex = ctypes.c_uint32(entityInfo.dwItemCount -
                                                  total_read)

                    neuroshare.ns_GetAnalogData(
                        hFile, dwEntityID, dwStartIndex, dwStopIndex,
                        ctypes.byref(pdwContCount),
                        pData[total_read:].ctypes.data_as(
                            ctypes.POINTER(ctypes.c_double)))
                    total_read += pdwContCount.value

                signal = pq.Quantity(pData,
                                     units=pAnalogInfo.szUnits,
                                     copy=False)

                # t_start
                dwIndex = 0
                pdTime = ctypes.c_double(0)
                neuroshare.ns_GetTimeByIndex(hFile, dwEntityID, dwIndex,
                                             ctypes.byref(pdTime))

                anaSig = AnalogSignal(
                    signal,
                    sampling_rate=pAnalogInfo.dSampleRate * pq.Hz,
                    t_start=pdTime.value * pq.s,
                    name=str(entityInfo.szEntityLabel),
                )
                anaSig.annotate(probe_info=str(pAnalogInfo.szProbeInfo))
                seg.analogsignals.append(anaSig)

            # segment
            if entity_types[
                    entityInfo.
                    dwEntityType] == 'ns_ENTITY_SEGMENT' and import_neuroshare_segment:

                pdwSegmentInfo = ns_SEGMENTINFO()
                if not str(entityInfo.szEntityLabel).startswith('spks'):
                    continue

                neuroshare.ns_GetSegmentInfo(hFile, dwEntityID,
                                             ctypes.byref(pdwSegmentInfo),
                                             ctypes.sizeof(pdwSegmentInfo))
                nsource = pdwSegmentInfo.dwSourceCount

                pszMsgBuffer = ctypes.create_string_buffer(" " * 256)
                neuroshare.ns_GetLastErrorMsg(ctypes.byref(pszMsgBuffer), 256)

                for dwSourceID in range(pdwSegmentInfo.dwSourceCount):
                    pSourceInfo = ns_SEGSOURCEINFO()
                    neuroshare.ns_GetSegmentSourceInfo(
                        hFile, dwEntityID, dwSourceID,
                        ctypes.byref(pSourceInfo), ctypes.sizeof(pSourceInfo))

                pdTimeStamp = ctypes.c_double(0.)
                dwDataBufferSize = pdwSegmentInfo.dwMaxSampleCount * pdwSegmentInfo.dwSourceCount
                pData = np.zeros((dwDataBufferSize), dtype='float64')
                pdwSampleCount = ctypes.c_uint32(0)
                pdwUnitID = ctypes.c_uint32(0)

                nsample = int(dwDataBufferSize)
                times = np.empty((entityInfo.dwItemCount), dtype='f')
                waveforms = np.empty(
                    (entityInfo.dwItemCount, nsource, nsample), dtype='f')
                for dwIndex in range(entityInfo.dwItemCount):
                    neuroshare.ns_GetSegmentData(
                        hFile, dwEntityID, dwIndex, ctypes.byref(pdTimeStamp),
                        pData.ctypes.data_as(ctypes.POINTER(ctypes.c_double)),
                        dwDataBufferSize * 8, ctypes.byref(pdwSampleCount),
                        ctypes.byref(pdwUnitID))

                    times[dwIndex] = pdTimeStamp.value
                    waveforms[dwIndex, :, :] = pData[:nsample *
                                                     nsource].reshape(
                                                         nsample,
                                                         nsource).transpose()

                sptr = SpikeTrain(
                    times=pq.Quantity(times, units='s', copy=False),
                    t_stop=times.max(),
                    waveforms=pq.Quantity(waveforms,
                                          units=str(pdwSegmentInfo.szUnits),
                                          copy=False),
                    left_sweep=nsample / 2. /
                    float(pdwSegmentInfo.dSampleRate) * pq.s,
                    sampling_rate=float(pdwSegmentInfo.dSampleRate) * pq.Hz,
                    name=str(entityInfo.szEntityLabel),
                )
                seg.spiketrains.append(sptr)

            # neuralevent
            if entity_types[
                    entityInfo.dwEntityType] == 'ns_ENTITY_NEURALEVENT':
                pNeuralInfo = ns_NEURALINFO()
                neuroshare.ns_GetNeuralInfo(hFile, dwEntityID,
                                            ctypes.byref(pNeuralInfo),
                                            ctypes.sizeof(pNeuralInfo))

                pData = np.zeros((entityInfo.dwItemCount, ), dtype='float64')
                dwStartIndex = 0
                dwIndexCount = entityInfo.dwItemCount
                neuroshare.ns_GetNeuralData(
                    hFile, dwEntityID, dwStartIndex, dwIndexCount,
                    pData.ctypes.data_as(ctypes.POINTER(ctypes.c_double)))
                times = pData * pq.s
                t_stop = times.max()

                sptr = SpikeTrain(
                    times,
                    t_stop=t_stop,
                    name=str(entityInfo.szEntityLabel),
                )
                seg.spiketrains.append(sptr)

        # close
        neuroshare.ns_CloseFile(hFile)

        seg.create_many_to_one_relationship()
        return seg
Exemple #48
0
    def _prepare_args(self, ty, val, stream, retr, kernelargs):
        """
        Convert arguments to ctypes and append to kernelargs
        """

        # map the arguments using any extension you've registered
        for extension in reversed(self.extensions):
            ty, val = extension.prepare_args(
                ty,
                val,
                stream=stream,
                retr=retr)

        if isinstance(ty, types.Array):
            devary = wrap_arg(val).to_device(retr, stream)

            c_intp = ctypes.c_ssize_t

            meminfo = ctypes.c_void_p(0)
            parent = ctypes.c_void_p(0)
            nitems = c_intp(devary.size)
            itemsize = c_intp(devary.dtype.itemsize)

            ptr = driver.device_pointer(devary)

            if driver.USE_NV_BINDING:
                ptr = int(ptr)

            data = ctypes.c_void_p(ptr)

            kernelargs.append(meminfo)
            kernelargs.append(parent)
            kernelargs.append(nitems)
            kernelargs.append(itemsize)
            kernelargs.append(data)
            for ax in range(devary.ndim):
                kernelargs.append(c_intp(devary.shape[ax]))
            for ax in range(devary.ndim):
                kernelargs.append(c_intp(devary.strides[ax]))

        elif isinstance(ty, types.Integer):
            cval = getattr(ctypes, "c_%s" % ty)(val)
            kernelargs.append(cval)

        elif ty == types.float64:
            cval = ctypes.c_double(val)
            kernelargs.append(cval)

        elif ty == types.float32:
            cval = ctypes.c_float(val)
            kernelargs.append(cval)

        elif ty == types.boolean:
            cval = ctypes.c_uint8(int(val))
            kernelargs.append(cval)

        elif ty == types.complex64:
            kernelargs.append(ctypes.c_float(val.real))
            kernelargs.append(ctypes.c_float(val.imag))

        elif ty == types.complex128:
            kernelargs.append(ctypes.c_double(val.real))
            kernelargs.append(ctypes.c_double(val.imag))

        elif isinstance(ty, (types.NPDatetime, types.NPTimedelta)):
            kernelargs.append(ctypes.c_int64(val.view(np.int64)))

        elif isinstance(ty, types.Record):
            devrec = wrap_arg(val).to_device(retr, stream)
            ptr = devrec.device_ctypes_pointer
            if driver.USE_NV_BINDING:
                ptr = ctypes.c_void_p(int(ptr))
            kernelargs.append(ptr)

        elif isinstance(ty, types.BaseTuple):
            assert len(ty) == len(val)
            for t, v in zip(ty, val):
                self._prepare_args(t, v, stream, retr, kernelargs)

        else:
            raise NotImplementedError(ty, val)
    def __call__(self, ar):
        # Interpolate the input variable to the new grid using the Gridspec
        # remap file generated when this GS_Remapper object was initialized.
        # >>>for now, ar is required to be a variable (MV) <<<

        #  Here, convert ar into a file for gs_fregrid
        # There's no special Gridspec way to write a variable; you write to any
        # *.nc file.  The tough part is making sure you have there exactly what's
        # needed for the gs_fregrid call, especially because the grids are
        # supposedly supergrids and you just have some keywords to use to figure
        # out what goes where.  And note that we'll need to check whether ar
        # really lives on self.ingrid .  Supposedly a future API will work
        # better in this respect

        # Write the variable to a temporary file, as required by gs_fregrid.
        # The remap path should be suitable.
        # >>> this should be done more carefully, e.g. deal with failures;
        # >>> more worth doing when we have mosaic variables.
        timestr = str(int(time.time()))
        varfile = cdms2.open(self.inpath + "/" + "invvar" + timestr + ".nc",
                             'w')
        varfile.write(ar)
        varfile.close()

        history = "GS_Regridder"
        mosaic_in = self.inpath + "/" + self.infile
        mosaic_out = self.outpath + "/" + self.outfile

        dir_in = 256 * "\x00"  # path is already encoded in input_file
        dir_out = 256 * "\x00"  # path is already encoded in output_file
        input_file = varfile.id + 256 * "\x00"
        nfiles = 1
        output_file = self.outpath + '/' + "outvar" + timestr + ".nc" + 256 * "\x00"
        nfiles_out = 1
        scalar_name = ar.id + 256 * "\x00"
        nscalar = 1
        u_name = 256 * "\x00"
        v_name = 256 * "\x00"
        nvector = 0
        nvector2 = 0

        interp_method = "conserve_order2"
        test_case = None
        test_param = c_double(1.0)
        opcode = c_uint(0)
        AGRID = 64
        grid_type = AGRID
        finer_step = c_uint(0)
        fill_missing = 0
        nlon = 0
        nlat = 0
        check_conserve = 0
        y_at_center = 0
        lonbegin = c_double(0.)
        lonend = c_double(360.)
        latbegin = c_double(-90.)
        latend = c_double(90.)
        lbegin = 0
        lend = -1
        kbegin = 0
        kend = -1

        print "__call__  remapfile=", self.remapfile
        libcf.gs_fregrid(history, mosaic_in, mosaic_out, dir_in, dir_out,
                         input_file, nfiles, output_file, nfiles_out,
                         self.remapfile, scalar_name, nscalar, u_name, nvector,
                         v_name, nvector2, interp_method, test_case,
                         test_param, opcode, grid_type, finer_step,
                         fill_missing, nlon, nlat, check_conserve, y_at_center,
                         lonbegin, lonend, latbegin, latend, kbegin, kend,
                         lbegin, lend)

        # Read the output_file into a variable, and return the variable
        f = cdms2.open(path + "/" + output_file)
        vout = f(scalar_name)
        f.close()
        return vout
Exemple #50
0
    def getCplexStyleArrays(
        self, lp, senseDict=None, LpVarCategories=None, LpObjSenses=None, infBound=1e20
    ):
        """returns the arrays suitable to pass to a cdll Cplex
        or other solvers that are similar

        Copyright (c) Stuart Mitchell 2007
        """
        if senseDict is None:
            senseDict = {
                const.LpConstraintEQ: "E",
                const.LpConstraintLE: "L",
                const.LpConstraintGE: "G",
            }
        if LpVarCategories is None:
            LpVarCategories = {const.LpContinuous: "C", const.LpInteger: "I"}
        if LpObjSenses is None:
            LpObjSenses = {const.LpMaximize: -1, const.LpMinimize: 1}

        import ctypes

        rangeCount = 0
        variables = list(lp.variables())
        numVars = len(variables)
        # associate each variable with a ordinal
        self.v2n = dict(((variables[i], i) for i in range(numVars)))
        self.vname2n = dict(((variables[i].name, i) for i in range(numVars)))
        self.n2v = dict((i, variables[i]) for i in range(numVars))
        # objective values
        objSense = LpObjSenses[lp.sense]
        NumVarDoubleArray = ctypes.c_double * numVars
        objectCoeffs = NumVarDoubleArray()
        # print "Get objective Values"
        for v, val in lp.objective.items():
            objectCoeffs[self.v2n[v]] = val
        # values for variables
        objectConst = ctypes.c_double(0.0)
        NumVarStrArray = ctypes.c_char_p * numVars
        colNames = NumVarStrArray()
        lowerBounds = NumVarDoubleArray()
        upperBounds = NumVarDoubleArray()
        initValues = NumVarDoubleArray()
        for v in lp.variables():
            colNames[self.v2n[v]] = to_string(v.name)
            initValues[self.v2n[v]] = 0.0
            if v.lowBound != None:
                lowerBounds[self.v2n[v]] = v.lowBound
            else:
                lowerBounds[self.v2n[v]] = -infBound
            if v.upBound != None:
                upperBounds[self.v2n[v]] = v.upBound
            else:
                upperBounds[self.v2n[v]] = infBound
        # values for constraints
        numRows = len(lp.constraints)
        NumRowDoubleArray = ctypes.c_double * numRows
        NumRowStrArray = ctypes.c_char_p * numRows
        NumRowCharArray = ctypes.c_char * numRows
        rhsValues = NumRowDoubleArray()
        rangeValues = NumRowDoubleArray()
        rowNames = NumRowStrArray()
        rowType = NumRowCharArray()
        self.c2n = {}
        self.n2c = {}
        i = 0
        for c in lp.constraints:
            rhsValues[i] = -lp.constraints[c].constant
            # for ranged constraints a<= constraint >=b
            rangeValues[i] = 0.0
            rowNames[i] = to_string(c)
            rowType[i] = to_string(senseDict[lp.constraints[c].sense])
            self.c2n[c] = i
            self.n2c[i] = c
            i = i + 1
        # return the coefficient matrix as a series of vectors
        coeffs = lp.coefficients()
        sparseMatrix = sparse.Matrix(list(range(numRows)), list(range(numVars)))
        for var, row, coeff in coeffs:
            sparseMatrix.add(self.c2n[row], self.vname2n[var], coeff)
        (
            numels,
            mystartsBase,
            mylenBase,
            myindBase,
            myelemBase,
        ) = sparseMatrix.col_based_arrays()
        elemBase = ctypesArrayFill(myelemBase, ctypes.c_double)
        indBase = ctypesArrayFill(myindBase, ctypes.c_int)
        startsBase = ctypesArrayFill(mystartsBase, ctypes.c_int)
        lenBase = ctypesArrayFill(mylenBase, ctypes.c_int)
        # MIP Variables
        NumVarCharArray = ctypes.c_char * numVars
        columnType = NumVarCharArray()
        if lp.isMIP():
            for v in lp.variables():
                columnType[self.v2n[v]] = to_string(LpVarCategories[v.cat])
        self.addedVars = numVars
        self.addedRows = numRows
        return (
            numVars,
            numRows,
            numels,
            rangeCount,
            objSense,
            objectCoeffs,
            objectConst,
            rhsValues,
            rangeValues,
            rowType,
            startsBase,
            lenBase,
            indBase,
            elemBase,
            lowerBounds,
            upperBounds,
            initValues,
            colNames,
            rowNames,
            columnType,
            self.n2v,
            self.n2c,
        )
Exemple #51
0
 def test_ctypes_double(self):
     data = ctypes.c_double(1.234)
     sz = driver.host_memory_size(data)
     self.assertTrue(ctypes.sizeof(data) == sz)
    def __init__(self,
                 ingrid,
                 outgrid,
                 infile=None,
                 outfile=None,
                 remapfile=None):
        # Save the grids, make and save a Gridspec remap file.
        # For now, we are using the libCF/Gridspec API which operates only on files;
        # thus temporary files are written out and read back in.  That requires the
        # input grids to support a "write_gridspec" method.
        # If a path is provided, it prefixes whatever filenames were input.
        # If there is no path provided, each filename must include its path.
        # Note: it's a bit messy to keep filenames and paths separate internally,
        # but the presnet Gridspec function expects lots of directories.

        self.ingrid = ingrid
        self.outgrid = outgrid
        if (not hasattr(ingrid, "gsfile")):
            ingrid.gsfile = None
            ingrid.gspath = None
        if (infile == None):
            self.infile = ingrid.gsfile
            self.inpath = ingrid.gspath
        else:
            self.infile = os.path.basename(infile)
            self.inpath = os.path.dirname(infile)
        if (not os.path.isfile(self.inpath + "/" + self.infile)):
            raise OSError, "cannot open infile " + self.inpath + "/" + self.infile

        if (not hasattr(outgrid, "gsfile")):
            outgrid.gsfile = None
            outgrid.gspath = None
        if (outfile == None):
            self.outfile = outgrid.gsfile
            self.outpath = outgrid.gspath
        else:
            self.outfile = os.path.basename(outfile)
            self.outpath = os.path.dirname(outfile)
        if (not os.path.isfile(self.outpath + "/" + self.outfile)):
            raise OSError, "cannot open outfile " + self.outpath + "/" + self.outfile

        if (remapfile == None):
            timestr = str(int(time.time()))
            self.remapfile = "remap" + timestr
            self.remappath = "/tmp"
        else:
            self.remapfile = os.path.basename(remapfile)
            self.remappath = os.path.dirname(remapfile)
        if (not os.path.isdir(self.remappath + "/")):
            raise OSError, "cannot open remapfile directory " + self.remappath + "/"

        ingrid.write_gridspec(self.inpath + "/" + self.infile)
        outgrid.write_gridspec(self.outpath + "/" + self.outfile)

        history = "GS_Regridder"
        mosaic_in = self.inpath + "/" + self.infile
        mosaic_out = self.outpath + "/" + self.outfile

        # No variables to interpolate; the gs_fregrid call will be just to
        # make a remap file...
        dir_in = 256 * "\x00"
        dir_out = 256 * "\x00"
        input_file = 256 * "\x00"
        nfiles = 0
        output_file = 256 * "\x00"
        nfiles_out = 0
        scalar_name = 256 * "\x00"
        nscalar = 0
        u_name = 256 * "\x00"
        v_name = 256 * "\x00"
        nvector = 0
        nvector2 = 0

        # For a call which only writes the remap files, gs_fregrid
        # expects remapfile to be a full path.  For a call in which
        # remapping takes place, gs_fregrid expects remapfile to be
        # a pure filename, in a path it gets from elsewhere, maybe dir_in.
        # (ARRGH - but with the API slated to be replaced, I'll live with it)
        remapf = os.path.abspath(self.remappath + "/" +
                                 self.remapfile) + "\0" * 256

        interp_method = "conserve_order2"
        test_case = None
        test_param = c_double(1.0)
        opcode = c_uint(0)
        AGRID = 64
        grid_type = AGRID
        finer_step = c_uint(0)
        fill_missing = 0
        nlon = 0
        nlat = 0
        check_conserve = 0
        y_at_center = 0
        lonbegin = c_double(0.)
        lonend = c_double(360.)
        latbegin = c_double(-90.)
        latend = c_double(90.)
        lbegin = 0
        lend = -1
        kbegin = 0
        kend = -1

        libcf.gs_fregrid(history, mosaic_in, mosaic_out, dir_in, dir_out,
                         input_file, nfiles, output_file, nfiles_out, remapf,
                         scalar_name, nscalar, u_name, nvector, v_name,
                         nvector2, interp_method, test_case, test_param,
                         opcode, grid_type, finer_step, fill_missing, nlon,
                         nlat, check_conserve, y_at_center, lonbegin, lonend,
                         latbegin, latend, kbegin, kend, lbegin, lend)
Exemple #53
0
    def sync_parameters(self) -> None:
        """
        Sync parameters sets the configuration of the instrument using the
        parameters specified in the Qcodes instrument.

        Sync parameters consists of five parts
            1. Center span configuration (freqs and span)
            2. Acquisition configuration
                lin-scale/log-scale
                avg/max power
            3. Configuring the external 10MHz reference
            4. Configuration of the mode that is being used
            5. Acquisition mode. At the moment only `sweeping` is implemented

        This does not currently implement Configuration of the tracking
        generator used in VNA mode
        """

        # 1. CenterSpan Configuration
        center = ct.c_double(self.frequency())
        span = ct.c_double(self.span())
        log.info('Setting device CenterSpan configuration.')

        err = self.dll.saConfigCenterSpan(self.deviceHandle, center, span)
        self.check_for_error(err, 'saConfigCenterSpan')

        # 2. Acquisition configuration
        detectorVals = {
            'min-max': ct.c_uint(self.hf.sa_MIN_MAX),
            'average': ct.c_uint(self.hf.sa_AVERAGE)
        }
        scaleVals = {
            'log-scale': ct.c_uint(self.hf.sa_LOG_SCALE),
            'lin-scale': ct.c_uint(self.hf.sa_LIN_SCALE),
            'log-full-scale': ct.c_uint(self.hf.sa_LOG_FULL_SCALE),
            'lin-full-scale': ct.c_uint(self.hf.sa_LIN_FULL_SCALE)
        }
        detector = detectorVals[self.acquisition_mode()]
        scale = scaleVals[self.scale()]

        err = self.dll.saConfigAcquisition(self.deviceHandle, detector, scale)
        self.check_for_error(err, 'saConfigAcquisition')

        # 3. Reference Level configuration
        log.info('Setting device reference level configuration.')
        err = self.dll.saConfigLevel(self.deviceHandle,
                                     ct.c_double(self.ref_lvl()))
        self.check_for_error(err, 'saConfigLevel')

        # 4. External Reference configuration
        if self.external_reference():
            external = self.hf.sa_REF_EXTERNAL_IN
            log.info('Setting reference frequency from external source.')
            err = self.dll.saSetTimebase(self.deviceHandle, external)
            self.check_for_error(err, 'saSetTimebase')

        reject_var = ct.c_bool(self.reject_image())
        log.info('Setting device Sweeping configuration.')
        err = self.dll.saConfigSweepCoupling(self.deviceHandle,
                                             ct.c_double(self.rbw()),
                                             ct.c_double(self.vbw()),
                                             reject_var)
        self.check_for_error(err, 'saConfigSweepCoupling')

        modeOpts = {
            'sweeping': self.hf.sa_SWEEPING,
            'real_time': self.hf.sa_REAL_TIME,  # not implemented
            'IQ': self.hf.sa_IQ,  # not implemented
            'idle': self.hf.sa_IDLE
        }
        mode = modeOpts[self.device_mode()]
        # the third argument to saInitiate is a flag that is
        # currently not used
        err = self.dll.saInitiate(self.deviceHandle, mode, 0)
        if err == saStatus.saInvalidParameterErr:
            extrainfo = """
                 In real-time mode, this value may be returned if the span
                 limits defined in the API header are broken. Also in
                 real-time mode, this error will be returned if the
                 resolution bandwidth is outside the limits defined in
                 the API header.
                 In time-gate analysis mode this error will be returned if
                 span limits defined in the API header are broken. Also in
                 time gate analysis, this error is returned if the
                 bandwidth provided require more samples for processing
                 than is allowed in the gate length. To fix this
                 increase rbw/vbw.
             """
        elif err == saStatus.saBandwidthErr:
            extrainfo = 'RBW is larger than your span. (Sweep Mode)!'
        else:
            extrainfo = None
        self.check_for_error(err, 'saInitiate', extrainfo)

        self._parameters_synced = True
Exemple #54
0
    def event_loop(self, nev=-1):

        #nev is number of events to analyze, negative for all

        #input generated particles
        pdg = std.vector(int)()
        en = std.vector(float)()
        self.tree.SetBranchAddress("gen_pdg", pdg)
        self.tree.SetBranchAddress("gen_en", en)

        #spectrometer hits
        up_hits = ParticleCounterHits("up", self.tree)
        up_hits.local_from_geo(self.geo, "LumiSUbox")

        down_hits = ParticleCounterHits("down", self.tree)
        down_hits.local_from_geo(self.geo, "LumiSDbox")

        #photon detector hits
        phot_hits = ParticleCounterHits("phot", self.tree)
        phot_hits.local_from_geo(self.geo, "LumiDbox")

        #flow counters hits
        ew_front_hits = ParticleCounterHits("cnt_ew_front", self.tree)
        ew_rear_hits = ParticleCounterHits("cnt_ew_rear", self.tree)
        mag_front_hits = ParticleCounterHits("cnt_mag_front", self.tree)
        mag_rear_hits = ParticleCounterHits("cnt_mag_rear", self.tree)
        ew_front_hits.local_from_geo(self.geo, "ExitWinBox")
        ew_rear_hits.local_from_geo(self.geo, "ExitWinBox")
        mag_front_hits.local_from_geo(self.geo, "lumi_dipole")
        mag_rear_hits.local_from_geo(self.geo, "lumi_dipole")

        #outputs
        out = TFile(self.outfile, "recreate")

        #interaction tree
        otree = TTree("event", "event")
        gen_en = c_double(0)
        up_en = c_double(0)
        down_en = c_double(0)
        is_spect = c_bool(0)
        phot_en = c_double(0)
        otree.Branch("gen_en", gen_en, "gen_en/D")
        otree.Branch("up_en", up_en, "up_en/D")
        otree.Branch("down_en", down_en, "down_en/D")
        otree.Branch("is_spect", is_spect, "is_spect/O")
        otree.Branch("phot_en", phot_en, "phot_en/D")

        #hit trees
        up_hits.CreateOutput("up")
        down_hits.CreateOutput("down")
        phot_hits.CreateOutput("phot")

        #hit trees for flow counters
        ew_front_hits.CreateOutput("ew_front")
        ew_rear_hits.CreateOutput("ew_rear")
        mag_front_hits.CreateOutput("mag_front")
        mag_rear_hits.CreateOutput("mag_rear")

        #bunch crossing tree
        btree = TTree("bunch", "bunch")
        bun_ni = c_int(0)
        bun_up_en = c_double(0)
        bun_down_en = c_double(0)
        bun_phot_en = c_double(0)
        btree.Branch("bun_ni", bun_ni, "bun_ni/I")
        btree.Branch("bun_up_en", bun_up_en, "bun_up_en/D")
        btree.Branch("bun_down_en", bun_down_en, "bun_down_en/D")
        btree.Branch("bun_phot_en", bun_phot_en, "bun_phot_en/D")

        #Poisson distribution for bunch crossings
        lam = self.get_scale()["lambda"]
        print("Lambda:", lam)
        fPois = TF1(
            "Pois", "TMath::Power([0], Int_t(TMath::Floor(x)) )\
            *TMath::Exp(-[0])/TMath::Factorial( Int_t(TMath::Floor(x)) )", 0,
            12. * lam)
        fPois.SetParameter(0, lam)

        #number of interactions in bunch crossing
        nI = int(TMath.Floor(fPois.GetRandom()))
        bun_ni.value = nI

        #print period
        if nev < 0: nev = self.tree.GetEntries()
        iprint = int(nev / 12)

        #interaction loop
        for ievt in range(nev):
            self.tree.GetEntry(ievt)

            if ievt % iprint == 0 and ievt > 0:
                print("{0:.1f} %".format(100. * ievt / nev))
                stdout.flush()

            gen_en.value = 0.
            up_en.value = 0.
            down_en.value = 0.
            is_spect.value = 0
            phot_en.value = 0.

            #generated photon energy
            for imc in range(pdg.size()):
                if pdg.at(imc) == 22: gen_en.value = en.at(imc)

            #flow counters hits
            ew_front_hits.LoopInLocal()
            ew_rear_hits.LoopInLocal()
            mag_front_hits.LoopInLocal()
            mag_rear_hits.LoopInLocal()

            #spectrometer hits
            for i in range(up_hits.GetN()):
                hit = up_hits.GetHit(i)
                hit.GlobalToLocal()

                up_en.value += hit.en
                up_hits.FillOutput()

            for i in range(down_hits.GetN()):
                hit = down_hits.GetHit(i)
                hit.GlobalToLocal()

                down_en.value += hit.en
                down_hits.FillOutput()

            #coincidence selection
            if up_en.value > self.emin and down_en.value > self.emin:
                is_spect.value = 1

            #photon hits
            for i in range(phot_hits.GetN()):
                hit = phot_hits.GetHit(i)
                hit.GlobalToLocal()

                phot_en.value += hit.en
                phot_hits.FillOutput()

            otree.Fill()

            #bunch crossing
            if nI == 0:
                btree.Fill()

                nI = int(TMath.Floor(fPois.GetRandom()))
                bun_ni.value = nI

                bun_up_en.value = 0.
                bun_down_en.value = 0.
                bun_phot_en.value = 0.

            else:
                nI -= 1

                bun_up_en.value += up_en.value
                bun_down_en.value += down_en.value
                bun_phot_en.value += phot_en.value

        #interaction loop

        otree.Write()
        up_hits.otree.Write()
        down_hits.otree.Write()
        phot_hits.otree.Write()
        ew_front_hits.otree.Write()
        ew_rear_hits.otree.Write()
        mag_front_hits.otree.Write()
        mag_rear_hits.otree.Write()
        btree.Write()
        self.print_stat(out)
        out.Close()

        print("Hit analysis done")
Exemple #55
0
 def read_base_temperature(self):
     "gets the cooler's hot side in degrees Celcius"
     T = c_double()
     self._libfli.FLIReadTemperature(self._dev, FLI_TEMPERATURE_BASE,
                                     byref(T))
     return T.value
Exemple #56
0
    def _fitorpredict_ptr(
            self,
            source_dev,
            m_train,
            n,
            m_valid,
            double_precision,
            order,
            a,  # trainX_ptr or train_xptr
            b,  # trainY_ptr
            c,  # validX_ptr
            d,  # validY_ptr or valid_xptr  # keep consistent with later uses
            e,  # weight_ptr
            do_predict=0,
            free_input_data=0):
        """Train a GLM with pointers to data on the GPU
           (if fit_intercept, then you should have added 1's as
           last column to m_train)


        :param source_dev GPU ID of device

        :param m_train Number of rows in the training set

        :param n Number of columns in the training set

        :param m_valid Number of rows in the validation set

        :param double_precision float32 (0) or double point precision (1) of fit
            No Default.

        :param order: Order of data.  Default is None and set elsewhere
            whether row 'r' or column 'c' major order.

        :param a Pointer to training features array

        :param b Pointer to training response array

        :param c Pointer to validation features

        :param d Pointer to validation response

        :param e Pointer to weight column

        :param int do_predict : Indicate if prediction should be done on
            validation set after train. Default is 0.

        :param int free_input_data : Indicate if input data should be freed at
            the end of fit(). Default is 1.
        """

        #store some things for later call to predict_ptr()

        self.source_dev = source_dev
        self.m_train = m_train
        self.n = n
        self.m_valid = m_valid
        self.a = a
        self.b = b
        self.c = c
        self.d = d
        self.e = e

        # ########## #

        #if fitted earlier clear
        #otherwise don't clear solution, just use it
        if do_predict == 0 and self.did_fit_ptr == 1:
            free_sols(self)

# ############## #

        self.did_fit_ptr = 1

        # ##############
        #not calling with self.source_dev because want option to never use
        #default but instead input pointers from foreign code's pointers

        if order is not None:  # set order if not already set
            if order in ['r', 'c']:
                self.ord = ord(order)
            else:
                self.ord = order

        if hasattr(self,
                   'double_precision') and self.double_precision is not None:
            which_precision = self.double_precision
        else:
            which_precision = double_precision
            self.double_precision = double_precision

# ############ #

        if do_predict == 0:

            #initialize if doing fit

            x_vs_alpha_lambda = c_void_p(0)
            x_vs_alpha = c_void_p(0)
            valid_pred_vs_alpha_lambda = c_void_p(0)
            valid_pred_vs_alpha = c_void_p(0)
            count_full = c_size_t(0)
            count_short = c_size_t(0)
            count_more = c_size_t(0)
        else:

            #restore if predict

            x_vs_alpha_lambda = self.x_vs_alpha_lambda
            x_vs_alpha = self.x_vs_alpha
            valid_pred_vs_alpha_lambda = self.valid_pred_vs_alpha_lambda
            valid_pred_vs_alpha = self.valid_pred_vs_alpha
            count_full = self.count_full
            count_short = self.count_short
            count_more = self.count_more

# ############## #
#

        c_size_t_p = POINTER(c_size_t)
        if which_precision == 1:
            c_elastic_net = self.lib.elastic_net_ptr_double
            self.dtype = np.float64
            self.myctype = c_double
            if self.verbose > 0:
                print('double precision fit')
                sys.stdout.flush()
        else:
            c_elastic_net = self.lib.elastic_net_ptr_float
            self.dtype = np.float32
            self.myctype = c_float
            if self.verbose > 0:
                print('single precision fit')
                sys.stdout.flush()

#precision - independent commands
        if self.alphas_list is not None:
            pass_alphas = (self.alphas_list.astype(self.dtype, copy=False))
            c_alphas = pass_alphas.ctypes.data_as(POINTER(self.myctype))
        else:
            c_alphas = cast(0, POINTER(self.myctype))
        if self.lambdas_list is not None:
            pass_lambdas = (self.lambdas_list.astype(self.dtype, copy=False))
            c_lambdas = pass_lambdas.ctypes.data_as(POINTER(self.myctype))
        else:
            c_lambdas = cast(0, POINTER(self.myctype))

#call elastic net in C backend
        c_elastic_net(
            c_int(self._family),
            c_int(do_predict),
            c_int(source_dev),
            c_int(1),
            c_int(self._shared_a),
            c_int(self.n_threads),
            c_int(self._gpu_id),
            c_int(self.n_gpus),
            c_int(self._total_n_gpus),
            c_int(self.ord),
            c_size_t(m_train),
            c_size_t(n),
            c_size_t(m_valid),
            c_int(self.fit_intercept),
            c_int(self._standardize),
            c_double(self.lambda_max),
            c_double(self.lambda_min_ratio),
            c_int(self.n_lambdas),
            c_int(self.n_folds),
            c_int(self.n_alphas),
            c_double(self.alpha_min),
            c_double(self.alpha_max),
            c_alphas,
            c_lambdas,
            c_double(self.tol),
            c_double(self.tol_seek_factor),
            c_int(self.lambda_stop_early),
            c_int(self.glm_stop_early),
            c_double(self.glm_stop_early_error_fraction),
            c_int(self.max_iter),
            c_int(self.verbose),
            a,
            b,
            c,
            d,
            e,
            self.store_full_path,
            pointer(x_vs_alpha_lambda),
            pointer(x_vs_alpha),
            pointer(valid_pred_vs_alpha_lambda),
            pointer(valid_pred_vs_alpha),
            cast(addressof(count_full), c_size_t_p),
            cast(addressof(count_short), c_size_t_p),
            cast(addressof(count_more), c_size_t_p),
        )
        #if should or user wanted to save or free data,
        #do that now that we are done using a, b, c, d, e
        #This means have to upload_data() again before fit_ptr
        # or predict_ptr or only call fit and predict

        if free_input_data == 1:
            free_data(self)

# ####################################
#PROCESS OUTPUT
#save pointers

        self.x_vs_alpha_lambda = x_vs_alpha_lambda
        self.x_vs_alpha = x_vs_alpha
        self.valid_pred_vs_alpha_lambda = valid_pred_vs_alpha_lambda
        self.valid_pred_vs_alpha = valid_pred_vs_alpha
        self.count_full = count_full
        self.count_short = count_short
        self.count_more = count_more

        count_full_value = count_full.value
        count_short_value = count_short.value
        count_more_value = count_more.value

        if self.store_full_path == 1:
            num_all = int(count_full_value / (self.n_alphas * self.n_lambdas))
        else:
            num_all = int(count_short_value / self.n_alphas)

        num_all_other = num_all - n
        num_error = 3  # should be consistent w/ src/common/elastic_net_ptr.cpp
        num_other = num_all_other - num_error
        if num_other != 3:
            print('num_other=%d but expected 3' % num_other)
            print('count_full_value=%d '
                  'count_short_value=%d '
                  'count_more_value=%d '
                  'num_all=%d num_all_other=%d' %
                  (int(count_full_value), int(count_short_value),
                   int(count_more_value), int(num_all), int(num_all_other)))
            sys.stdout.flush()
            #TODO raise an exception instead
            exit(0)

        if self.store_full_path == 1 and do_predict == 0:
            #x_vs_alpha_lambda contains solution(and other data)
            #for all lambda and alpha

            self.x_vs_alpha_lambdanew = \
                np.fromiter(cast(x_vs_alpha_lambda,
                                 POINTER(self.myctype)), dtype=self.dtype,
                            count=count_full_value)

            self.x_vs_alpha_lambdanew = \
                np.reshape(self.x_vs_alpha_lambdanew, (self.n_lambdas,
                                                       self.n_alphas, num_all))

            self.x_vs_alpha_lambdapure = \
                self.x_vs_alpha_lambdanew[:, :, 0:n]

            self.error_vs_alpha_lambda = \
                self.x_vs_alpha_lambdanew[:, :, n:n + num_error]

            self._lambdas = \
                self.x_vs_alpha_lambdanew[:, :, n + num_error:n + num_error + 1]

            self._alphas = self.x_vs_alpha_lambdanew[:, :, n + num_error +
                                                     1:n + num_error + 2]

            self._tols = self.x_vs_alpha_lambdanew[:, :, n + num_error + 2:n +
                                                   num_error + 3]

            if self.fit_intercept == 1:
                self.intercept_ = self.x_vs_alpha_lambdapure[:, :, -1]
            else:
                self.intercept_ = None

        if self.store_full_path == 1 and do_predict == 1:
            thecount = int(count_full_value / (n + num_all_other) * m_valid)
            self.valid_pred_vs_alpha_lambdanew = \
                np.fromiter(cast(valid_pred_vs_alpha_lambda,
                                 POINTER(self.myctype)), dtype=self.dtype,
                            count=thecount)
            self.valid_pred_vs_alpha_lambdanew = \
                np.reshape(self.valid_pred_vs_alpha_lambdanew,
                           (self.n_lambdas, self.n_alphas, m_valid))
            self.valid_pred_vs_alpha_lambdapure = \
                self.valid_pred_vs_alpha_lambdanew[:, :, 0:m_valid]

        if do_predict == 0:  # store_full_path==0 or 1
            #x_vs_alpha contains only best of all lambda for each alpha

            self.x_vs_alphanew = np.fromiter(cast(x_vs_alpha,
                                                  POINTER(self.myctype)),
                                             dtype=self.dtype,
                                             count=count_short_value)
            self.x_vs_alphanew = np.reshape(self.x_vs_alphanew,
                                            (self.n_alphas, num_all))
            self.x_vs_alphapure = self.x_vs_alphanew[:, 0:n]
            self.error_vs_alpha = self.x_vs_alphanew[:, n:n + num_error]
            self._lambdas2 = self.x_vs_alphanew[:, n + num_error:n +
                                                num_error + 1]
            self._alphas2 = self.x_vs_alphanew[:, n + num_error + 1:n +
                                               num_error + 2]
            self._tols2 = self.x_vs_alphanew[:, n + num_error + 2:n +
                                             num_error + 3]

            if self.fit_intercept == 1:
                self.intercept2_ = self.x_vs_alphapure[:, -1]
            else:
                self.intercept2_ = None

#preds exclusively operate for x_vs_alpha or x_vs_alpha_lambda
        if self.store_full_path == 0 and do_predict == 1:
            thecount = int(count_short_value / (n + num_all_other) * m_valid)
            if self.verbose > 0:
                print('thecount=%d '
                      'count_full_value=%d '
                      'count_short_value=%d '
                      'n=%d num_all_other=%d '
                      'm_valid=%d' % (
                          thecount,
                          count_full_value,
                          count_short_value,
                          n,
                          num_all_other,
                          m_valid,
                      ))
                sys.stdout.flush()
            self.valid_pred_vs_alphanew = \
                np.fromiter(cast(valid_pred_vs_alpha,
                                 POINTER(self.myctype)), dtype=self.dtype,
                            count=thecount)
            self.valid_pred_vs_alphanew = \
                np.reshape(self.valid_pred_vs_alphanew, (self.n_alphas,
                                                         m_valid))
            self.valid_pred_vs_alphapure = \
                self.valid_pred_vs_alphanew[:, 0:m_valid]

        return self
Exemple #57
0
 def get_temperature(self):
     "gets the camera's temperature in degrees Celcius"
     T = c_double()
     self._libfli.FLIGetTemperature(self._dev, byref(T))
     return T.value
Exemple #58
0
 def get_cooler_power(self):
     "gets the cooler's power in watts (undocumented API function)"
     P = c_double()
     self._libfli.FLIGetCoolerPower(self._dev, byref(P))
     return P.value
Exemple #59
0
 def set_temperature(self, T):
     "set the camera's temperature target in degrees Celcius"
     self._libfli.FLISetTemperature(self._dev, c_double(T))
Exemple #60
0
 def read_CCD_temperature(self):
     "gets the CCD's temperature in degrees Celcius"
     T = c_double()
     self._libfli.FLIReadTemperature(self._dev, FLI_TEMPERATURE_CCD,
                                     byref(T))
     return T.value