Ejemplo n.º 1
0
// Processing thread nStorage: size of the array
void processing(short *data,int nStorage, int name){
  short *data_bin;
  int nDataB=27200;
  data_bin=new short[nDataB];
  
  std::this_thread::yield();
  //Do something heavy with data:
  
  DispVal(nStorage);
  
  // Save data received to file
  std::string s1= "data/received"+std::to_string(name) +".dat" ;
  std::ofstream ofs(s1, std::ifstream::out );
  ofs.write((char * ) data, nStorage*sizeof(short));
  ofs.close();
  //std::cout << "Finish Writing to file\n";
  
  auto t_start = std::chrono::high_resolution_clock::now(); // Timer
  
  //Process online data:
  
  //std::clock_t c_start = std::clock();
  
  receiverSignalProcessing(data, nStorage, data_bin, nDataB);
  //std::cout<<"Detected!\n";
	

  //std::clock_t c_end = std::clock();
  auto t_end = std::chrono::high_resolution_clock::now();
  std::cout << "Data Processed!\n";
  std::cout << "Wall clock time passed: "
	    << std::chrono::duration_cast<std::chrono::microseconds>(t_end - t_start).count()
	    << " us\n";
  
	

  std::cout << "Data Received and Processed!\n";
   

   // Save decoded data to file
   string s2= "data/decoded"+std::to_string(name) +".dat" ;
   std::ofstream ofs1( s2 , std::ifstream::out );
   ofs1.write((char * ) data_bin, nDataB*sizeof(short));
   ofs1.close();


   int r=system("octave cpptoctave.m");

   std::cout<<"\nWaiting for new transmission.\n\n";

   // std::this_thread::yield();
   //Release the memory
   delete[] (data);
  
}
Ejemplo n.º 2
0
// Processing thread nStorage: size of the array
void processing(int nStorage){
  short *data;
  short *data_bin;
  int nDataB=6250;
  data_bin=new short[nDataB];
  bool forever=true;
  while(forever){
    // Ask for data
    sem_wait(&detectionReady);
    data=detectionQ.front();

    std::this_thread::yield();
    //Do something heavy with data:
    
    //Process online data:

    receiverSignalProcessing(data, nStorage, data_bin, nDataB);

    // Save data to file
    std::ofstream ofs( "received.dat" , std::ifstream::out );
    ofs.write((char * ) data, nStorage*sizeof(short));
    ofs.close();
    //std::cout << "Finish Writing to file\n";




    std::cout << "Data Received and Processed!\n";

     // Save data to file
     std::ofstream ofs1( "data_from_harness.dat" , std::ifstream::out );
     ofs1.write((char * ) data_bin, nDataB*sizeof(short));
     ofs1.close();

    std::this_thread::yield();
    //Release the memory
    delete[] (detectionQ.front());
    mtxDetection.lock();
    detectionQ.pop();
    mtxDetection.unlock();
    forever=false;
  }
}
Ejemplo n.º 3
0
int main()
{
	//txtPostureData読み込み
	std::ifstream ifs("GetPositionALL.txt");
	std::string str;
	int CountData = 0;
	//postureDataを入れるvector確保
	//std::vector<std::vector<double>>txtPosture(3, std::vector<double>(25));
	std::vector<std::vector<std::vector<double>>> Posture(3, std::vector<std::vector<double>>(25, std::vector<double>(3000, 0)));//1595

	std::vector< std::vector<double> > position( 25, std::vector<double>( 3 ) );
	std::vector< std::vector<double> > PositionBase( 25, std::vector<double>( 3 ) );
	std::vector< std::vector<double> > RotatePosition( 25, std::vector<double>( 3 ) );
	std::vector< std::vector<double> > XRotatePosition( 25, std::vector<double>( 3 ) );
	std::vector< std::vector<double> > YRotatePosition( 25, std::vector<double>( 3 ) );
	std::vector< std::vector<double> > ZRotatePosition( 25, std::vector<double>( 3 ) );

	std::ofstream ofs( "GetPositionALL.txt", std::ios::out | std::ios::app );
	
	std::ofstream ofs2( "GetPositionArm.txt", std::ios::out | std::ios::app );

	while (getline(ifs, str))
	{
		std::string tmp;
		std::istringstream stream(str);
		int CountXYZ = 0, CountPosture = 0;
		while (getline(stream, tmp, '\t'))
		{
			//文字列から数字(double)に変換
			std::istringstream is;
			is.str(tmp);    
			double x;             
			is >> x;                
			//postureにtxtPostureDataを代入
			Posture[CountXYZ][CountPosture][CountData] = x;
			//std::cout <<"("<<CountXYZ<<":"<<CountPosture<<":"<<CountData<<")->"<< x << std::endl;
			
			//countを取ってpostureに代入
			CountXYZ++;
			if (CountXYZ == 3)
			{
				CountPosture++;
				CountXYZ = 0;
			}
			if (CountPosture == 25)
			{
				CountData++;
				CountPosture = 0;
			}
		}
	}

	for ( int i = 0; i <= CountData; i++ )
	{
		//テキストベースでpositionを保存
		for ( int count = 0; count <= 24; count++ )
		{
			for ( int PosCount = 0; PosCount <= 2; PosCount++ )
			{
				Posture[PosCount][count][i] = position[count][PosCount];
			}
		}
		for ( int count = 0; count <= 24; count++ )
		{
			for ( int PosCount = 0; PosCount <= 2; PosCount++ )
			{
				PositionBase[count][PosCount] = position[count][PosCount] - position[0][PosCount];
			}
		}


		//座標変換ユーザの角度
		double crossX = ( PositionBase[8][1] * PositionBase[4][2] ) - ( PositionBase[8][2] * PositionBase[4][1] );
		double crossY = ( PositionBase[8][2] * PositionBase[4][0] ) - ( PositionBase[8][0] * PositionBase[4][2] );
		double crossZ = ( PositionBase[8][0] * PositionBase[4][1] ) - ( PositionBase[8][1] * PositionBase[4][0] );//外積
		double nLength = sqrtf( ( crossX*crossX ) + ( crossY*crossY ) + ( crossZ*crossZ ) );//normalize

		double nx = crossX / nLength;//1より大きかったらだめifブンツクレ
		double ny = crossY / nLength;
		double nz = crossZ / nLength;//面法線ベクトル
		double nxx = crossX / sqrtf( ( crossX*crossX ) + ( crossY*crossY ) );
		double nzz = crossZ / sqrtf( ( crossX*crossX ) + ( crossZ*crossZ ) );
		/*
		if ( nx >= 1 )nx = 1;
		if ( ny >= 1 )ny = 1;
		if ( nz >= 1 )nz = 1;
		*/
		double cosX = nx;//nx / nLength;
		double cosY = ny;//ny / nLength;
		double cosZ = nz;//nz / nLength;//面の傾き(cos)?
		double cosXX = nxx;//x / √x^2+y^2
		double cosZZ = nzz;
		double cosZZZ = ( PositionBase[4][1] ) / sqrtf( ( PositionBase[4][1] * PositionBase[4][1] ) + ( PositionBase[4][2] * PositionBase[4][2] ) );

		double sinX = crossZ / nLength;//sqrtf( 1 - ( cosX*cosX ) );//マイナスになってる?正じゃないといけない
		double sinY = sqrtf( ( crossX*crossX ) + ( crossY*crossY ) ) / nLength;//sqrtf( 1 - ( cosY*cosY ) );
		double sinZ = crossY / nLength;//sqrtf( 1 - ( cosZ*cosZ ) );//面の傾き(sin)?
		double sinXX = sqrtf( 1 - ( cosXX*cosXX ) );
		double sinZZ = crossX / sqrtf( ( crossX*crossX ) + ( crossZ*crossZ ) );
		double sinZZZ = ( PositionBase[4][2] ) / sqrtf( ( PositionBase[4][1] * PositionBase[4][1] ) + ( PositionBase[4][2] * PositionBase[4][2] ) );
		
		//各軸回転行列
		std::vector< std::vector<double> > vectorRx( 3, std::vector<double>( 3 ) );
		std::vector< std::vector<double> > vectorRy( 3, std::vector<double>( 3 ) );
		std::vector< std::vector<double> > vectorRz( 3, std::vector<double>( 3 ) );
		std::vector< std::vector<double> > vectorR( 3, std::vector<double>( 3 ) );

		vectorRx[0][0] = 1;
		vectorRx[0][1] = 0;
		vectorRx[0][2] = 0;
		vectorRx[1][0] = 0;
		vectorRx[1][1] = sinY;//cosX(90"-")
		vectorRx[1][2] = -cosY;//-sinX
		vectorRx[2][0] = 0;
		vectorRx[2][1] = cosY;//sinX
		vectorRx[2][2] = sinY;//cosX//X軸周り回転行列

		vectorRy[0][0] = cosZZ;//cosZ;//cosY
		vectorRy[0][1] = 0;
		vectorRy[0][2] = -sinZZ;//sinZ;//sinY
		vectorRy[1][0] = 0;
		vectorRy[1][1] = 1;
		vectorRy[1][2] = 0;
		vectorRy[2][0] = sinZZ;//-sinZ;//sinY
		vectorRy[2][1] = 0;
		vectorRy[2][2] = cosZZ;//cosY//Y軸周り回転行列

		vectorRz[0][0] = cosX;//cosZ
		vectorRz[0][1] = -sinX;//-sinZ
		vectorRz[0][2] = 0;
		vectorRz[1][0] = sinX;//sinZ
		vectorRz[1][1] = cosX;//cosZ
		vectorRz[1][2] = 0;
		vectorRz[2][0] = 0;
		vectorRz[2][1] = 0;
		vectorRz[2][2] = 1;//Z軸周り回転行列


		//行列計算->Y軸周りの計算
		for ( int count = 0; count <= 24; count++ )
		{
			for ( int PosCount = 0; PosCount <= 2; PosCount++ )
			{
				//cout << position[count][PosCount] << endl;
				//ofs << position[count][PosCount] << "\t";
				if ( PosCount == 0 )
				{
					for ( int i = 0; i <= 2; i++ )
					{
						YRotatePosition[count][PosCount] += PositionBase[count][i] * vectorRy[0][i];
					}
				}
				else if ( PosCount == 1 )
				{
					for ( int i = 0; i <= 2; i++ )
					{
						YRotatePosition[count][PosCount] += PositionBase[count][i] * vectorRy[1][i];
					}
				}
				else if ( PosCount == 2 )
				{
					for ( int i = 0; i <= 2; i++ )
					{
						YRotatePosition[count][PosCount] += PositionBase[count][i] * vectorRy[2][i];
					}
				}
				//RotatePosition[count][PosCount] = PositionBase[count][PosCount];
			}
		}

		//行列計算->X軸周りの計算
		for ( int count = 0; count <= 24; count++ )
		{
			for ( int PosCount = 0; PosCount <= 2; PosCount++ )
			{
				if ( PosCount == 0 )
				{
					for ( int i = 0; i <= 2; i++ )
					{
						XRotatePosition[count][PosCount] += YRotatePosition[count][i] * vectorRx[0][i];
					}
				}
				else if ( PosCount == 1 )
				{
					for ( int i = 0; i <= 2; i++ )
					{
						XRotatePosition[count][PosCount] += YRotatePosition[count][i] * vectorRx[1][i];
					}
				}
				else if ( PosCount == 2 )
				{
					for ( int i = 0; i <= 2; i++ )
					{
						XRotatePosition[count][PosCount] += YRotatePosition[count][i] * vectorRx[2][i];
					}
				}
			}
		}


		std::vector<double> shoulder( 3 );
		shoulder[0] = /*PositionBase[4][0] - PositionBase[8][0];*/XRotatePosition[4][0] - XRotatePosition[8][0];
		shoulder[1] = /*PositionBase[4][1] - PositionBase[8][1]; */XRotatePosition[4][1] - XRotatePosition[8][1];
		shoulder[2] = /*PositionBase[4][2] - PositionBase[8][2];*/XRotatePosition[4][2] - XRotatePosition[8][2];

		double cosXshoulder = shoulder[0] / sqrtf( ( shoulder[0] * shoulder[0] ) + ( shoulder[1] * shoulder[1] ) + ( shoulder[2] * shoulder[2] ) );
		double sinXshoulder = shoulder[1] / sqrtf( ( shoulder[0] * shoulder[0] ) + ( shoulder[1] * shoulder[1] ) + ( shoulder[2] * shoulder[2] ) );
		vectorRz[0][0] = cosXshoulder;//cosZ
		vectorRz[0][1] = sinXshoulder;//-sinZ
		vectorRz[0][2] = 0;
		vectorRz[1][0] = -sinXshoulder;//sinZ
		vectorRz[1][1] = cosXshoulder;//cosZ
		vectorRz[1][2] = 0;
		vectorRz[2][0] = 0;
		vectorRz[2][1] = 0;
		vectorRz[2][2] = 1;//Z軸周り回転行列

		//行列計算->Z軸周りの計算
		for ( int count = 0; count <= 24; count++ )
		{
			for ( int PosCount = 0; PosCount <= 2; PosCount++ )
			{
				if ( PosCount == 0 )
				{
					for ( int i = 0; i <= 2; i++ )
					{
						ZRotatePosition[count][PosCount] += XRotatePosition[count][i] * vectorRz[0][i];
					}
				}
				else if ( PosCount == 1 )
				{
					for ( int i = 0; i <= 2; i++ )
					{
						ZRotatePosition[count][PosCount] += XRotatePosition[count][i] * vectorRz[1][i];
					}
				}
				else if ( PosCount == 2 )
				{
					for ( int i = 0; i <= 2; i++ )
					{
						ZRotatePosition[count][PosCount] += XRotatePosition[count][i] * vectorRz[2][i];
					}
				}
			}
		}
		//今回はz軸回転->y軸回転->z軸回転順に回転行列を計算した原点は骨格の腰中央点
		RotatePosition = ZRotatePosition;
		//どの回転結果を表示するか->以下RotatePositionを表示


		//座標変換後のpostureをテキストファイルに保存
		std::ofstream ofs1( "RotatePostureALL.txt", std::ios::out | std::ios::app );
		for ( int count = 0; count <= 24; count++ )
		{
			for ( int PosCount = 0; PosCount <= 2; PosCount++ )
			{
				//cout << position[count][PosCount] << endl;
				ofs1 << RotatePosition[count][PosCount] * 80000 << "\t";

			}
			if ( count == 24 )
			{
				ofs1 << "\n";
			}
		}
		std::ofstream ofs3( "RotatePostureArm.txt", std::ios::out | std::ios::app );
		for ( int count = 0; count <= 24; count++ )
		{
			if ( count == 8 || count == 9 || count == 11 )
			{
				ofs3 << RotatePosition[count][0] * 80000 << "\t" << -RotatePosition[count][1] * 80000 << "\t" << RotatePosition[count][2] * 80000 << "\t";
			}
			else
			{
				ofs3 << RotatePosition[count][0] * 80000 << "\t" << -RotatePosition[count][1] * 80000 << "\t" << RotatePosition[count][2] * 80000 << "\t";
			}
			if ( count == 24 )
			{
				ofs3 << "\n";
			}
		}

	}


    return 0;
}
Ejemplo n.º 4
0
int UHD_SAFE_MAIN(int argc, char *argv[]){



    if (uhd::set_thread_priority_safe(1,true)) {
       std::cout << "set priority went well " << std::endl;
    };


    //variables to be set by po
    std::string args;
    double seconds_in_future;
    size_t total_num_samps;
    double tx_rate, freq, LOoffset;
    float gain;
    bool demoMode, use_8bits;
    bool use_external_10MHz; 
    std::string filename;
    uhd::tx_streamer::sptr tx_stream;
    uhd::device_addr_t dev_addr;
    uhd::usrp::multi_usrp::sptr dev;
    uhd::stream_args_t stream_args;

    //setup the program options
    po::options_description desc("Allowed options");
    desc.add_options()
      ("help", "help message")
      ("args", po::value<std::string>(&args)->default_value(""), "simple uhd device address args")
      ("secs", po::value<double>(&seconds_in_future)->default_value(3), "number of seconds in the future to transmit")
      ("nsamps", po::value<size_t>(&total_num_samps)->default_value(37028), "total number of samples to transmit")//9428
      ("txrate", po::value<double>(&tx_rate)->default_value(100e6/4), "rate of outgoing samples")
      ("freq", po::value<double>(&freq)->default_value(70e6), "rf center frequency in Hz")
      ("LOoffset", po::value<double>(&LOoffset)->default_value(0), "Offset between main LO and center frequency")
      ("demoMode",po::value<bool>(&demoMode)->default_value(true), "demo mode")
      ("10MHz",po::value<bool>(&use_external_10MHz)->default_value(false), 
       "external 10MHz on 'REF CLOCK' connector (true=1=yes)")
      ("filename",po::value<std::string>(&filename)->default_value("codedData.dat"), "input filename")
      ("gain",po::value<float>(&gain)->default_value(0), "gain of transmitter(0-13) ")
      ("8bits",po::value<bool>(&use_8bits)->default_value(false), "Use eight bits/sample to increase bandwidth")
    ;

    
    
    po::variables_map vm;
    po::store(po::parse_command_line(argc, argv, desc), vm);
    po::notify(vm);

    
    //print the help message
    if (vm.count("help")){
      std::cout << boost::format("tx %s") % desc << std::endl;
      return ~0;
    }
    
 ///////////////////////////////////////////////////////////////// START PROCESSING /////////////////////////////////////////////////////////////////////
    
    std::complex<int16_t> *buffer0;
    buffer0 = new std::complex<int16_t>[total_num_samps];
    std::complex<int16_t> *buffer1;
    buffer1 = new std::complex<int16_t>[total_num_samps];
    std::complex<int16_t> *buffer2;
    buffer2 = new std::complex<int16_t>[total_num_samps];
    std::complex<int16_t> *buffer3;
    buffer3 = new std::complex<int16_t>[total_num_samps];
    std::complex<int16_t> *buffer4;
    buffer4 = new std::complex<int16_t>[total_num_samps];

    
    int16_t *aux0;
    aux0 = new int16_t[2*total_num_samps];
    int16_t *aux1;
    aux1 = new int16_t[2*total_num_samps];
    int16_t *aux2;
    aux2 = new int16_t[2*total_num_samps];
    int16_t *aux3;
    aux3 = new int16_t[2*total_num_samps];
    int16_t *aux4;
    aux4 = new int16_t[2*total_num_samps];
    
    //generate the picture as grayscale
    int r=system("octave image_transmition.m &");
    if(r){
      std::cout<<" loading picture - check!\n";
    }
    
    int nPicRaw = 16384;//size of the image in grayscale 128*128
    double nBinPac = 27200;//size of binary data in one packet
 

    //loading picture as grayscale
    int16_t pictureRaw[nPicRaw];
    std::ifstream ifs( "data_toSend.dat", std::ifstream::in );
    ifs.read((char * )pictureRaw,nPicRaw*sizeof(int16_t));
    ifs.close();  
    
    //converting grayscale to binary and XOR with pseudonoise
    itpp::bvec picBinInter = prepairPic(pictureRaw,nPicRaw);//transforms grayscale in binary data

    //cutting the large binary data into 5 packets
    bvec dataBinTmp0;
    dataBinTmp0.ins(dataBinTmp0.length(),picBinInter.get(0,(nBinPac-1)));
    bvec dataBinTmp1;
    dataBinTmp1.ins(dataBinTmp1.length(),picBinInter.get(nBinPac,(2*nBinPac-1)));
    bvec dataBinTmp2;
    dataBinTmp2.ins(dataBinTmp2.length(),picBinInter.get(2*nBinPac,(3*nBinPac-1)));
    bvec dataBinTmp3;
    dataBinTmp3.ins(dataBinTmp3.length(),picBinInter.get(3*nBinPac,(4*nBinPac-1)));
    bvec dataBinTmp4;
    dataBinTmp4.ins(dataBinTmp4.length(),picBinInter.get(4*nBinPac,picBinInter.length()));
    dataBinTmp4.ins(dataBinTmp4.length(),randb(nBinPac-dataBinTmp4.length())); //filling the last packet with random data

    //saving the binary picture
    it_file my_file("binPicture.it");
    my_file << Name("picBinInter") << picBinInter;
    my_file.flush();
    my_file.close();
    
    
    //processing each packet
    tx_funct(aux0,dataBinTmp0,dataBinTmp0.length());
    tx_funct(aux1,dataBinTmp1,dataBinTmp1.length());
    tx_funct(aux2,dataBinTmp2,dataBinTmp2.length());
    tx_funct(aux3,dataBinTmp3,dataBinTmp3.length());
    tx_funct(aux4,dataBinTmp4,dataBinTmp4.length());
    
    //filling the output buffer
    for(int i=0,count1=0;i<(int)(2*total_num_samps);i=i+2){
      buffer0[count1]=std::complex<short>(aux0[i],aux0[i+1]);
      buffer1[count1]=std::complex<short>(aux1[i],aux1[i+1]);
      buffer2[count1]=std::complex<short>(aux2[i],aux2[i+1]);
      buffer3[count1]=std::complex<short>(aux3[i],aux3[i+1]);
      buffer4[count1]=std::complex<short>(aux4[i],aux4[i+1]);
      count1++;
    }
 
    
   
    // Save data to file to check what was sent
    std::ofstream ofs( "sent0.dat" , std::ifstream::out );
    ofs.write((char * ) buffer0, 2*total_num_samps*sizeof(int16_t));
    ofs.flush();
    ofs.close();
    // Save data to file to check what was sent
    std::ofstream ofs1( "sent1.dat" , std::ifstream::out );
    ofs1.write((char * ) buffer1, 2*total_num_samps*sizeof(int16_t));
    ofs1.flush();
    ofs1.close();
    // Save data to file to check what was sent
    std::ofstream ofs2( "sent2.dat" , std::ifstream::out );
    ofs2.write((char * ) buffer2, 2*total_num_samps*sizeof(int16_t));
    ofs2.flush();
    ofs2.close();
    // Save data to file to check what was sent
    std::ofstream ofs3( "sent3.dat" , std::ifstream::out );
    ofs3.write((char * ) buffer3, 2*total_num_samps*sizeof(int16_t));
    ofs3.flush();
    ofs3.close();
    // Save data to file to check what was sent
    std::ofstream ofs4( "sent4.dat" , std::ifstream::out );
    ofs4.write((char * ) buffer4, 2*total_num_samps*sizeof(int16_t));
    ofs4.flush();
    ofs4.close();

    //Conjugate!!!
    for(int i=0; i<(int)(total_num_samps);i++){
      buffer0[i]=std::conj(buffer0[i]);
      buffer1[i]=std::conj(buffer1[i]);
      buffer2[i]=std::conj(buffer2[i]);
      buffer3[i]=std::conj(buffer3[i]);
      buffer4[i]=std::conj(buffer4[i]);
    } 
    
    

    std::cout << " ----------- " << std::endl;
    std::cout<<" Conjugated! \n";
    std::cout << " ----------- " << std::endl;
    
    ///////////////////////////////////////////////////////////////// END  PROCESSING /////////////////////////////////////////////////////////////////////
    
    //create a usrp device and streamer
    dev_addr["addr0"]="192.168.10.2";
    dev = uhd::usrp::multi_usrp::make(dev_addr);    


    // Internal variables 
    uhd::clock_config_t my_clock_config; 

    if (!demoMode) {
      dev->set_time_source("external");
    };

    if (use_external_10MHz) { 
      dev->set_clock_source("external");
    }
    else {
      dev->set_clock_source("internal");
    };


    uhd::usrp::dboard_iface::sptr db_iface;
    db_iface=dev->get_tx_dboard_iface(0);

    board_60GHz_TX  my_60GHz_TX(db_iface);  //60GHz 
    my_60GHz_TX.set_gain(gain); // 60GHz 

    uhd::tune_result_t tr;
    uhd::tune_request_t trq(freq,LOoffset); //std::min(tx_rate,10e6));
    tr=dev->set_tx_freq(trq,0);
    

    //dev->set_tx_gain(gain);
    std::cout << tr.to_pp_string() << "\n";
 

    stream_args.cpu_format="sc16";
    if (use_8bits)
      stream_args.otw_format="sc8";
    else
      stream_args.otw_format="sc16";

    tx_stream=dev->get_tx_stream(stream_args);


    //set properties on the device
    std::cout << boost::format("Setting TX Rate: %f Msps...") % (tx_rate/1e6) << std::endl;
    dev->set_tx_rate(tx_rate);
    std::cout << boost::format("Actual TX Rate: %f Msps...") % (dev->get_tx_rate()/1e6) << std::endl;
    std::cout << boost::format("Setting device timestamp to 0...") << std::endl;


    

    uhd::tx_metadata_t md;


    if(demoMode){

    dev->set_time_now(uhd::time_spec_t(0.0));
    md.start_of_burst = true;
    md.end_of_burst = false;
    md.has_time_spec = false;
    md.time_spec = uhd::time_spec_t(seconds_in_future);

   
    tx_stream->send(buffer0,total_num_samps,md,60);
    
    tx_stream->send(buffer1,total_num_samps,md,3);
    
    tx_stream->send(buffer2,total_num_samps,md,3);

    tx_stream->send(buffer3,total_num_samps,md,3);

    tx_stream->send(buffer4,total_num_samps,md,3);

    tx_stream->send(buffer4,total_num_samps,md,3);

    md.start_of_burst = false;

    std::cout << " " << std::endl;
    std::cout<< "picture transmitted once!" << std::endl;
    std::cout << " " << std::endl;
    
    int f=system("octave toMatlab.m");
    if(f){
      std::cout << " Programm Paused - Press Any Key To leave! " << std::endl;
    }


    }
    else
    {
    
    dev->set_time_now(uhd::time_spec_t(0.0));
    md.start_of_burst = true;
    md.end_of_burst = false;
    md.has_time_spec = false;
    md.time_spec = uhd::time_spec_t(seconds_in_future);

      
    tx_stream->send(buffer0,total_num_samps,md,60);
    
    tx_stream->send(buffer1,total_num_samps,md,3);
    
    tx_stream->send(buffer2,total_num_samps,md,3);

    tx_stream->send(buffer3,total_num_samps,md,3);

    tx_stream->send(buffer4,total_num_samps,md,3);

    tx_stream->send(buffer4,total_num_samps,md,3);

    md.start_of_burst = false;

    std::cout << " " << std::endl;
    std::cout<< "picture transmitted once!" << std::endl;
    std::cout << " " << std::endl;

    };

    //finished
    std::cout << std::endl << "Done!" << std::endl << std::endl;


    return 0;
}
Ejemplo n.º 5
0
void IDPNagato::sinc()
{
  //char fname_energy[64]; sprintf(fname_energy, ftemp_energy, 0);
  //ofstream ofs_energy(fname_energy);
  //ofstream ofs_r1_st(fname_r1_sinc_st), ofs_r1_ev(fname_r1_sinc_ev);
  //ofstream ofs_r2_st(fname_r2_sinc_st), ofs_r2_ev(fname_r2_sinc_ev);
  //ofstream ofs_endeffector(fname_sinc_endeffector);
  ofstream ofs_energy(fname_lst[eENERGY][eSinc][eName]);
  ofstream ofs_r1_st(fname_lst[eGRAPH_ST_R1][eSinc][eName]);
  ofstream ofs_r1_ev(fname_lst[eGRAPH_EV_R1][eSinc][eName]);
  ofstream ofs_r2_st(fname_lst[eGRAPH_ST_R2][eSinc][eName]);
  ofstream ofs_r2_ev(fname_lst[eGRAPH_EV_R2][eSinc][eName]);
  ofstream ofs_endeffector(fname_lst[eGRAPH_ENDEFFECTOR][eSinc][eName]);
  
  //  FILE* fp_energy = fopen(fname_energy,"w");
  //printf("line=%d %s\n", __LINE__, fname_r1_sinc_st);
  //printf("line=%d %s\n", __LINE__, fname_r2_sinc_st);
  //printf("line=%d %s\n", __LINE__, fname_r1_sinc_ev);
  printf("line=%d %s\n", __LINE__
	 , fname_lst[eGRAPH_ST_R1][eSinc][eName]);
  printf("line=%d %s\n", __LINE__
	 , fname_lst[eGRAPH_EV_R1][eSinc][eName]);
  printf("line=%d %s\n", __LINE__
	 , fname_lst[eGRAPH_ST_R2][eSinc][eName]);
  printf("line=%d %s\n", __LINE__
	 , fname_lst[eGRAPH_EV_R2][eSinc][eName]);
  sleep(2);
  
  double t = 0;
  for(nt = 0; nt <= static_cast<int>(Ts/dt); ++nt )
    {
      graph_standard(ofs_r1_st, t,
		     r1.th, r1.thv, r1.tha,
		     e1.ev, e1.ia, e1.tau,
		     e1.energy, e1.ev*e1.ia);
      graph_volt_constituent(ofs_r1_ev, t, e1.ev,
			     b1*r1.thv, b2*r1.tha, b3*e1.tau);
        
      graph_standard(ofs_r2_st, t,
		     r2.th, r2.thv, r2.tha,
		     e2.ev, e2.ia, e2.tau,
		     e2.energy, e2.ev*e2.ia);
      graph_volt_constituent(ofs_r2_ev, t, e2.ev,
			     b1*r2.thv, b2*r2.tha, b3*e2.tau);
      
      graph_endeffector(ofs_endeffector,  t, v1, r3);
      
      t = t + dt;
      v1.th  = sc.sin_th1(t);
      v1.thv = sc.sin_th1v(t);
      v1.tha = sc.sin_th1a(t);

      enemin2 = En();
      // if (nt < nt11){ enemin2 = En1(); }
      // if (nt >= nt11 && nt < nt22){ enemin2 = En2(); }
      // if (nt >= nt22){ enemin2 = En3(); }
      
      ofs_energy << t <<" "<< enemin2 << endl;
      //      fprintf(fp_energy, "%8.4lf %8.4lf\n", t, enemin2 );

      if (nt % 10 == 0)
	{
	  //char fname[4][64];
	  //sprintf(fname[1], ftemp_sinc_e[1], nt);
	  //sprintf(fname[2], ftemp_sinc_e[2], nt);	
	  //sprintf(fname[3], ftemp_sinc_e[3], nt);
	  sprintf(fname_lst[eZU_E1][eSinc][eName],
		  fname_lst[eZU_E1][eSinc][eTemp], nt);
	  sprintf(fname_lst[eZU_E2][eSinc][eName],
		  fname_lst[eZU_E2][eSinc][eTemp], nt);
	  sprintf(fname_lst[eZU_E3][eSinc][eName],
		  fname_lst[eZU_E3][eSinc][eTemp], nt);
	  
	  ofstream ofs1(fname_lst[eZU_E1][eSinc][eName]);
	  ofstream ofs2(fname_lst[eZU_E2][eSinc][eName]);
	  ofstream ofs3(fname_lst[eZU_E3][eSinc][eName]);
	  //zu( ofs1 ); all in
	  //zu( ofs1, ofs2 );
	  zu( ofs1, ofs2, ofs3 );// !not implement
	}
      // output volt ampere field
      // plot("");
    }
  //assert(false);
}
Ejemplo n.º 6
0
void IDPDIRECT::sinc()
{
  //char fname_energy[64]; sprintf(fname_energy, ftemp_energy, 0);
  ofstream ofs_energy(fname_lst[eENERGY][eSinc][eName]     );
  ofstream ofs_r1_st (fname_lst[eGRAPH_ST_R1][eSinc][eName]);
  ofstream ofs_r1_ev (fname_lst[eGRAPH_EV_R1][eSinc][eName]);
  ofstream ofs_r2_st (fname_lst[eGRAPH_ST_R2][eSinc][eName]);
  ofstream ofs_r2_ev (fname_lst[eGRAPH_ST_R2][eSinc][eName]);
  ofstream ofs_r3_st (fname_lst[eGRAPH_ST_R3][eSinc][eName]);
  ofstream ofs_r3_ev (fname_lst[eGRAPH_ST_R3][eSinc][eName]);
  
  //  FILE* fp_energy = fopen(fname_energy,"w");
  printf("line=%d %s\n", __LINE__, fname_lst[eGRAPH_ST_R1][eSinc][eName]);
  printf("line=%d %s\n", __LINE__, fname_lst[eGRAPH_EV_R1][eSinc][eName]);
  printf("line=%d %s\n", __LINE__, fname_lst[eGRAPH_ST_R2][eSinc][eName]);
  printf("line=%d %s\n", __LINE__, fname_lst[eGRAPH_EV_R2][eSinc][eName]);
  printf("line=%d %s\n", __LINE__, fname_lst[eGRAPH_ST_R3][eSinc][eName]);
  printf("line=%d %s\n", __LINE__, fname_lst[eGRAPH_EV_R3][eSinc][eName]);
  
  double t = 0;
  for( int i = 0; i <= static_cast<int>(Ts/dt); ++i )
    {
      graph_standard(ofs_r1_st, t,
		     r1.th, r1.thv, r1.tha,
		     e1.ev, e1.ia, e1.tau,
		     e1.energy, e1.ev*e1.ia);
      graph_volt_constituent(ofs_r1_ev, t, e1.ev,
			     b1*r1.thv, b2*r1.tha, b3*e1.tau);
      // --------------------------------------------------
      graph_standard(ofs_r2_st, t,
		     r2.th, r2.thv, r2.tha,
		     e2.ev, e2.ia, e2.tau,
		     e2.energy, e2.ev*e2.ia);
      graph_volt_constituent(ofs_r2_ev, t, e2.ev,
			     b1*r2.thv, b2*r2.tha, b3*e2.tau);
      // --------------------------------------------------
      graph_standard(ofs_r3_st, t,
		     r3.z0, r3.Thv(), r3.Tha(),
		     e3.ev, e3.ia, e3.tau,
		     e3.energy, e3.ev*e3.ia);
      graph_volt_constituent(ofs_r3_ev, t, e3.ev,
			     b1*r3.Thv(), b2*r3.Tha(), b3*e3.tau);
      // --------------------------------------------------
      t = t + dt;
      v1.th  = sc.sin_th1(t);
      v1.thv = sc.sin_th1v(t);
      v1.tha = sc.sin_th1a(t);
      enemin2 = En();

      ofs_energy << t <<" "<< enemin2 << endl;
      //      fprintf(fp_energy, "%8.4lf %8.4lf\n", t, enemin2 );

      if (i % 10 == 0)
	{
	  sprintf(fname_lst[eZU_E1][eSinc][eName],
		  fname_lst[eZU_E1][eSinc][eTemp], i);
	  sprintf(fname_lst[eZU_E2][eSinc][eName],
		  fname_lst[eZU_E2][eSinc][eTemp], i);
	  sprintf(fname_lst[eZU_E3][eSinc][eName],
		  fname_lst[eZU_E3][eSinc][eTemp], i);
	  
	  ofstream ofs1(fname_lst[eZU_E1][eSinc][eName]);
	  ofstream ofs2(fname_lst[eZU_E2][eSinc][eName]);
	  ofstream ofs2(fname_lst[eZU_E3][eSinc][eName]);
	  // ofstream ofs3(fname_lst[eZU_E2][eSinc][eName]);
	  //zu( ofs1 ); all in
	  //zu( ofs1, ofs2 );
	  zu( ofs1, ofs2, ofs3 );// !not implement
	}
      // output volt ampere field
      // plot("");
    }
}
int main(int argc, char *argv[])
{
    unsigned long file_size, all_state_num, iter_num;
    vector<board> all_state;

    uint64_t count[4] = {-1,0,0,0};
    uint64_t count4created[4] = {-1,0,0,0};
    iter_num = 1;

    printf("program started.\n");

    // 全ての局面 all-state_sorted.dat の読込
    file_size     = get_file_size("all-state_sorted.dat");
    all_state_num = file_size / sizeof(board);
    all_state.resize(all_state_num);
    ifstream ifs("all-state_sorted.dat");
    ifs.read((char*)&all_state[0], all_state.size() * sizeof(board));

    printf("read all-state_sorted\n");

    // 勝敗判定の結果,INDEXは all_state 内の局面の位置
    vector<unsigned char> judge(all_state_num,0);

    // 勝敗判定が着くまでの手数
    vector<unsigned char> judge_count(all_state_num,0);

    // 繰り返し操作の上限
    unsigned long MAX_ITER_NUM = 0;
    unsigned long MAX_ITER_STATE_NUM = all_state_num;
    if (argc == 3) {
        MAX_ITER_NUM = atoi(argv[1]);
        MAX_ITER_STATE_NUM = atoi(argv[2]);
    }

    // 初期化
    for (size_t i=0; i<MAX_ITER_STATE_NUM; i++) {
        board b = all_state[i];
        if (is_win_state(b)) {
            judge[i] = WIN;
            count[WIN]++;
        } else if (is_lose_state(b)) {
            judge[i] = LOSE;
            count[LOSE]++;
        } else {
            judge[i] = UNKNOWN;
            count[UNKNOWN]++;
        }
        judge_count[i] = 0;
    }


    printf("begin create win lose baord\n");

    // 繰り返し勝敗データを更新していく
    for(;;) {
        vector<unsigned char> judge_new(judge);

        unsigned int win_add_num = 0;
        unsigned int lose_add_num = 0;
        if (MAX_ITER_NUM != 0 && iter_num > MAX_ITER_NUM) {
            break;
        }

        for (size_t i=0; i<MAX_ITER_STATE_NUM; i++) {
            board b = all_state[i];
            if (judge[i] == UNKNOWN) {
                unsigned char winorlose = get_winorlose(b, all_state, judge);

                if (winorlose == WIN) {
                    judge_new[i] = WIN;
                    judge_count[i] = iter_num;
                    count[WIN]++;
                    count[UNKNOWN]--;
                    win_add_num++;
                } else if(winorlose == LOSE) {
                    judge_new[i] = LOSE;
                    judge_count[i] = iter_num;
                    count[LOSE]++;
                    count[UNKNOWN]--;
                    lose_add_num++;
                }

            }
        }

        count4created[LOSE] += lose_add_num;
        count4created[WIN]  += win_add_num;

        printf("---------------------\n");
        printf("iter_num: %ld\n", iter_num);
        printf("win_add_num: %d\n", win_add_num);
        printf("lose_add_num: %d\n", lose_add_num);
        printf("count4created[win] = %ld\n", count4created[WIN]);
        printf("count4created[lose] = %ld\n", count4created[LOSE]);

        judge.swap(judge_new);

        if (win_add_num == 0 && lose_add_num == 0) {
            break;
        }

        iter_num++;
    }

    // 結果を出力
    printf("---------------------\n");
    printf("size = %ld\n", all_state.size());
    printf("win_num = %ld\n", count[WIN]);
    printf("lose_num = %ld\n", count[LOSE]);
    printf("count4created[win] = %ld\n", count4created[WIN]);
    printf("count4created[lose] = %ld\n", count4created[LOSE]);
    printf("unknown_num = %ld\n", count[UNKNOWN]);
    printf("iter_num = %ld\n", iter_num);

    ofstream ofs1("judge.dat");
    ofs1.write((char *)&judge[0], judge.size()*sizeof(unsigned char));

    ofstream ofs2("judge_count.dat");
    ofs2.write((char *)&judge_count[0], judge_count.size()*sizeof(unsigned char));

    return 0;
}
Ejemplo n.º 8
0
int cond::TestGTPerf::execute(){

  std::string gtag = getOptionValue<std::string>("globaltag");
  bool debug = hasDebug();
  std::string connect = getOptionValue<std::string>("connect");
  bool verbose = hasOptionValue("verbose");

  int nThrF = getOptionValue<int>("n_fetch");
  int nThrD = getOptionValue<int>("n_deser");
  std::cout << "\n++> going to use " << nThrF << " threads for loading, " << nThrD << " threads for deserialization. \n" << std::endl;

  std::string serType = "unknown";
  if ( connect.find("CMS_CONDITIONS") != -1 ) {
    serType = "ROOT-5";
  } else if (connect.find("CMS_TEST_CONDITIONS") != -1 ) {
    serType = "boost";
  }

  Time_t startRun= 150005;
  if(hasOptionValue("start_run")) startRun = getOptionValue<Time_t>("start_run");
  Time_t startTs= 5800013687234232320;
  if(hasOptionValue("start_ts")) startTs = getOptionValue<Time_t>("start_ts");
  Time_t startLumi= 908900979179966;
  if(hasOptionValue("start_lumi")) startLumi = getOptionValue<Time_t>("start_lumi");

  std::string authPath("");
  if( hasOptionValue("authPath")) authPath = getOptionValue<std::string>("authPath");

  initializePluginManager();

  Timer timex(serType);

  ConnectionPoolWrapper connPool( 1, authPath, hasDebug() );
  Session session = connPool.createSession( connect );
  session.transaction().start();
  
  std::cout <<"Loading Global Tag "<<gtag<<std::endl;
  GTProxy gt = session.readGlobalTag( gtag );

  session.transaction().commit();

  std::cout <<"Loading "<<gt.size()<<" tags..."<<std::endl;
  std::vector<UntypedPayloadProxy *> proxies;
  std::map<std::string,size_t> requests;
  size_t nt = 0;
  for( auto t: gt ){
    nt++;
    UntypedPayloadProxy * p = new UntypedPayloadProxy;
    p->init( session );
    try{
      p->load( t.tagName() );
      if (nThrF == 1) { // detailed info only needed in single-threaded mode to get the types/names
	p->setRecordInfo( t.recordName(), t.recordLabel() );
      }
      proxies.push_back( p );
      requests.insert( std::make_pair( t.tagName(), 0 ) );
    } catch ( const cond::Exception& e ){
      std::cout <<"ERROR: "<<e.what()<<std::endl;
    }
  }
  std::cout << proxies.size() << " tags successfully loaded." << std::endl;
  timex.interval("loading iovs");
  
  Time_t run = startRun;
  Time_t lumi = startLumi;
  Time_t ts = startTs;

  if (nThrF > 1) session.transaction().commit();

  tbb::task_scheduler_init init( nThrF );
  std::vector<std::shared_ptr<FetchWorker> > tasks;

  std::string payloadTypeName;
  for( auto p: proxies ){
      payloadTypeName = p->payloadType();
      // ignore problematic ones for now
      if ( (payloadTypeName == "SiPixelGainCalibrationOffline")  // 2 * 133 MB !!!
	   ) { 
	std::cout << "WARNING: Ignoring problematic payload of type " << payloadTypeName << std::endl;
	continue;
      }

      if (nThrF > 1) {
        auto fw = std::make_shared<FetchWorker>(connPool, connect, p, (std::map<std::string,size_t> *) &requests,
							    run, lumi, ts);
	tasks.push_back(fw);
      } else {
	bool loaded = false;
	time::TimeType ttype = p->timeType();
	auto r = requests.find( p->tag() );
	try{
	  if( ttype==runnumber ){
	    p->get( run, hasDebug() );	
	    r->second++;
	  } else if( ttype==lumiid ){
	    p->get( lumi, hasDebug() );
	    r->second++;
	  } else if( ttype==timestamp){
	    p->get( ts, hasDebug() );
	    r->second++;
	  } else {
	    std::cout <<"WARNING: iov request on tag "<<p->tag()<<" (timeType="<<time::timeTypeName(p->timeType())<<") has been skipped."<<std::endl;
	  }
	  timex.fetchInt(p->getBufferSize()); // keep track of time vs. size
	} catch ( const cond::Exception& e ){
	  std::cout <<"ERROR:"<<e.what()<<std::endl;
	}
      } // end else (single thread)
  }

  tbb::parallel_for_each(tasks.begin(),tasks.end(),invoker<std::shared_ptr<FetchWorker> >() );

  std::cout << "global counter : " << fooGlobal << std::endl;

  if (nThrF == 1) session.transaction().commit();
  // session.transaction().commit();

  timex.interval("loading payloads");

  size_t totBufSize = 0;
  for( auto p: proxies ){
      totBufSize += p->getBufferSize();
  }
  std::cout << "++> total buffer size used : " << totBufSize << std::endl;

  std::vector<std::shared_ptr<void> > payloads;
  payloads.resize(400); //-todo: check we don't have more payloads than that !!

  std::shared_ptr<void> payloadPtr;

  tbb::task_scheduler_init initD( nThrD );
  std::vector<std::shared_ptr<DeserialWorker> > tasksD;

  timex.interval("setup deserialization");

  int nEmpty = 0;
  int nBig = 0;
  int index = 0;
  for( auto p: proxies ){

///     if ( p->getBufferSize() == 0 ) { // nothing to do for these ... 
///       std::cout << "empty buffer found for " << p->payloadType() << std::endl;
///       nEmpty++;
///       continue;
///     }

    payloadTypeName = p->payloadType();

    // ignore problematic ones for now
    if ( (payloadTypeName == "SiPixelGainCalibrationForHLT")
	 or (payloadTypeName == "SiPixelGainCalibrationOffline")  // 2 * 133 MB !!!
	 or (payloadTypeName == "DTKeyedConfig") 
	 or (payloadTypeName == "std::vector<unsigned long long>") 
	 or (payloadTypeName == "  AlignmentSurfaceDeformations")
	 // only in root for now:
	 or (payloadTypeName == "PhysicsTools::Calibration::MVAComputerContainer")
	 or (payloadTypeName == "PhysicsTools::Calibration::MVAComputerContainer")
	 or (payloadTypeName == "PhysicsTools::Calibration::MVAComputerContainer")
	 or (payloadTypeName == "PhysicsTools::Calibration::MVAComputerContainer")
	 ) { 
      std::cout << "INFO: Ignoring payload of type " << payloadTypeName << std::endl;
      continue;
    }
    
    if (nThrD > 1) {
      auto dw = std::make_shared<DeserialWorker>(p, payloads[index]);
      tasksD.push_back(dw); 
    } else { // single tread only
       try {
	 std::pair<std::string, std::shared_ptr<void> > result = fetchOne( payloadTypeName, p->getBuffer(), p->getStreamerInfo(), payloadPtr);
           payloads.push_back(result.second);
       } catch ( const cond::Exception& e ){
           std::cout << "\nERROR (cond): " << e.what() << std::endl;
           std::cout << "for payload type name: " << payloadTypeName << std::endl;
       } catch ( const std::exception& e ){
           std::cout << "\nERROR (boost/std): " << e.what() << std::endl;
           std::cout << "for payload type name: " << payloadTypeName << std::endl;
       }
       timex.deserInt(p->getBufferSize()); // keep track of time vs. size
    } // single-thread
    index++; // increment index into payloads
  }
  std::cout << std::endl;

  tbb::parallel_for_each(tasksD.begin(),tasksD.end(),invoker<std::shared_ptr<DeserialWorker> >() );
 
  timex.interval("deserializing payloads");

  std::cout << "global counter : " << fooGlobal << std::endl;
  std::cout << "found   " << nEmpty << " empty payloads while deserialising " << std::endl;

  std::cout <<std::endl;
  std::cout <<"*** End of job."<<std::endl;
  std::cout <<"*** GT: "<<gtag<<" Tags:"<<gt.size()<<" Loaded:"<<proxies.size()<<std::endl;
  std::cout<<std::endl;
  for( auto p: proxies ){
    auto r = requests.find( p->tag() );
    if( verbose ){
      std::cout <<"*** Tag: "<<p->tag()<<" Requests processed:"<<r->second<<" Queries:"<< p->numberOfQueries() <<std::endl;
      const std::vector<std::string>& hist = p->history();
      for( auto e: p->history() ) std::cout <<"    "<<e<<std::endl;
    }
  }

  // only for igprof checking of live mem:
  // ::exit(0);

  timex.interval("postprocessing ... ");
  timex.showIntervals();
  
  if ( nThrF == 1) {
    std::ofstream ofs("fetchInfo.txt");
    timex.showFetchInfo(ofs);
    std::ofstream ofs2("sizeInfo.txt");
    for ( auto p: proxies ) {
      ofs2 << p->payloadType() << "[" << p->recName() << ":" << p->recLabel() << "]" << " : " << p->getBufferSize() << std::endl;
    }
  }
  if ( nThrD == 1) {
    std::ofstream ofs1("deserializeInfo.txt");
    timex.showDeserInfo(ofs1);
  }
  
  return 0;
}