Моделирование канала записи-воспроизведения на ЭВМ

FormPrBar->PrBar->Progress = 30; //30%

for (n = 0; n < COUNT; n++)

{

logFile.open("Calculate.log", ios::app); logFile<<" "<<i<<"-й цикл ..."<<endl;

logFile.close();

xeps = 0.0f; eps1 = HX(0.,y0[n]);

do

{

xeps += 0.2 * hd.workBacklashWidth;

} while (HX(xeps, y0[n])/eps1 > 0.15);

dx = heps / LEN - 1;

do

{

exm = 0.; x1 = dx; x2 = xeps; e = dx/LEN;

do

{

if (fabs(x1-x2) <= e)

{

x0 = (x1+x2)/2.0f;

a1 = cAccounts::F(x1, y0[n]); a2 = cAccounts::F(x0, y0[n]);

if (a1*a2 > 0.0f) x1 = x0;

if (a1*a2 < 0.0f) x2 = x0;

}

else break;

} while(a1*a2 != 0.0f);

xh = (x1+x2)/2.0f; H0 = 1.0;

for (i = 0; i < LEN; i++)

{

x[i] = i * dx + xh; ahx[i] = H0*HX(x[i],y0[n]);

adhx[i] = dHX(x[i],y0[n]); ahy[i] = H0*HY(x[i],y0[n]);

ahx[i] += ahy[i] / 3.0f; q = Hx(x[i], y0[n]) / ahx[i];

adhx[i] += dHY(x[i], y0[n]) / 3.0f; ahy[i] = q;

ro0[i] = exp(-sqr(cp.alpha * (cp.betta * ahx[i]-1.)));

ex[i] = -ahx[i] * adhx[i] * ro0[i] * q;

if (ex[i] <= exm) continue;

exm = ex[i];

}

if (ex[ARR_SIZE]/exm > 0.03f) dx *= 2.0f;

} while (ex[ARR_SIZE]/exm > 0.03f);

if (n + 2 - COUNT <= 0.) dxm = dx;

for (int i = 0; i < LEN; i++)

{

x[i] = x[i] / hd.workBacklashWidth; ex[i] /= exm;

}

f<<endl<<"Значение функции чувствительности (ex) для "<<n<<"-го слоя"<<endl;

for (i = 0; i < LEN; i++)

f<<"x("<<i<<") = "<<x[i]<<setw(5)<<"ex("<<setw(2)<<i<<") = "<<ex[i]<<endl;

xm = CalcCentOfGrav(ex, dx, LEN);

for (int i = 0; i < LEN; i++)

{

sens_l[i].x = x[i]; sens_l[i].y = ex[i];

}

for (int i = 0; i < LEN; i++) ex[i] *= exm * c;

FormPrBar->PrBar->Progress = 50;

dp = 10.; dp1 = 14.;

r = 2.0 * PI * dp * dx;

logFile.open("Calculate.log", ios::app);

logFile<<" Вызов функции CalcDRTF() ..."<<endl;

logFile.close();

for (ip = 0; ip < LEN; ip++)

{

CalcDRTF(ex, LEN, ip, r, dx, si, sr); sni[ip] = si; snr[ip] = sr;

}

double sn0 = sqrt(sni[0] * sni[0] + snr[0] * snr[0]);

logFile.open("Calculate.log", ios::app);

logFile<<" Расщет АВХ и ФВХ "<<n<<"-го слоя ..."<<endl; logFile.close();

for(int i = 0; i < LEN; i++)

{

smn[i] = sqrt(sni[i] * sni[i] + snr[i] * snr[i]) / sn0;

phin[i] = 180./PI*(atan(sni[i]/snr[i]) - atan(tan(r*i*xm/dx)));

f<<"smn["<<setw(2)<<ip<<"] = "<<smn[ip]<<" phin["<<setw(2)<<ip<<"] = "<<phin[ip]<<endl;

}

for (int i = 0; i < LEN; i++)

{

awc_l[i].x = pwc_l[i].x = dp1 * i; awc_l[i].y = smn[i]; pwc_l[i].y = phin[i];

}

double yr = y0[n] - cp.nonContactRec + cp.nonContactRep;

logFile.open("Calculate.log", ios::app);

logFile<<" Вызов функции Kadn() ..."<<endl; logFile.close();

Kadn(dp1, yr, dy[n], td.maxMagnPermeabOfCarrier, td.initMagnPermeabOfCarrier, sni, snr);

logFile.open("Calculate.log", ios::app);

logFile<<" Расщет остаточной намагниченности "<<n<<"-го слоя ..."<<endl;

logFile.close();

switch (n)

{

case 0: case 6: ak = 1.0f; break;

case 1: case 3: case 5: ak = 4.0f; break;

case 2: case 4: ak = 2.0f; break;

}

for(int i = 0; i < LEN; i++)

{

s1[i] = s1[i] + ak * sni[i] * dy[0] / (3.0 * td.thicknessOfWorkLayer);

s1[i] *= LossesSelfMagnetic(td.initMagnPermeabOfCarrier, td.maxMagnPermeabOfCarrier, dy[n],i+1) *

LossesInvertSelfMagnetic(td.thicknessOfWorkLayer, cp.nonContactRec, td.maxMagnPermeabOfCarrier, i+1);

imResidMagn[i] = s1[i];

s2[i] = s2[i] + ak * snr[i] * dy[0] / (3.0 * td.thicknessOfWorkLayer);

s2[i] *= LossesSelfMagnetic(td.initMagnPermeabOfCarrier, td.maxMagnPermeabOfCarrier, dy[n],i+1) *

LossesInvertSelfMagnetic(td.thicknessOfWorkLayer, cp.nonContactRec, td.maxMagnPermeabOfCarrier, i+1);

reResidMagn[i] = s2[i];

}

}

Application->ProcessMessages();

FormPrBar->PrBar->Progress = 100;

for(i = 0; i < LEN; i++)

f<<"s1["<<setw(2)<<i<<"] = "<<s1[i]<<" s2["<<setw(2)<<i<<"] = "<<s2[i]<<endl;

logFile.open("Calculate.log", ios::app);

logFile<<"Рсчет потока в головке воспроизведения ..."<<endl; logFile.close();

for(int i = 0; i < LEN; i++)

{

sm[i] = sqrt(s1[i]*s1[i] + s2[i]*s2[i]); awcChannelOnFlow[i] = sm[i];

emf[i]= sm[i] * 2.0 * PI * dp1 * i; awcChannelOnEDF[i] = emf[i];

}

smm = sm[0]; emfm = 0;

for (int i = 0; i < LEN; i++)

{

if (fabs(emf[i]) > fabs(emfm)) emfm = emf[i];

}

for (int i = 0; i < LEN; i++)

{

sm[i] /= smm; awcChannelOnFlow[i] = sm[i];

emf[i] /= emfm; awcChannelOnEDF[i] = emf[i];

}

logFile.open("Calculate.log", ios::app);

logFile<<"Расчет импульсной характеристики канала ..."<<endl;

logFile.close();

double r1 = 0.0f, excm = 0.0f,

si1 = 0.0f, sr1 = 0.0f,

ep = 0.0f, j54 = 0.0f;

int j52 = 0, iexc = 0;

do

{

r = 2.0 * PI * dp1 * dxm;

r1 = 2.0 * PI * dp1;

excm = iexc = 0.0;

j52 = 2 * LEN;

logFile.open("Calculate.log", ios::app); logFile<<" for ..."<<endl; logFile.close();

for (int i = LEN; i < j52; i++)

{

ip = i - LEN;

CalcDRTF(s1, LEN, i, r, r1, si, sr); CalcDRTF(s2, LEN, i, r, r1, si1, sr1);

exc[i] = 1.0 / r1 * (si + sr1);

if ((fabs(exc[i]) - fabs(excm)) > 0) excm = exc[i];

}

ep = exc[j52-1] / excm;

logFile.open("Calculate.log", ios::app); logFile<<" ep = "<<ep<<endl; logFile.close();

if (ep > 0.05) dxm *= 2.0;

}

while(ep > 0.05);

j54 = LEN-1.;

logFile.open("Calculate.log", ios::app);

logFile<<"for ..."<<endl;

logFile.close();

for (int i = 0; i <= j54; i++)

{

ip = i;

CalcDRTF(s1, LEN, ip, r, r1, si, sr); CalcDRTF(s1, LEN, ip, r, r1, si1, sr1);

a1 = 1.0 / PI * (sr1 - si); exc[LEN-i] = a1;

if (i == (j54 - 1)) iexc = LEN-1.;

}

j54 = LEN + iexc + 1;

logFile.open("Calculate.log", ios::app);

logFile<<"for ..."<<endl;

logFile.close();

for (i = 0; i < j54; i++)

{

exc[i] = exc[LEN-iexc+i] / excm;

pcChannel[i] = exc[i];

}

int j53 = 2*(int)((LEN+iexc)/2.0f)+1;

f<<"Импульсная характеристика ..."<<endl;

for (int i =0; i < j53; i++)

{

puls_ch[i].x = dxm * i / hd.workBacklashWidth; puls_ch[i].y = exc[i];

f<<"x = "<<puls_ch[i].x<<" exc["<<i<<"] = "<<exc[i]<<endl;

}

Application->ProcessMessages();

logFile.open("Calculate.log", ios::app);

logFile<<"Расчет потерь при воспроизведении ..."<<endl;

logFile.close();

double m0 = 4.0f*PI*1e-4, b = 3e-3;

double Kad[LEN], Kl[LEN], S[LEN], Ka[LEN] ;

Kad[0] = 1.0f; Kl[0] = 0.0f; S[0] = 1.0f; Ka[0] = 0.0f;

for (int i = 0; i < LEN; i++)

{

double k = i;

if (i==0) k=0.0001;

double ch = tanh(2.0f*PI*td.thicknessOfWorkLayer)*

(1.0f + tanh(PI*k*td.thicknessOfWorkLayer)/hd.initMagnPermeab);

double zn1 = 2.0f*PI*td.thicknessOfWorkLayer*k*cosh(2.0f*PI*td.thicknessOfWorkLayer*k);

double zn2 = 1.0f + tanh(PI*k*td.thicknessOfWorkLayer) +

(1.0f/hd.maxMagnPermeab + tanh(2.0f*PI*k*td.thicknessOfWorkLayer)*hd.maxMagnPermeab)*

tanh(2.0f*PI*k*td.thicknessOfWorkLayer);

Kad[i] = ch / (zn1*zn2);

}

logFile.open("Calculate.log", ios::app);

logFile<<"Расчет Kl ..."<<endl;

logFile.close();

for (int i = 0; i < LEN; i++)

{

Kl[i] = 1.0f - exp(-i*hd.radiusOfPoleTips);

}

Application->ProcessMessages();

logFile.open("Calculate.log", ios::app);

logFile<<"Расчет S ..."<<endl;

logFile.close();

for (int i = 0; i < LEN; i++)

{

double k = i;

if (!i) k=0.0001;

S[i] = sin(k*hd.workBacklashWidth)/(k*hd.workBacklashWidth);

}

logFile.open("Calculate.log", ios::app);

logFile<<"Расчет Ka ..."<<endl;

logFile.close();

for (int i = 0; i < LEN; i++) Ka[i] = S[i] * Kl[i];

for (int i = 0; i < LEN; i++)

{

double k = i;

if (!i) k=0.0001;

double ksh = hd.magnResOfCore / hd.magnResOfBacklash;

double tet = hd.thicknessPlatesOfCore*sqrt(hd.initMagnPermeab*2*PI*k/hd.specElecResOfMater);

double tg = (sinh(tet)-sin(tet))/(sinh(tet)+sin(tet));

Ka[i] *= LossesFrequency(ksh, hd.maxMagnPermeab, hd.initMagnPermeab, tg);

}

logFile.open("Calculate.log", ios::app);

logFile<<"Расчет АВХ канала по потоку ..."<<endl; logFile.close();

f<<"Расчет АВХ канала по потоку ..."<<endl;

for (int i = 0; i < LEN; i++)

{

imFlow[i] = m0*b*Ka[i]*s1[i]*Kad[i]; reFlow[i] = m0*b*Ka[i]*s2[i]*Kad[i];

awcChannelOnFlow[i] = sqrt(sqr(imFlow[i]) + sqr(reFlow[i]));

f<<"АВХ("<<i<<") = "<<awcChannelOnFlow[i]<<endl;

}

awcChannelOnFlow[0] = awcChannelOnFlow[1];

logFile.open("Calculate.log", ios::app);

logFile<<"Расчет коэффициента нелинейных искажений ..."<<endl; logFile.close();

facOfHarm[0] = 0.0f;

for (int i = 0; i < LEN/3; i++)

{

facOfHarm[i] = awcChannelOnFlow[3*i]/awcChannelOnFlow[i];

f<<"АВХ("<<i<<") = "<<awcChannelOnFlow[i]<<endl;

}

Application->ProcessMessages();

logFile.open("Calculate.log", ios::app);

logFile<<"Расчет ФВХ канала по потоку ..."<<endl; logFile.close();

pwcChannel[0] = 0.0f;

for (int i = 1; i < LEN; i++)

{

pwcChannel[i] = atan(awcChannelOnEDF[i]); //imFlow[i]/reFlow[i]);

f<<"ФВХ("<<i<<") = "<<pwcChannel[i]<<endl;

};

logFile.open("Calculate.log", ios::app);

logFile<<"Расчет АВХ канала по потоку ..."<<endl; logFile.close();

for (int i = 1; i < LEN; i++)

{

awcChannelOnEDF[i] = 1200 * i * awcChannelOnFlow[i]/awcChannelOnFlow[0];

f<<"АВХ("<<i<<") = "<<awcChannelOnFlow[i]<<endl;

}

f.close(); FormPrBar->Hide(); return (1);

}

double sign(double x)

{

if (x == 0.0f) return (0.0f);

if (x > 0.0f) return (1.0f);

if (x < 0.0f) return (-1.0f);

}

double cAccounts::Hz(double x, double y)

{

double z = PI * sqrt(sqrt(sqr(x*x - y*y -sqr(hd.workBacklashWidth)/4.0f) + 4.0f*x*x*y*y));

return hd.workBacklashWidth / z;

}

double cAccounts::Hx(double x, double y)

{

double res = Hz(x,y)*cos(atan(2.0f*x*y /(x*x-y*y-sqr(hd.workBacklashWidth/2.0f)))/2.0f);

return res;

}

double cAccounts::Hy(double x, double y)

{

double res = Hz(x,y)*sin(atan(2.0f*x*y /(x*x-y*y-sqr(hd.workBacklashWidth/2.0f)))/2.0f)*sign(-x);

return res;

}

void cAccounts::CalcArr(double mas1[], double mas2[])

{

for(int i = 0; i < LEN; i++) mas1[i] = mas2[i];

}

void cAccounts::LetArr(int valtype, double mas[])

{

switch (valtype)

{

case G_AWC_CHANNEL_ON_FLOW : CalcArr(mas, awcChannelOnFlow); break;

case G_AWC_CHANNEL_ON_EDF : CalcArr(mas, awcChannelOnEDF); break;

case G_PWC_CHANNEL : CalcArr(mas, pwcChannel); break;

case G_FACT_OF_HARM : CalcArr(mas, facOfHarm); break;

}

}

void cAccounts::GetData(sHeadData h){ hd = h;}

void cAccounts::GetData(sTapeData t){ td = t;}

void cAccounts::GetData(sChParam p){ cp = p;}

void cAccounts::Normalize(const double mas1[], double mas[])

{

CheckData(mas1);

for (int i = 0; i < LEN; i++) mas[i] = mas1[i];

double m = fabs(mas[0]) ;

for (int i = 1; i < LEN; i++) if (m < fabs(mas[i])) m = fabs(mas[i]);

for (int i = 0; i < LEN; i++) mas[i] /= m;

return;

}

void cAccounts::Normalize(double mas1[], double mas2[], double mas3[])

{

CheckData(mas1, mas2, mas3);

double m = fabs(mas1[0]) ;

for (int i = 1; i < LEN; i++)

{

if (m < fabs(mas1[i])) m = fabs(mas1[i]); if (m < fabs(mas2[i])) m = fabs(mas2[i]);

if (m < fabs(mas3[i])) m = fabs(mas3[i]);

}

for (int i = 0; i < LEN; i++) { mas1[i] /= m; mas2[i] /= m; mas3[i] /= m; }

return;

}

void cAccounts::CheckData(double mas1[], double mas2[], double mas3[])

{

isNegative = false; isPozitive = false;

for (int i = 0; i < LEN; i++)

{

if ((mas1[i] < 0)||(mas2[i] < 0)||(mas3[i] < 0)) isNegative = true;

if ((mas1[i] > 0)||(mas2[i] > 0)||(mas3[i] > 0)) isPozitive = true;

}

}

void cAccounts::CheckData(const double mas[])

{

isNegative = false; isPozitive = false;

for (int i = 0; i < LEN; i++)

{

if (mas[i] < 0) isNegative = true;

if (mas[i] > 0) isPozitive = true;

}

}

eRET_VAL cAccounts::CalculatePoints(bool norm, int type, sRect rect, TPoint points[])

{

double mas[LEN];

switch (type)

{

case G_AWC_CHANNEL_ON_FLOW :

if (norm) Normalize(awcChannelOnFlow, mas); break;

case G_AWC_CHANNEL_ON_EDF :

if (norm) Normalize(awcChannelOnEDF, mas); break;

case G_PULS_CHARACT :

if (norm) Normalize(pcChannel, mas); break;

case G_PWC_CHANNEL : if (norm) Normalize(pwcChannel, mas); break;

case G_HEAD_FLOW : if (norm) Normalize(flow, mas); break;

case G_FACT_OF_HARM : if (norm) Normalize(facOfHarm, mas);break;

case G_AMPLIT : if (norm) Normalize(amplitude, mas); break;

case G_EDF : if (norm) Normalize(edf, mas); break;

}

eRET_VAL res;

int scaly; int half = 0;

if (isNegative && !isPozitive)

{

res = RV_NEG; scaly = (rect.y2 - rect.y1)/(-10);

} else

if (!isNegative && isPozitive)

{

res = RV_POZ; scaly = (rect.y2 - rect.y1)/(10);

} else

{

res = RV_PN; half = (rect.y2 - rect.y1)/2; scaly = half / 10;

}

scaly *= 10;

int scalx = (rect.x2 - rect.x1) / LEN, int x = rect.x1;

for (int i = 0; i < LEN; i++)

{

points[i] = Point(x, rect.y2 - mas[i] * scaly - half - 1); x += scalx;

}

return res;

}

//---------------------------------------------------------------------------

eRET_VAL cAccounts::CalculatePoints(bool norm, int type, sRect rect, TPoint p1[],

TPoint p2[], TPoint p3[],

double mas1[], double mas2[], double mas3[])

{

if (norm) Normalize(mas1, mas2, mas3);

eRET_VAL res;

int scaly, half = 0;

if (isNegative && !isPozitive)

{

res = RV_NEG; scaly = (rect.y2 - rect.y1)/(-10);

} else

if (!isNegative && isPozitive)

{

res = RV_POZ; scaly = (rect.y2 - rect.y1)/(10);

} else

{

half = (rect.y2 - rect.y1)/2; scaly = half / 10;

}

scaly *= 10;

int scalx = (rect.x2 - rect.x1) / LEN, x = rect.x1;

for (int i = 0; i < LEN; i++)

{

p1[i] = Point(x, rect.y2 - mas1[i] * scaly - half - 1);

p2[i] = Point(x, rect.y2 - mas2[i] * scaly - half - 1);

p3[i] = Point(x, rect.y2 - mas3[i] * scaly - half - 1);

x += scalx;

}

return res;

}

double LossesInvertSelfMagnetic( // Потери из-за обратимого саморазмагничивания

double thickness, // толщина рабочего слоя

double nonContact, // неконтакт

double convertiblePermeability, // обратимая проницаемость

double densityOfRec // плотность записи

)

{

double g = densityOfRec * thickness;

double p = densityOfRec * nonContact;

double numerator = tanh(g) * (1. + (1. / convertiblePermeability) * tanh(g/2.));

double denominator = g * (1. + tanh(p) + (1. / convertiblePermeability +

convertiblePermeability * tanh(p)) * tanh(g)) * cosh(p);

return (numerator / denominator);

}

double LossesSlotHole( // щелевые потери

double wideOfWorkBacklash, // ширина рабочего зазора

double densityOfRec // плотность записи

)

{

double g = densityOfRec * wideOfWorkBacklash;

double g2 = g * g;

double s1;

s1 = (5./3.- 10./g2 + 20./(g2 * g2)) * sin(g)/g + (10./(3.* g)- 20./(g2 * g))* cos(g)/g;

return s1;

}

double LossesSkew( // потери из-за перекоса

double widthOfPoleTips, // ширина полюсных наконечников

double skewAngle, // угол перекоса

double densityOfRec // плотность записи

)

{

double b = widthOfPoleTips;

double k = sin(densityOfRec * b * tan(skewAngle))/(densityOfRec * b * tan(skewAngle));

return k;

}

double LossesHeadSizes( // потери из-за конечных размеров головки

double externalHeadRadius, // внешний радиус головки

double densityOfRec // плотность записи

)

{

return (1.- exp(-densityOfRec * externalHeadRadius));

}

// потери из-за неравномерности рабочего зазора

double LossesNonUniformityOfWorkBacklash(

double rmsDeviationOfBacklash, // среднеквадратичное отклонение зазора от прямой

double densityOfRec // плотность записи

)

{

double den2 = densityOfRec * densityOfRec;

double sig2 = rmsDeviationOfBacklash * rmsDeviationOfBacklash;

return (exp(-den2 * sig2/2.));

}

double LossesFrequency( // частотные потери

double facShuntOfWorkBacklash, // коэффициент шунтирования рабочего зазора

double fullPerOfCore, // полная проницаемость материала сердечника

double beginPerOfCore, // начальная проницаемость материала сердечника

double tgAngLoss // тангенс угла потерь

)

{

double g = fullPerOfCore/beginPerOfCore * sqrt(1.+ tgAngLoss * tgAngLoss);

double numerator = 1.+ facShuntOfWorkBacklash;

double denominator = sqrt(sqr(1.+ facShuntOfWorkBacklash /g)+

sqr(facShuntOfWorkBacklash * tgAngLoss/g));

return (numerator/denominator);

}

double LossesSelfMagnetic( // потери из-за саморазмагничивания

double m1, // средняя относительная проницаемость рабочего слоя

// на спинке симметричной петли гистерезиса

double m2, // средняя обратимая проницаемость на петле возврата

double d, // толщина слоя

double densityOfRec // плотность записи

)

{

double kni = (m2/m1)*(1.+((m1-m2)*(1.+ m1/tanh(densityOfRec *d / 2.))* tanh(densityOfRec * d))/

(m1*m2*(2.+ (m1+1./m1)*tanh(densityOfRec * d))));

return kni;

}

void cAccounts::CalculateDynamicRange()

{

double v0 = 9.53f;

double j0 = 70;//td.residualMagn;

double v = cp.speedOfMoveCarrier * 1e+2;

for (int i = 0; i < LEN; i++)

{

dynamicRange[i] = 300.0f * (v/v0)*(i/j0)/sqrt(5.0f+sqr(v*i/(v0*j0))+sqr(sqr(sqr(i/j0))));

}

}

double cAccounts::GetMin(const double mas[])

{

double min = mas[0];

for(int i=1; i<LEN; i++)

if (min > mas[i]) min = mas[i];

return (min);

}

double cAccounts::GetMax(const double mas[])

{

double max = mas[0];

for(int i=1; i<LEN; i++) if (max < mas[i]) max = mas[i];

return (max);

}

void cAccounts::CopyArr(const double curmas[], double destmas[])

{

for (int i = 0; i < LEN; i++)

{

destmas[i] = curmas[i];

}

}

void cAccounts::CalculatePoints(const double mas[], sGraphData &gd, sRect rect,

sGridData &grid_data, bool norm)

{

int width = rect.x2 - rect.x1; int height = rect.y2 - rect.y1 - 20;

double arr[LEN];

if (norm) Normalize(mas, arr); else CopyArr(mas, arr);

double min = gd.ymin = grid_data.ymin = GetMin(arr);

double max = gd.ymax = GetMax(arr);

double y_scal = height / (max - min); // размах

double x_scal = width / LEN;

double dy = height - max * y_scal;

for(int i = 0; i < LEN; i++)

{

double x = 0.0f, y = 0.0f;

x = rect.x1 + i * x_scal; y = rect.y2 - 10 - (arr[i] * y_scal + dy);

gd.point[i] = Point(x, y);

}

switch (gd.graph_type)

{

case G_DYNAMIC_RANGE :

{

strcpy(gd.graph_name, "ДИНАМИЧЕСКИЙ ДИАПАЗОН");

strcpy(gd.x_name, "ОСТАТОЧНАЯ НАМАГНИЧЕННОСТЬ, kA//m");

strcpy(gd.y_name, "ОТНОШЕНИЕ СИГНАЛ/ШУМ");

} break;

case G_AWC_CHANNEL_ON_FLOW :

{

strcpy(gd.graph_name, "АВХ КАНАЛА ПО ПОТОКУ");

strcpy(gd.x_name, "ПЛОТНОСТЬ ЗАПИСИ");

strcpy(gd.y_name, "НОРМИРОВАННОЕ АМПЛИТУДНОЕ ЗНАЧЕНИЕ");

} break;

case G_AWC_CHANNEL_ON_EDF :

{

strcpy(gd.graph_name, "АВХ КАНАЛА ПО ЭДС");

strcpy(gd.x_name, "ПЛОТНОСТЬ ЗАПИСИ");

strcpy(gd.y_name, "НОРМИРОВАННОЕ АМПЛИТУДНОЕ ЗНАЧЕНИЕ");

} break;

case G_PULS_CHARACT :

{

strcpy(gd.graph_name, "ИМПУЛЬСНАЯ ХАРАКТЕРИСТИКА КАНАЛА");

strcpy(gd.x_name, "???");

strcpy(gd.y_name, "НОРМИРОВАННОЕ АМПЛИТУДНОЕ ЗНАЧЕНИЕ");

} break;

case G_PWC_CHANNEL :

{

strcpy(gd.graph_name, "ФВХ КАНАЛА");

strcpy(gd.x_name, "ПЛОТНОСТЬ ЗАПИСИ");

strcpy(gd.y_name, "???");

} break;

case G_HEAD_FLOW :

{

strcpy(gd.graph_name, "ПОТОК ГОЛОВКИ ВОСПРОИЗВЕДЕНИЯ");

strcpy(gd.x_name, "ПЛОТНОСТЬ ЗАПИСИ");

strcpy(gd.y_name, "НОРМИРОВАННОЕ АМПЛИТУДНОЕ ЗНАЧЕНИЕ");

} break;

case G_FACT_OF_HARM :

{

strcpy(gd.graph_name, "КОЭФФИЦИЕНТ ГАРМОНИК");

strcpy(gd.x_name, "???");

strcpy(gd.y_name, "???");

} break;

case G_AMPLIT :

{

strcpy(gd.graph_name, "АМПЛИТУДНАЯ ХАРАКТЕРИСТИКА");

strcpy(gd.x_name, "ПЛОТНОСТЬ ЗАПИСИ");

strcpy(gd.y_name, "НОРМИРОВАННОЕ АМПЛИТУДНОЕ ЗНАЧЕНИЕ");

} break;

case G_EDF :

{

strcpy(gd.graph_name, "ЭДС ГОЛОВКИ ВОСПРОИЗВЕДЕНИЯ");

strcpy(gd.x_name, "ПЛОТНОСТЬ ЗАПИСИ");

strcpy(gd.y_name, "НОРМИРОВАННОЕ АМПЛИТУДНОЕ ЗНАЧЕНИЕ");

} break;

}

gd.xmin = grid_data.xmin = 0;

gd.xmax = 180;

grid_data.dx = 10 * (gd.xmax - gd.xmin) / LEN;

grid_data.dy = (gd.ymax - gd.ymin) / 20;

}

void cAccounts::CalculateGraphPoints(int type, sGraphData &graph_data,

sRect rect, sGridData &grid_data, bool norm)

{

graph_data.graph_type = type;

switch(type)

{

case G_DYNAMIC_RANGE :

{

CalculateDynamicRange();

CalculatePoints(dynamicRange, graph_data, rect, grid_data, norm);

} break;

case G_AWC_CHANNEL_ON_FLOW :

CalculatePoints(awcChannelOnFlow, graph_data, rect, grid_data, norm); break;

case G_AWC_CHANNEL_ON_EDF :

CalculatePoints(awcChannelOnEDF, graph_data, rect, grid_data, norm); break;

case G_PULS_CHARACT :

CalculatePoints(pcChannel, graph_data, rect, grid_data, norm); break;

case G_PWC_CHANNEL :

CalculatePoints(pwcChannel, graph_data, rect, grid_data, norm); break;

case G_HEAD_FLOW :

CalculatePoints(pwcHead, graph_data, rect, grid_data, norm); break;

case G_FACT_OF_HARM :

CalculatePoints(facOfHarm, graph_data, rect, grid_data, norm); break;

}

}

Листинг файла GetVal.h

//---------------------------------------------------------------------------

#ifndef GetValH

#define GetValH

#include <Classes.hpp>

#include <Controls.hpp>

#include <StdCtrls.hpp>

#include <Forms.hpp>

#include "te_controls.h"

#include "te_engine.h"

#include <ExtCtrls.hpp>

#include "te_extended.h"

#include "MainUnit.h"

#include "Definitions.h"

#include "te_managers.h"

#include "FormFact.h"

class TFormGetVal : public TForm

{

__published:// IDE-managed Components

TTePanel *TePanel1; TTePanel *TePanel2;

TTeButton *bLet; TTeButton *bCancel;

TTeForm *TeForm1; TTeEdit *Edit;

TTeLabel *TeLabel1; TTeLabel *TeLabel2;

TImage *Pict;

void __fastcall TeForm1FormShown(TObject *Sender);

void __fastcall FormCreate(TObject *Sender);

void __fastcall EditKeyPress(TObject *Sender, char &Key);

void __fastcall bLetClick(TObject *Sender);

void __fastcall EditExit(TObject *Sender);

void __fastcall FormClose(TObject *Sender, TCloseAction &Action);

private:// User declarations

int curVal;

Graphics::TPicture *g_pict[23];

void __fastcall LoadPict();

void __fastcall DelPict();

public:// User declarations

__fastcall TFormGetVal(TComponent* Owner);

};

extern PACKAGE TFormGetVal *FormGetVal;

#endif

Листинг файла GetVal.cpp

//---------------------------------------------------------------------------

#include <vcl.h>

#pragma hdrstop

#include "GetVal.h"

#pragma package(smart_init)

#pragma link "te_controls"

#pragma link "te_engine"

#pragma link "te_extended"

#pragma link "te_managers"

#pragma resource "*.dfm"

TFormGetVal *FormGetVal;

__fastcall TFormGetVal::TFormGetVal(TComponent* Owner) : TForm(Owner)

{

}

void __fastcall TFormGetVal::LoadPict()

{

for (int i = 0; i < 23; i++) g_pict[i] = new Graphics::TPicture;

g_pict[CP_NON_CONTACT_REC]->LoadFromFile("Pic_NonContact.bmp");

g_pict[CP_NON_CONTACT_REP]->LoadFromFile("Pic_NonContact.bmp");

g_pict[HD_BL_WIDE]->LoadFromFile("Pic_blWidth.bmp");

g_pict[TD_THICKNESS_OF_WORK_LAYER]->LoadFromFile("Pic_ThickOfWL.bmp");

g_pict[HD_THICKNESS_PLATES_OF_CORE]->LoadFromFile("Pic_ThicknessPlOfCore.bmp");

}

void __fastcall TFormGetVal::DelPict()

{

for (int i = 0; i < 23; i++) delete g_pict[i];

}

void __fastcall TFormGetVal::TeForm1FormShown(TObject *Sender)

{

TeLabel2->Caption = (String)STR_ARRAY[curVal];

if (g_pict[curVal]) Pict->Picture = g_pict[curVal]; else Pict->Picture = NULL;

}

void __fastcall TFormGetVal::FormCreate(TObject *Sender)

{

String str = GetCurrentDir(); int len = str.Length(); str.Delete(len - 3, 4); str += "Pict";

SetCurrentDir(str); LoadPict();

if (MainForm->isMain) curVal = MainForm->GetCurVal();

else curVal = Form1->GetCurVal();

}

void __fastcall TFormGetVal::EditKeyPress(TObject *Sender, char &Key)

{

gUserKeyPress(Key, Edit->Text, Edit->SelStart);

}

void __fastcall TFormGetVal::bLetClick(TObject *Sender)

{

if (MainForm->isMain) MainForm->LetVal(StrToFloat(Edit->Text));

else Form1->LetVal(StrToFloat(Edit->Text));

}

void __fastcall TFormGetVal::EditExit(TObject *Sender)

{

double res;

if (Edit->Text == (WideString)"") res = -1; else res = StrToFloat(Edit->Text);

double min = MainForm->GetMinRangeVal(curVal);

double max = MainForm->GetMaxRangeVal(curVal);

if (res < min) Edit->Text = FloatToStr(min);

if (res > max) Edit->Text = FloatToStr(max);

}

void __fastcall TFormGetVal::FormClose(TObject *Sender, TCloseAction &Action)

{

DelPict();

}

Листинг файла RangeEdit.h

//---------------------------------------------------------------------------

#ifndef RangeEditH

#define RangeEditH

#include <Classes.hpp>

#include <Controls.hpp>

#include <StdCtrls.hpp>

#include <Forms.hpp>

#include "te_controls.h"

#include <ExtCtrls.hpp>

#include "MainUnit.h"

#include "Definitions.h"

class TFormRangeEdit : public TForm

{

__published:// IDE-managed Components

TTeEdit *eMin; TTeEdit *eMax;

TTePanel *TePanel1; TTeLabel *TeLabel1; TTeLabel *TeLabel2;

TTeLabel *TeLabel3; TTePanel *TePanel2; TTeButton *bSave;

TTeButton *bCancel; TTeForm *TeForm1;

void __fastcall eMinKeyPress(TObject *Sender, char &Key);

void __fastcall eMaxKeyPress(TObject *Sender, char &Key);

void __fastcall FormShow(TObject *Sender);

void __fastcall FormCreate(TObject *Sender);

void __fastcall bSaveClick(TObject *Sender);

private:// User declarations

int curMenuItem;

public:// User declarations

__fastcall TFormRangeEdit(TComponent* Owner);

};

extern PACKAGE TFormRangeEdit *FormRangeEdit;

#endif

Листинг файла RangeEdit.cpp

//---------------------------------------------------------------------------

#include <vcl.h>

#pragma hdrstop

#include "RangeEdit.h"

#pragma package(smart_init)

#pragma link "te_controls"

#pragma resource "*.dfm"

TFormRangeEdit *FormRangeEdit;

__fastcall TFormRangeEdit::TFormRangeEdit(TComponent* Owner) : TForm(Owner)

{

}

void __fastcall TFormRangeEdit::eMinKeyPress(TObject *Sender, char &Key)

{

gUserKeyPress(Key, eMin->Text, eMin->SelStart);

}

void __fastcall TFormRangeEdit::eMaxKeyPress(TObject *Sender, char &Key)

{

gUserKeyPress(Key, eMax->Text, eMax->SelStart);

}

void __fastcall TFormRangeEdit::FormShow(TObject *Sender)

{

TeLabel3->Caption = (String)STR_ARRAY[curMenuItem];

}

void __fastcall TFormRangeEdit::FormCreate(TObject *Sender)

{

curMenuItem = MainForm->GetCurMenuItem();

}

void __fastcall TFormRangeEdit::bSaveClick(TObject *Sender)

{

sRANGE_VAL range;

range.min = StrToFloat(eMin->Text); range.max = StrToFloat(eMax->Text);

MainForm->LetRange(range);

}

Размещено на allbest.ru