#include
#include
#include
#include
#include
#define MPH_MODE 1
#define ET_MODE 2
#define HP_MODE 3
#define ITERATE_ONCE 1
#define ITERATE_MANY 2
/************************************************************************/
/* definiation of the over all data structure */
/************************************************************************/
struct performance
{
float startMph,endMph;
float startHp , endHp;
float startEt,endEt;
float interator;
float mph ;
float hp ;
float et;
float minFuelPumpCap ;
float totalFuelConsmp;
float reqInjectorSize ;
float currInjectorSize;
float currFuelPressure;
float reqFuelPressure;
int weight;
int numOfInjectors;
float bsfc;
float tireDia;
float peekRpm;
float gearRatio;
int mode;
int calcRangeFlag;
FILE *outFile;
};
typedef struct performance * PERFORMANCE_PTR;
double persix[]={ 100.0,10.0 , 1. , 0.1 , 0.01, 0.001,0.0001,0.00001 };
/************************************************************************/
/* Cube root function of positive double's > 1.0 */
/************************************************************************/
double largeCube(double theNum)
{
int x;
double currNum =0.0 , prevNum =0.0, retNum =0.0;
currNum = theNum /2.0 ;
for (x=0; x < 8 ; x++ )
{
retNum = pow( currNum , 3.0);
while ( retNum > theNum)
{
prevNum = currNum;
currNum -= persix[x];
retNum = pow( currNum , 3.0);
}
currNum = prevNum;
}
return( currNum);
}
/************************************************************************/
/* Cuge root Function for positive double's < 1.0 */
/************************************************************************/
double smallCube( double theNum)
{
int x;
double currNum =0.0 , prevNum =0.0, retNum =0.0;
for (x =0; x < 8 ; x++ )
{
retNum = pow( currNum , 3.0);
while ( retNum < theNum)
{
prevNum = currNum;
currNum += persix[x];
retNum = pow( currNum , 3.0);
}
currNum = prevNum;
}
return( currNum);
}
/************************************************************************/
/* Cube root user interface */
/************************************************************************/
double jcube(double theNum)
{
if ( theNum < 0.0)
return( 0.0);
if ( theNum > 1 )
return( largeCube(theNum)) ;
else
return( smallCube(theNum));
}
/************************************************************************/
/* print the header Information */
/************************************************************************/
void printHeader(PERFORMANCE_PTR ptr,FILE *fp)
{
fprintf(fp," ");
fprintf(fp," \n\n ");
/* fprintf(fp," Home " ); */
}
/************************************************************************/
/* Calc Gear Ratio see Example (8) */
/************************************************************************/
float calcGearRatio( PERFORMANCE_PTR ptr )
{
return( (ptr->peekRpm * ptr->tireDia ) / ( 336 * ptr->mph) );
}
/************************************************************************/
/* Calc Fuel Pressuer see page Example (7) */
/************************************************************************/
float calcFuelPressure ( PERFORMANCE_PTR ptr)
{
float temp;
temp = (float)pow( ( ptr->reqInjectorSize / ptr->currInjectorSize ),2);
return( temp * ptr->currFuelPressure );
}
/************************************************************************/
/* Calc Injector Size see Example (6) */
/************************************************************************/
float calcInjectSize ( PERFORMANCE_PTR ptr )
{
/* 115% = 15% leeway */
return( ( ptr->totalFuelConsmp * 1.15 ) / ptr->numOfInjectors );
}
/************************************************************************/
/* Calc Min Fuel Pump Size see Example (5a) */
/************************************************************************/
float calcPump(PERFORMANCE_PTR ptr)
{
/* 6.25 lbs per gallon */
/* 3.785 gallons per liter */
return( ptr->totalFuelConsmp * (3.785/6.25) );
}
/************************************************************************/
/* Calc Total Fuel Comsumption see Example ( 5) */
/************************************************************************/
float calcTFC(PERFORMANCE_PTR ptr)
{
/* BSFC = .5 = engine efficiancy */
if ( ptr->bsfc == 0.0)
ptr->bsfc = 0.5;
return( ptr->hp * ptr->bsfc );
}
/************************************************************************/
/* Calc Horse Power by ET see Example (2) */
/************************************************************************/
float calcHpByEt( PERFORMANCE_PTR ptr)
{
float temp = 0.0;
temp = (float)pow( (ptr->et/5.825) , 3);
return( ptr->weight/ temp);
}
/************************************************************************/
/* Calc Horse Power by MPH see Example ( 1) */
/************************************************************************/
float calcHpByMph( PERFORMANCE_PTR ptr)
{
/* trap speed constant 234 */
float rem=0.0;
rem = (float)pow((ptr->mph/234),3);
return(rem * ptr->weight);
}
/************************************************************************/
/* Calc ET using Horse Power and Weight see Example (3) */
/************************************************************************/
float calcEtByHP( PERFORMANCE_PTR ptr)
{
float temp;
if ( ptr->hp != 0.0 )
temp = jcube( ( double ) (ptr->weight / ptr->hp) ) ;
return( temp * 5.825 );
}
/************************************************************************/
/* Calc MPH by Horse Power and Weight see Example (4) */
/************************************************************************/
float calcMphByHp(PERFORMANCE_PTR ptr)
{
float temp;
temp = jcube((double)(ptr->hp / ptr->weight) ) ;
return ( temp * 234 );
}
/************************************************************************/
/* Start of the User Interface */
/************************************************************************/
void getData(PERFORMANCE_PTR ptr)
{
extern char *getCharValueFromPost(char * theValue);
extern float getFloatValueFromPost(char * theValue);
extern int getIntValueFromPost(char * theValue);
char inputField[200];
ptr->mode = getIntValueFromPost("TheMode");
ptr->calcRangeFlag = ITERATE_MANY;
switch ( ptr->mode)
{
case MPH_MODE:
if ( ptr->calcRangeFlag == ITERATE_ONCE)
{
ptr->startMph = ptr->endMph = ptr->mph = getFloatValueFromPost("TheStart");
ptr->interator = 10.0;
}
else
{
ptr->startMph = getFloatValueFromPost("TheStart");
ptr->endMph = getFloatValueFromPost("TheEnd");
ptr->interator = getFloatValueFromPost("TheIncrement");
if ( ptr->interator < 0.0 )
ptr->interator = 10.0;
ptr->mph = ptr->startMph;
}
break;
case ET_MODE:
if ( ptr->calcRangeFlag == ITERATE_ONCE)
{
ptr->et= getFloatValueFromPost("TheStart");
ptr->startEt = ptr->et;
ptr->endEt = ptr->et;
ptr->interator = 0.1;
}
else
{
ptr->startEt = getFloatValueFromPost("TheStart");
ptr->endEt = getFloatValueFromPost("TheEnd");
ptr->interator = getFloatValueFromPost("TheIncrement");
if ( ptr->interator < 0.0 )
ptr->interator= 0.1;
ptr->et = ptr->startEt;
}
break;
case HP_MODE:
if ( ptr->calcRangeFlag == ITERATE_ONCE)
{
ptr->hp = getFloatValueFromPost("TheStart");
ptr->startHp = ptr->hp;
ptr->endHp = ptr->hp;
ptr->interator = 5;
}
else
{
ptr->startHp = getFloatValueFromPost("TheStart");
ptr->endHp = getFloatValueFromPost("TheEnd");
ptr->interator = getFloatValueFromPost("TheIncrement");
if ( ptr->interator < 0.0)
ptr->interator = 5.0;
ptr->hp = ptr->startHp;
}
break;
default:
printf( " INCORRECT MODE: RESTART \n");
exit(3);
}
ptr->weight = getIntValueFromPost("Weight");
ptr->numOfInjectors =getIntValueFromPost("NumOfInjectors");
if ( ptr->numOfInjectors == 0 )
ptr->numOfInjectors = 8;
ptr->currInjectorSize = getFloatValueFromPost("InjectorSize");
if ( ptr->currInjectorSize == 0.0 )
ptr->currInjectorSize = 19.0;
ptr->currFuelPressure = getFloatValueFromPost("FuelPressure");
if ( ptr->currFuelPressure == 0.0 )
ptr->currFuelPressure = 39.0;
ptr->bsfc = getFloatValueFromPost("bsfc");
ptr->tireDia = getFloatValueFromPost("TireSize");
if ( ptr->tireDia == 0.0 )
ptr->tireDia = 26.0;
ptr->peekRpm = getFloatValueFromPost("RPM");
if ( ptr->peekRpm == 0.0 )
ptr->peekRpm = 5500.0;
}
/************************************************************************/
/* Interface to all calcualation routines */
/* NOTE: do not change the order of the calls */
/************************************************************************/
void doCalc(PERFORMANCE_PTR ptr)
{
switch ( ptr->mode)
{
case MPH_MODE:
ptr->hp = calcHpByMph( ptr);
ptr->et = calcEtByHP ( ptr);
break;
case ET_MODE:
ptr->hp = calcHpByEt( ptr);
ptr->mph = calcMphByHp( ptr);
break;
case HP_MODE:
ptr->mph = calcMphByHp( ptr);
ptr->et = calcEtByHP ( ptr);
break;
}
ptr->totalFuelConsmp = calcTFC( ptr);
ptr->minFuelPumpCap = calcPump( ptr);
ptr->reqInjectorSize = calcInjectSize( ptr) ;
ptr->reqFuelPressure = calcFuelPressure(ptr);
ptr->gearRatio = calcGearRatio(ptr);
if( ptr->outFile != NULL )
printResults(ptr,ptr->outFile);
printResults( ptr,stdout );
}
/************************************************************************/
/* Main Driver Code */
/************************************************************************/
main(int argc, char *argv[])
{
extern buildVars(int a,char *b[]);
struct performance calcCar;
memset ( &calcCar,0,sizeof (struct performance));
/* calcCar.outFile = fopen ("perf.txt","w"); */
buildVars(argc,argv);
getData (&calcCar);
printHeader(&calcCar,stdout);
if( calcCar.outFile != NULL )
printHeader(&calcCar,calcCar.outFile);
switch ( calcCar.mode)
{
case MPH_MODE:
while ( calcCar.mph <= calcCar.endMph )
{
doCalc(&calcCar);
calcCar.mph += calcCar.interator;
}
break;
case ET_MODE:
while ( calcCar.et <= calcCar.endEt )
{
doCalc(&calcCar);
calcCar.et += calcCar.interator;
}
break;
case HP_MODE:
while ( calcCar.hp <= calcCar.endHp )
{
doCalc(&calcCar);
calcCar.hp += calcCar.interator;
}
break;
}
printInfo(&calcCar,stdout);
if ( calcCar.outFile != NULL)
{
printInfo(&calcCar,calcCar.outFile);
fclose(calcCar.outFile);
}
}