weiye
/
Droplet_LTORC
Observar 1
Favorito 0
Fork 0
Código Issues 0 Pull requests 0 Versões 0 Wiki Atividade
Droplet Lagrangian Transient One-dimensional Reacting Code Implementation of both liquid and gas phase governing equations.
Você não pode selecionar mais de 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.
11 Commits
1 Branch
1.6MB
Tag: 73b9451213
Branches Tags
${ item.name }
Criar branch ${ searchTerm }
de 73b9451213
${ noResults }
Droplet_LTORC/src/UserData.cpp

575 linhas
16KB
Original Anotar Histórico 

  1. #include "UserData.h"

  2. #include "parse.h"

  3. 

  4. void freeUserData(UserData data){

  5. 	if(data!=NULL){

  6. 		if(data->trmix!=NULL){

  7. 			delete data->trmix;

  8. 			printf("Transport Deleted!\n");

  9. 

  10. 		}

  11. 		if(data->gas!=NULL){

  12. 			delete data->gas;

  13. 			printf("Gas Deleted!\n");

  14. 

  15. 		}

  16. 		if(data->adaptiveGrid){

  17. 			if(data->grid->xOld!=NULL){

  18. 				delete[] data->grid->xOld;

  19. 				printf("old grid array Deleted!\n");

  20. 			}

  21. 			if(data->grid->x!=NULL){

  22. 				delete[] data->grid->x;

  23. 				printf("current grid array Deleted!\n");

  24. 			}

  25. 			if(data->grid!=NULL){

  26. 				free(data->grid);

  27. 				printf("grid object Freed!\n");

  28. 			}

  29. 		}

  30. 		else{

  31. 			if(data->uniformGrid!=NULL){

  32. 				delete[] data->uniformGrid;

  33. 				printf("uniformGrid deleted!\n");

  34. 			}

  35. 		}

  36. 		if(data->innerMassFractions!=NULL){

  37. 			delete[] data->innerMassFractions;

  38. 			printf("innerMassFractions array Deleted!\n");

  39. 		}

  40. 		if(data->output!=NULL){

  41.   			fclose(data->output);

  42. 			printf("Output File Cleared from Memory!\n");

  43. 		}

  44. 		if(data->gridOutput!=NULL){

  45.   			fclose(data->gridOutput);

  46. 			printf("Grid Output File Cleared from Memory!\n");

  47. 		}

  48. 		//if(data->ratesOutput!=NULL){

  49.   		//	fclose(data->ratesOutput);

  50. 		//	printf("Rates Output File Cleared from Memory!\n");

  51. 		//}

  52. 		if(data->globalOutput!=NULL){

  53.   			fclose(data->globalOutput);

  54. 			printf("Global Output File Cleared from Memory!\n");

  55. 		}

  56. 		if(data->timescaleOutput!=NULL){

  57.   			fclose(data->timescaleOutput);

  58. 			printf("Characteristic Timescale Output File Cleared from Memory!\n");

  59. 		}

  60. 		//if(data->rxnROPOutput!=NULL){

  61.   		//	fclose(data->rxnROPOutput);

  62. 		//	printf("Reactions Rate of Progress Output File Cleared from Memory!\n");

  63. 		//}

  64. 		//if(data->spROPOutput!=NULL){

  65.   		//	fclose(data->spROPOutput);

  66. 		//	printf("Species Rate of Production Output File Cleared from Memory!\n");

  67. 		//}

  68. 	}

  69.   	free(data);             /* Free the user data */

  70. 	printf("\n\n");

  71. }

  72. 

  73. UserData allocateUserData(FILE *input){

  74. 

  75. 	UserData data;

  76.   	data = (UserData) malloc(sizeof *data);

  77. 

  78. 	if(!data){

  79. 		printf("Allocation Failed!\n");

  80. 		return(NULL);

  81. 	}

  82. 	setSaneDefaults(data);

  83. 

  84. 	int ier;

  85. 

  86. 	ier=parseNumber<size_t>(input, "basePts"	, MAXBUFLEN, &data->npts);

  87. 	if(ier==-1 || data->npts<=0){

  88. 		printf("Enter non-zero basePts!\n");

  89. 		return(NULL);

  90. 	}

  91. 

  92. 	ier=parseNumber<double>(input, "domainLength", MAXBUFLEN, &data->domainLength);

  93. 	if(ier==-1 || data->domainLength<=0.0e0){

  94. 		printf("domainLength error!\n");

  95. 		return(NULL);

  96. 	}

  97. 

  98. 	ier=parseNumber<double>(input, "Rd", MAXBUFLEN, &data->Rd);

  99. 	if(ier==-1 || data->Rd<=0.0e0){

  100. 		printf("Rd error!\n");

  101. 		return(NULL);

  102. 	}

  103. 

  104. 	ier=parseNumber<int>(input, "constantPressure"	, MAXBUFLEN, &data->constantPressure);

  105. 	if(ier==-1 || (data->constantPressure!=0 && data->constantPressure!=1)){

  106. 		printf("constantPressure error!\n");

  107. 		return(NULL);

  108. 	}

  109. 

  110. 	ier=parseNumber<int>(input, "problemType"	, MAXBUFLEN, &data->problemType);

  111. 	if(ier==-1 || (data->problemType!=0 

  112. 		       && data->problemType!=1

  113. 			&& data->problemType!=2

  114. 			&& data->problemType!=3)){

  115. 		printf("include valid problemType!\n");

  116. 		printf("0: premixed combustion with NO equilibrated ignition kernel\n");

  117. 		printf("1: premixed combustion WITH equilibrated ignition kernel\n");

  118. 		printf("2: arbitrary initial conditions\n");

  119. 		printf("3: Restart\n");

  120. 		return(NULL);

  121. 	}

  122. 

  123. 	ier=parseNumber<int>(input,"dropType",MAXBUFLEN,&data->dropType);

  124. 	if(ier==-1 || (data->dropType!=0 

  125. 		       && data->dropType!=1)){

  126. 		printf("include valid dropletType!\n");

  127. 		printf("0: single component droplet\n");

  128. 		printf("1: multi-component droplet\n");

  129. 		return(NULL);

  130. 	}

  131. 

  132. 	ier=parseDropSpec<double>(input,"dropletMole",MAXBUFLEN,&data->dropType,dropMole);

  133. 	if(ier== -1){

  134. 		printf("include correct format for droplet mole fraction!\n");

  135. 		printf("single composition droplet: dropletMole:1.00\n");

  136. 		printf("binary composition droplet: dropletMole:0.3,0.7\n");

  137. 		return(NULL);

  138. 	}

  139. 

  140. 	ier=parseDropSpec<std::string>(input,"dropletComposition",MAXBUFLEN,&data->dropType,dropSpec);

  141. 	if(ier== -1){

  142. 		printf("include correct format for droplet composition!\n");

  143. 		printf("single composition droplet: dropletComposition:n-heptane\n");

  144. 		printf("binary composition droplet: dropletComposition:propane,n-heptane\n");

  145. 		return(NULL);

  146. 	}

  147. 	

  148. 	

  149. 	//ier=parseNumber<int>(input, "quasiSteady"	, MAXBUFLEN, &data->quasiSteady);

  150. 	//if(ier==-1 || (data->quasiSteady!=0 

  151. 	//	       && data->quasiSteady!=1)){

  152. 	//	printf("include valid quasiSteady!\n");

  153. 	//	printf("0: The droplet surface recedes and the droplet losses mass\n");

  154. 	//	printf("1: The droplet surface does not move and the droplet mass is constant\n");

  155. 	//	return(NULL);

  156. 	//}

  157. 

  158. 	ier=parseNumber<double>(input, "dPdt", MAXBUFLEN, &data->dPdt);

  159. 

  160. 	ier=parseNumber<double>(input, "Rg", MAXBUFLEN, &data->Rg);

  161. 	if(data->Rg < 0.0){

  162. 		printf("Rg must be greater than 0");

  163. 		return(NULL);

  164. 	}

  165. 

  166. 	ier=parseNumber<int>   (input, "reflectProblem"	, MAXBUFLEN, &data->reflectProblem);

  167. 	if(data->reflectProblem!=0 && data->reflectProblem!=1){

  168. 		printf("Invalid entry for reflectProblem! Can be only 1 or 0.\n");

  169. 		return(NULL);

  170. 	}

  171. 	

  172. 	ier=parseNumber<double>(input, "mdot"		, MAXBUFLEN, &data->mdot);

  173. 	

  174. 	ier=parseNumber<double>(input, "initialTemperature", MAXBUFLEN,

  175. 			&data->initialTemperature);

  176. 	if(ier==-1 || data->initialTemperature<=0.0e0){

  177. 		printf("Enter positive initialTemperature in K!\n");

  178. 		return(NULL);

  179. 	}

  180. 

  181. 

  182. 	ier=parseNumber<double>(input, "initialPressure", MAXBUFLEN,

  183. 			&data->initialPressure);

  184. 	if(ier==-1 || data->initialTemperature<=0.0e0){

  185. 		printf("Enter positive initialPressure in atm!\n");

  186. 		return(NULL);

  187. 	}

  188. 

  189. 	ier=parseNumber<int>   (input, "metric"	, MAXBUFLEN, &data->metric);

  190. 	if(data->metric!=0 && data->metric!=1 && data->metric!=2){

  191. 		printf("Invalid entry for metric!\n");

  192. 		printf("0: Cartesian\n");

  193. 		printf("1: Cylindrical\n");

  194. 		printf("2: Spherical\n");

  195. 		return(NULL);

  196. 	}

  197. 

  198. 	ier=parseNumber<double>(input, "QDot", MAXBUFLEN, &data->maxQDot);

  199. 	if(ier==-1 && data->problemType==0){

  200. 		printf("Need to specify QDot for problemType 0!\n");

  201. 		return(NULL);

  202. 	}

  203. 

  204. 	ier=parseNumber<double>(input, "kernelSize", MAXBUFLEN, &data->kernelSize);

  205. 	if(ier==-1 && data->problemType==0){

  206. 		printf("Need to specify kernelSize for problemType 0!\n");

  207. 		return(NULL);

  208. 	}

  209. 

  210. 	ier=parseNumber<double>(input, "ignTime", MAXBUFLEN, &data->ignTime);

  211. 	if(ier==-1 && data->problemType==0){

  212. 		printf("Need to specify ignTime for problemType 0!\n");

  213. 		return(NULL);

  214. 	}

  215. 

  216. 	ier=parseNumber<double>(input, "mixingWidth", MAXBUFLEN,

  217. 			&data->mixingWidth);

  218. 	if(ier==-1){

  219. 		printf("Need to specify mixingWidth!\n");

  220. 		return(NULL);

  221. 	}

  222. 	

  223. 	ier=parseNumber<double>(input, "shift", MAXBUFLEN, &data->shift);

  224. 

  225. 	ier=parseNumber<double>(input, "firstRadius", MAXBUFLEN, &data->firstRadius);

  226. 	

  227. 	ier=parseNumber<double>(input, "wallTemperature", MAXBUFLEN, &data->wallTemperature);

  228. 

  229. 	ier=parseNumber<int>   (input, "dirichletInner"	, MAXBUFLEN,

  230. 			&data->dirichletInner);

  231. 	if(data->dirichletInner!=0 && data->dirichletInner!=1){

  232. 		printf("dirichletInner can either be 0 or 1!\n");

  233. 		return(NULL);

  234. 	}

  235. 

  236. 	ier=parseNumber<int>   (input, "dirichletOuter"	, MAXBUFLEN,

  237. 			&data->dirichletOuter);

  238. 	if(data->dirichletOuter!=0 && data->dirichletOuter!=1){

  239. 		printf("dirichletOuter can either be 0 or 1!\n");

  240. 		return(NULL);

  241. 	}

  242. 

  243. 	ier=parseNumber<int>   (input, "adaptiveGrid"	, MAXBUFLEN,

  244. 			&data->adaptiveGrid);

  245. 	if(ier==-1 || (data->adaptiveGrid!=0 && data->adaptiveGrid!=1)){

  246. 		printf("specify adaptiveGrid as 0 or 1!\n");

  247. 		return(NULL);

  248. 	}

  249. 

  250. 	ier=parseNumber<int>   (input, "moveGrid"	, MAXBUFLEN,

  251. 			&data->moveGrid);

  252. 	if(ier==-1 || (data->moveGrid!=0 && data->moveGrid!=1)){

  253. 		printf("specify moveGrid as 0 or 1!\n");

  254. 		return(NULL);

  255. 	}

  256. 

  257. 	ier=parseNumber<double>   (input, "isotherm"	, MAXBUFLEN,

  258. 			&data->isotherm);

  259. 	if(ier==-1){

  260. 		printf("specify temperature of isotherm!\n");

  261. 		return(NULL);

  262. 	}

  263. 

  264. 	ier=parseNumber<double>(input, "gridOffset", MAXBUFLEN, &data->gridOffset);

  265. 

  266. 	ier=parseNumber<int>   (input, "nSaves"	, MAXBUFLEN, &data->nSaves);

  267. 	if(data->nSaves<0 ){

  268. 		printf("nSaves must be greater than 0!\n");

  269. 		return(NULL);

  270. 	}

  271. 	

  272. 	ier=parseNumber<int>   (input, "writeRates"	, MAXBUFLEN,

  273. 			&data->writeRates);

  274. 	if(data->writeRates!=0 && data->writeRates!=1){

  275. 		printf("writeRates must either be 0 or 1!\n");

  276. 		return(NULL);

  277. 	}

  278. 

  279. 	ier=parseNumber<int>   (input, "writeEveryRegrid", MAXBUFLEN,

  280. 			&data->writeEveryRegrid);

  281. 	if(data->writeEveryRegrid!=0 && data->writeEveryRegrid!=1){

  282. 		printf("writeEveryRegrid must either be 0 or 1!\n");

  283. 		return(NULL);

  284. 	}

  285. 

  286. 	ier=parseNumber<int>   (input, "setConstraints"	, MAXBUFLEN,

  287. 			&data->setConstraints);

  288. 	if(data->setConstraints!=0 && data->setConstraints!=1){

  289. 		printf("setConstraints must either be 0 or 1!\n");

  290. 		return(NULL);

  291. 	}

  292. 

  293. 	ier=parseNumber<int>   (input, "suppressAlg"	, MAXBUFLEN,

  294. 			&data->suppressAlg);

  295. 	if(data->suppressAlg!=0 && data->suppressAlg!=1){

  296. 		printf("suppressAlg must either be 0 or 1!\n");

  297. 		return(NULL);

  298. 	}

  299. 

  300. 	ier=parseNumber<int>   (input, "dryRun"	, MAXBUFLEN,

  301. 			&data->dryRun);

  302. 	if(data->dryRun!=0 && data->dryRun!=1){

  303. 		printf("dryRun must either be 0 or 1!\n");

  304. 		return(NULL);

  305. 	}

  306. 

  307. 	ier=parseNumber<double>   (input, "finalTime"	, MAXBUFLEN,

  308. 			&data->finalTime);

  309. 

  310. 	ier=parseNumber<double>   (input, "relativeTolerance"	, MAXBUFLEN,

  311. 			&data->relativeTolerance);

  312. 	ier=parseNumber<double>   (input, "radiusTolerance"	, MAXBUFLEN,

  313. 			&data->radiusTolerance);

  314. 	ier=parseNumber<double>   (input, "temperatureTolerance", MAXBUFLEN,

  315. 			&data->temperatureTolerance);

  316. 	ier=parseNumber<double>   (input, "pressureTolerance", MAXBUFLEN,

  317. 			&data->pressureTolerance);

  318. 	ier=parseNumber<double>   (input, "massFractionTolerance", MAXBUFLEN,

  319. 			&data->massFractionTolerance);

  320. 	ier=parseNumber<double>   (input, "bathGasTolerance", MAXBUFLEN,

  321. 			&data->bathGasTolerance);

  322. 	ier=parseNumber<double>   (input, "MdotTolerance", MAXBUFLEN,

  323. 			&data->MdotTolerance);

  324. 

  325. 	char chem[MAXBUFLEN],mix[MAXBUFLEN],tran[MAXBUFLEN];

  326. 

  327. 	ier=parseNumber<char>(input, "chemistryFile"	, MAXBUFLEN, chem);

  328. 	if(ier==-1){

  329. 		printf("Enter chemistryFile!\n");

  330. 		return(NULL);

  331. 	}else{

  332. 		try{

  333. 			data->gas = new Cantera::IdealGasMix(chem);

  334. 			data->nsp=data->gas->nSpecies(); //assign no: of species

  335. 

  336.     		} catch (Cantera::CanteraError& err) {

  337. 		    printf("Error:\n");

  338. 		    printf("%s\n",err.what());

  339. 		    return(NULL);

  340.     		}

  341. 	}

  342. 

  343. 	ier=parseNumber<char>(input, "transportModel", MAXBUFLEN, tran);

  344. 	if(ier==-1){

  345. 		printf("Enter transportModel!\n");

  346. 		return(NULL);

  347. 	}else{

  348. 		try{

  349.   			data->trmix = Cantera::newTransportMgr(tran, data->gas);

  350. 		}catch (Cantera::CanteraError& err) {

  351. 			printf("Error:\n");

  352. 			printf("%s\n",err.what());

  353. 			return(NULL);

  354.     		}

  355. 	}

  356. 

  357. 	ier=parseNumber<char>(input, "mixtureComposition", MAXBUFLEN, mix);

  358. 	if(ier==-1){

  359. 		printf("Enter mixtureComposition!\n");

  360. 		return(NULL);

  361. 	}else{

  362. 		if(data->gas!=NULL){

  363. 			try{

  364. 				data->gas->setState_TPX(data->initialTemperature,

  365. 							data->initialPressure*Cantera::OneAtm,

  366. 							mix);

  367. 			}catch (Cantera::CanteraError& err) {

  368. 		    		printf("Error:\n");

  369. 		    		printf("%s\n",err.what());

  370. 		    		return(NULL);

  371.     			}

  372. 		}

  373. 	}

  374. 

  375. 	//ier=parseNumber<char>(input, "dropletComposition", MAXBUFLEN, data->dropSpec);

  376. 	//if(ier==-1){

  377. 	//	printf("Enter composition of droplet!\n");

  378. 	//	return(NULL);

  379. 	//}

  380. 

  381.     //ier=parseDrop(input,"dropletComposition",data->dropSpec,data->dropMole,MAXBUFLEN);

  382.     //ier=parseDrop(input,"dropletDensity",data->dropSpec,data->dropDens,MAXBUFLEN);

  383. 

  384. 

  385. 	ier=parseNumber<int>   (input, "nThreads", MAXBUFLEN, &data->nThreads);

  386. 	if(data->nThreads<0 ){

  387. 		printf("nThreads must be greater than 0!\n");

  388. 		return(NULL);

  389. 	}

  390.     

  391. 

  392. 	ier=parseNumber<double>(input, "PCAD", MAXBUFLEN, &data->PCAD);

  393. 	if(ier==-1){

  394. 		printf("Enter PCAD value!\n");

  395. 		return(NULL);

  396. 	}

  397.     ier=parseNumber<double>(input,"RGTC", MAXBUFLEN, &data->RGTC);

  398. 	if(ier==-1){

  399. 		printf("Enter PGTC value!\n");

  400. 		return(NULL);

  401. 	}

  402.     ier=parseNumber<int>(input,"JJRG", MAXBUFLEN, &data->JJRG);

  403. 	if(ier==-1){

  404. 		printf("Enter JJRG value!\n");

  405. 		return(NULL);

  406. 	}

  407.     ier=parseNumber<double>(input,"deltaT", MAXBUFLEN, &data->deltaT);

  408. 	if(ier==-1){

  409. 		printf("Enter deltaT value!\n");

  410. 		return(NULL);

  411. 	}

  412. 	

  413.     data->nr=0;

  414. 	//data->np=data->nr+1;

  415. 	data->nt=data->nr+1;

  416. 	data->ny=data->nt+1;

  417. 	data->np=data->ny+data->nsp;

  418. 	data->nm=data->np+1;

  419. 				

  420. 	data->nvar=data->nsp+4;		 //assign no: of variables (R,T,P,Mdot,nsp species)

  421. 

  422. 

  423.     double MW[2]; 

  424.     for(int i=0;i<=1;i++){

  425.         int speciesIndex = data->gas->speciesIndex(data->dropSpec[i]);

  426.         double weight = data->gas->molecularWeight(speciesIndex);

  427.         MW[i]= weight;

  428.     }

  429. 

  430.     // double massSum = 0.0; 

  431.     // for(int i=0;i<=1;i++){

  432.     //     massSum = massSum + data->dropMole[i] * MW[i];

  433.     // }

  434.     // data->dropRho = 0.0;

  435.     // for(int i=0;i<=1;i++){

  436.     //     data->dropMassFrac[i] = data->dropMole[i]*MW[i]/massSum;

  437.     //     data->dropRho = data->dropRho + data->dropMassFrac[i]*data->dropDens[i];

  438.     // }

  439. 	

  440.     printf("Density of droplet is: %.3f [kg/m^3]\n",data->dropRho);

  441. 	//Mass of droplet

  442. 	//data->massDrop=1.0/3.0*pow(data->Rd,3)*997.0; //TODO: The density of the droplet should be a user input

  443.     //data->massDrop=1.0/3.0*pow(data->Rd,3)*684.00; //TODO: The density of the droplet(n-heptane) should be a user input

  444.     data->massDrop=1.0/3.0*pow(data->Rd,3)*data->dropRho;

  445. 

  446. 	/* Update the gamma using UNIFAC method for propane and n-heptane */

  447. 	getGamma(data->dropMole,data->gamma) ; 

  448. 	printf("Gamma of Propane and n-heptane are %.3f and %.3f .\n",data->gamma[0],data->gamma[1]) ;

  449. 

  450. 	if(!data->adaptiveGrid){

  451. 		data->uniformGrid = new double [data->npts];

  452. 		data->neq=data->nvar*data->npts;

  453. 	}

  454. 	else{

  455. 		data->grid=(UserGrid) malloc(sizeof *data->grid);

  456. 		ier=getGridSettings(input,data->grid);

  457. 		if(ier==-1)return(NULL);

  458. 

  459. 		ier=initializeGrid(data->grid);

  460. 		if(ier==-1)return(NULL);

  461. 

  462. 		ier=reGrid(data->grid, data->grid->position);

  463. 		if(ier==-1)return(NULL);

  464. 

  465. 		data->npts=data->grid->nPts;

  466. 		data->neq=data->nvar*data->npts;

  467. 	}

  468. 

  469. 	data->output=fopen("output.dat","w");

  470. 	data->globalOutput=fopen("globalOutput.dat","w");

  471. 	data->gridOutput=fopen("grid.dat","w");

  472. 	data->timescaleOutput=fopen("timeScale.dat","w") ;

  473.     data->rxnROPOutput=fopen("rxnROP.dat","w");

  474.     data->spROPOutput=fopen("spROP.dat","w");

  475. 	//data->ratesOutput=fopen("rates.dat","w");

  476. 	

  477. 	data->innerMassFractions = new double [data->nsp];

  478. 	//data->wdot_mole = new double [data->nsp] ; 

  479. 	//data->wdot_mass = new double [data->nsp] ; 

  480. 	data->time_scale = new double [(data->npts) * (data->nsp)] ; 

  481. 	//data->MW = new double [data->nsp] ; 

  482. 

  483. 	return(data);

  484. }

  485. 

  486. void setSaneDefaults(UserData data){

  487. 	data->domainLength=1.0e-02;

  488. 	data->Rd=100.0e-06;

  489. 	data->constantPressure=1;

  490. 	data->problemType=1;

  491. 	data->quasiSteady=1;

  492. 	data->dPdt=0.0e0;

  493. 	data->reflectProblem=0;

  494. 	data->mdot=0.0;

  495. 	data->initialTemperature=300.0;

  496. 	data->initialPressure=1.0;

  497. 	data->metric=0;

  498. 	data->ignTime=1e-09;

  499. 	data->maxQDot=0.0e0;

  500. 	data->maxTemperature=300.0e0;

  501. 	data->mixingWidth=1e-04;

  502. 	data->shift=3.0e-03;

  503. 	data->firstRadius=1e-04;

  504. 	data->wallTemperature=298.0e0;

  505. 	data->dirichletInner=0;

  506. 	data->dirichletOuter=0;

  507. 	data->adaptiveGrid=0;

  508. 	data->moveGrid=0;

  509. 	data->gridOffset=0.0e0;

  510. 	data->Rg=1.0;

  511. 	data->isotherm=1000.0;

  512. 	data->nSaves=30;

  513. 	data->writeRates=0;

  514. 	data->writeEveryRegrid=0;

  515. 	data->relativeTolerance=1e-06;

  516. 	data->radiusTolerance=1e-08;

  517. 	data->temperatureTolerance=1e-06;

  518. 	data->pressureTolerance=1e-06;

  519. 	data->massFractionTolerance=1e-09;

  520. 	data->bathGasTolerance=1e-06;

  521. 	data->finalTime=1e-02;

  522. 	data->tNow=0.0e0;

  523. 	data->setConstraints=0;

  524. 	data->suppressAlg=1;

  525. 	data->regrid=0;

  526. 	data->gridDirection=1;

  527. 	data->dryRun=0;

  528. 	data->nThreads=1;

  529. 

  530. 	data->flamePosition[0]=0.0e0;

  531. 	data->flamePosition[1]=0.0e0;

  532. 	data->flameTime[0]=0.0e0;

  533. 	data->flameTime[1]=0.0e0;

  534. 	data->nTimeSteps=0;

  535.     data->PCAD=0.75;

  536.     data->RGTC=1.0;

  537.     data->JJRG=0;

  538.     data->deltaT=200.0;

  539. }

  540. 

  541. 

  542. void getGamma(const double mole[],double gamma[]){

  543.     /* define relevant matrix */

  544.     Eigen::Matrix2d nu_ ;

  545.     nu_ << 2,1,2,5;

  546.     /* define relevant vectors */

  547.     Eigen::Vector2d R_(0.9011,0.6744),Q_(0.8480,0.5400);

  548.     Eigen::Vector2d r_,q_,x_,l_,ones_(1.0,1.0),v_,ksi_,gammaC_;

  549.     double sum_q, sum_r,sum_l;

  550. 

  551.     r_ = nu_ * R_ ;

  552.     q_ = nu_ * Q_ ;

  553.     x_ << mole[0], mole[1] ;

  554. 

  555.     sum_q = x_.dot(q_) ;

  556.     sum_r = x_.dot(r_) ;

  557. 

  558.     for(int i=0; i<v_.size() ; i++){

  559.         v_[i] = q_[i] * x_[i] / sum_q;

  560.         ksi_[i] = r_[i] * x_[i] / sum_r ;

  561.     }

  562. 

  563.     l_ = 5 * (r_ - q_) - (r_ - ones_) ;

  564.     sum_l = l_.dot(x_) ;

  565.     /* calculate the gamma_c  */

  566.     for(int i=0; i<v_.size() ; i++){

  567.         gammaC_[i] =std::exp( std::log(ksi_[i]/x_[i]) + 5*q_[i]*std::log(v_[i]/ksi_[i]) + l_[i] - ksi_[i]/x_[i]*sum_l );

  568.     }

  569.     /******* gamma_R for both propane and n-heptane are 0 **********/

  570.     /* return the gamma */

  571.     for(int i=0; i<v_.size(); i++){

  572.         gamma[i] = gammaC_[i] ;

  573.     }

  574. 

  575. }