Zo vstupného súboru so 6 stĺpcami vyberie číslo častice - tretí stĺpec

/* ========================================================================== */
/*                                                                            */
/*   CCastic.cpp                                                              */
/*                                                                            */
/*   Description                                                              */
/*   Trida vypocita rapitity castice pt nad souborem podle vzorce:            */
/*                ____________________                                        */
/*               V m2 + (px)2 + (py)2 + pz                                    */
/*   y = 1/2*ln(----------------------------)                                 */
/*                ____________________                                        */
/*               V m2 + (px)2 + (py)2 - pz                                    */
/*                                                                            */
/*   Vypocita faktor c pro 2 castice:                                         */
/*        _______________________________    _______________________________  */
/*   c =(V m2 + (px1)2 + (py1)2 + (pz1)2  * V m2 + (px2)2 + (py2)2 + (pz2)2  - (px1 * px2 + py1*py2 + pz1*pz2))*1/m2 */
/*                _____                                                       */
/*   y12 = ln(c+ Vc2-1)                                                       */
/*                                                                            */
/* ========================================================================== */
 
#include <conio.h>
#include <string.h>
#include <io.h>
#include "ccastic.h"
 
 
// konstruktor
CCastic::CCastic(char* meno, float _m)
{
	m = _m;
	memset(&cs, 0x00, sizeof(cs));
	lsize = 1;
	por = 0;
	N   = 1;
	rz = '|';
 
	// znuluj kursory
	for(int i=0; i<POC_CURSORS; i++)
	{
		filepos[i] = 0;
		memset(&cs_cursor[i], 0x00, sizeof(cs));
	}
 
	// hledana castice
	hcast = _m;
 
	// otevre soubor
	f = fopen(meno, "rb");
	GetLineSize();
 
	cs.por = 0;
//	MoveNext();
}
 
 
// destruktor
CCastic::~CCastic()
{
	fclose(f);
}
 
 
// nastav parametr m
void CCastic::SetM(float _m)
{
	m = _m;
}
 
// vypocita rapitity castice
//              ____________________
//             V m2 + (px)2 + (py)2 + pz
// y = 1/2*ln(----------------------------)
//              ____________________
//             V m2 + (px)2 + (py)2 - pz
//
float CCastic::CalcRapidity()
{
float mv;
 
	// medzivypocet
	mv = pow(m,2) + pow(cs.px,2) + pow(cs.py,2) + pow(cs.pz,2);
 
	// vysledek
	cs.y = 1.0/2 * log( (sqrt(mv) + cs.pz) / (sqrt(mv) - cs.pz));
	return cs.y;
}
 
 
// vypocita faktor c pro 2 castice
//      _______________________________    _______________________________
// c =(V m2 + (px1)2 + (py1)2 + (pz1)2  * V m2 + (px2)2 + (py2)2 + (pz2)2  - (px1 * px2 + py1*py2 + pz1*pz2))*1/m2
//              _____
// y12 = ln(c+ Vc2-1)
//
float CCastic::CalcFaktorC(castic cs2)
{
float c1,c2,c3,c;
float y12;
 
	c1 = sqrt( pow(m,2) + pow(cs.px,2) + pow(cs.py,2) + pow(cs.pz,2));
	c2 = sqrt( pow(m,2) + pow(cs2.px,2) + pow(cs2.py,2) + pow(cs2.pz,2));
	c3 = cs.px * cs2.px + cs.py * cs2.py + cs.pz * cs2.pz;
	c = (c1*c2-c3) / pow(m,2);
 
	y12 = log(c + sqrt(pow(c,2) - 1));
	return y12;
}
 
// vypocita Pt
//       __________
// Pt = V px2 + py2
//
float CCastic::CalcPt()
{
float Pt;
 
	Pt = sqrt( pow(cs.px,2) + pow(cs.py,2));
	return Pt;
}
 
 
// vrat hodnotu aktualne castice
castic CCastic::GetCastice()
{
	return cs;
}
 
// hodnota cursora
castic CCastic::GetCasticeCursor(int i)
{
    return cs_cursor[i];
}
 
 
// aka je velikost radku
void CCastic::GetLineSize()
{
	fseek(f,0L, SEEK_SET);
	fscanf(f,"%d%d%d%g%g%g", &cs.event, &cs.poradi, &cs.cislo, &cs.px, &cs.py, &cs.pz);
 
	fgetpos(f, &lsize);
	lsize++;				// aj \n
	fseek(f,0L, SEEK_SET);
}
 
 
// presun na prvni radek
void CCastic::MoveFirst()
{
	fseek(f,0L, SEEK_SET);
	cs.por = 0;
	MoveNext();
}
 
 
// precte dalsi radek
void CCastic::MoveNext()
{
	if( IsEOF())
		return;
 
	do
	{
		// precti
		fscanf(f,"%d%d%d%g%g%g\n", &cs.event, &cs.poradi, &cs.cislo, &cs.px, &cs.py, &cs.pz);
		cs.por++;
 
		// zobraz ruzici aby videl ze neco dela, iba kazdych 10 aby nezdrzoval
//      if(( cs.por % 10 ) == 0)
//    		ViewRuzica(cs.por);
	}
	while(( cs.cislo != hcast )
		&& !IsEOF());
 
	// vypocti rapitidy
//	CalcRapidity();
}
 
 
// precte predosly rad
void CCastic::MovePrev()
{
fpos_t pos;
 
	// aktualni pozice
	fgetpos(f, &pos);
 
	do
	{
		pos -= 2*lsize;
		fseek(f, pos, SEEK_SET);
 
		fscanf(f,"%d%d%d%f%f%f\n", &cs.event, &cs.poradi, &cs.cislo, &cs.px, &cs.py, &cs.pz);
		cs.por--;
	}
	while(( abs(cs.cislo) != hcast )
	   && ( pos > 0 ));
 
	// vypocti rapitidy
	CalcRapidity();
}
 
 
// presun na posledni
void CCastic::MoveLast()
{
long size;
 
	fseek(f, 0L, SEEK_END);
 
	fgetpos(f, &size);
	cs.por = size/lsize;
 
	fseek(f, (size-lsize), SEEK_SET);
	fscanf(f,"%d%d%d%f%f%f\n", &cs.event, &cs.poradi, &cs.cislo, &cs.px, &cs.py, &cs.pz);
 
	// posledny nesuhlasi - hladaj predosly
	if( abs(cs.cislo) != hcast )
		MovePrev();
}
 
 
// je konec souboru
int CCastic::IsEOF()
{
	return feof(f);
}
 
 
// zmaze aktualni castici
void CCastic::ClearCursor()
{
fpos_t pos;
int i;
 
	// ulozime poziciu
	fgetpos(f, &pos);
	fclose(f);
 
	// otvorime a zapiseme nuly
	f = fopen(TMP_FILE, "r+b");
    i = 1;
 
    while( cs_cursor[i].por != 0 )
    {
        //
    	fseek(f, (cs_cursor[i].por-1) * lsize, SEEK_SET);
 
    	// zmazanu zapis
    	cs_cursor[i].cislo = 0;
    	fprintf(f,"%8d%7d%9d%12.8f%12.8f%12.8f\n", cs_cursor[i].event, cs_cursor[i].poradi, cs_cursor[i].cislo
                                                 , cs_cursor[i].px, cs_cursor[i].py, cs_cursor[i].pz);
 
        // cele zmaz
    	memset(&cs_cursor[i], 0x00, sizeof(cs_cursor[i]));
        i++;
    }
   	fclose(f);
 
	// otovrime znova na pozicii
	f = fopen(TMP_FILE, "rb");
	fsetpos(f, &pos);
}
 
 
// zapamatuje si pozici kurzora
void CCastic::GetCursor(int i)
{
	// prekrocen max. pocet cursoru
	if( i>= POC_CURSORS )
		return;
 
	fgetpos(f, &filepos[i]);
	cs_cursor[i] = cs;
}
 
 
// obnovi pozici kurzora
void CCastic::SetCursor(int i)
{
	// prekrocen max. pocet cursoru
	if( i>= POC_CURSORS )
		return;
 
	if( filepos != 0 )
	{
		fsetpos(f, &filepos[i]);
		cs = cs_cursor[i];
	}
}
 
 
// kresli ruzicu aby bylo videt ze neco dela
void CCastic::ViewRuzica(long cislo)
{
int x,y;
 
	x = wherex();
	y = wherey();
 
	if( cislo != 0 )
	    printf("%8ld %c", cislo, rz);
	else
	    printf("         %c", rz);
 
	gotoxy(x,y);
 
	// posune na dalsi znak
	switch( rz )
	{
		case '|' : rz = '/';  break;
		case '/' : rz = '-';  break;
		case '-' : rz = '\\'; break;
		case '\\': rz = '|';  break;
	}
}
 
// spocte N
void CCastic::CountN()
{
	MoveLast();
	N = cs.por / cs.event;
}
 
// vrati N
int CCastic::GetN()
{
	return N;
}