//
// Shift new data values into the real time data series
//
void RealtimeChart::getData()
{
// The current time
QDateTime now = QDateTime::currentDateTime();
// This is our formula for the random number generator
do
{
// We need the currentTime in millisecond resolution
double currentTime = Chart::chartTime2(m_nextDataTime.toTime_t())
+ m_nextDataTime.time().msec() / 1000.0;
// Get a data sample
double p = currentTime * 4;
double dataA = 20 + cos(p * 129241) * 10 + 1 / (cos(p) * cos(p) + 0.01);
double dataB = 150 + 100 * sin(p / 27.7) * sin(p / 10.1);
double dataC = 150 + 100 * cos(p / 6.7) * cos(p / 11.9);
// Shift the values into the arrays
shiftData(m_dataSeriesA, sampleSize, dataA);
shiftData(m_dataSeriesB, sampleSize, dataB);
shiftData(m_dataSeriesC, sampleSize, dataC);
shiftData(m_timeStamps, sampleSize, currentTime);
m_nextDataTime = m_nextDataTime.addMSecs(DataInterval);
}
while (m_nextDataTime < now);
}
void regG::execWP()
{
if(SEQ::isAsserted(CLG)) write(0);
if(SEQ::isAsserted(RP2)) writeField(15, 15, PAR::register_P2.read());
if(SEQ::isAsserted(GP)) writeField(15, 15, PAR::gen1_15Parity(PAR::register_P.read()));
if(SEQ::isAsserted(WGn)) writeShift(BUS::glbl_RWBUS, MBF::conv_WGn);
// This is only used in PINC, MINC, and SHINC. Does not clear G
// register; writes (ORs) into G from RWBus and writes into parity
// from 1-15 generator. All done in one operation, although I show
// it in two steps here. The sequence calls CLG in a previous TP.
if(SEQ::isAsserted(WGx))
{
write(read() | shiftData(read(), BUS::glbl_RWBUS, MBF::conv_WGn));
writeField(15, 15, PAR::gen1_15Parity(PAR::register_P.read()));
}
if(SEQ::isAsserted(W20)) writeShift(BUS::glbl_RWBUS, MBF::conv_W20);
if(SEQ::isAsserted(W21)) writeShift(BUS::glbl_RWBUS, MBF::conv_W21);
if(SEQ::isAsserted(W22)) writeShift(BUS::glbl_RWBUS, MBF::conv_W22);
if(SEQ::isAsserted(W23)) writeShift(BUS::glbl_RWBUS, MBF::conv_W23);
if(SEQ::isAsserted(SBEWG)) writeShift(MBF::readMemory(), MBF::conv_SBEWG);
if(SEQ::isAsserted(SBFWG)) writeShift(MBF::readMemory(), MBF::conv_SBFWG);
if(SEQ::isAsserted(WE)) MBF::writeMemory(shiftData(0, MBF::register_G.read(), MBF::conv_WE));
}
void shapeAlign::printShifts(void){
int mult;
int lastidx = nameFile.find_last_of(".");
string shiftOutFile = nameFile.substr(0,lastidx) + ".shift.stats.txt";
ofstream shiftData (shiftOutFile.c_str());
if (shiftData.is_open()){
// Loop over all sites and output data from shape alignment
for (size_t i = 0; i < nSites; i++){
// Adjust the output for reversed sequences -- note that this
// adjustment is only necessary in the summary output but not in
// the actual shifted output!
gsl_matrix_get(R,i,cIdx) ? mult = 1 : mult = -1;
shiftData << names[i] << "\t" << gsl_matrix_get(D,i,cIdx)
<< "\t" << mult*gsl_matrix_get(S,i,cIdx) << "\t"
<< gsl_matrix_get(R,i,cIdx) << "\t"
<< endl;
}
} else {
cerr << "Error: Could not open output file ("
<< shiftOutFile << "). Exiting." << endl;
exit(1);
}
shiftData.close();
return;
}
void ParserHost::read( const std::string & i_mode, std::string & output)
{
parse( i_mode, output);
const char * out_data = output.data();
int out_size = output.size();
#ifdef AFOUTPUT
printf("\"");for(int c=0;c<out_size;c++)if(out_data[c]>=32)printf("%c", out_data[c]);printf("\":\n");
#endif
// writing output in buffer
//
//printf("\nParser::read: size = %d ( datasize = %d )\n", size, datasize);
const char * copy_data = out_data;
int copy_size = out_size;
if( (m_datasize+output.size()) > ms_DataSizeMax )
{
//printf("(datasize+size) > DataSizeMax : (%d+%d)>%d\n", datasize, size, DataSizeMax);
if( m_datasize < ms_DataSizeHalf )
{
memcpy( m_data+m_datasize, out_data, ms_DataSizeHalf-m_datasize);
copy_data = out_data + ms_DataSizeHalf - m_datasize ;
copy_size = out_size - ( ms_DataSizeHalf - m_datasize);
m_datasize = ms_DataSizeHalf;
}
int sizeShift = ms_DataSizeShift;
if( m_datasize+copy_size-sizeShift > ms_DataSizeMax ) sizeShift = m_datasize + copy_size - ms_DataSizeMax;
//printf("sizeShift=%d\n", sizeShift);
if( sizeShift < m_datasize-ms_DataSizeHalf ) shiftData( sizeShift);
else
{
copy_data = out_data + copy_size - ms_DataSizeHalf;
copy_size = ms_DataSizeHalf;
m_datasize = ms_DataSizeHalf;
//printf("sizeShift >= datasize-DataSizeHalf ( %d >= %d-%d )\n", sizeShift, datasize, DataSizeHalf);
}
if( m_overload == false ) setOverload();
}
//printf("memcpy: datasize=%d, copysize=%d, size=%d\n", datasize, copy_size, size);
memcpy( m_data+m_datasize, copy_data, copy_size);
m_datasize += copy_size;
/*#ifdef AFOUTPUT
fflush( stdout);
printf("\n############################## ParserHost::read: ##############################\n");
fflush( stdout);
::write( 1, data, datasize);
fflush( stdout);
printf("\n#############################################################################\n", datasize);
fflush( stdout);
#endif*/
//printf("end: datasize = %d\n", datasize);
}
void regG::execRP()
{ if(SEQ::isAsserted(RG))
if(ADR::register_S.read() >= 020)
BUS::glbl_RWBUS|=shiftData(BUS::glbl_RWBUS, read(), MBF::conv_RG);
}
