/* This example models the failure repair behavior of a reliability block diagram
*/
# include	"user.h"

#define max(x,y) ((x>y)?(x):(y))
#define min(x,y) ((x<y)?(x):(y))

double lambda, coverage;

parameters() {

	iopt(IOP_METHOD,VAL_TSUNIF);
	iopt(IOP_MC,VAL_CTMC);
	iopt(IOP_PR_MARK_ORDER,VAL_CANONIC);
	iopt(IOP_PR_RSET,VAL_YES);
	iopt(IOP_PR_RGRAPH,VAL_YES);
	iopt(IOP_ITERATIONS,20000);
	iopt(IOP_CUMULATIVE,VAL_NO);
	fopt(FOP_ABS_RET_M0,0.0);
	fopt(FOP_PRECISION,0.00000001);

	lambda = input("failure rate");
	coverage = 0.9;

}

enabling_type enall() {
			if ( (mark("pup11") == 0 && mark("pup12") == 0)||
			     (mark("pup21") == 0 && mark("pup22") == 0 &&
			      mark("pup23") == 0 && mark("pup24") == 0)||
			     (mark("pup31") == 0 && mark("pup32") == 0))
			     return(0);
			else
				return(1); }

enabling_type entfail() {
			if ( (mark("pup11") == 0 && mark("pup12") == 0)||
			     (mark("pup21") == 0 && mark("pup22") == 0 &&
			      mark("pup23") == 0 && mark("pup24") == 0)||
			     (mark("pup31") == 0 && mark("pup32") == 0))
			     return(1);
			else
				return(0); }

int arc11() { return(mark("pup11")); }
int arc12() { return(mark("pup12")); }
int arc21() { return(mark("pup21")); }
int arc22() { return(mark("pup22")); }
int arc23() { return(mark("pup23")); }
int arc24() { return(mark("pup24")); }
int arc31() { return(mark("pup31")); }
int arc32() { return(mark("pup32")); }

net() {

	/* the behavior of each component is modeled by a Petri net */
	place("pup11");
	init("pup11",2);
	place("ptmp11");
	place("pfl11");

	trans("tfl11");
	enabling("tfl11",enall);
	trans("tc11");
	priority("tc11",100);
	trans("tuc11");
	priority("tuc11",100);

	ratedep("tfl11",lambda,"pup11");
	probval("tc11",coverage);
	probval("tuc11",1.0 - coverage);

	iarc("tfl11","pup11");	oarc("tfl11","ptmp11");
	iarc("tc11","ptmp11");	oarc("tc11","pfl11");
	iarc("tuc11","ptmp11");	moarc("tuc11","pfl11",2);
	iarc("tuc11","pup11");

	place("pup12");
	init("pup12",2);
	place("ptmp12");
	place("pfl12");

	trans("tfl12");
	enabling("tfl12",enall);
	trans("tc12");
	priority("tc12",100);
	trans("tuc12");
	priority("tuc12",100);

	ratedep("tfl12",lambda,"pup12");
	probval("tc12",coverage);
	probval("tuc12",1.0 - coverage);

	iarc("tfl12","pup12");	oarc("tfl12","ptmp12");
	iarc("tc12","ptmp12");	oarc("tc12","pfl12");
	iarc("tuc12","ptmp12");	moarc("tuc12","pfl12",2);
	iarc("tuc12","pup12");

	place("pup21");
	init("pup21",2);
	place("ptmp21");
	place("pfl21");

	trans("tfl21");
	enabling("tfl21",enall);
	trans("tc21");
	priority("tc21",100);
	trans("tuc21");
	priority("tuc21",100);

	ratedep("tfl21",lambda,"pup21");
	probval("tc21",coverage);
	probval("tuc21",1.0 - coverage);

	iarc("tfl21","pup21");	oarc("tfl21","ptmp21");
	iarc("tc21","ptmp21");	oarc("tc21","pfl21");
	iarc("tuc21","ptmp21");	moarc("tuc21","pfl21",2);
	iarc("tuc21","pup21");

	place("pup22");
	init("pup22",2);
	place("ptmp22");
	place("pfl22");

	trans("tfl22");
	enabling("tfl22",enall);
	trans("tc22");
	priority("tc22",100);
	trans("tuc22");
	priority("tuc22",100);

	ratedep("tfl22",lambda,"pup22");
	probval("tc22",coverage);
	probval("tuc22",1.0 - coverage);

	iarc("tfl22","pup22");	oarc("tfl22","ptmp22");
	iarc("tc22","ptmp22");	oarc("tc22","pfl22");
	iarc("tuc22","ptmp22");	moarc("tuc22","pfl22",2);
	iarc("tuc22","pup22");

	place("pup23");
	init("pup23",2);
	place("ptmp23");
	place("pfl23");

	trans("tfl23");
	enabling("tfl23",enall);
	trans("tc23");
	priority("tc23",100);
	trans("tuc23");
	priority("tuc23",100);

	ratedep("tfl23",lambda,"pup23");
	probval("tc23",coverage);
	probval("tuc23",1.0 - coverage);

	iarc("tfl23","pup23");	oarc("tfl23","ptmp23");
	iarc("tc23","ptmp23");	oarc("tc23","pfl23");
	iarc("tuc23","ptmp23");	moarc("tuc23","pfl23",2);
	iarc("tuc23","pup23");

	place("pup24");
	init("pup24",2);
	place("ptmp24");
	place("pfl24");

	trans("tfl24");
	enabling("tfl24",enall);
	trans("tc24");
	priority("tc24",100);
	trans("tuc24");
	priority("tuc24",100);

	ratedep("tfl24",lambda,"pup24");
	probval("tc24",coverage);
	probval("tuc24",1.0 - coverage);

	iarc("tfl24","pup24");	oarc("tfl24","ptmp24");
	iarc("tc24","ptmp24");	oarc("tc24","pfl24");
	iarc("tuc24","ptmp24");	moarc("tuc24","pfl24",2);
	iarc("tuc24","pup24");

	place("pup31");
	init("pup31",2);
	place("ptmp31");
	place("pfl31");

	trans("tfl31");
	enabling("tfl31",enall);
	trans("tc31");
	priority("tc31",100);
	trans("tuc31");
	priority("tuc31",100);

	ratedep("tfl31",lambda,"pup31");
	probval("tc31",coverage);
	probval("tuc31",1.0 - coverage);

	iarc("tfl31","pup31");	oarc("tfl31","ptmp31");
	iarc("tc31","ptmp31");	oarc("tc31","pfl31");
	iarc("tuc31","ptmp31");	moarc("tuc31","pfl31",2);
	iarc("tuc31","pup31");

	place("pup32");
	init("pup32",2);
	place("ptmp32");
	place("pfl32");

	trans("tfl32");
	enabling("tfl32",enall);
	trans("tc32");
	priority("tc32",100);
	trans("tuc32");
	priority("tuc32",100);

	ratedep("tfl32",lambda,"pup32");
	probval("tc32",coverage);
	probval("tuc32",1.0 - coverage);

	iarc("tfl32","pup32");	oarc("tfl32","ptmp32");
	iarc("tc32","ptmp32");	oarc("tc32","pfl32");
	iarc("tuc32","ptmp32");	moarc("tuc32","pfl32",2);
	iarc("tuc32","pup32");

	place("sysup");
	init("sysup",1);
	trans("tfail");
	enabling("tfail",entfail);
	priority("tfail",50);
	probval("tfail",1.0);

	iarc("tfail","sysup");
	viarc("tfail","pup11",arc11); voarc("tfail","pfl11",arc11);
	viarc("tfail","pup12",arc12); voarc("tfail","pfl12",arc12);
	viarc("tfail","pup21",arc21); voarc("tfail","pfl21",arc21);
	viarc("tfail","pup22",arc22); voarc("tfail","pfl22",arc22);
	viarc("tfail","pup23",arc23); voarc("tfail","pfl23",arc23);
	viarc("tfail","pup24",arc24); voarc("tfail","pfl24",arc24);
	viarc("tfail","pup31",arc31); voarc("tfail","pfl31",arc31);
	viarc("tfail","pup32",arc32); voarc("tfail","pfl32",arc32);

}

assert() {
		return(RES_NOERR);
}

ac_init() {
	pr_net_info();
}

ac_reach() {
	pr_rg_info();
}

reward_type	ef0() { return(mark("sysup")); }

ac_final() {

	double time_point;

	for ( time_point = 0.02; time_point < 0.2; time_point += 0.02)
	{
	   time_value( time_point );
	   pr_expected("reliability",ef0);
	}
	for ( time_point = 0.2; time_point < 1.0; time_point += 0.2)
	{
	   time_value( time_point );
	   pr_expected("reliability",ef0);
	}
	for ( time_point = 1.0; time_point < 10.0; time_point += 1.0)
	{
	   time_value( time_point );
	   pr_expected("reliability",ef0);
	}
	for ( time_point = 10.0; time_point < 20.0; time_point += 5.0)
	{
	   time_value( time_point );
	   pr_expected("reliability",ef0);
	}

}