void CEle_Power_DecomposeView::OnFileOpen()
{
	static char BASED_CODE szFilter[] = "DataBase Files (*.mdb)|*.mdb; *.mdb|All Files (*.*)|*.*||";

	CFileDialog    DataRead(TRUE, // TRUE for FileOpen, FALSE for FileSaveAs
		"mdb", NULL,
		OFN_PATHMUSTEXIST|OFN_OVERWRITEPROMPT,
		szFilter,
		NULL);
	
	char DirectPath[MAX_PATH]; 
	GetCurrentDirectory( MAX_PATH, DirectPath); 

	if(IDOK == DataRead.DoModal())
	{
		CString szFileName = DataRead.GetPathName();
		if(szFileName.IsEmpty())
			return;
		
		CEle_Power_DecomposeDoc* pDoc = GetDocument();
		pDoc->SetTitle(DataRead.GetFileName());
		ReadFromMDB(szFileName);
	}

	SetCurrentDirectory(DirectPath);
}
示例#2
0
文件: cygnal_c2.c 项目: GBert/misc
/* Procedure servicing the ioctl */
long c2_ioctl (struct file *filp,
	      unsigned int cmd, unsigned long arg)
{
//TODO: Locking is probably required since we don't run under BKL anymore.
//      Although it isn't possible to open the c2 device twice, a single
//      process with multiple threads might be abble to issue simultaneous
//      ioctls() --DI
  long buf;
  unsigned char cbuf;
  int err=0,ret;
  if (_IOC_TYPE(cmd) != C2_IOC_MAGIC) return -ENOTTY;
  if (_IOC_NR(cmd) > C2_IOC_MAXNR) return -ENOTTY;
  if (_IOC_DIR(cmd) & _IOC_READ)
    err = !access_ok(VERIFY_WRITE, (void *)arg, _IOC_SIZE(cmd));
  else if (_IOC_DIR(cmd) & _IOC_WRITE)
    err = !access_ok(VERIFY_READ, (void *)arg, _IOC_SIZE(cmd));
  if (err) return -EFAULT;
  switch(_IOC_NR(cmd)) {
  case _IOC_NR(C2_IOCRESET):
    //printk(KERN_ERR "C2_IOCRESET");
    C2CK_reset();
    return 0;
  case _IOC_NR(C2_IOCAWRITE):
    ret = __get_user(cbuf, (unsigned char *)arg);
    //printk(KERN_ERR "C2_IOCAWRITE: address=%u\n", cbuf);
    AddressWrite(cbuf);
    return ret;
  case _IOC_NR(C2_IOCDWRITE):
    ret = __get_user(buf, (long *)arg);
    //printk(KERN_ERR "C2_IOCDWRITE: len=%u, data=%u\n", (_IOC_SIZE(cmd)-1) & 3, buf);
    return DataWrite((_IOC_SIZE(cmd)-1) & 3, buf);
  case _IOC_NR(C2_IOCAREAD):
    cbuf=AddressRead();
    //printk(KERN_ERR "C2_IOCAREAD: address=%u\n", cbuf);
    ret = __put_user(cbuf, (unsigned char *)arg);
    return ret;
  case _IOC_NR(C2_IOCDREAD):
    ret = DataRead((_IOC_SIZE(cmd)-1) & 3, &buf);
    if(ret) return ret;
    //printk(KERN_ERR "C2_IOCDREAD: len=%u, data=%u\n", (_IOC_SIZE(cmd)-1) & 3, buf);
    ret = __put_user(buf, (long *)arg);
    return ret;
  case _IOC_NR(C2_IOCQRESET):
    //printk(KERN_ERR "C2_IOCQRESET");
    C2CK_ENA();
    C2CK_low_pulse();  /* a "quick reset" is just a low pulse, less than 20us */
    C2CK_DIS();
    return 0;
  case _IOC_NR(C2_IOCIRQCHK):
    //printk(KERN_ERR "C2_IOCIRQCHK");
    return CheckForInterrupts();
  default:
    return -ENOTTY;
  }
}
示例#3
0
/*-----------------------------------------------------------------------------------------------------------------------*/
void *AcquireData(gpointer Data)                                    //Data acquisition thread triggered by StartCallBack
{
gulong Curr[4],Prev[4];
gint Overflow[4];
gdouble Rate[4];
gint i,Period;
FILE *Fp;
struct timeval Tv;
gdouble StartTime,ElapsedTime,Delta,TimeNow,TimePrev;
time_t DateTime;
gchar Str[120];

if (InitCamac()) { SAttention("Could not initialise CAMAC\nCheck if crate is on"); AcqOn=FALSE; pthread_exit(NULL); }
if (!(Fp=fopen(RunName,"w"))) 
   { SAttention("Could not open output file\nCheck disk full, file permissions"); AcqOn=FALSE; pthread_exit(NULL); }
CamacZ(); Period=0; for (i=0;i<NScalers;++i) { Prev[i]=0; Overflow[i]=0; }
gettimeofday(&Tv,NULL); StartTime=(gdouble)Tv.tv_sec+(gdouble)Tv.tv_usec*1.0e-06;
TimePrev=StartTime; DateTime=time(NULL);
sprintf(Str,"%s Started:%s",RunName,ctime(&DateTime));
gdk_threads_enter(); gtk_label_set_text(GTK_LABEL(S_Start),Str); gdk_threads_leave();
fprintf(Fp,"%s Started:%s",RunName,ctime(&DateTime));
fprintf(Fp," Elapsed     Scaler1       Rate1     Scaler2       Rate2     Scaler3       Rate3     Scaler4       Rate4\n");
while (TRUE) 
   {
   while (TRUE)
      {
      gettimeofday(&Tv,NULL); TimeNow=(gdouble)Tv.tv_sec+(gdouble)Tv.tv_usec*1.0e-06;
      Delta=TimeNow-TimePrev;
      if (Delta >= (gdouble)Interval[Period]) { TimePrev=TimeNow; break; }
      if (StopSignal) break;
      }
   for (i=0;i<NScalers;++i) 
       { 
       CamacNAF(StnNo,SubA[i],0); Curr[i]=DataRead()+Overflow[i]*SCALER_OVERFLOW; 
       if (Curr[i]<Prev[i]) { ++Overflow[i]; Curr[i]+=SCALER_OVERFLOW; }
       if (Delta>0.0) Rate[i]=(Curr[i]-Prev[i])/Delta; Prev[i]=Curr[i];
       }
   ElapsedTime=TimeNow-StartTime;
   if (ElapsedTime>(gdouble)Duration[0]) Period=1;
   if (ElapsedTime>(gdouble)(Duration[0]+Duration[1])) Period=2;
   sprintf(Str,"%08.2f",ElapsedTime); 
   gdk_threads_enter(); gtk_text_insert(GTK_TEXT(S_Output),NULL,NULL,NULL,Str,-1); gdk_threads_leave();
   fprintf(Fp,"%8.2f",ElapsedTime);
   for (i=0;i<NScalers;++i) 
       {
       sprintf(Str,"       %010ld  %010.2f",Curr[i],Rate[i]);
       gdk_threads_enter(); gtk_text_insert(GTK_TEXT(S_Output),NULL,NULL,NULL,Str,-1); gdk_threads_leave();
       }
   for (i=0;i<NScalers;++i) fprintf(Fp,"  %10ld  %10.2f",Curr[i],Rate[i]);
   gdk_threads_enter(); gtk_text_insert(GTK_TEXT(S_Output),NULL,NULL,NULL,"\n",-1); gdk_threads_leave();
   fprintf(Fp,"\n");
   if (StopSignal) break;
   }
DateTime=time(NULL);
sprintf(Str,"%s Stopped:%s",RunName,ctime(&DateTime)); 
gdk_threads_enter(); 
gtk_text_insert(GTK_TEXT(S_Output),NULL,NULL,NULL,"--------------------------------------------------------------------------------------------------------------------------------------------------------\n",-1);
gtk_label_set_text(GTK_LABEL(S_Stop),Str); gdk_threads_leave();
fprintf(Fp,"%s Stopped:%s",RunName,ctime(&DateTime));
AcqOn=FALSE; FinishCamac(); fclose(Fp); pthread_exit(NULL);
}
示例#4
0
文件: clip.c 项目: svn2github/staden
/*
 * Perform quality clipping on an individual contig.
 * This identifies low quality regions at the ends of contigs and clips them
 *
 * Note that this can produce holes, which need to be fixed by the fix_holes()
 * function, and can also reorder the readings.
 */
static int quality_clip_contig(GapIO *io, int contig, int start, int end,
			       int qual_avg, int *old_start, int *old_end)
{
    int rnum;
    int win_len = 31; /* odd num */
    int i, i_end;
    int left, right;
    GReadings r;
    int1 *conf = NULL;
    int conf_alloc = 10000; /* realloced as needed */
    int total;
    int qual_tot, win_len2;
    
    qual_tot = win_len * qual_avg;
    win_len2 = win_len / 2;

    if (NULL == (conf = (int1 *)xmalloc(conf_alloc)))
	return -1;

    /* Find start reading */
    for (rnum = io_clnbr(io, contig);
	 io_relpos(io, rnum) < start;
	 rnum = io_rnbr(io, rnum))
	;

    /*
     * Loop through readings up to 'end' position.
     * The leftmost and rightmost sequences need to be treated specially
     * as we do not want to clip these. Doing so will change the length of the
     * consensus. Doing that means that we need to deal with consensus tags
     * (shifting, clipping and deleting them).
     */
    for (; rnum && io_relpos(io, rnum) <= end; rnum = io_rnbr(io, rnum)) {
	/* Find left and right clip points */
	gel_read(io, rnum, r);
	if (r.length < win_len)
	    continue;

	/* Realloc conf if necessary */
	if (r.length > conf_alloc) {
	    int1 *conf2;
	    conf_alloc = r.length + 100;
	    conf2 = (int1 *)xrealloc(conf, conf_alloc);
	    if (!conf2) {
		xfree(conf);
		return -1;
	    }
	    conf = conf2;
	}

	if (DataRead(io, r.confidence, conf, r.length * sizeof(*conf),
		     sizeof(*conf)))
	    continue;

	/* Clip left by quality */
	if (rnum != io_clnbr(io, contig)) {
	    total = 0;
	    for (i = 0; i < win_len; i++)
		total += conf[i];

	    if (total > qual_tot) {
		i = r.start;
	    } else {
		i_end = r.length - win_len2 - 1;
		i = win_len2 + 1;
		do {
		    total += conf[i + win_len2] - conf[i - win_len2 - 1];
		    i++;
		} while (total < qual_tot && i < i_end);
		i--;
	    }
	    left = MAX(i, r.start);
	} else {
	    left = r.start;
	}

	/* Clip right by quality */
	if (r.position + r.sequence_length <= io_clength(io, contig)) {
	    total = 0;
	    for (i = 0; i < win_len; i++)
		total += conf[r.length - i - 1];
	    
	    if (total > qual_tot) {
		i = r.end;
	    } else {
		i = r.length - win_len2 - 2;
		i_end = win_len2 + 1;
		do {
		    total += conf[i - win_len2] - conf[i + win_len2 + 1];
		    i--;
		} while (total < qual_tot && i > i_end);
		i++;
	    }
	    right = MIN(i, r.end);
	} else {
	    right = r.end;
	}

	if (left >= r.end - 1)
	    left = r.end - 2;
	if (right <= r.start + 1)
	    right = r.start + 2;

	if (right < left + 2)
	    right = left + 2;

	/* printf("Gel %d: L %d->%d    R %d->%d\n",
	       rnum, r.start, left, r.end, right); */

	r.position += left - r.start;
	old_start[rnum] = r.start;
	old_end[rnum] = r.end;
	r.start = left;
	r.end = right;
	r.sequence_length = r.end - r.start - 1;

	gel_write(io, rnum, r);
	io_relpos(io, rnum) = r.position;
	io_length(io, rnum) = r.sense ? -r.sequence_length : r.sequence_length;
    }

    xfree(conf);
    return 0;
}
示例#5
0
//+------------------------------------------------------------------+
//| Main data reading function                                       |
//+------------------------------------------------------------------+
int CSourceInterface::Read(FeedData *inf)
  {
   DWORD   ctm;
//---- check
   if(inf==NULL || m_buffer==NULL)      return(FALSE);
   inf->ticks_count=0;
//---- есть синтетические инструменты?
   if(m_syntetics.GetTicks(inf)!=FALSE) return(TRUE);
//---- is connection opened?
   if(m_socket==INVALID_SOCKET)
     {
      //---- try connect
      if(Connect(m_server,m_login,m_password)==FALSE)
        {
         _snprintf(inf->result_string,sizeof(inf->result_string)-1,"no connection %s",m_server);
         inf->result=FALSE;
         return(FALSE);
        }
      //if(Login(inf)==FALSE) return(FALSE);
     }
//---- is login succesful?
   //if(m_loginflag==FALSE)
     //if(Login(inf)==FALSE) return(FALSE);
//---- read data
   while(m_socket!=INVALID_SOCKET)
     {
      //---- send ping every minute
      ctm=GetTickCount();
      if(ctm<m_lasttime) m_lasttime=ctm-1000; // проверка перехода через 49 дней
      if((ctm-m_lasttime)>60000)
        {
         //---- заодно загрузим базу синтетических инструментов
         m_syntetics.Load();
         //----
         m_lasttime=ctm;
         if(SendString("> Ping\r\n")==FALSE)
           {
            strcpy(inf->result_string,"ping failed");
            ExtLogger.Out("Read: %s",inf->result_string);
            return(FALSE);
           }
        }
      //---- check data
      if(DataRead()==FALSE)
        {
         COPY_STR(inf->result_string,"connection lost");
         ExtLogger.Out("Read: %s",inf->result_string);
         return(FALSE);
        }
      //---- parse while we can read strings
      while(DataParseLine(m_buffer,BUFFER_SIZE-1))
        {
         //---- it is news?
         if(memcmp(m_buffer,"< News",6)==0)       return ReadNews(inf);
         //---- skip service information
         if(m_buffer[0]=='<' || m_buffer[0]=='>') continue;
         //---- parse ticks
         if(ReadTicks(m_buffer,inf)==FALSE)       return(FALSE);
         //---- check free space for new account
         if(inf->ticks_count<COUNTOF(inf->ticks)) continue;
         //---- break parsing
         break;
        }
      //---- check ticks
      if(inf->ticks_count>0) 
        {
         //---- update syntetics
         m_syntetics.AddQuotes(inf);
         //---- return data to server
         return(TRUE);
        }
      //----
      Sleep(10);
     }
//---- some error
   return(TRUE);
  }
/**
  Process asynchronous requests
*/
TInt DCrashDriverChannel::DoRequest(TInt aReqNo, TRequestStatus* aStatus, TAny* a1, TAny* a2)
    {               
    
    
	Kern::Printf("DCrashDriverChannel::DoRequest");

    TInt err = KErrNone;   
    
    switch(aReqNo)
        {      
        case RKernelCrashDrv::EPrefetchAbort:
        	{    
        	err = StartInfLoop();  
        	if(err != KErrNone)
        		return err;
        	PrefetchAbort();
        	break;
        	}            
        case RKernelCrashDrv::EDataRead:
        	{
        	err = StartInfLoop();  
        	if(err != KErrNone)
        		return err;
        	DataRead();
            break;
        	}
        case RKernelCrashDrv::EDataWrite:
        	{
        	err = StartInfLoop();  
        	if(err != KErrNone)
        		return err;
        	DataWrite();
            break;
        	}         
        case RKernelCrashDrv::EUndefInst:
        	{
        	err = StartInfLoop();  
        	if(err != KErrNone)
        		return err;
        	UndefinedInst();
            break;
        	}            
        case RKernelCrashDrv::EDivByZero:
        	{
        	err = StartInfLoop();  
        	if(err != KErrNone)
        		return err;
        	DivByZero();
        	break;
        	}        	
        case RKernelCrashDrv::EStackOverflow:
        	{
        	err = StartInfLoop();  
        	if(err != KErrNone)
        		return err;
        	StackOverFlow();
            break;
        	}
        case RKernelCrashDrv::ETestSCMConfigInsertMethod:
        	{
        	//read the argmuents
        	HBuf8* tmp = HBuf8::New(KMaxBufferSize);
        	
        	TInt err = Kern::ThreadDesRead(iClient, a2, *tmp, 0, 0 );
			if (err != KErrNone || tmp->MaxLength() < KMaxBufferSize)
			{				
				Kern::Printf("Unable to read argument or buffer too small");

				// We could not read information from the user, so the a2 argument is probably wrong
				Kern::RequestComplete(iClient, aStatus, KErrArgument);
				return KErrArgument;
			}
        	
			//run the test and gather the results
			TBool pass;
			
			//run test
        	//TestConfigInsertL(pass, *tmp);
        	
        	//write the results back to client thread
        	err = Kern::ThreadRawWrite(iClient, a1, (TUint8*)&pass, sizeof(TBool), iClient);
        	if(err != KErrNone)
        		{
				Kern::Printf("Unable to write data back to client");

				// We could not read information from the user, so the a2 argument is probably wrong
				Kern::RequestComplete(iClient, aStatus, KErrArgument);
				return err;
        		}
        	
        	//and write the buffer back...
        	err = Kern::ThreadDesWrite(iClient, a2, *tmp, 0, 0, iClient);
        	if(err != KErrNone)
        		{
        		Kern::Printf("Unable to write data back to client");
        		
				// We could not read information from the user, so the a2 argument is probably wrong
				Kern::RequestComplete(iClient, aStatus, KErrArgument);
				return err;
        		}
        	
        	break;
        	}
        default:
        	{        	
            err=KErrNotSupported;
            break;
        	}
        }

    return err;
    }
示例#7
0
/*
 * Produce a quality value profile based on all sequences of a specific
 * chemistry. Chemistry==0 implies all sequences regardless of chemistry.
 * 
 * Returns: a count of how many samples have been added into total_conf;
 */
int read_conf_dist(GapIO *io, int chemistry, int *total_conf) {
    int i, j;
    GReadings r;
    int1 conf[MAXREADLEN];
    int count = 0;


    for (i = 1; i <= NumReadings(io); i++) {
	gel_read(io, i, r);
	if (!r.confidence)
	    continue;

	if (r.length >= MAXREADLEN)
	    continue;

	if (chemistry && r.chemistry != chemistry)
	    continue;

	if (DataRead(io, r.confidence, conf, r.length * sizeof(int1),
		     sizeof(int1)))
	    continue;

	/* Always work on top strand data */
	if (r.sense == 1) {
	    int left, right;
	    for (left = 0, right = r.length-1; left < right; left++, right--) {
		int tmp = conf[left];
		conf[left] = conf[right];
		conf[right] = tmp;
	    }
	}


	/* All < conf 10 - probably not a real */
	for (j = 0; j < r.length; j++) {
	    if (conf[j] >= 10)
		break;
	}
	if (j == r.length)
	    continue;

	/* All > conf 40 - probably not a real sequence */
	for (j = 0; j < r.length; j++) {
	    if (conf[j] < 40)
		break;
	}
	if (j == r.length)
	    continue;

	/* All same value - probably not a real sequence */
	for (j = 1; j < r.length; j++) {
	    if (conf[j] != conf[0])
		break;
	}
	if (j == r.length)
	    continue;

	/* Accumulate totals and counts */
	for (j = 0; j < r.length; j++) {
	    total_conf[j] += conf[j];
	}

	count++;
    }

    return count;
}
示例#8
0
文件: stream.cpp 项目: IcaroL2ORK/pd
/*! Get sample frames
	\param buf		pointer array to channel buffers
	\param frames	number of maximum frames to get
	\return			frames put into buffers
*/
int Stream::doGet(int ch,float *const *buf,int frames,float sr)
{
	ASSERT(ch > 0 && frames >= 0 && sr > 0);

	if(isOk() && !isInitializing()) {
		// signal thread worker
		pthread_cond_signal(&cond);

		// check/(re)allocate buffers

		int strch = getChannels();
		if(bufs && bufch < strch) { 
			delete[] decoded;
			for(int i = 0; i < bufch; ++i) src_delete(src_state[i]);
			delete[] src_state;
			delete[] bufs;	bufs = NULL; 
		}

		if(!bufs) {
			if(bufch < strch) bufch = strch;
			bufs = new float *[bufch];
			decoded = new Fifo<float>[bufch];

			src_state = new SRC_STATE *[bufch];
			for(int i = 0; i < bufch; ++i) {
				int error;
				src_state[i] = src_new(SRC_ZERO_ORDER_HOLD,1,&error);
				if(!src_state[i]) post("src init error %i",error);
			}
		}

		// get frames

		float ratio = sr/getSamplerate();
		int frneed = (int)(frames/ratio)+DECMORE;  // number of frames to read from decoder fifo

		if(decoded[0].Size() < frneed) {
			// fifos are too small -> resize them (while keeping their contents)
			for(int i = 0; i < bufch; ++i) decoded[i].Resize(frneed,true);
		}

		// how many frames do we need to get from decoder?
		int frread = frneed-decoded[0].Have();

		int ret = state == ST_WAIT?0:DataRead(frread);

		if(ret < 0) {
			if(debug) post("read error");
			// clear output
			for(int c = 0; c < ch; ++c)
				memset(buf[c],0,frames*sizeof *buf[c]);
			return 0;
		}
		else {
			// how many channels do we really need for output?
			// this should be set elsewhere, because we can't change anyway!!! 
			// (SRC_STATE for dangling channels would be incorrect)
			int cmin = strch;
			if(ch < cmin) cmin = ch;

			// write data to fifo
			for(int i = 0; i < cmin; ++i) {
				int wr = decoded[i].Write(ret,bufs[i]);
				if(wr < ret) post("fifo overflow");
			}

//			state = ST_PROCESS;

			if(ratio == 1) {
				// no resampling necessary

				// hopefully all channel fifos advance uniformly.....
				for(int i = 0; i < cmin; ++i) {

					for(int got = 0; got < frames; ) {
						int cnt = frames-got;

						if(decoded[i].Have()) {
							got += decoded[i].Read(cnt,buf[i]+got);
						}
						else {
							state = ST_WAIT;
							if(debug) post("fifo underrun");

							// Buffer underrun!! -> zero output buffer
							memset(buf[i]+got,0,cnt*sizeof(*buf[i]));
							got += cnt;
						}
					}
				}
			}
			else 
			{
				SRC_DATA src_data;
				src_data.src_ratio = ratio;
				src_data.end_of_input = 0;

				// hopefully all channel fifos advance uniformly.....
				for(int i = 0; i < cmin; ++i) {
					src_set_ratio(src_state[i],ratio);

					for(int got = 0; got < frames; ) {
						src_data.data_out = buf[i]+got;
						src_data.output_frames = frames-got;

						if(decoded[i].Have()) {
							src_data.data_in = decoded[i].ReadPtr();
							src_data.input_frames = decoded[i].ReadSamples();

							int err = src_process(src_state[i],&src_data);
							if(err) post("src_process error %i",err);

							// advance buffer
							decoded[i].Read(src_data.input_frames_used,NULL);
						}
						else {
							state = ST_WAIT;
							if(debug) post("fifo underrun");

							// Buffer underrun!! -> zero output buffer
							memset(src_data.data_out,0,src_data.output_frames*sizeof(*src_data.data_out));
							src_data.output_frames_gen = src_data.output_frames;
						}
						got += src_data.output_frames_gen;
					}
				}
			}

			// zero remaining channels
			for(int c = cmin; c < ch; ++c)
				memset(buf[c],0,frames*sizeof *buf[c]);

			return ret;
		}
	}
	else {
		for(int c = 0; c < ch; ++c)
			memset(buf[c],0,frames*sizeof *buf[c]);
		return 0;
	}
}