new 1000, 300000;  
screen on;			

@ Set working directory @
    dir=changedir("C:\\My\Documents\\_Projects_\\IAP_Universities_and_Firms\\Keuzegedrag\\Participation_and_Schooling\\Analyse\\080619_revisions\\2_estsim"); /* change working directory. If still get 
	"Error 34. cannot open file", then manually set working directory through menu: File --> Change working directory */

@ Estimate model: doit(pdata,pnl,phesscalc,pph,psh,puc,pestsim,pNONEspec) @
    /* pdata is the name of the datafile, specified without extension. 
	   
       pnl is the type of model to estimate or simulate. 
        pnl=0:      logit,          		                                        	uses llclogit
        pnl=1:      simultaneous nested logit,                                      	uses llAB
        pnl=2.9:    sequential nested logit (upper model),  		                	uses llABtrueseq3
        pnl=3:      sequential nested logit, computation of corrected vcov-matrix		see phesscalc for method
        note:       In case of simulation (pestsim=="s"), then 1, 2.9 and 3 will lead to simnested.
					use pnl=3 to simulate for nested logit (otherwise assignment of parameter values not correct because have to use two different files which is hard-coded).

       phesscalc indicates that SE's should be corrected in case of sequential estimation (pnl=3)
        phesscalc=2: using product of gradients
        phesscalc=3: using Murphy-Topel
    
       pph refers to the travel cost specification used
        pph=2 is non-linear model with renters & commuters with interaction terms
            
	   psh refers to the model specification (variables)
        psh=2 is model with high school focus variables but without HE focus variables 
        psh=3 is psh=2 + HE focus variables

       puc refers to the institution dummies
        puc="uc" means university and college dummies 

       pestsim says whether we want to do estimation or simulation
        pestsim="e" is estimation
        pestsim="s" is simulation 

       pNONEspec says which NONE-variables we want to include in the upper model
        pNONEspec=5 is NONE NONEMALE NONEFOR NONEAGE NONEASO NONETSO NONECATH NONECLAS NONELANG NONEECON NONESCIE NONEMATH NONETSOH */


/* MODEL 1 : simple logit */
	// call doit("54alt_rs14464pup_rsallaltf",0,2,2,2,"uc","e",5,1550); 		// Aggregate logit model 

/* MODEL 2 : simultaneous nested logit */
	// call doit("54alt_rs14464pup_rsallaltf",1,2,2,2,"uc","e",5,1550); 		// Aggregate nested logit model 

/* MODEL 3 : sequential nested logit */
	// call doit("155alt_rs12690stud_rs19altf",0,2,2,3,"uc","e",5,1550); 		// Disaggregate nested logit model, part 1
	// call doit("155alt_rs19237pup_rsallaltf",2.9,2,2,3,"uc","e",5,1550); 		// Disaggregate nested logit model, part 2
	// call doit("155alt_rs19237pup_rsallaltf",3,2,2,3,"uc","e",5,1550); 		// Disaggregate nested logit model, part 3 (SE correction)

	// call doit("155alt_rs19237pup_rsallaltf",3,2,2,3,"uc","s",5,1550);		// Simulate using disaggregate nested logit model

proc (0)=doit(pdata,pnl,phesscalc,pph,psh,puc,pestsim,pNONEspec,pctrav_outside);   
    local   f1, posfirst_, hulp, possecond_, posalt, alts, indivs, agglevel, est_logfile,
            model, travel, spec, NONEspec, CTRAV0value,
            othervname, startv, startvW, startvCTRAV, startvNONE, startvNESTA, startvphi,  
            nrvars, rowbytes, filesize, memsize, indivchunk, beta, f, g, cov, ret, gr, w, xmat, 
            V1, V1_name, g11, g11_name, V2, V2_name, g22, g22_name, g21, g21_name, g21m, i, C, R, vcov_corr, vcov_corr_name, temp, m;

    /* Create logfile */
        clearg logfile;
        if pnl==0;          model="logit";
        elseif pnl==1;      model="simulNLllAB";
        elseif pnl==2.9;    model="trueseqNL3";
        elseif pnl==3;      
            if phesscalc==2;        model="seqNLcorrectedSE";
            endif;
        endif;

        if pph==2;      travel="cutoffint";
        endif;

        if psh==2;  spec="long";
        elseif psh==3;  spec="extlong1";
        endif;

        if pNONEspec==5;  	NONEspec="NONEall";
        endif;

        CTRAV0value= ftos(1550,"%*.*lf",1,0);

        logfile=pdata $+ "_" $+ model $+ "_" $+ travel $+ "_" $+ spec $+ "_" $+ puc $+ "_" $+ NONEspec $+ "_" $+ CTRAV0value; /* "logfile" is re-used in the simulations part */
        if pestsim$=="e";
            est_logfile="est_" $+ logfile $+ ".txt";
            output file=^est_logfile reset;
            print "Started estimation at " timestr(time);
            print "Estimation on: " pdata;
        endif;

    /* Initialize global variables (shared with other procedures). These are symbols that are used by both procedure doit 
        and the ll-functions, so have to make them global. */
        clearg nalt, nindiv, studsonly;
        clearg ph, nl, sh; ph = pph; nl = pnl;  sh=psh;	/* 	In the ll-procedures we cannot use "pph", "pnl" and "psh" because these are local to 
                                               				procedure doit. So we declare global variables that the ll-functions can access. */

    /* Verify which version of the dataset we're dealing with */
        /* determine pupils versus students only version (using filename) */
            studsonly=strindx(pdata,"stud",1); /* Returns 0 if "stud" cannot be found in the file name. So 0 
                                                    means pupilsdataset, different from 0 means studentsdataset.
                                                    We make this distiction so we can make the logit model run on
                                                    a specification that only includes the student variables. */
        /* determine aggregation level (using filename) */
            posfirst_ = strindx(pdata,"_",1); /* find position of first underscore; this is needed to 
                                                 determine the aggregation level of the dataset we're working with */
            agglevel = strsect(pdata,1,posfirst_ - 4);
            agglevel = strtof(agglevel);    
        /* determine nr of alternatives per individual (using filename) */
            hulp= strsect(pdata,posfirst_+1,strlen(pdata)-posfirst_);    
            possecond_= strindx(hulp,"_",1);
            posalt= strindx(hulp,"alt",1); 
            alts= strsect(hulp,possecond_+3,posalt-(possecond_+3));
            if alts $== "all";
                nalt=agglevel;          /*  in subsequent comment lines, we refer to nalt as "J" */
            else;
                nalt=strtof(alts);
            endif;
            indivs= strsect(hulp,3,possecond_-4);
            if indivs $== "all";
                print "Check out the nr of individuals and hardcode it (e.g. nindiv=55905)";
                end;
            else;
                nindiv=strtof(indivs);  /* in subsequent comment lines, we refer to nindiv as "N" */
            endif;
        print "Nr of individuals in data: ";;nindiv; 
        print "Nr of alternatives per individual: ";;nalt;
        if studsonly eq 0;  
            print "Dataset with pupils (students+outsiders)";
        else;
            print "Dataset with students only";
        endif;

        clearg dataset; dataset=pdata;

    /* Open dataset */
        open f1 = ^pdata;    /* make file handle for dataset. Note: if "bad filehandle"-error, check whether 
                                file exists in "dir" (see supra). */

    /* Define specification and supply starting values for each group of parameters (these can be overruled below) */
        /* 1. Define the non-travel cost variables (and their starting values) to take up in each specification */
            clearg vnamesW, vnamesNONE;
            if psh==2;                      
                if puc$=="uc";
                   let vnamesW =   LSIZE ACAD I_HANT I_PLANT I_KDGH I_KHKEMP I_KHMECH I_ERASM I_HVWK I_KHLEUV I_HGENT I_KHSTL I_HLIM I_KHLIM I_PHLIM I_HWVL I_KHBO I_KHZWVL I_EHSAL I_LESSIU I_ARTEV I_KUL I_RUG I_UA I_VUB ACADMALE ACADFOR ACADAGE ACADASO ACADTSO ACADCATH ACADCLAS ACADLANG ACADECON ACADSCIE ACADMATH ACADTSOH CATH CATHMALE CATHFOR CATHAGE CATHASO CATHTSO CATHCATH CATHCLAS CATHLANG CATHECON CATHSCIE CATHMATH CATHTSOH;
					startvW=		{0.9980817,-2.102486,-0.6102922,0.1389641,0.1808546,0.2629046,0.9404353,-0.0191727,-0.0142008,0.682776,0.5191959,0.2404635,0.4777167,0.3713351,-0.1364224,0.0466398,0.1934374,0.4634125,1.907103,0.9156062,1.027429,0.5967702,1.020563,-0.045814,-3.770228,-0.0244072,0.5120116,-0.1778181,1.982158,-0.3579022,0.4080487,1.605766,-0.0333321,-0.3814592,0.5524705,0.954127,0.1478033,-0.9199263,-0.1842165,-0.4195043,-0.1427806,0.4216472,0.3236069,1.073488,0.1346009,-0.136822,0.051238,-0.2218057,-0.0960174,0.0160825};
                endif;
            elseif psh==3;   
                if puc$=="uc"; 
                   let vnamesW =    LSIZE VOCL I_HANT I_PLANT I_KDGH I_KHKEMP I_KHMECH I_ERASM I_HVWK I_KHLEUV I_HGENT I_KHSTL I_HLIM I_KHLIM I_PHLIM I_HWVL I_KHBO I_KHZWVL I_EHSAL I_LESSIU I_ARTEV VOCLMALE VOCLFOR VOCLAGE VOCLASO VOCLTSO VOCLCLAS VOCLLANG VOCLECON VOCLSCIE VOCLMATH VOCLTSOH VOCLCATH ACAD I_KUL I_RUG I_UA I_VUB ACADMALE ACADFOR ACADAGE ACADASO ACADTSO ACADCLAS ACADLANG ACADECON ACADSCIE ACADMATH ACADTSOH ACADCATH CATH CATHMALE CATHFOR CATHAGE CATHASO CATHTSO CATHCLAS CATHLANG CATHECON CATHSCIE CATHMATH CATHTSOH CATHCATH SCI SCIMALE SCIFOR SCIAGE SCIASO SCITSO SCICLAS SCILANG SCIECON SCISCIE SCIMATH SCITSOH SCICATH SSCI SSCIMALE SSCIFOR SSCIAGE SSCIASO SSCITSO SSCICLAS SSCILANG SSCIECON SSCISCIE SSCIMATH SSCITSOH SSCICATH BIOM BIOMMALE BIOMFOR BIOMAGE BIOMASO BIOMTSO BIOMCLAS BIOMLANG BIOMECON BIOMSCIE BIOMMATH BIOMTSOH BIOMCATH;
                   startvW =        {0.679419,-0.8949793,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0.3231494,0.5740139,-0.0867578,0.3297015,-0.5601478,0.8699025,0.4258491,0.6217406,0.9923066,1.32968,0.6167558,0.4485321,-1.930922,0,0,0,0,0.1447738,0.4925821,-0.2288836,2.211358,-0.3822376,1.806514,-0.0908109,-0.1726079,0.8684862,1.29339,0.2338069,0.4074486,-0.282832,-0.0808047,-0.346792,-0.1097265,0.0043854,0.0546504,0.023486,-0.1259135,-0.0072808,-0.0099735,-0.137168,-0.4318339,0.9453302,-2.200569,1.357588,0.5270835,-0.0687631,0.2734437,0.2372261,-1.276994,-0.1839549,-0.1091392,1.39366,2.089782,3.088453,0.4005141,-1.727008,0.0817753,-0.3542112,0.1971826,2.134774,2.46712,-0.7090026,-0.148569,0.8795028,0.5665468,0.7923318,-0.2556727,0.2202336,-3.151301,-0.5817633,-0.1004679,0.1267851,2.734554,2.870815,-0.6023598,-0.8003326,0.1669325,1.616434,1.024438,1.13568,0.2370256};
                endif;
            endif;
            if studsonly eq 0; @ students + outsiders @
                if pNONEspec==5;
                    let vnamesNONE =    NONE NONEMALE NONEFOR NONEAGE NONEASO NONETSO NONECATH NONECLAS NONELANG NONEECON NONESCIE NONEMATH NONETSOH;
					startvNONE=		{-20.40295,0.4559949,-0.2877054,-0.1354221,2.465096,1.625604,1.011718,0.3993884,-0.5239462,0.7919269,1.266145,1.880612,1.829517};
                endif;
            endif;

        /* 2. Define the travel cost variables (and their starting values) to take up in each specification */
            clearg regCTRAV,regCTR61, vnamesCTRAV, vnamesCTR61, vnameCTRAVm, vnameCTR61m, vnamesCTRAVi;
            let vnameCTRAVm= CTRAV; 
            if pph==2;
                let vnamesCTRAV =   CTRAV CTRAVMAL CTRAVFOR CTRAVAGE CTRAVASO CTRAVTSO CTRAVCAT CTRAVCLA CTRAVLAN CTRAVECO CTRAVSCI CTRAVMAT CTRAVTS1 CTRAV61;    
				startvCTRAV =       {-5.457198,0.0649064,-0.1643363,-0.1758093,0.0206554,-1.347452,0.256565,0.2972341,-0.2911676,-0.4186646,0.1029429,0.0864484,1.278949,2.43568}; 
                let vnamesCTR61 =   CTR61MAL CTR61FOR CTR61AGE CTR61ASO CTR61TSO CTR61CAT CTR61CLA CTR61LAN CTR61ECO CTR61SCI CTR61MAT CTR61TS1;  /* Note: the CTR61 interaction variables are constrained parameters */
                let vnameCTR61m=    CTRAV61;
                let vnamesCTRAVi=   CTRAVMAL CTRAVFOR CTRAVAGE CTRAVASO CTRAVTSO CTRAVCAT CTRAVCLA CTRAVLAN CTRAVECO CTRAVSCI CTRAVMAT CTRAVTS1;
            endif;

    /*  Determine the max. number of individuals that can be submitted to the ll-function given available RAM. 
        This is to deal with "insufficient memory"-messages. */
        clearg rowschunk;
        if agglevel==54;
            rowbytes = 1000;
        elseif agglevel==155;
            rowbytes = 1800;        
        endif;
        filesize = nindiv*nalt*rowbytes;
        memsize = 250000000;
        if filesize<memsize;
            rowschunk = nindiv*nalt;    
            print "file fits in memory";    /*  If Gauss says "Insufficient memory" after all, it means that the "memsize" specified
                                                a few lines higher is not really available to Gauss. Reduce "memsize" or free some RAM. */
        else;                       /*  If file > memsize, then read in steps with each step = __row. If "Bad expression or missing
                                        arguments G0105"-error in this line, then the value of __row doesn't make sense for some 
                                        reason (not an integer, greater than total nr of rows,...). */
            indivchunk=600;        /*  The number of individuals that we want to process as a whole i.e. with all their 
                                       corresponding observations if filesize>memsize. Increasing it gives better performance,
                                       but if "Insufficient memory"-error, than have to reduce it (minimum value=1). */
            rowschunk = indivchunk*nalt; /* Example: for the 54alt_rs9619pups_rsallaltf-file (434MB): if we set memsize to 400MB we impose
                                           rowschunk=500*54=27000 rows at a time. Maxlik will then process the data by first calculating p for 
                                           19 blocks of 27000 rows (19 blocks * 500 individuals = 9500 processed individuals) and then for the 
                                           remaining block of 6426 rows (=119 individuals). */ 
            print "file does not fit in memory; if __row is used, then it has now the value ";;rowschunk;
        endif;

    /*  Create variable labels for variables and parameters that we need as separate vectors (e.g. for creation of auxiliary 
        variables, for simulations,...). */
        clearg  vnameINDIV, 	vnameCHOSEN, 	vnameOPTION, 	vnameACAD, 			vnameVOC, 		vnameVOCS,		vnameVOCL,		vnameNONE, 		vnameCATH, 
                vnameI_KUL, 	vnameI_RUG, 	vnameI_VUB, 	vnameI_UA, 			vnameI_LUC,		vnamesaux,
				vnameAKUL,		vnameAUG,		vnameAUA,		vnameAVUB,			vnameALUC,
				vnameCDIST,		vnameCTIME_RL,	vnameDIST,
                vnameCTRAV,     vnameCTRAVMAL,  vnameCTRAVFOR,  vnameCTRAVAGE,  	vnameCTRAVASO,  vnameCTRAVTSO,  vnameCTRAVCAT, 
								vnameCTRAVCLA,  vnameCTRAVLAN,  vnameCTRAVECO,  	vnameCTRAVSCI,  vnameCTRAVMAT,  vnameCTRAVTS1,
                vnameCTRAV61,   vnameCTR61MAL,  vnameCTR61FOR,  vnameCTR61AGE,  	vnameCTR61ASO,  vnameCTR61TSO,  vnameCTR61CAT,
                vnameCTRAV2,    vnameMALE,      vnameFORE,      vnameAGE,       	vnameASO,       vnameTSO,       vnameCATH1,
				vnameCLAS, 		vnameLANG1, 	vnameECON1, 	vnameMATH, 			vnameSCIE, 		vnameTSOH, 		vnameWEIGHT,
				vnameSCI,		vnameSSCI,		vnameBIOM,		vnameARTS; 
        let vnameINDIV =    INDIV;  	let vnameCHOSEN = 	CHOSEN; 		let vnameOPTION=	OPTION;
        let vnameACAD =     ACAD;   	let vnameVOC = 		VOC;            let vnameVOCS = 	VOCS;			let vnameVOCL = 	VOCL;		let vnameNONE = 	NONE;
		let vnameAKUL =     AKUL;   	let vnameAUG =    	AUG;			let vnameAUA =    	AUA;			let vnameAVUB =     AVUB;		let vnameALUC =     ALUC;
        let vnameCATH =     CATH;   	let vnameI_KUL = 	I_KUL;         	let vnameI_RUG = 	I_RUG;
        let vnameI_VUB =    I_VUB;  	let vnameI_UA = 	I_UA;           let vnameI_LUC = 	I_LUC;
		let vnameCDIST =    CDIST;		let vnameCTIME_RL = CTIME_RL;   	let vnameDIST =		DIST; 
        let vnameCTRAV =    CTRAV;      let vnameCTRAVMAL = CTRAVMALE;  	let vnameCTRAVFOR = CTRAVFOR;   	let vnameCTRAVAGE = CTRAVAGE;   let vnameCTRAVASO = CTRAVASO;   let vnameCTRAVTSO = CTRAVTSO;   let vnameCTRAVCAT = CTRAVCAT;
        								let vnameCTRAVCLA = CTRAVCLA;  		let vnameCTRAVLAN = CTRAVLAN;   	let vnameCTRAVECO = CTRAVECO;   let vnameCTRAVSCI = CTRAVSCI;   let vnameCTRAVMAT = CTRAVMAT;   let vnameCTRAVTS1 = CTRAVTS1;
        let vnameCTRAV61 =  CTRAV61;    let vnameCTR61MAL = CTR61MALE;  	let vnameCTR61FOR = CTR61FOR;   	let vnameCTR61AGE = CTR61AGE;   let vnameCTR61ASO = CTR61ASO;   let vnameCTR61TSO = CTR61TSO;   let vnameCTR61CAT = CTR61CAT;
        let vnameCTRAV2 =   CTRAV2;     let vnameMALE = 	MALE;           let vnameFORE = 	FORE;           let vnameAGE = 		AGE;        let vnameASO = 		ASO;        let vnameTSO = 		TSO;        let vnameCATH1 = 	CATH1;
		let vnameSCI = 		SCI;		let vnameSSCI = 	SSCI;			let vnameBIOM = 	BIOM;			let vnameARTS = 	ARTS;
		let vnameCLAS = 	CLAS;		let vnameLANG1 = 	LANG1;			let vnameECON1 = 	ECON1;			let vnameMATH = 	MATH;		let vnameSCIE = 	SCIE;		let vnameTSOH = 	TSOH;		let vnameWEIGHT = 	WEIGHT;
        let vnamesaux =     INDIV VOC CHOSEN;
        if pph==2;
            vnamesaux=  vnamesaux | vnamesCTR61 ; 
        endif;
   
    /* Set options for maxlik, common for all models */
        library maxlik,pgraph;
        #include maxlik.ext;
        maxset;                     
        _max_GradTol=0.0001;        
        _max_MaxIters=50;           
        _max_Algorithm=5;           
        _max_LineSearch=2;          
        _max_MaxTry=200;            
        _max_RandRadius=1e-1;       
        _max_Diagnostic=1;
        _max_CovPar=2;

    /*  Group the starting values in one vector "startv" & group the parameter names in one vector "vnames". */
        clearg vnamesreg, vnamesreg2, pnames, pnameNESTA, pnamephi;
        let pnameNESTA=studnest;
        let pnamephi=phi;
        if studsonly eq 0;  @  all pupils dataset: includes NONE-variables @
            /* ALL PUP, SIMPLE LOGIT*/
                if pnl==0;
                    vnamesreg=      vnamesW|vnamesCTRAV|vnamesNONE;
                    pnames=         vnamesreg;
                    if exist("est_" $+ logfile $+ "_params.dat")==1;    /* if previous estimates available, use these as starting values for the current estimation or simulation */
						startv= getstartv("est_" $+ logfile $+ "_params",pnames);
                    else;
                        "********* No previous estimates found; using generic starting values *********";
                        startv=         startvW|startvCTRAV|startvNONE; /* otherwise use generic values (see supra) */
                    endif;
                    _max_Active=    ones(rows(startv),1);

            /* ALL PUP, SIMULTANEOUS NESTED*/
                elseif pnl==1;
                    vnamesreg=      vnamesW|vnamesCTRAV|vnamesNONE;
                    pnames=         vnamesreg|pnameNESTA;
                    if exist("est_" $+ logfile $+ "_params.dat")==1;    /* if previous estimates available, use these as starting values for the current estimation or simulation */
                        startv= getstartv("est_" $+ logfile $+ "_params",pnames);
                    else;
                        "********* No previous estimates found; using generic starting values *********";
                        startvNESTA=    0.5;
                        startv=         startvW|startvCTRAV|startvNONE|startvNESTA; /* otherwise use generic values (defined supra) */
                    endif;
                    _max_Active=    ones(rows(startv),1);                          

            /* ALL PUP, SEQ NESTED*/
                elseif pnl==2.9;
					if pph==2 and psh==3;
                        vnamesreg=  vnamesW|vnamesCTRAV|vnamesNONE;
                        pnames=     vnamesreg|pnameNESTA;
						startv=     getstartv("est_155alt_rs12690stud_rs19altf_logit_cutoffint_extlong1_uc_NONEall_1550_params",vnamesW|vnamesCTRAV); /* estimates for 1st stage parameters */
                    endif;
                    if exist("est_" $+ logfile $+ "_params.dat")==1;    /* if previous estimates available for 2nd stage parameters, use these as starting values for the current estimation or simulation */
                        startv= startv|getstartv("est_" $+ logfile $+ "_params",vnamesNONE|pnameNESTA);
                    else;
                        "********* No previous estimates found for 2nd stage params; using generic starting values *********";
						startvNESTA=    0.5;
                        startv=         startv|startvNONE|startvNESTA;
                    endif; 
                    _max_Active=    zeros(rows(startvW)+rows(startvCTRAV),1)|ones(rows(startvNONE)+rows(pnameNESTA),1); /* use rows(pnameNESTA) instead of rows(startvNESTA) because startvNESTA is only initialized in case no previous 2nd stage params are found on disk */

            /* ALL PUP, SEQ NESTED: FOR CORRECTION OF VCOV AND SIMULATIONS */
                elseif pnl==3;
					if pph==2 and psh==3;
                        vnamesreg=      vnamesW|vnamesCTRAV|vnamesNONE;
                        pnames=         vnamesreg|pnameNESTA;
						startv=         getstartv("est_155alt_rs12690stud_rs19altf_logit_cutoffint_extlong1_uc_NONEall_1550_params",vnamesW|vnamesCTRAV);            /* estimates for 1st stage parameters */
                        startv=         startv|getstartv("est_155alt_rs19237pup_rsallaltf_trueseqNL3_cutoffint_extlong1_uc_NONEall_1550_params",vnamesNONE|pnameNESTA);  /* estimates for 2nd stage parameters */
                        _max_Active=    ones(rows(startv),1);
                    endif;
                    if phesscalc==3; /* stuff needed for Murphy-topel */ 
                        clearg theta1names, theta2names, theta1, theta2;
                        theta1names=    vnamesW|vnamesCTRAV;
                        theta2names=    vnamesNONE|pnameNESTA;
                        theta1=         startv[indcv(theta1names,pnames),1];
                        theta2=         startv[indcv(theta2names,pnames),1];    /* to be used within gradg21 to get the NONE params and the IV param */
                    endif;
                endif;

        elseif studsonly ne 0; @ students only dataset: does not include NONE-variables @
            /* STUD ONLY, SIMPLE LOGIT*/
	            if pnl==0;  
                    vnamesreg=      vnamesW|vnamesCTRAV;
                    pnames=         vnamesreg;
                    if exist("est_" $+ logfile $+ "_params.dat")==1;    /* if previous estimates available, use these as starting values for the current estimation or simulation */
                        startv= getstartv("est_" $+ logfile $+ "_params",pnames);
                    else;
                        "********* No previous estimates found; using generic starting values *********";
                        startv=         startvW|startvCTRAV; /* otherwise use generic values (see supra) */
                    endif;
                    _max_Active=    ones(rows(startv),1);
	        	endif;
		endif;
        _max_ParNames=pnames;               /*  label the parameters */
        vnamesreg2 = vnamesreg|vnamesaux;   /*  Add the names of the auxiliary variables that we will need in the likelihood 
                                                functions. Using "vnamesreg2" as an argument for maxlik then ensures that also 
                                                the auxiliary variables are read into memory. */


/* Call the appropriate ll-function */
    if pnl==0 and pestsim$=="e";    
    @   **** SIMPLE LOGIT (llclogit) **** @
        __row= rowschunk;
		print "vnamesreg2" $vnamesreg2;
        {beta,f,g,cov,ret}=maxlik(pdata,vnamesreg2,&llclogit,startv); 
        call maxprt(beta,f,g,cov,ret);
        print "Finished estimation at " timestr(time);
        print "travel costs for outside option: " pctrav_outside;
        print "startvalues used: " startv';
        print "final results: " beta';
        call storeparams(logfile,pnames,beta);
        V1_name=    "est_" $+ logfile $+ "_V1";
        save -v96 ^V1_name=cov; /* save vcov-matrix in diskfile; needed for CI's of choice probs */

    elseif pnl==1 and pestsim$=="e";   
    @   **** SIMULTANEOUS NESTED LOGIT (llAB) **** @
        __row=rowschunk;
        {beta,f,g,cov,ret}=maxlik(pdata,vnamesreg2,&llAB,startv);
        call maxprt(beta,f,g,cov,ret);
        print "Finished estimation at " timestr(time);
        print "travel costs for outside option: " pctrav_outside;
        print "startvalues used: " startv';
        print "final results: " beta';
        call storeparams(logfile,pnames,beta);
        V1_name=    "est_" $+ logfile $+ "_V1";
        save -v96 ^V1_name=cov; /* save vcov-matrix in diskfile; needed for CI's of choice probs */

    elseif pnl==2.9 and pestsim$=="e";  
    @   **** SEQUENTIAL NESTED LOGIT step 2 **** @
            clearg gINDIV,gINCVALA,gINCVALB;
        /* get all data vectors from disk needed to estimate upper model */
            clearg regNONE, CHOSEN, ACAD, VOC, NONE, depm, depNESTA, depNESTB, depmNESTA, depmNESTB;
            print "...constructing global variables...";
            regNONE=    buildreg(pdata, vnamesNONE, "logit");   /* N by K */
            CHOSEN=     buildreg(pdata, "CHOSEN", "clogit");    /* NJ by 1 */
            depm=       reshape(CHOSEN,nindiv,nalt);            /* N by J */
            clearg      CHOSEN;
            ACAD=       buildreg(pdata, "ACAD", "clogit");      /* NJ by 1 */
            VOC=        buildreg(pdata, "VOC", "clogit");       /* NJ by 1 */
            depNESTA=   reshape(ACAD+VOC,nindiv,nalt);          /* N by J */
            clearg      ACAD, VOC;
            depmNESTA=  sumc(depm' .* depNESTA');               /* N by 1 */
            NONE=       buildreg(pdata, "NONE", "clogit");      /* NJ by 1 */
            depNESTB=   reshape(NONE,nindiv,nalt);              /* N by J */
            clearg      NONE;
            depmNESTB=  sumc(depm' .* depNESTB');               /* N by 1 */
            clearg      depm, depNESTA, depNESTB;
            print;
            print "!...all global variables ready...!";
        /* call ll-function (don't pass any data to it, we have all we need available as a global vector) */
            pnames=         vnamesNONE|pnameNESTA;      /* only need params for the upper model, incvalues already calculated */
            _max_ParNames=  pnames;
            startv=         selif(startv,_max_Active);  /*  cut startv: only include upper model params. */
            _max_Active=    ones(rows(startvNONE)+rows(pnameNESTA),1);  /* adjust dimension of _max_Active so it matches startv */
            xmat=           ones(nindiv*nalt,1);                        
            {beta,f,g,cov,ret}=maxlik(xmat,0,&llABtrueseq3,startv);
            call maxprt(beta,f,g,cov,ret);
            print "Finished estimation at " timestr(time);
            print "travel costs for outside option: " pctrav_outside;
            print "startvalues used (study params fixed): (startv)" startv';
            call storeparams(logfile,pnames,beta);
            V2_name=    "est_" $+ logfile $+ "_V2";
            save -v96 ^V2_name=cov; /* save vcov-matrix in diskfile; needed for CI's of choice probs */
            if phesscalc==3;
                g22_name=   "est_" $+ logfile $+ "_g22";
                g22=        gradp(&gradg22,beta);
                save -v96 ^g22_name=g22; /* store g22 in matrixfile on disk (.fmt), needed for Murphy-Topel. */
            endif;

    elseif pnl==3 and pestsim$=="e";   
    @ **** SEQUENTIAL NESTED LOGIT step 3, computation of Hessian **** @
            __row=rowschunk;
            if phesscalc==2; 
                gr = gradp(&gradgfull,startv);  /* N by K */
                w = inv(gr'*gr);                /* K by K */
                print "Point estimates= " startv;
                print "Standard errors (2nd stage=corrected SE's)= " sqrt(diag(w));
                print "t-statistics= " (startv ./ sqrt(diag(w)));
		        V1_name= "est_" $+ logfile $+ "_V1";
		        save -v96 ^V1_name=w;
            elseif phesscalc==3;
                /* read vcov-matrices and gradients from 1st and 2nd step */
                    V1_name=    "est_226alt_rs12669stud_rs19altf_logit2_cutoffint_extlong2_uc_NONEall" $+ "_V1";         /* K1 by K1 */
                    g11_name=   "est_226alt_rs12669stud_rs19altf_logit2_cutoffint_extlong2_uc_NONEall" $+ "_g11";        /* N by K1 */
                    V2_name=    "est_226alt_rs19215pup_rsallaltf_trueseqNL3_cutoffint_extlong2_uc_NONEall" $+ "_V2";     /* K2 by K2 */
                    g22_name=   "est_226alt_rs19215pup_rsallaltf_trueseqNL3_cutoffint_extlong2_uc_NONEall" $+ "_g22";    /* N by K2 */
                    load  V1= ^V1_name, g11= ^g11_name, V2= ^V2_name, g22= ^g22_name;
                    g21_name=   "est_" $+ logfile $+ "_g21.fmt";
                    if exist(g21_name)==1;
                        print "g21 found: read from disk file with name ";;g21_name;
                        load g21= ^g21_name;                /* N by K1 */
                    else;
                        print "g21 not found on disk, calculating with gradg21";
                        g21= gradp(&gradg21,theta1);        /* N by K1 */
                        save -v96 ^g21_name=g21;
                    endif;
                /* calculate vcov_corr */
                    for i(1,nindiv,1);  /* create N K2 by K1 matrices and sum the corresponding elements */
                        if i==1;
                            C=  g22[i,.]' .* g21[i,.];  	/* outer product: [K2,1] .* [1,K1] = K2 by K1 */
                        else;
                            C= C + g22[i,.]' .* g21[i,.];
                        endif;
                    endfor;
                    C= 1/nindiv * C;      /* K2 by K1 */
                    print "C= " C;
                    vcov_corr=  V2 + V2 * (C * V1 * C') * V2;   /* K2 by K2 */
                    temp = V2 * (C * V1 * C') * V2;
                    print "correction term added to V2 = " temp;
                    vcov_corr_name=    "est_" $+ logfile $+ "_vcov_corr_noR";
                    save -v96 ^vcov_corr_name=vcov_corr;
                    print "Corrected variance-covariance matrix= " vcov_corr;
                    print "Corrected standard errors= " sqrt(diag(vcov_corr)); 
                    print "t-statistics= " (theta2 ./ sqrt(diag(vcov_corr)));
            endif;

    elseif (pnl==1 or pnl==2.9 or pnl==3) and pestsim$=="s";
    @ **** NESTED LOGIT : simulations **** @
		/* 	We use naming convention for the simulations to indicate what fee increases are applied to which alternatives. 
			We have the status quo simulation ("SQ"), the uniform increase for all study options ("STUDY"), the simple non-uniform increase	i.e.
			only one fee increase is used (e.g. ACAD, VOC, ACADSCI,...) and the complex non-uniform increase i.e. more than one fee increase 
			amount is used. for the latter, a number is used to indicate the number of different fee increases e.g. ACAD2 (=ACADSCI&ACADBIOM 
			get a different fee increase than ACADSSCI&ACADARTS). WHICH options get which fee increase is more or less indicated by the name (e.g.
			if it says ACADKUL2 then you know there are two different amounts for ACADKUL-options) but you have to check the code to know it exactly. */
        clearg  mpSTUD,     	mpACAD,     	mpVOC,  		mpVOCS,			mpVOCL,		mpCATH,     	mpNCATH,		mpI_KUL,  		mpI_RUG,  mpI_VUB,  mpI_UA,   mpI_LUC,  mpACADSCI,	mpACADSSCI,		mpACADBIOM,		mpACADARTS,		mpVOCSCI,	mpVOCSSCI,		mpVOCBIOM,		mpVOCARTS,	mpAKUL,		mpAUG,	mpAUA,	mpAVUB,		mpALUC,		mCS, 	tCS, 	tPS, 	tevSTUDY, 	tevNONE,
                mpSTUD1,    	mpACAD1,    	mpVOC1, 		mpVOCS1,		mpVOCL1,	mpCATH1,    	mpNCATH1,		mpI_KUL1, 		mpI_RUG1, mpI_VUB1, mpI_UA1,  mpI_LUC1, mpACADSCI1,	mpACADSSCI1,	mpACADBIOM1,	mpACADARTS1,	mpVOCSCI1,	mpVOCSSCI1,		mpVOCBIOM1,		mpVOCARTS1,	mpAKUL1,	mpAUG1,	mpAUA1,	mpAVUB1,	mpALUC1,	mCS1, 	tCS1, 	tPS1,	tevSTUDY1, 	tevNONE1,
				mpACADSCI_KUL, 	mpACADSCI_RUG, 	mpACADSCI_VUB,	mpACADSCI_UA,	mpACADSCI_LUC,
				mpACADSCI_KUL1, mpACADSCI_RUG1, mpACADSCI_VUB1,	mpACADSCI_UA1,	mpACADSCI_LUC1,
				mpACADBIOM_KUL, mpACADBIOM_RUG, mpACADBIOM_VUB, mpACADBIOM_UA, 	mpACADBIOM_LUC,
				mpACADBIOM_KUL1,mpACADBIOM_RUG1,mpACADBIOM_VUB1,mpACADBIOM_UA1, mpACADBIOM_LUC1,
				size1, @ The size of the fee increase is expressed in 10.000's Euros so size1=0.1 is equal to increase of 1000 Euro @
				size2, @ To allow for two different non-zero increases; size2 is only used for ACAD2, for the other simulations the value of size2 is irrelevant: it is not used in simnested. @
				size3, @ Used in 2 possible ways: 1) To allow for three different non-zero increases; size for ACADSCI_KUL, size2 for ACADBIOM_KUL and size3 for the other ACAD. 2) for the ACADVOC_DIST simulation where size3 is the subsidy per kilometre. @
				vnamecondvar, sim_logfile, sim_logfile2;
		call create_simlogfile(startv);
		call create_simlogfile2(startv);

		call simnested(startv, size1, size2, size3, "INDIV",-1);
		size1 = 0.1200;	size2 = 0.1200;	size3 = 0.000553; call simnested(startv, size1, size2, size3, "ACADVOC_dist",-1); // Adjust this line to get different simulations

		closeall sim_logfile, sim_logfile2;
    endif;
closeall;
endp;


/*  --------- Log-likelihood routines --------- */

proc llclogit(b,x);
    @ procedure for estimating simple logit (pnl=0) @
    local   posparW, posregW, posparCTRAV, posregCTRAV, posparCTR61, posregCTR61, posparCTRAVm, posparCTR61m, posparCTRAVi, 
            posparNONE, posregNONE, posparphi, posCHOSEN, dum, sigma, r, ev, depm, p;
    /* determine position of the different parameter- and variablegroups in b and x */
        posparW=       indcv(vnamesW,pnames);               posregW=       indcv(vnamesW,vnamesreg2);
        posparCTRAV=   indcv(vnamesCTRAV,pnames);           posregCTRAV=   indcv(vnamesCTRAV,vnamesreg2);
        if ph==2;
            posregCTR61=   indcv(vnamesCTR61,vnamesreg2);   posparCTRAVm=  indcv(vnameCTRAVm,pnames);
            posparCTR61m=  indcv(vnameCTR61m,pnames);       posparCTRAVi=  indcv(vnamesCTRAVi,pnames);
        endif;
        if studsonly eq 0;
            posparNONE=    indcv(vnamesNONE,pnames);        posregNONE=    indcv(vnamesNONE,vnamesreg2);
        endif;
    /* calculate ev */
        if ph==2; 
            if studsonly ne 0;
                ev=exp((x[.,posregW] * b[posparW,1]) + (x[.,posregCTRAV] * b[posparCTRAV,1]) + (x[.,posregCTR61] * (b[posparCTR61m,1] .* (b[posparCTRAVi,1] ./ b[posparCTRAVm,1])))); 
            elseif studsonly eq 0; 
                ev=exp((x[.,posregW] * b[posparW,1]) + (x[.,posregNONE] * b[posparNONE,1]) + (x[.,posregCTRAV] * b[posparCTRAV,1]) + (x[.,posregCTR61] * (b[posparCTR61m,1] .* (b[posparCTRAVi,1] ./ b[posparCTRAVm,1]))));
            endif;  
        endif;
    /* construct p */
        ev=reshape(ev,rows(x)/nalt,nalt);   /* N by J. Note: 'N' may be a subset of individuals in case only part of the datafile was supplied to the ll-function */
        posCHOSEN = indcv(vnameCHOSEN,vnamesreg2);  
        depm = reshape(x[.,posCHOSEN],rows(x)/nalt,nalt); /* N by J */
        p=sumc((ev .* depm)') ./ sumc(ev');
    retp(ln(p));
endp;


proc llAB(b,x);
    @ procedure for estimating simultaneous nested logit (pnl=1) and 2nd step of sequential nested logit (pnl=2.9) @
    local   posparW, posregW, posparCTRAV, posregCTRAV, posparCTR61, posregCTR61, posparCTRAVm, posparCTR61m, posparCTRAVi, 
            posparNONE, posregNONE, posparphi, posCHOSEN, k, kk, posparNESTA,
            parW, parCTRAV, parCTRAVm, parCTR61m, parCTRAVi, parNONE, phi,
            sigma, r, dum,
            ev, regW, regCTRAV, regCTR61, regNONE, CHOSEN, posACAD, ACAD, posVOC, VOC, posNONE, NONE,
            depm, NESTA, NESTB, depNESTA, depNESTB, depmNESTA, depmNESTB, evNESTA, evNESTB, evNESTA1, evNESTB1, num, p; 
    /* split the parameters and variables in separate vectors: easier for calculating ev */
        k=ones(2,1);
        posparNESTA=    indcv(pnameNESTA,pnames);       k[1,1]=     b[posparNESTA,1];
        posACAD =       indcv(vnameACAD,vnamesreg2);    ACAD =      x[.,posACAD];
        posVOC =        indcv(vnameVOC,vnamesreg2);     VOC =       x[.,posVOC];
        posNONE=        indcv(vnameNONE,vnamesreg2);    NONE=       x[.,posNONE];
        NESTA =         ACAD + VOC;
        NESTB =         NONE;
        kk=             k[1,1].*NESTA+k[2,1].*NESTB;    /* NJ by 1 */
        posparW=        indcv(vnamesW,pnames);          parW=       b[posparW,1];          
        posregW=        indcv(vnamesW,vnamesreg2);      regW=       x[.,posregW];
        posparCTRAV=    indcv(vnamesCTRAV,pnames);      parCTRAV=   b[posparCTRAV,1];      
        posregCTRAV=    indcv(vnamesCTRAV,vnamesreg2);  regCTRAV=   x[.,posregCTRAV];
        posparNONE=     indcv(vnamesNONE,pnames);       parNONE=    b[posparNONE,1];       
        posregNONE=     indcv(vnamesNONE,vnamesreg2);   regNONE=    x[.,posregNONE];
        if ph==1;
            posparphi=  indcv(pnamephi,pnames);         phi=        b[posparphi,1];
        elseif ph==2;
            posregCTR61=   indcv(vnamesCTR61,vnamesreg2);   regCTR61=   x[.,posregCTR61];
            posparCTRAVm=  indcv(vnameCTRAVm,pnames);       parCTRAVm=  b[posparCTRAVm,1];
            posparCTR61m=  indcv(vnameCTR61m,pnames);       parCTR61m=  b[posparCTR61m,1];
            posparCTRAVi=  indcv(vnamesCTRAVi,pnames);      parCTRAVi=  b[posparCTRAVi,1];
        endif;
    /* calculate ev */
        if ph==2; 
            ev=exp((regW*parW) + (regNONE*parNONE) + (regCTRAV*parCTRAV) + (regCTR61 * (parCTR61m.*(parCTRAVi./parCTRAVm))));
        endif;
    /* construct p */
        ev=reshape(ev,rows(x)/nalt,nalt);   /* N by J. Note: 'N' may be a subset of individuals in case only part
                                             of the datafile was supplied to the ll-function */
        posCHOSEN = indcv(vnameCHOSEN,vnamesreg2);  CHOSEN = x[.,posCHOSEN];
        depm =      reshape(CHOSEN,rows(x)/nalt,nalt);
        depNESTA =  reshape(NESTA,rows(x)/nalt,nalt);    /*  N by J, each of the J columns indicates whether the 
                                                             alternative is a study-alternative */
        depNESTB =  reshape(NESTB,rows(x)/nalt,nalt);    /*  N by J, depNESTA's complement */
        depmNESTA=  sumc(depm' .* depNESTA');            /*  N by 1: each element indicates whether the 
                                                             individual's choice is a study alternative or whether
                                                             it is the outside option. (sumc sums the columns, then takes the transpose.) */ 
        depmNESTB=  sumc(depm' .* depNESTB');            /*  N by 1, depmNESTB's complement */
        evNESTA = sumc((ev .* depNESTA)');               /*  N by 1: for each indiv, the sum of the ev-terms of all alternatives in NESTA */
        evNESTA1 = evNESTA .^ (k[1,1]-1);                /*  N by 1 */
        evNESTB = sumc((ev .* depNESTB)');                  
        evNESTB1 = evNESTB .^ (k[2,1]-1);
        num = (evNESTA1 .* depmNESTA) + (evNESTB1 .* depmNESTB);
        p=sumc((ev .* depm)') .* num ./ ((evNESTA.^k[1,1])+(evNESTB.^k[2,1]));
    retp(ln(p));
endp;


proc gradgfull(b);
@   This procedure is used to compute the gradient of the log likelihood of the COMPLETE model i.e. the ll of the simultaneous nested logit 
    model (pnl==3, phesscalc==2). The matrix of choice probabilities p is computed in steps to avoid memory problems. A dataloop is used 
    for this. @
    local   posparW, posparCTRAV, posparCTR61, posparCTRAVm, posparCTR61m, posparCTRAVi, posparNONE, posparphi, posparNESTA,
            posCHOSEN, posACAD, posVOC, posNONE, posregNONE, posregCTR61, posregCTRAV, posregW, 
            k, kk, f2, allvars, i, nrdone, chunk,
            dum, sigma, r,
            ev, depNESTA, depNESTB, depmNESTA, depmNESTB, evNESTA, evNESTB, depm, 
            pchunk, p;
    /* split the parameters in separate vectors: easier for calculating ev */
        k=ones(2,1);
        posparNESTA=    indcv(pnameNESTA,pnames);        
        k[1,1]=         b[posparNESTA,1];
        posparW=        indcv(vnamesW,pnames);
        posparCTRAV=    indcv(vnamesCTRAV,pnames);
        posparNONE=     indcv(vnamesNONE,pnames);
        if ph==2;
            posparCTRAVm=  indcv(vnameCTRAVm,pnames);   posparCTR61m=  indcv(vnameCTR61m,pnames);   posparCTRAVi=  indcv(vnamesCTRAVi,pnames);
        endif;
    /* start dataloop: read whole dataset in chunks and do the necessary calculations */
        open f2 = ^dataset;
        allvars=getnamef(f2);
        allvars=0 $+ allvars;   /* convert type of allvars from "string array" to "matrix", needed for indcv-function below. */
        i = 0;
        nrdone = 0;
        print "processing datafile in chunks";
        do until nrdone>=nindiv*nalt;  
            i = i + 1;
            print ".";;
            /* read datachunk and split in subvectors: easier for calculating ev */
                chunk =         readr(f2,rowschunk);
                nrdone=         nrdone + rows(chunk);
                posregW=        indcv(vnamesW,allvars);
                posregCTRAV=    indcv(vnamesCTRAV,allvars);
                posregNONE=     indcv(vnamesNONE,allvars);
                posCHOSEN =     indcv(vnameCHOSEN,allvars);
                posACAD=        indcv(vnameACAD,allvars);
                posVOC=         indcv(vnameVOC,allvars);
                posNONE=        indcv(vnameNONE,allvars);
                kk=             k[1,1].*(chunk[.,posACAD] + chunk[.,posVOC]) + k[2,1].*chunk[.,posNONE]; /*  NJ by 1 */
                if ph==2;
                    posregCTR61=    indcv(vnamesCTR61,allvars);
                endif;
            /* calculate ev */
                if ph==2; 
                    ev=exp((chunk[.,posregW]*b[posparW,1]) + (chunk[.,posregNONE]*b[posparNONE,1]) + (chunk[.,posregCTRAV]*b[posparCTRAV,1]) + (chunk[.,posregCTR61] * (b[posparCTR61m,1].*(b[posparCTRAVi,1]./b[posparCTRAVm,1])) ));
                endif;
            /* construct pchunk i.e. choice probability for current datachunk */
                ev=             reshape(ev,rows(chunk)/nalt,nalt);      /* N by J */
                depm=           reshape(chunk[.,posCHOSEN],rows(chunk)/nalt,nalt);                  /* N by J */
                depNESTA =      reshape(chunk[.,posACAD] + chunk[.,posVOC],rows(chunk)/nalt,nalt);  /* N by J */
                depNESTB =      reshape(chunk[.,posNONE],rows(chunk)/nalt,nalt);
                evNESTA =       sumc((ev .* depNESTA)');  /*  N by 1: for each indiv, the sum of the ev-terms of all alternatives in NESTA */
                evNESTB =       sumc((ev .* depNESTB)');
                depmNESTA=      sumc(depm' .* depNESTA');      clear depNESTA;      
                depmNESTB=      sumc(depm' .* depNESTB');      clear depNESTB;            
                pchunk=         sumc((ev .* depm)') .* ( ((evNESTA .^ (k[1,1]-1)) .* depmNESTA) + ((evNESTB .^ (k[2,1]-1)) .* depmNESTB) )./ ((evNESTA.^k[1,1])+(evNESTB.^k[2,1]));
            /* store choice probs for this data chunk */
                if i==1;
                    p =         pchunk;
                else;
                    p =         p|pchunk;
                endif;
        endo;
        f2 = close(f2);
    retp(ln(p));
endp;


proc gradg21(b);
@  This procedure is used to compute the gradient of the lnL (cfr pnl==3, phesscalc==3) wrt the FIRST STAGE parameters.  
   The matrix of choice probabilities p is computed in steps to avoid memory problems: a dataloop is used for this. 
   Notes:   The IV and the NONE parameters are not passed via "b", we retrieve those from the global variable "theta2".
            The 1st stage parameters (CTRAV and W) are retrieved from the passed "b". @
    local   posparW, posregW, posparCTRAV, posregCTRAV, posparCTR61, posregCTR61, posparCTRAVm, posparCTR61m, posparCTRAVi, posparNESTA,
            posparNONE, posregNONE, posparphi, posCHOSEN, posACAD, posVOC, posNONE, 
            k, kk, f2, allvars, i, chunk, dum, sigma, r,
            ev, depNESTA, depNESTB, depmNESTA, depmNESTB, evNESTA, evNESTB, depm, pchunk, p, nrdone;
    /* 1st stage params: determine position within parameter set passed through b (=theta1) */
        posparW=        indcv(vnamesW,theta1names);
        posparCTRAV=    indcv(vnamesCTRAV,theta1names);   
        if ph==2;
            posparCTRAVm=  indcv(vnameCTRAVm,theta1names);   posparCTR61m=  indcv(vnameCTR61m,theta1names);   posparCTRAVi=  indcv(vnamesCTRAVi,theta1names);
        endif;
    /* 2nd stage params: determine position within theta2 (=global variable because these params not passed to gradg21 */
        posparNESTA=    indcv(pnameNESTA,theta2names);      
        k=              ones(2,1);
        k[1,1]=         theta2[posparNESTA,1];                  
        posparNONE=     indcv(vnamesNONE,theta2names);
    /* start dataloop: read whole dataset in chunks and do the necessary calculations */
        open f2 = ^dataset;
        allvars=getnamef(f2);
        allvars=0 $+ allvars;   /* convert type of allvars from "string array" to "matrix", needed for indcv-function below. */
        i = 0;
        nrdone = 0;
        print "processing datafile in chunks    ";;
        do until nrdone>=nindiv*nalt;            
            i = i + 1;
            print ".";;
            /* read datachunk and determine position of regressors */
                chunk =         readr(f2,rowschunk);
                nrdone=         nrdone + rows(chunk);
                posregW=        indcv(vnamesW,allvars);     posregCTRAV=    indcv(vnamesCTRAV,allvars); posregNONE=     indcv(vnamesNONE,allvars);  
                posCHOSEN=      indcv(vnameCHOSEN,allvars); posACAD=        indcv(vnameACAD,allvars);   posVOC=         indcv(vnameVOC,allvars);
                posNONE=        indcv(vnameNONE,allvars);
                kk=             k[1,1].*(chunk[.,posACAD] + chunk[.,posVOC]) + k[2,1].*chunk[.,posNONE]; /*  NJ by 1 */
                if ph==2;
                    posregCTR61=    indcv(vnamesCTR61,allvars);
                endif;
            /* calculate ev */
                if ph==2; 
                    ev=exp((chunk[.,posregW]*b[posparW,1]) + (chunk[.,posregNONE]*theta2[posparNONE,1]) + (chunk[.,posregCTRAV]*b[posparCTRAV,1]) + (chunk[.,posregCTR61] * (b[posparCTR61m,1].*(b[posparCTRAVi,1]./b[posparCTRAVm,1])) ));
                endif;
            /* construct pchunk i.e. choice probability for current datachunk */
                ev=             reshape(ev,rows(chunk)/nalt,nalt);                                  /* N by J */
                depm=           reshape(chunk[.,posCHOSEN],rows(chunk)/nalt,nalt);                  /* N by J */
                depNESTA =      reshape(chunk[.,posACAD] + chunk[.,posVOC],rows(chunk)/nalt,nalt);  /* N by J */
                depNESTB =      reshape(chunk[.,posNONE],rows(chunk)/nalt,nalt);
                evNESTA =       sumc((ev .* depNESTA)');  /*  N by 1: for each indiv, the sum of the ev-terms of all alternatives in NESTA */
                evNESTB =       sumc((ev .* depNESTB)');
                depmNESTA=      sumc(depm' .* depNESTA');      clear depNESTA;      
                depmNESTB=      sumc(depm' .* depNESTB');      clear depNESTB;            
                pchunk=         sumc((ev .* depm)') .* ( ((evNESTA .^ (k[1,1]-1)) .* depmNESTA) + ((evNESTB .^ (k[2,1]-1)) .* depmNESTB) )./ ((evNESTA.^k[1,1])+(evNESTB.^k[2,1]));
            /* store choice probs for this data chunk */
                if i==1;
                    p =         pchunk;
                else;
                    p =         p|pchunk;
                endif;
        endo;
        f2 = close(f2);
    retp(ln(p));
endp;


proc llABtrueseq3(b,x);
@   Only does the calculations for the upper model (i.e. estimates a simple logit). It requires the inclusive values
    and regressors to be available as global vectors. @
    local k, parNONE, p;
            k=ones(2,1);
            k[1,1]=     b[rows(b),1];
            parNONE=    b[1:rows(b)-1,1];
			p =         ( depmNESTA .* exp(k[1,1].*gINCVALA) + depmNESTB .* exp(gINCVALB + regNONE * parNONE) ) ./ ( exp( k[1,1].*gINCVALA) + exp(gINCVALB + regNONE * parNONE) );
    retp(ln(p));
endp;


proc gradg22(b);
@   Procedure for calculating the gradient of the second-stage ll to the second-stage parameters. The procedure expects the regressors
    to be available as global variables, as in llABtrueseq3 (actually gradg22 is an exact copy of llABtrueseq3 with the exception
    of the parameter x). @
    local k, parNONE, p;
            k=ones(2,1);
            k[1,1]=     b[rows(b),1];
            parNONE=    b[1:rows(b)-1,1];
            p =         ( depmNESTA .* exp(k[1,1].*gINCVALA) + depmNESTB .* exp(regNONE * parNONE) ) ./ ( exp( k[1,1].*gINCVALA) + exp(regNONE * parNONE) );
    retp(ln(p));
endp;


proc gnested(b);
@   This procedure is used to return the gradient of the aggregated choice probabilities and the gradient of the CS to the K parameters. 
    Notes:
    - 	The procedure needs "size" and "vnamecondvar" because it should calculate the simulated probabilities. Since gradp does not
        allow any parameter passing besides b, these two pieces of information are made available to gradp as global variables.
    -	The procedure returns a NJ by K vector of the simulated choice probabilities. @
    local   posparW, posregW, posparCTRAV, posregCTRAV, posparCTR61, posregCTR61, posparCTRAVm, posparCTR61m, posparCTRAVi, 
            posparNESTA, posparNONE, posregNONE, posparphi, posACAD, posVOC, posNONE, poscondvar, posCTRAV, posCTRAV61, 
			posMALE, posFORE, posAGE, posASO, posTSO, posCATH1, posCLAS, posLANG1, posECON1, posSCIE, posMATH, posTSOH,
			posparCTRAVMAL, posparCTRAVFOR, posparCTRAVAGE, posparCTRAVASO, posparCTRAVTSO, posparCTRAVCAT, posparCTRAVCLA, posparCTRAVLAN, posparCTRAVECO, posparCTRAVSCI, posparCTRAVMAT, posparCTRAVTS1,
			posWEIGHT, posCATH, posSCI, posSSCI, posBIOM, posARTS, posI_KUL, posI_RUG,
            k, kk, f2, allvars, i, nrdone, chunksize, z, chunk, FEE, notKUL, notRUG,
            dum, sigma, r, DUMTR61, d,
            ev, evNESTA, evNESTB, depNESTA, depNESTB, p1, p2, CHOSEN, depm, pchunk, 
			depACAD, pchunkACAD, pACAD, depVOC, pchunkVOC, pVOC, pchunkSTUD, pSTUD, depCATH, pchunkCATH, pCATH, depNCATH, pchunkNCATH, pNCATH, NOTCATH;
    /* determine position of the different parameters in b */
        k=ones(2,1);
        posparNESTA=   indcv(pnameNESTA,pnames);        	k[1,1]=     	b[posparNESTA,1];
        posparW=       indcv(vnamesW,pnames);           	posparCTRAV=   	indcv(vnamesCTRAV,pnames); 		posparNONE=    indcv(vnamesNONE,pnames);
        posparCTRAVm=  indcv(vnameCTRAVm,pnames);
        if ph==2;
            posparCTR61m=  indcv(vnameCTR61m,pnames);   posparCTRAVi=  indcv(vnamesCTRAVi,pnames);

			posparCTRAVMAL=	indcv(vnameCTRAVMAL,pnames);	posparCTRAVFOR=	indcv(vnameCTRAVFOR,pnames);	posparCTRAVAGE=	indcv(vnameCTRAVAGE,pnames);
			posparCTRAVASO=	indcv(vnameCTRAVASO,pnames);	posparCTRAVTSO=	indcv(vnameCTRAVTSO,pnames);	posparCTRAVCAT=	indcv(vnameCTRAVCAT,pnames);
			posparCTRAVCLA=	indcv(vnameCTRAVCLA,pnames);	posparCTRAVLAN=	indcv(vnameCTRAVLAN,pnames);	posparCTRAVECO=	indcv(vnameCTRAVECO,pnames);	
			posparCTRAVSCI=	indcv(vnameCTRAVSCI,pnames);	posparCTRAVMAT=	indcv(vnameCTRAVMAT,pnames);	posparCTRAVTS1=	indcv(vnameCTRAVTS1,pnames);	
		endif;
    /*  read whole dataset in chunks and do the necessary calculations */
        open f2 = ^dataset;
        allvars=getnamef(f2);
        allvars=0 $+ allvars;
        posregW=        indcv(vnamesW,allvars);         posregCTRAV=    indcv(vnamesCTRAV,allvars);     posregNONE=     indcv(vnamesNONE,allvars);
        posACAD=        indcv(vnameACAD,allvars);       posVOC=         indcv(vnameVOC,allvars);        posNONE=        indcv(vnameNONE,allvars);
        posCATH=        indcv(vnameCATH,allvars);  
        poscondvar=     indcv(vnamecondvar,allvars);    posregCTR61=    indcv(vnamesCTR61,allvars);		posWEIGHT=		indcv(vnameWEIGHT,allvars);
		posMALE=		indcv(vnameMALE,allvars);       posFORE=		indcv(vnameFORE,allvars);		posAGE=			indcv(vnameAGE,allvars);
		posASO=			indcv(vnameASO,allvars);      	posTSO=			indcv(vnameTSO,allvars);      	posCATH1=		indcv(vnameCATH1,allvars);	
		posCLAS=		indcv(vnameCLAS,allvars);		posLANG1=		indcv(vnameLANG1,allvars);		posECON1=		indcv(vnameECON1,allvars);		
		posMATH=		indcv(vnameMATH,allvars);		posSCIE=		indcv(vnameSCIE,allvars);		posTSOH=		indcv(vnameTSOH,allvars);		
        i = 0;
		nrdone = 0;
        chunksize = rowschunk;
        do until nrdone>=nindiv*nalt; 
            i=i+1;
            chunk=          readr(f2,chunksize);
            nrdone=         nrdone + rows(chunk);
            /* determine fee increase vector to include in utility calculation */
                if vnamecondvar $== "INDIV";
                    FEE=    zeros(rows(chunk),1);
                elseif vnamecondvar $== "STUDY";
                    FEE=    size1 .* (chunk[.,posACAD] + chunk[.,posVOC]);
                elseif vnamecondvar $== "NCATH";
					NOTCATH=	recode(chunk[.,posCATH]+ones(rows(chunk),1), chunk[.,posCATH]+chunk[.,posNONE], zeros(1,1));
                    FEE=    	size1 .* NOTCATH;
                elseif vnamecondvar $== "ACADSCI";
                    FEE=    size1 .* (chunk[.,posACAD] .* chunk[.,posSCI]);
                elseif vnamecondvar $== "ACADSSCI";
                    FEE=    size1 .* (chunk[.,posACAD] .* chunk[.,posSSCI]);
                elseif vnamecondvar $== "ACADBIOM";
                    FEE=    size1 .* (chunk[.,posACAD] .* chunk[.,posBIOM]);
                elseif vnamecondvar $== "ACADARTS";
                    FEE=    size1 .* (chunk[.,posACAD] .* chunk[.,posARTS]);
                elseif vnamecondvar $== "VOCSCI";
                    FEE=    size1 .* (chunk[.,posVOC] .* chunk[.,posSCI]);
                elseif vnamecondvar $== "VOCSSCI";
                    FEE=    size1 .* (chunk[.,posVOC] .* chunk[.,posSSCI]);
                elseif vnamecondvar $== "VOCBIOM";
                    FEE=    size1 .* (chunk[.,posVOC] .* chunk[.,posBIOM]);
                elseif vnamecondvar $== "VOCARTS";
                    FEE=    size1 .* (chunk[.,posVOC] .* chunk[.,posARTS]);
                elseif vnamecondvar $== "ACADVOC";			/* ACAD (size1) vs VOC (size2) */
                    FEE=    size1 .* chunk[.,posACAD] + size2 .* chunk[.,posVOC];
                elseif vnamecondvar $== "FB"; 			/* first-best */
                    FEE=    (chunk[.,posWEIGHT] .* (0.2593 .* chunk[.,posACAD] + 0.2300 .* chunk[.,posVOC])) - ((chunk[.,posACAD] + chunk[.,posVOC]).*0.05);
                elseif vnamecondvar $== "STUDY_FB";
                    FEE=    (chunk[.,posWEIGHT] .* (0.2593 .* chunk[.,posACAD] + 0.2300 .* chunk[.,posVOC])) + (size1 .* (chunk[.,posACAD] + chunk[.,posVOC])) - ((chunk[.,posACAD] + chunk[.,posVOC]).*0.05);
                elseif vnamecondvar $== "ACADVOC_FB";		/* ACAD (size1) vs VOC (size2) */
                    FEE=    (chunk[.,posWEIGHT] .* (0.2593 .* chunk[.,posACAD] + 0.2300 .* chunk[.,posVOC])) + (size1 .* chunk[.,posACAD]) + (size2 .* chunk[.,posVOC]) - ((chunk[.,posACAD] + chunk[.,posVOC]).*0.05);
                else;
                    FEE=    size1 .* chunk[.,poscondvar];
                endif;
            /* calculate ev for current datachunk */
                kk= k[1,1] .* (chunk[.,posACAD] + chunk[.,posVOC]) + k[2,1] .* chunk[.,posNONE]; /*  NJ by 1 */
                if ph==2; 
					ev=exp( (chunk[.,posregW]*b[posparW,1]) + (chunk[.,posregNONE]*b[posparNONE,1]) + (chunk[.,posregCTRAV]*b[posparCTRAV,1]) + (chunk[.,posregCTR61] * (b[posparCTR61m,1].*(b[posparCTRAVi,1]./b[posparCTRAVm,1]))) + b[posparCTRAVm,1].*FEE + b[posparCTRAVMAL,1].*chunk[.,posMALE].*FEE + b[posparCTRAVFOR,1].*chunk[.,posFORE].*FEE + b[posparCTRAVAGE,1].*chunk[.,posAGE].*FEE + b[posparCTRAVASO,1].*chunk[.,posASO].*FEE + b[posparCTRAVTSO,1].*chunk[.,posTSO].*FEE + b[posparCTRAVCAT,1].*chunk[.,posCATH1].*FEE + b[posparCTRAVCLA,1].*chunk[.,posCLAS].*FEE + b[posparCTRAVLAN,1].*chunk[.,posLANG1].*FEE + b[posparCTRAVECO,1].*chunk[.,posECON1].*FEE + b[posparCTRAVSCI,1].*chunk[.,posSCIE].*FEE + b[posparCTRAVMAT,1].*chunk[.,posMATH].*FEE + b[posparCTRAVTS1,1].*chunk[.,posTSOH].*FEE);
                endif;
            /* construct pchunk i.e. choice probability for current datachunk, and aggregated choice probs */
                ev=             reshape(ev,rows(chunk)/nalt,nalt);   /* N by J */
                depNESTA=       reshape(chunk[.,posACAD] + chunk[.,posVOC],rows(chunk)/nalt,nalt);    /* N by J */
                depNESTB=       reshape(chunk[.,posNONE],rows(chunk)/nalt,nalt);
                evNESTA=        sumc((ev .* depNESTA)');  /* N by 1: for each indiv, the sum of the ev-terms of all alternatives in NESTA */
                evNESTB=        sumc((ev .* depNESTB)');
                /* do no longer return the chosen prob's as in maxlik, but in principle the full N by J vector of choice prob's or summary sums thereof */
                    p1=         	ev ./ (evNESTA .* depNESTA + evNESTB .* depNESTB); /* N by J ./ N by J = N by J */
                    p2=         	( (evNESTA .* depNESTA) .^k[1,1] + (evNESTB .* depNESTB) .^k[2,1]) ./ (  (evNESTA.^k[1,1])+(evNESTB.^k[2,1])  );
                    pchunk=     	p1 .* p2; /* this is the full N by J vector */
	                pchunkSTUD=     sumc((pchunk .* depNESTA)');   /* N by 1 */ 
	                depACAD=        reshape(chunk[.,posACAD],rows(chunk)/nalt,nalt);																			pchunkACAD=     sumc((pchunk .* depACAD)');		/* N by 1 */   
	                depVOC=         reshape(chunk[.,posVOC],rows(chunk)/nalt,nalt);     																		pchunkVOC=      sumc((pchunk .* depVOC)');  	/* N by 1 */   
	                depCATH=        reshape(chunk[.,posCATH],rows(chunk)/nalt,nalt);    																		pchunkCATH=     sumc((pchunk .* depCATH)'); 	/* N by 1 */   
					depNCATH=		reshape(recode(chunk[.,posCATH]+ones(rows(chunk),1), chunk[.,posCATH]+chunk[.,posNONE], zeros(1,1)),rows(chunk)/nalt,nalt);	pchunkNCATH=    sumc((pchunk .* depNCATH)'); 	/* N by 1 */   
            /* store choice probs for this data chunk */
                if i==1;
                    pSTUD=      pchunkSTUD;     		pACAD=  	pchunkACAD;  				pVOC=  		pchunkVOC;  	pCATH=		pchunkCATH;			pNCATH=		pchunkNCATH;		
                else;
                    pSTUD=      pSTUD|pchunkSTUD;   	pACAD=  	pACAD|pchunkACAD;    		pVOC=  		pVOC|pchunkVOC; pCATH=		pCATH|pchunkCATH;	pNCATH=		pNCATH|pchunkNCATH;		
                endif;
            clear chunk;
        endo;
        f2 = close(f2);
	    /* calculate mean probabilities: each probability is reduced from N by 1 size to a scalar */
            pSTUD=		meanc(pSTUD);       pACAD=		meanc(pACAD);           pVOC=		meanc(pVOC);      	pCATH=		meanc(pCATH);	pNCATH=		meanc(pNCATH);   	
        retp(pSTUD|pACAD|pVOC|pCATH|pNCATH); 
endp;


proc (0) = simnested(b, psize1, psize2, psize3, pvnamecondvar, pm);
	@ 	This procedure calculates the simulated (aggregated) choice probabilites for the nested logit.
		psize2 is only used for non-uniform fee increase simulations with two amounts that are different from zero (e.g. ACADSCI and ACADBIOM are
		increased with 1000 Euros, ACADSSCI and ACADBIOM are increased with 800 and the other options are not increased).
		In terms of output, it shows the aggregated probabilities and their CI's for all simulations (status quo + the other ones). The breaking down
		of aggregated choice probs is only done for the status quo simulation and the uniform fee increase simulation. @
    local   posparW, posregW, posparCTRAV, posregCTRAV, posparCTR61, posregCTR61, posparCTRAVm, posparCTR61m, posparCTRAVi, 
            posparNESTA, posparNONE, posregNONE, posparphi, posCHOSEN, posINDIV, posACAD, posVOC, posVOCS, posVOCL, posNONE, posCATH, posWEIGHT,
			posparCTRAVMAL, posparCTRAVFOR, posparCTRAVAGE, posparCTRAVASO, posparCTRAVTSO, posparCTRAVCAT, posparCTRAVCLA, posparCTRAVLAN, posparCTRAVECO, posparCTRAVSCI, posparCTRAVMAT, posparCTRAVTS1,
            posI_KUL, posI_RUG, posI_VUB, posI_UA, posI_LUC, poscondvar, posCTRAV, posCTRAV61, posDIST,
			posAKUL, posAUG, posAUA, posALUC, posAVUB,
			posMALE, posFORE, posAGE, posASO, posTSO, posCATH1, posCLAS, posLANG1, posECON1, posMATH, posSCIE, posTSOH, posSCI, posSSCI, posBIOM, posARTS,
			depMALE, depFORE, depAGE, depASO, depTSO, depCLAS, depLANG1, depECON1, depSCIE, depMATH, depTSOH, depCATH1, depFEM, depBEL, depNCATH1, depNOREP, depREP1, depREP2,
			chunkMALE, chunkFORE, chunkAGE, chunkASO, chunkTSO, chunkCLAS, chunkLANG1, chunkECON1, chunkSCIE, chunkMATH, chunkTSOH, chunkCATH1,
			mpSTUDMALE, mpSTUDFORE, mpSTUDASO, mpSTUDTSO, mpSTUDKBSO, mpSTUDCLAS, mpSTUDLANG1, mpSTUDECON1, mpSTUDSCIE, mpSTUDMATH, mpSTUDTSOH, mpSTUDCATH1, mpSTUDFEM, mpSTUDBEL, mpSTUDNOREP, mpSTUDREP1, mpSTUDREP2, mpSTUDNCATH1,
			mpACADMALE,mpACADFORE,mpACADASO,mpACADTSO, mpACADKBSO, mpACADCLAS,mpACADLANG1,mpACADECON1,mpACADSCIE,mpACADMATH,mpACADTSOH,mpACADCATH1, mpACADFEM, mpACADBEL, mpACADNOREP, mpACADREP1, mpACADREP2, mpACADNCATH1,
			mpVOCMALE,mpVOCFORE,mpVOCASO,mpVOCTSO, mpVOCKBSO, mpVOCCLAS,mpVOCLANG1,mpVOCECON1,mpVOCSCIE,mpVOCMATH,mpVOCTSOH,mpVOCCATH1, mpVOCFEM, mpVOCBEL, mpVOCNOREP, mpVOCREP1, mpVOCREP2, mpVOCNCATH1,
			mpCATHMALE,mpCATHFORE,mpCATHASO,mpCATHTSO,mpCATHCLAS,mpCATHLANG1,mpCATHECON1,mpCATHSCIE,mpCATHMATH,mpCATHTSOH,mpCATHCATH1, mpCATHFEM, mpCATHBEL, mpCATHNOREP, mpCATHNCATH1,
			mpNCATHMALE,mpNCATHFORE,mpNCATHASO,mpNCATHTSO,mpNCATHCLAS,mpNCATHLANG1,mpNCATHECON1,mpNCATHSCIE,mpNCATHMATH,mpNCATHTSOH,mpNCATHCATH1,mpNCATHFEM,mpNCATHBEL,mpNCATHNOREP,mpNCATHNCATH1,
			mpI_KULMALE,mpI_KULFORE,mpI_KULASO,mpI_KULTSO,mpI_KULCLAS,mpI_KULLANG1,mpI_KULECON1,mpI_KULSCIE,mpI_KULMATH,mpI_KULTSOH,mpI_KULCATH1,
			mpI_RUGMALE,mpI_RUGFORE,mpI_RUGASO,mpI_RUGTSO,mpI_RUGCLAS,mpI_RUGLANG1,mpI_RUGECON1,mpI_RUGSCIE,mpI_RUGMATH,mpI_RUGTSOH,mpI_RUGCATH1,
			mpI_VUBMALE,mpI_VUBFORE,mpI_VUBASO,mpI_VUBTSO,mpI_VUBCLAS,mpI_VUBLANG1,mpI_VUBECON1,mpI_VUBSCIE,mpI_VUBMATH,mpI_VUBTSOH,mpI_VUBCATH1,
			mpI_UAMALE,mpI_UAFORE,mpI_UAASO,mpI_UATSO,mpI_UACLAS,mpI_UALANG1,mpI_UAECON1,mpI_UASCIE,mpI_UAMATH,mpI_UATSOH,mpI_UACATH1,
			mpI_LUCMALE,mpI_LUCFORE,mpI_LUCASO,mpI_LUCTSO,mpI_LUCCLAS,mpI_LUCLANG1,mpI_LUCECON1,mpI_LUCSCIE,mpI_LUCMATH,mpI_LUCTSOH,mpI_LUCCATH1,
			mcsMALE,mcsFORE,mcsASO,mcsTSO,mcsCLAS,mcsLANG1,mcsECON1,mcsSCIE,mcsMATH,mcsTSOH,mcsCATH1,
			mpACADSCIMALE,mpACADSCIFORE,mpACADSCIASO,mpACADSCITSO,mpACADSCICLAS,mpACADSCILANG1,mpACADSCIECON1,mpACADSCISCIE,mpACADSCIMATH,mpACADSCITSOH,mpACADSCICATH1,
			mpACADSSCIMALE,mpACADSSCIFORE,mpACADSSCIASO,mpACADSSCITSO,mpACADSSCICLAS,mpACADSSCILANG1,mpACADSSCIECON1,mpACADSSCISCIE,mpACADSSCIMATH,mpACADSSCITSOH,mpACADSSCICATH1,
			mpACADBIOMMALE,mpACADBIOMFORE,mpACADBIOMASO,mpACADBIOMTSO,mpACADBIOMCLAS,mpACADBIOMLANG1,mpACADBIOMECON1,mpACADBIOMSCIE,mpACADBIOMMATH,mpACADBIOMTSOH,mpACADBIOMCATH1,
			mpACADARTSMALE,mpACADARTSFORE,mpACADARTSASO,mpACADARTSTSO,mpACADARTSCLAS,mpACADARTSLANG1,mpACADARTSECON1,mpACADARTSSCIE,mpACADARTSMATH,mpACADARTSTSOH,mpACADARTSCATH1,
			mpVOCSCIMALE,mpVOCSCIFORE,mpVOCSCIASO,mpVOCSCITSO,mpVOCSCICLAS,mpVOCSCILANG1,mpVOCSCIECON1,mpVOCSCISCIE,mpVOCSCIMATH,mpVOCSCITSOH,mpVOCSCICATH1,
			mpVOCSSCIMALE,mpVOCSSCIFORE,mpVOCSSCIASO,mpVOCSSCITSO,mpVOCSSCICLAS,mpVOCSSCILANG1,mpVOCSSCIECON1,mpVOCSSCISCIE,mpVOCSSCIMATH,mpVOCSSCITSOH,mpVOCSSCICATH1,
			mpVOCBIOMMALE,mpVOCBIOMFORE,mpVOCBIOMASO,mpVOCBIOMTSO,mpVOCBIOMCLAS,mpVOCBIOMLANG1,mpVOCBIOMECON1,mpVOCBIOMSCIE,mpVOCBIOMMATH,mpVOCBIOMTSOH,mpVOCBIOMCATH1,
			mpVOCARTSMALE,mpVOCARTSFORE,mpVOCARTSASO,mpVOCARTSTSO,mpVOCARTSCLAS,mpVOCARTSLANG1,mpVOCARTSECON1,mpVOCARTSSCIE,mpVOCARTSMATH,mpVOCARTSTSOH,mpVOCARTSCATH1,
			pOPTION, mpOPTION, chunknrOPTION, nrOPTION, mnrOPTION, posOPTION,
            k, kk, f2, allvars, i, nrdone, chunksize, z, chunk, FEE, RVchunk, RV, SUBchunk, SUB, NOTKUL, NOTRUG, NOTUA, NOTCATH,
            dum, sigma, r, DUMTR61, d,
            ev, evNESTA, evNESTB, depNESTA, depNESTB, p1, p2, CHOSEN, depm, pchunk, p, pchunkchosen, pchosen, INDIV, indivnr, strsize, stroption, coltitles, coltitles2, outfile,
            pchunkACAD, pACAD, pchunkVOC, pVOC, pchunkVOCS, pVOCS, pchunkVOCL, pVOCL, pchunkSTUD, pSTUD, pchunkCATH, pCATH, pchunkNCATH, pNCATH, pchunkI_KUL, pI_KUL, pchunkI_RUG, pI_RUG, pchunkI_VUB, pI_VUB, pchunkI_UA, pI_UA, pchunkI_LUC, pI_LUC, pchunkACADSCI, pACADSCI, pchunkACADSSCI, pACADSSCI, pchunkACADBIOM, pACADBIOM, pchunkACADARTS, pACADARTS, pchunkVOCSCI, pVOCSCI, pchunkVOCSSCI, pVOCSSCI, pchunkVOCBIOM, pVOCBIOM, pchunkVOCARTS, pVOCARTS, cschunk, cs, 
			pchunkAKUL, pAKUL, pchunkAUG, pAUG, pchunkAUA, pAUA, pchunkAVUB, pAVUB, pchunkALUC, pALUC, 
			pchunkACADSCI_KUL, pACADSCI_KUL, pchunkACADSCI_RUG, pACADSCI_RUG, pchunkACADSCI_VUB, pACADSCI_VUB, pchunkACADSCI_UA, pACADSCI_UA, pchunkACADSCI_LUC, pACADSCI_LUC, 
			pchunkACADBIOM_KUL, pACADBIOM_KUL, pchunkACADBIOM_RUG, pACADBIOM_RUG, pchunkACADBIOM_VUB, pACADBIOM_VUB, pchunkACADBIOM_UA, pACADBIOM_UA, pchunkACADBIOM_LUC, pACADBIOM_LUC, 
			lowerSTUD,upperSTUD,lowerSTUDC,upperSTUDC,lowerACAD,upperACAD,lowerACADC,upperACADC,lowerVOC,upperVOC,lowerVOCC,upperVOCC,lowerCATH,upperCATH,lowerCATHC,upperCATHC,lowerNCATH,upperNCATH,lowerNCATHC,upperNCATHC,
			evSTUDY, evNONE;
	clear 	lowerSTUD,upperSTUD,lowerSTUDC,upperSTUDC,lowerACAD,upperACAD,lowerACADC,upperACADC,lowerVOC,upperVOC,lowerVOCC,upperVOCC,lowerCATH,upperCATH,lowerCATHC,upperCATHC,lowerNCATH,upperNCATH,lowerNCATHC,upperNCATHC;	/* necessary in case we comment out the get_CI call */
    /* determine position of the different parameters in b */
        k=ones(2,1);
        posparNESTA=   indcv(pnameNESTA,pnames);        k[1,1]=     	b[posparNESTA,1];
        posparW=       indcv(vnamesW,pnames);           posparCTRAV=   	indcv(vnamesCTRAV,pnames);   posparNONE=    indcv(vnamesNONE,pnames);
        posparCTRAVm=  indcv(vnameCTRAVm,pnames);
        if ph==2;
            posparCTR61m=  indcv(vnameCTR61m,pnames);   posparCTRAVi=  indcv(vnamesCTRAVi,pnames);

			posparCTRAVMAL=	indcv(vnameCTRAVMAL,pnames);	posparCTRAVFOR=	indcv(vnameCTRAVFOR,pnames);	posparCTRAVAGE=	indcv(vnameCTRAVAGE,pnames);
			posparCTRAVASO=	indcv(vnameCTRAVASO,pnames);	posparCTRAVTSO=	indcv(vnameCTRAVTSO,pnames);	posparCTRAVCAT=	indcv(vnameCTRAVCAT,pnames);
			posparCTRAVCLA=	indcv(vnameCTRAVCLA,pnames);	posparCTRAVLAN=	indcv(vnameCTRAVLAN,pnames);	posparCTRAVECO=	indcv(vnameCTRAVECO,pnames);	
			posparCTRAVSCI=	indcv(vnameCTRAVSCI,pnames);	posparCTRAVMAT=	indcv(vnameCTRAVMAT,pnames);	posparCTRAVTS1=	indcv(vnameCTRAVTS1,pnames);	
		endif;
    /*  read whole dataset in chunks and do the necessary calculations */
        open f2 = ^dataset;
        allvars=getnamef(f2);
        allvars=0 $+ allvars;   /* convert type of allvars from "string array" to "matrix", needed for indcv-function below. */
        posregW=        indcv(vnamesW,allvars);         posregCTRAV=    indcv(vnamesCTRAV,allvars);     posregNONE=     indcv(vnamesNONE,allvars);      posCHOSEN =     indcv(vnameCHOSEN,allvars);
        posINDIV=       indcv(vnameINDIV,allvars);      posACAD=        indcv(vnameACAD,allvars);       posVOC=         indcv(vnameVOC,allvars);        posVOCS=        indcv(vnameVOCS,allvars);		posVOCL=	indcv(vnameVOCL,allvars);	posNONE=        indcv(vnameNONE,allvars);
        posCATH=        indcv(vnameCATH,allvars);       posI_KUL=       indcv(vnameI_KUL,allvars);      posI_RUG=       indcv(vnameI_RUG,allvars);      posI_VUB=       indcv(vnameI_VUB,allvars);
        posI_UA=        indcv(vnameI_UA,allvars);       posI_LUC=       indcv(vnameI_LUC,allvars);      poscondvar=     indcv(pvnamecondvar,allvars);   posCTRAV=       indcv(vnameCTRAV,allvars);
		posAKUL=        indcv(vnameAKUL,allvars);		posAUG=        	indcv(vnameAUG,allvars);		posAUA=   	    indcv(vnameAUA,allvars);		posAVUB=        indcv(vnameAVUB,allvars);		posALUC=    indcv(vnameALUC,allvars);
        posregCTR61=    indcv(vnamesCTR61,allvars);		posMALE=		indcv(vnameMALE,allvars);       posFORE=		indcv(vnameFORE,allvars);		posAGE=			indcv(vnameAGE,allvars);
		posASO=			indcv(vnameASO,allvars);      	posTSO=			indcv(vnameTSO,allvars);      	posCATH1=		indcv(vnameCATH1,allvars);		
		posSCI=			indcv(vnameSCI,allvars);		posSSCI=		indcv(vnameSSCI,allvars);		posBIOM=		indcv(vnameBIOM,allvars);		posARTS=		indcv(vnameARTS,allvars);		
		posCLAS=		indcv(vnameCLAS,allvars);		posLANG1=		indcv(vnameLANG1,allvars);		posECON1=		indcv(vnameECON1,allvars);		posMATH=		indcv(vnameMATH,allvars);		
		posSCIE=		indcv(vnameSCIE,allvars);		posTSOH=		indcv(vnameTSOH,allvars);		posWEIGHT=		indcv(vnameWEIGHT,allvars);		posOPTION=		indcv(vnameOPTION,allvars);		
		posDIST=		indcv(vnameDIST,allvars);
        i = 0;
        nrdone = 0;
        chunksize = rowschunk;
        do until nrdone>=nindiv*nalt;
            i=i+1;
            chunk=          readr(f2,chunksize);
            nrdone=         nrdone + rows(chunk);
            /* determine fee increase vector to include in utility calculation */
                if pvnamecondvar $== "INDIV";
                    FEE=    zeros(rows(chunk),1);
                elseif pvnamecondvar $== "STUDY";
                    FEE=    psize1 .* (chunk[.,posACAD] + chunk[.,posVOC]);
                elseif pvnamecondvar $== "NCATH";
					NOTCATH=	recode(chunk[.,posCATH]+ones(rows(chunk),1), chunk[.,posCATH]+chunk[.,posNONE], zeros(1,1));
                    FEE=    	psize1 .* NOTCATH;
                elseif pvnamecondvar $== "ACADSCI";
                    FEE=    psize1 .* (chunk[.,posACAD] .* chunk[.,posSCI]);
                elseif pvnamecondvar $== "ACADSSCI";
                    FEE=    psize1 .* (chunk[.,posACAD] .* chunk[.,posSSCI]);
                elseif pvnamecondvar $== "ACADBIOM";
                    FEE=    psize1 .* (chunk[.,posACAD] .* chunk[.,posBIOM]);
                elseif pvnamecondvar $== "ACADARTS";
                    FEE=    psize1 .* (chunk[.,posACAD] .* chunk[.,posARTS]);
                elseif pvnamecondvar $== "VOCSCI";
                    FEE=    psize1 .* (chunk[.,posVOC] .* chunk[.,posSCI]);
                elseif pvnamecondvar $== "VOCSSCI";
                    FEE=    psize1 .* (chunk[.,posVOC] .* chunk[.,posSSCI]);
                elseif pvnamecondvar $== "VOCBIOM";
                    FEE=    psize1 .* (chunk[.,posVOC] .* chunk[.,posBIOM]);
                elseif pvnamecondvar $== "VOCARTS";
                    FEE=    psize1 .* (chunk[.,posVOC] .* chunk[.,posARTS]);
                elseif pvnamecondvar $== "ACADVOC";			/* ACAD (size1) vs VOC (size2) */
                    FEE=    psize1 .* chunk[.,posACAD] + psize2 .* chunk[.,posVOC];
                elseif pvnamecondvar $== "ACADVOC_dist";			/* ACAD (size1) vs VOC (size2) - subsidy per kilometre (size3) */
                    FEE=    (psize1 .* chunk[.,posACAD]) + (psize2 .* chunk[.,posVOC]) - (psize3 .* chunk[.,posDIST] .* (chunk[.,posACAD] + chunk[.,posVOC]));
                elseif pvnamecondvar $== "FB"; 				/* first-best */
                    FEE=    (chunk[.,posWEIGHT] .* 0.2300 .* (chunk[.,posACAD] + chunk[.,posVOC])) - ((chunk[.,posACAD] + chunk[.,posVOC]).*0.05);
                elseif pvnamecondvar $== "STUDY_FB";	
                    FEE=    (chunk[.,posWEIGHT] .* 0.2300 .* (chunk[.,posACAD] + chunk[.,posVOC])) + (psize1 .* (chunk[.,posACAD] + chunk[.,posVOC])) - ((chunk[.,posACAD] + chunk[.,posVOC]).*0.05);
                elseif pvnamecondvar $== "ACAD_FB";	
                    FEE=    (chunk[.,posWEIGHT] .* 0.2300 .* (chunk[.,posACAD] + chunk[.,posVOC])) + (psize1 .* chunk[.,posACAD]) - ((chunk[.,posACAD] + chunk[.,posVOC]).*0.05);
                elseif pvnamecondvar $== "VOC_FB";	
                    FEE=    (chunk[.,posWEIGHT] .* 0.2300 .* (chunk[.,posACAD] + chunk[.,posVOC])) + (psize1 .* chunk[.,posVOC]) - ((chunk[.,posACAD] + chunk[.,posVOC]).*0.05);
                elseif pvnamecondvar $== "ACADVOC_FB";		/* ACAD (size1) vs VOC (size2) */
                    FEE=    (chunk[.,posWEIGHT] .* 0.2300 .* (chunk[.,posACAD] + chunk[.,posVOC])) + (psize1 .* chunk[.,posACAD]) + (psize2 .* chunk[.,posVOC]) - ((chunk[.,posACAD] + chunk[.,posVOC]).*0.05);
                elseif pvnamecondvar $== "ACADVOC2_FB";		/* ACADSSCI (size1) vs VOCSCI (size2) vs other STUDY (size3) */
					FEE=    (chunk[.,posWEIGHT] .* 0.2300 .* (chunk[.,posACAD] + chunk[.,posVOC])) - ((chunk[.,posACAD] + chunk[.,posVOC]).*0.05) + (psize1 .* (chunk[.,posACAD].*chunk[.,posSSCI])) + (psize2 .* (chunk[.,posVOC].*chunk[.,posSCI])) + (psize3 .* ( (chunk[.,posACAD].*(chunk[.,posSSCI].==0)) + (chunk[.,posVOC].*(chunk[.,posSCI].==0)) ) );
			    elseif pvnamecondvar $== "OPTION_FB";		/* option pm is priced at marginal cost+size1, the others at marginal cost level */
                    FEE=    (chunk[.,posWEIGHT] .* 0.2300 .* (chunk[.,posACAD] + chunk[.,posVOC])) + (psize1 .* (chunk[.,posOPTION].==pm)) - ((chunk[.,posACAD] + chunk[.,posVOC]).*0.05);
                else;
                    FEE=    psize1 .* chunk[.,poscondvar];
                endif;
            /* calculate ev for current datachunk */
                kk= k[1,1] .* (chunk[.,posACAD] + chunk[.,posVOC]) + k[2,1] .* chunk[.,posNONE]; /*  NJ by 1 */
                if ph==2; 
					ev=exp( (chunk[.,posregW]*b[posparW,1]) + (chunk[.,posregNONE]*b[posparNONE,1]) + (chunk[.,posregCTRAV]*b[posparCTRAV,1]) + (chunk[.,posregCTR61] * (b[posparCTR61m,1].*(b[posparCTRAVi,1]./b[posparCTRAVm,1]))) + b[posparCTRAVm,1].*FEE + b[posparCTRAVMAL,1].*chunk[.,posMALE].*FEE + b[posparCTRAVFOR,1].*chunk[.,posFORE].*FEE + b[posparCTRAVAGE,1].*chunk[.,posAGE].*FEE + b[posparCTRAVASO,1].*chunk[.,posASO].*FEE + b[posparCTRAVTSO,1].*chunk[.,posTSO].*FEE + b[posparCTRAVCAT,1].*chunk[.,posCATH1].*FEE + b[posparCTRAVCLA,1].*chunk[.,posCLAS].*FEE + b[posparCTRAVLAN,1].*chunk[.,posLANG1].*FEE + b[posparCTRAVECO,1].*chunk[.,posECON1].*FEE + b[posparCTRAVSCI,1].*chunk[.,posSCIE].*FEE + b[posparCTRAVMAT,1].*chunk[.,posMATH].*FEE + b[posparCTRAVTS1,1].*chunk[.,posTSOH].*FEE);
                endif;
            /* construct pchunk i.e. choice probability for current datachunk */
                ev=             reshape(ev,rows(chunk)/nalt,nalt);   /* N by J */
                depm=           reshape(chunk[.,posCHOSEN],rows(chunk)/nalt,nalt); /* N by J */
                INDIV=          reshape(chunk[.,posINDIV],rows(chunk)/nalt,nalt);
                INDIV=          INDIV[1:rows(INDIV),1]; /* keep just first column because they're all the same */
				chunknrOPTION=	reshape(chunk[.,posOPTION],rows(chunk)/nalt,nalt); /* N by J */
                depNESTA =      reshape(chunk[.,posACAD] + chunk[.,posVOC],rows(chunk)/nalt,nalt);    /* N by J */
                depNESTB =      reshape(chunk[.,posNONE],rows(chunk)/nalt,nalt);
                evNESTA =       sumc((ev .* depNESTA)');  /* N by 1: for each indiv, the sum of the ev-terms of all alternatives in NESTA */
                evNESTB =       sumc((ev .* depNESTB)');
                /* do no longer return the chosen probs as in maxlik, but in principle the full N by J vector of choice probs or summary sums thereof !!!!! */
                    p1 =        ev ./ (evNESTA .* depNESTA + evNESTB .* depNESTB);
                    p2 =        ( (evNESTA .* depNESTA) .^k[1,1] + (evNESTB .* depNESTB) .^k[2,1]) ./ (  (evNESTA.^k[1,1])+(evNESTB.^k[2,1])  );
                    pchunk =    p1 .* p2; /* this is the full N by J vector */
					RVchunk=	sumc( (FEE + (chunk[.,posACAD] + chunk[.,posVOC]).*0.05) .* reshape(pchunk,rows(chunk),1) );	/* scalar; note that for the revenue effects we include the current fee of 500 Euros for all STUDY options in the calculation */
					SUBchunk=	sumc( (chunk[.,posWEIGHT] .* 0.2300 .* (chunk[.,posACAD] + chunk[.,posVOC])) .* reshape(pchunk,rows(chunk),1) );	/* scalar = weight * base amount * probability */
            /* derived choice probs */
                pchunkchosen=   		sumc((pchunk .*depm)');         /* N by 1 */
                pchunkSTUD=     		sumc((pchunk .* depNESTA)');    /* sum over depNESTA : N by 1 */
				pchunkACAD=				sumc((pchunk .* reshape(chunk[.,posACAD],rows(chunk)/nalt,nalt))');
                pchunkVOC=      		sumc((pchunk .* reshape(chunk[.,posVOC],rows(chunk)/nalt,nalt))');
                pchunkVOCS=      		sumc((pchunk .* reshape(chunk[.,posVOCS],rows(chunk)/nalt,nalt))');
                pchunkVOCL=      		sumc((pchunk .* reshape(chunk[.,posVOCL],rows(chunk)/nalt,nalt))');
				pchunkCATH=     		sumc((pchunk .* reshape(chunk[.,posCATH],rows(chunk)/nalt,nalt))');
				pchunkNCATH=			sumc((pchunk .* reshape(recode(chunk[.,posCATH]+ones(rows(chunk),1), chunk[.,posCATH]+chunk[.,posNONE], zeros(1,1)),rows(chunk)/nalt,nalt))');
				pchunkI_KUL=    		sumc((pchunk .* reshape(chunk[.,posI_KUL],rows(chunk)/nalt,nalt))');   
				pchunkI_RUG=    		sumc((pchunk .* reshape(chunk[.,posI_RUG],rows(chunk)/nalt,nalt))');   
				pchunkI_VUB=    		sumc((pchunk .* reshape(chunk[.,posI_VUB],rows(chunk)/nalt,nalt))');   
				pchunkI_UA=     		sumc((pchunk .* reshape(chunk[.,posI_UA],rows(chunk)/nalt,nalt))');    
				pchunkI_LUC=    		sumc((pchunk .* reshape(chunk[.,posI_LUC],rows(chunk)/nalt,nalt))');
				pchunkAKUL=	    		sumc((pchunk .* reshape(chunk[.,posAKUL],rows(chunk)/nalt,nalt))');
				pchunkAUG=	    		sumc((pchunk .* reshape(chunk[.,posAUG],rows(chunk)/nalt,nalt))');
				pchunkAUA=	    		sumc((pchunk .* reshape(chunk[.,posAUA],rows(chunk)/nalt,nalt))');
				pchunkAVUB=	    		sumc((pchunk .* reshape(chunk[.,posAVUB],rows(chunk)/nalt,nalt))');
				pchunkALUC=	    		sumc((pchunk .* reshape(chunk[.,posALUC],rows(chunk)/nalt,nalt))');
				pchunkACADSCI=  		sumc((pchunk .* reshape(chunk[.,posACAD] .* chunk[.,posSCI],rows(chunk)/nalt,nalt))');
					pchunkACADSCI_KUL=  sumc((pchunk .* reshape(chunk[.,posACAD] .* chunk[.,posSCI] .* chunk[.,posI_KUL],rows(chunk)/nalt,nalt))');
					pchunkACADSCI_RUG=	sumc((pchunk .* reshape(chunk[.,posACAD] .* chunk[.,posSCI] .* chunk[.,posI_RUG],rows(chunk)/nalt,nalt))');
					pchunkACADSCI_VUB=	sumc((pchunk .* reshape(chunk[.,posACAD] .* chunk[.,posSCI] .* chunk[.,posI_VUB],rows(chunk)/nalt,nalt))');
					pchunkACADSCI_UA=	sumc((pchunk .* reshape(chunk[.,posACAD] .* chunk[.,posSCI] .* chunk[.,posI_UA],rows(chunk)/nalt,nalt))');
					pchunkACADSCI_LUC=	sumc((pchunk .* reshape(chunk[.,posACAD] .* chunk[.,posSCI] .* chunk[.,posI_LUC],rows(chunk)/nalt,nalt))');
				pchunkACADSSCI= 		sumc((pchunk .* reshape(chunk[.,posACAD] .* chunk[.,posSSCI],rows(chunk)/nalt,nalt))');
				pchunkACADBIOM= 		sumc((pchunk .* reshape(chunk[.,posACAD] .* chunk[.,posBIOM],rows(chunk)/nalt,nalt))');
					pchunkACADBIOM_KUL= sumc((pchunk .* reshape(chunk[.,posACAD] .* chunk[.,posBIOM] .* chunk[.,posI_KUL],rows(chunk)/nalt,nalt))');
					pchunkACADBIOM_RUG=	sumc((pchunk .* reshape(chunk[.,posACAD] .* chunk[.,posBIOM] .* chunk[.,posI_RUG],rows(chunk)/nalt,nalt))');
					pchunkACADBIOM_VUB=	sumc((pchunk .* reshape(chunk[.,posACAD] .* chunk[.,posBIOM] .* chunk[.,posI_VUB],rows(chunk)/nalt,nalt))');
					pchunkACADBIOM_UA=	sumc((pchunk .* reshape(chunk[.,posACAD] .* chunk[.,posBIOM] .* chunk[.,posI_UA],rows(chunk)/nalt,nalt))');
					pchunkACADBIOM_LUC=	sumc((pchunk .* reshape(chunk[.,posACAD] .* chunk[.,posBIOM] .* chunk[.,posI_LUC],rows(chunk)/nalt,nalt))');
				pchunkACADARTS= 		sumc((pchunk .* reshape(chunk[.,posACAD] .* chunk[.,posARTS],rows(chunk)/nalt,nalt))');
				pchunkVOCSCI= 			sumc((pchunk .* reshape(chunk[.,posVOC]  .* chunk[.,posSCI],rows(chunk)/nalt,nalt))');
				pchunkVOCSSCI= 			sumc((pchunk .* reshape(chunk[.,posVOC]  .* chunk[.,posSSCI],rows(chunk)/nalt,nalt))');
				pchunkVOCBIOM= 			sumc((pchunk .* reshape(chunk[.,posVOC]  .* chunk[.,posBIOM],rows(chunk)/nalt,nalt))');
				pchunkVOCARTS= 			sumc((pchunk .* reshape(chunk[.,posVOC]  .* chunk[.,posARTS],rows(chunk)/nalt,nalt))');
				/* vectors needed to split the choice probs by subsample & some are needed for the CS calculation (see infra) */
					chunkMALE=		reshape(chunk[.,posMALE],rows(chunk)/nalt,nalt); 					chunkMALE=		chunkMALE[1:rows(chunkMALE),1];
					chunkFORE=		reshape(chunk[.,posFORE],rows(chunk)/nalt,nalt); 					chunkFORE=		chunkFORE[1:rows(chunkFORE),1];
					chunkAGE=		reshape(chunk[.,posAGE],rows(chunk)/nalt,nalt); 					chunkAGE=		chunkAGE[1:rows(chunkAGE),1];
					chunkASO=		reshape(chunk[.,posASO],rows(chunk)/nalt,nalt); 					chunkASO=		chunkASO[1:rows(chunkASO),1];
					chunkTSO=		reshape(chunk[.,posTSO],rows(chunk)/nalt,nalt); 					chunkTSO=		chunkTSO[1:rows(chunkTSO),1];
					chunkCLAS=		reshape(chunk[.,posCLAS],rows(chunk)/nalt,nalt); 					chunkCLAS=		chunkCLAS[1:rows(chunkCLAS),1];
					chunkLANG1=		reshape(chunk[.,posLANG1],rows(chunk)/nalt,nalt); 					chunkLANG1=		chunkLANG1[1:rows(chunkLANG1),1];
					chunkECON1=		reshape(chunk[.,posECON1],rows(chunk)/nalt,nalt); 					chunkECON1=		chunkECON1[1:rows(chunkECON1),1];
					chunkSCIE=		reshape(chunk[.,posSCIE],rows(chunk)/nalt,nalt); 					chunkSCIE=		chunkSCIE[1:rows(chunkSCIE),1];
					chunkMATH=		reshape(chunk[.,posMATH],rows(chunk)/nalt,nalt); 					chunkMATH=		chunkMATH[1:rows(chunkMATH),1];
					chunkTSOH=		reshape(chunk[.,posTSOH],rows(chunk)/nalt,nalt); 					chunkTSOH=		chunkTSOH[1:rows(chunkTSOH),1];
					chunkCATH1=		reshape(chunk[.,posCATH1],rows(chunk)/nalt,nalt); 					chunkCATH1=		chunkCATH1[1:rows(chunkCATH1),1];
				if ph==2;	
					cschunk=	(-1 ./ (( b[posparCTRAVm,1].*ones(rows(chunk)/nalt,1) + b[posparCTRAVMAL,1].*chunkMALE + b[posparCTRAVFOR,1].*chunkFORE + b[posparCTRAVAGE,1].*chunkAGE + b[posparCTRAVASO,1].*chunkASO + b[posparCTRAVTSO,1].*chunkTSO + b[posparCTRAVCAT,1].*chunkCATH1 + b[posparCTRAVCLA,1].*chunkCLAS + b[posparCTRAVLAN,1].*chunkLANG1 + b[posparCTRAVECO,1].*chunkECON1 + b[posparCTRAVSCI,1].*chunkSCIE + b[posparCTRAVMAT,1].*chunkMATH + b[posparCTRAVTS1,1].*chunkTSOH) .* k[1,1]) ) .* ln( (evNESTA.^k[1,1]) + (evNESTB.^k[2,1]) );
				endif;
            /* store choice probs for this data chunk */
                if i==1;
                    pchosen=    	pchunkchosen;
					pOPTION=		pchunk;
					nrOPTION=		chunknrOPTION;
					RV=				RVchunk;
					SUB=			SUBchunk;
                    indivnr=    	INDIV;
                    pSTUD=      	pchunkSTUD;     	pACAD=  		pchunkACAD;  		pVOC=  			pchunkVOC;  		pVOCS=  		pchunkVOCS;			pVOCL= 			pchunkVOCL;			pCATH=			pchunkCATH;			pNCATH=			pchunkNCATH;
					pI_KUL=     	pchunkI_KUL;    	pI_RUG= 		pchunkI_RUG; 		pI_VUB=			pchunkI_VUB; 		pI_UA=			pchunkI_UA;			pI_LUC=			pchunkI_LUC;		
					pAKUL=			pchunkAKUL;			pAUG=			pchunkAUG;			pAUA=			pchunkAUA;			pAVUB=			pchunkAVUB;			pALUC=			pchunkALUC;
					cs=         	cschunk;
					pACADSCI=		pchunkACADSCI;		pACADSSCI=		pchunkACADSSCI; 	pACADBIOM=		pchunkACADBIOM;		pACADARTS=		pchunkACADARTS;
					pACADSCI_KUL=	pchunkACADSCI_KUL;	pACADSCI_RUG=	pchunkACADSCI_RUG;	pACADSCI_VUB=	pchunkACADSCI_VUB;	pACADSCI_UA=	pchunkACADSCI_UA;	pACADSCI_LUC=	pchunkACADSCI_LUC;	
					pACADBIOM_KUL=	pchunkACADBIOM_KUL;	pACADBIOM_RUG=	pchunkACADBIOM_RUG;	pACADBIOM_VUB=	pchunkACADBIOM_VUB;	pACADBIOM_UA=	pchunkACADBIOM_UA;	pACADBIOM_LUC=	pchunkACADBIOM_LUC;	
					pVOCSCI=		pchunkVOCSCI;		pVOCSSCI=		pchunkVOCSSCI; 		pVOCBIOM=		pchunkVOCBIOM;		pVOCARTS=		pchunkVOCARTS;
					depMALE=		chunkMALE;			depFORE=		chunkFORE;			depASO=			chunkASO;			depTSO=			chunkTSO;		
					depCLAS=		chunkCLAS;			depLANG1=		chunkLANG1;			depECON1=		chunkECON1;			depSCIE=		chunkSCIE;
					depMATH=		chunkMATH;			depTSOH=		chunkTSOH;			depCATH1=		chunkCATH1;
					depFEM=			recode(chunkMALE+ones(rows(chunk)/nalt,1), chunkMALE, zeros(1,1));
					depBEL=			recode(chunkFORE+ones(rows(chunk)/nalt,1), chunkFORE, zeros(1,1));
					depNCATH1=		recode(chunkCATH1+ones(rows(chunk)/nalt,1), chunkCATH1, zeros(1,1));
					depAGE=			chunkAGE;
					depNOREP=		chunkAGE .le 1; 
					depREP1=		chunkAGE .eq 2;	/* 1 year repetition in high school */
					depREP2=		chunkAGE .eq 3; /* 2 years repetition in high school */
                else;
                    pchosen=    	pchosen|pchunkchosen;
					pOPTION=		pOPTION|pchunk;
					nrOPTION=		nrOPTION|chunknrOPTION;
					RV=				RV+RVchunk;
					SUB=			SUB+SUBchunk;
                    indivnr=   	 	indivnr|INDIV;
                    pSTUD=     	 	pSTUD|pchunkSTUD;   				pACAD=  		pACAD|pchunkACAD;    				pVOC=  			pVOC|pchunkVOC;     				pVOCS=  		pVOCS|pchunkVOCS;				pVOCL= 			pVOCL|pchunkVOCL;		pCATH=			pCATH|pchunkCATH;				pNCATH=			pNCATH|pchunkNCATH;
					pI_KUL=			pI_KUL|pchunkI_KUL;					pI_RUG= 		pI_RUG|pchunkI_RUG;  				pI_VUB=			pI_VUB|pchunkI_VUB;  				pI_UA=			pI_UA|pchunkI_UA; 				pI_LUC=			pI_LUC|pchunkI_LUC;				
					pAKUL=			pAKUL|pchunkAKUL;					pAUG=			pAUG|pchunkAUG;						pAUA=			pAUA|pchunkAUA;						pAVUB=			pAVUB|pchunkAVUB;				pALUC=			pALUC|pchunkALUC;
					cs=    			cs|cschunk;
					pACADSCI=		pACADSCI|pchunkACADSCI;				pACADSSCI=		pACADSSCI|pchunkACADSSCI; 			pACADBIOM=		pACADBIOM|pchunkACADBIOM;			pACADARTS=		pACADARTS|pchunkACADARTS;
					pACADSCI_KUL=	pACADSCI_KUL|pchunkACADSCI_KUL;		pACADSCI_RUG=	pACADSCI_RUG|pchunkACADSCI_RUG;		pACADSCI_VUB=	pACADSCI_VUB|pchunkACADSCI_VUB;		pACADSCI_UA=	pACADSCI_UA|pchunkACADSCI_UA;	pACADSCI_LUC=	pACADSCI_LUC|pchunkACADSCI_LUC;	
					pACADBIOM_KUL=	pACADBIOM_KUL|pchunkACADBIOM_KUL;	pACADBIOM_RUG=	pACADBIOM_RUG|pchunkACADBIOM_RUG;	pACADBIOM_VUB=	pACADBIOM_VUB|pchunkACADBIOM_VUB;	pACADBIOM_UA=	pACADBIOM_UA|pchunkACADBIOM_UA;	pACADBIOM_LUC=	pACADBIOM_LUC|pchunkACADBIOM_LUC;	
					pVOCSCI=		pVOCSCI|pchunkVOCSCI;				pVOCSSCI=		pVOCSSCI|pchunkVOCSSCI; 			pVOCBIOM=		pVOCBIOM|pchunkVOCBIOM;				pVOCARTS=		pVOCARTS|pchunkVOCARTS;
					depMALE=		depMALE|chunkMALE;					depFORE=		depFORE|chunkFORE;					depASO=			depASO|chunkASO;					depTSO=			depTSO|chunkTSO;		
					depCLAS=		depCLAS|chunkCLAS;					depLANG1=		depLANG1|chunkLANG1;				depECON1=		depECON1|chunkECON1;				depSCIE=		depSCIE|chunkSCIE;
					depMATH=		depMATH|chunkMATH;					depTSOH=		depTSOH|chunkTSOH;					depCATH1=		depCATH1|chunkCATH1;
					depFEM=			depFEM|recode(chunkMALE+ones(rows(chunk)/nalt,1), chunkMALE, zeros(1,1));
					depBEL=			depBEL|recode(chunkFORE+ones(rows(chunk)/nalt,1), chunkFORE, zeros(1,1));
					depNCATH1=		depNCATH1|recode(chunkCATH1+ones(rows(chunk)/nalt,1), chunkCATH1, zeros(1,1));
					depAGE=			depAGE|chunkAGE;
					depNOREP=		depNOREP|(chunkAGE .le 1);
					depREP1=		depREP1|(chunkAGE .eq 2);
					depREP2=		depREP2|(chunkAGE .eq 3);
                endif;
            clear chunk;
        endo;
        f2= close(f2);
		/* save mean option choice probs to ASCII file (only when pm>-1, so if not interested in having a file with product-level choice probs, then call simnested with pm==-1) */
			if pm>-1;
				mpOPTION=	meanc(pOPTION);		/* J by 1 */
				mnrOPTION=	meanc(nrOPTION);	/* J by 1 */
		        strsize= 	ftos(psize1*10000,"%*.*lf",1,0);
				stroption= 	ftos(pm,"%*.*lf",1,0);
		        outfile =  "sim_" $+ logfile $+ "_" $+ strsize $+ "_" $+ pvnamecondvar $+ stroption $+ ".txt";
		        outwidth 256;   
		        output file = ^outfile reset;
		            screen off; /* don't print outmatrix to screen, only to diskfile */
		            let coltitles=nrOPTION mpOPTION$+stroption;
		            print /rdn $coltitles';
		            print /rdn /ma1 mnrOPTION~mpOPTION;
		            screen on;
		        closeall outfile;
			endif;
    /* calculate and report mean aggregated probabilities & CS (across individuals) */
        if pvnamecondvar $=="INDIV"; /* the status quo simulation */
            mpSTUD= 			meanc(pSTUD);       mpSTUDMALE=		meanc(selif(pSTUD,depMALE));		mpSTUDFEM=		meanc(selif(pSTUD,depFEM));		mpSTUDFORE=		meanc(selif(pSTUD,depFORE));	mpSTUDBEL=		meanc(selif(pSTUD,depBEL));		mpSTUDNOREP=		meanc(selif(pSTUD,depNOREP));		mpSTUDREP1=		meanc(selif(pSTUD,depREP1));	mpSTUDREP2=		meanc(selif(pSTUD,depREP2));	mpSTUDASO=		meanc(selif(pSTUD,depASO));		mpSTUDTSO=		meanc(selif(pSTUD,depTSO));		mpSTUDCLAS=		meanc(selif(pSTUD,depCLAS));	mpSTUDLANG1=	meanc(selif(pSTUD,depLANG1));		mpSTUDECON1=	meanc(selif(pSTUD,depECON1));		mpSTUDSCIE=		meanc(selif(pSTUD,depSCIE));	mpSTUDMATH=		meanc(selif(pSTUD,depMATH));	mpSTUDTSOH=		meanc(selif(pSTUD,depTSOH));	mpSTUDKBSO=		meanc(selif(pSTUD,(depASO .ne 1) .* (depTSO .ne 1) ));		mpSTUDCATH1=	meanc(selif(pSTUD,depCATH1));	mpSTUDNCATH1=	meanc(selif(pSTUD,depNCATH1)); 
			mpACAD=				meanc(pACAD);       mpACADMALE=		meanc(selif(pACAD,depMALE));		mpACADFEM=		meanc(selif(pACAD,depFEM));		mpACADFORE=		meanc(selif(pACAD,depFORE));	mpACADBEL=		meanc(selif(pACAD,depBEL));		mpACADNOREP=		meanc(selif(pACAD,depNOREP));		mpACADREP1=		meanc(selif(pACAD,depREP1));	mpACADREP2=		meanc(selif(pACAD,depREP2));	mpACADASO=		meanc(selif(pACAD,depASO));		mpACADTSO=		meanc(selif(pACAD,depTSO));		mpACADCLAS=		meanc(selif(pACAD,depCLAS));	mpACADLANG1=	meanc(selif(pACAD,depLANG1));		mpACADECON1=	meanc(selif(pACAD,depECON1));		mpACADSCIE=		meanc(selif(pACAD,depSCIE));	mpACADMATH=		meanc(selif(pACAD,depMATH));	mpACADTSOH=		meanc(selif(pACAD,depTSOH));	mpACADKBSO=		meanc(selif(pACAD,(depASO .ne 1) .* (depTSO .ne 1) ));		mpACADCATH1=	meanc(selif(pACAD,depCATH1)); 	mpACADNCATH1=	meanc(selif(pACAD,depNCATH1));   
			mpVOC=				meanc(pVOC);      	mpVOCMALE=		meanc(selif(pVOC,depMALE));			mpVOCFEM=		meanc(selif(pVOC,depFEM));		mpVOCFORE=		meanc(selif(pVOC,depFORE));		mpVOCBEL=		meanc(selif(pVOC,depBEL));		mpVOCNOREP=			meanc(selif(pVOC,depNOREP));		mpVOCREP1=		meanc(selif(pVOC,depREP1));		mpVOCREP2=		meanc(selif(pVOC,depREP2));		mpVOCASO=		meanc(selif(pVOC,depASO));		mpVOCTSO=		meanc(selif(pVOC,depTSO));		mpVOCCLAS=		meanc(selif(pVOC,depCLAS));		mpVOCLANG1=		meanc(selif(pVOC,depLANG1));		mpVOCECON1=		meanc(selif(pVOC,depECON1));		mpVOCSCIE=		meanc(selif(pVOC,depSCIE));		mpVOCMATH=		meanc(selif(pVOC,depMATH));		mpVOCTSOH=		meanc(selif(pVOC,depTSOH));		mpVOCKBSO=		meanc(selif(pVOC,(depASO .ne 1) .* (depTSO .ne 1) ));		mpVOCCATH1=		meanc(selif(pVOC,depCATH1));	mpVOCNCATH1=	meanc(selif(pVOC,depNCATH1));
			mpVOCS=				meanc(pVOCS);      	
			mpVOCL=				meanc(pVOCL);      	
			mpCATH=				meanc(pCATH);    	mpCATHMALE=		meanc(selif(pCATH,depMALE));		mpCATHFEM=		meanc(selif(pCATH,depFEM));		mpCATHFORE=		meanc(selif(pCATH,depFORE));	mpCATHBEL=		meanc(selif(pCATH,depBEL));		mpCATHNOREP=		meanc(selif(pCATH,depNOREP));																										mpCATHASO=		meanc(selif(pCATH,depASO));		mpCATHTSO=		meanc(selif(pCATH,depTSO));		mpCATHCLAS=		meanc(selif(pCATH,depCLAS));	mpCATHLANG1=	meanc(selif(pCATH,depLANG1));		mpCATHECON1=	meanc(selif(pCATH,depECON1));		mpCATHSCIE=		meanc(selif(pCATH,depSCIE));	mpCATHMATH=		meanc(selif(pCATH,depMATH));	mpCATHTSOH=		meanc(selif(pCATH,depTSOH));																				mpCATHCATH1=	meanc(selif(pCATH,depCATH1));	mpCATHNCATH1=	meanc(selif(pCATH,depNCATH1));
			mpNCATH=			meanc(pNCATH);    	mpNCATHMALE=	meanc(selif(pNCATH,depMALE));		mpNCATHFEM=		meanc(selif(pNCATH,depFEM));	mpNCATHFORE=	meanc(selif(pNCATH,depFORE));	mpNCATHBEL=		meanc(selif(pNCATH,depBEL));	mpNCATHNOREP=		meanc(selif(pNCATH,depNOREP));																										mpNCATHASO=		meanc(selif(pNCATH,depASO));	mpNCATHTSO=		meanc(selif(pNCATH,depTSO));	mpNCATHCLAS=	meanc(selif(pNCATH,depCLAS));	mpNCATHLANG1=	meanc(selif(pNCATH,depLANG1));		mpNCATHECON1=	meanc(selif(pNCATH,depECON1));		mpNCATHSCIE=	meanc(selif(pNCATH,depSCIE));	mpNCATHMATH=	meanc(selif(pNCATH,depMATH));	mpNCATHTSOH=	meanc(selif(pNCATH,depTSOH));																				mpNCATHCATH1=	meanc(selif(pNCATH,depCATH1));	mpNCATHNCATH1=	meanc(selif(pNCATH,depNCATH1));
			mpI_KUL=			meanc(pI_KUL);		mpI_KULMALE=	meanc(selif(pI_KUL,depMALE));														mpI_KULFORE=	meanc(selif(pI_KUL,depFORE));																																																			mpI_KULASO=		meanc(selif(pI_KUL,depASO));	mpI_KULTSO=		meanc(selif(pI_KUL,depTSO));	mpI_KULCLAS=	meanc(selif(pI_KUL,depCLAS));	mpI_KULLANG1=	meanc(selif(pI_KUL,depLANG1));		mpI_KULECON1=	meanc(selif(pI_KUL,depECON1));		mpI_KULSCIE=	meanc(selif(pI_KUL,depSCIE));	mpI_KULMATH=	meanc(selif(pI_KUL,depMATH));	mpI_KULTSOH=	meanc(selif(pI_KUL,depTSOH));																				mpI_KULCATH1=	meanc(selif(pI_KUL,depCATH1));
            mpI_RUG= 			meanc(pI_RUG);      mpI_RUGMALE=	meanc(selif(pI_RUG,depMALE));														mpI_RUGFORE=	meanc(selif(pI_RUG,depFORE));																																																			mpI_RUGASO=		meanc(selif(pI_RUG,depASO));	mpI_RUGTSO=		meanc(selif(pI_RUG,depTSO));	mpI_RUGCLAS=	meanc(selif(pI_RUG,depCLAS));	mpI_RUGLANG1=	meanc(selif(pI_RUG,depLANG1));		mpI_RUGECON1=	meanc(selif(pI_RUG,depECON1));		mpI_RUGSCIE=	meanc(selif(pI_RUG,depSCIE));	mpI_RUGMATH=	meanc(selif(pI_RUG,depMATH));	mpI_RUGTSOH=	meanc(selif(pI_RUG,depTSOH));																				mpI_RUGCATH1=	meanc(selif(pI_RUG,depCATH1));
			mpI_VUB=			meanc(pI_VUB);      mpI_VUBMALE=	meanc(selif(pI_VUB,depMALE));														mpI_VUBFORE=	meanc(selif(pI_VUB,depFORE));																																																			mpI_VUBASO=		meanc(selif(pI_VUB,depASO));	mpI_VUBTSO=		meanc(selif(pI_VUB,depTSO));	mpI_VUBCLAS=	meanc(selif(pI_VUB,depCLAS));	mpI_VUBLANG1=	meanc(selif(pI_VUB,depLANG1));		mpI_VUBECON1=	meanc(selif(pI_VUB,depECON1));		mpI_VUBSCIE=	meanc(selif(pI_VUB,depSCIE));	mpI_VUBMATH=	meanc(selif(pI_VUB,depMATH));	mpI_VUBTSOH=	meanc(selif(pI_VUB,depTSOH));																				mpI_VUBCATH1=	meanc(selif(pI_VUB,depCATH1));    
			mpI_UA=				meanc(pI_UA);    	mpI_UAMALE=		meanc(selif(pI_UA,depMALE));														mpI_UAFORE=		meanc(selif(pI_UA,depFORE));																																																			mpI_UAASO=		meanc(selif(pI_UA,depASO));		mpI_UATSO=		meanc(selif(pI_UA,depTSO));		mpI_UACLAS=		meanc(selif(pI_UA,depCLAS));	mpI_UALANG1=	meanc(selif(pI_UA,depLANG1));		mpI_UAECON1=	meanc(selif(pI_UA,depECON1));		mpI_UASCIE=		meanc(selif(pI_UA,depSCIE));	mpI_UAMATH=		meanc(selif(pI_UA,depMATH));	mpI_UATSOH=		meanc(selif(pI_UA,depTSOH));																				mpI_UACATH1=	meanc(selif(pI_UA,depCATH1));
			mpI_LUC=			meanc(pI_LUC);  	mpI_LUCMALE=	meanc(selif(pI_LUC,depMALE));														mpI_LUCFORE=	meanc(selif(pI_LUC,depFORE));																																																			mpI_LUCASO=		meanc(selif(pI_LUC,depASO));	mpI_LUCTSO=		meanc(selif(pI_LUC,depTSO));	mpI_LUCCLAS=	meanc(selif(pI_LUC,depCLAS));	mpI_LUCLANG1=	meanc(selif(pI_LUC,depLANG1));		mpI_LUCECON1=	meanc(selif(pI_LUC,depECON1));		mpI_LUCSCIE=	meanc(selif(pI_LUC,depSCIE));	mpI_LUCMATH=	meanc(selif(pI_LUC,depMATH));	mpI_LUCTSOH=	meanc(selif(pI_LUC,depTSOH));																				mpI_LUCCATH1=	meanc(selif(pI_LUC,depCATH1));
			mpAKUL=				meanc(pAKUL);
			mpAUG=				meanc(pAUG);
			mpAUA=				meanc(pAUA);
			mpAVUB=				meanc(pAVUB);
			mpALUC=				meanc(pALUC);
			mCS=				meanc(cs);			mcsMALE=		meanc(selif(cs,depMALE));															mcsFORE=		meanc(selif(cs,depFORE));																																																				mcsASO=			meanc(selif(cs,depASO));		mcsTSO=			meanc(selif(cs,depTSO));		mcsCLAS=		meanc(selif(cs,depCLAS));		mcsLANG1=		meanc(selif(cs,depLANG1));			mcsECON1=		meanc(selif(cs,depECON1));			mcsSCIE=		meanc(selif(cs,depSCIE));		mcsMATH=		meanc(selif(cs,depMATH));		mcsTSOH=		meanc(selif(cs,depTSOH));		mcsCATH1=		meanc(selif(cs,depCATH1));
			tCS=				sumc(cs);			tPS=RV-SUB;
			mpACADSCI= 			meanc(pACADSCI);	mpACADSCIMALE=	meanc(selif(pACADSCI,depMALE));														mpACADSCIFORE=	meanc(selif(pACADSCI,depFORE));																																																															mpACADSCIASO=	meanc(selif(pACADSCI,depASO));	mpACADSCITSO=	meanc(selif(pACADSCI,depTSO));	mpACADSCICLAS=	meanc(selif(pACADSCI,depCLAS));	mpACADSCILANG1=	meanc(selif(pACADSCI,depLANG1));	mpACADSCIECON1=	meanc(selif(pACADSCI,depECON1));	mpACADSCISCIE=	meanc(selif(pACADSCI,depSCIE));	mpACADSCIMATH=	meanc(selif(pACADSCI,depMATH));	mpACADSCITSOH=	meanc(selif(pACADSCI,depTSOH));	mpACADSCICATH1=	meanc(selif(pACADSCI,depCATH1));
			mpACADSCI_KUL= 		meanc(pACADSCI_KUL);
			mpACADSCI_RUG= 		meanc(pACADSCI_RUG);
			mpACADSCI_VUB= 		meanc(pACADSCI_VUB);
			mpACADSCI_UA= 		meanc(pACADSCI_UA);
			mpACADSCI_LUC= 		meanc(pACADSCI_LUC);
			mpACADSSCI=			meanc(pACADSSCI);	mpACADSSCIMALE=	meanc(selif(pACADSSCI,depMALE));													mpACADSSCIFORE=	meanc(selif(pACADSSCI,depFORE));																																																														mpACADSSCIASO=	meanc(selif(pACADSSCI,depASO));	mpACADSSCITSO=	meanc(selif(pACADSSCI,depTSO));	mpACADSSCICLAS=	meanc(selif(pACADSSCI,depCLAS));mpACADSSCILANG1=meanc(selif(pACADSSCI,depLANG1));	mpACADSSCIECON1=meanc(selif(pACADSSCI,depECON1));	mpACADSSCISCIE=	meanc(selif(pACADSSCI,depSCIE));mpACADSSCIMATH=	meanc(selif(pACADSSCI,depMATH));mpACADSSCITSOH=	meanc(selif(pACADSSCI,depTSOH));mpACADSSCICATH1=meanc(selif(pACADSSCI,depCATH1));	
			mpACADBIOM=			meanc(pACADBIOM);	mpACADBIOMMALE=	meanc(selif(pACADBIOM,depMALE));													mpACADBIOMFORE=	meanc(selif(pACADBIOM,depFORE));																																																														mpACADBIOMASO=	meanc(selif(pACADBIOM,depASO));	mpACADBIOMTSO=	meanc(selif(pACADBIOM,depTSO));	mpACADBIOMCLAS=	meanc(selif(pACADBIOM,depCLAS));mpACADBIOMLANG1=meanc(selif(pACADBIOM,depLANG1));	mpACADBIOMECON1=meanc(selif(pACADBIOM,depECON1));	mpACADBIOMSCIE=	meanc(selif(pACADBIOM,depSCIE));mpACADBIOMMATH=	meanc(selif(pACADBIOM,depMATH));mpACADBIOMTSOH=	meanc(selif(pACADBIOM,depTSOH));mpACADBIOMCATH1=meanc(selif(pACADBIOM,depCATH1));
			mpACADBIOM_KUL= 	meanc(pACADBIOM_KUL);
			mpACADBIOM_RUG= 	meanc(pACADBIOM_RUG);
			mpACADBIOM_VUB= 	meanc(pACADBIOM_VUB);
			mpACADBIOM_UA= 		meanc(pACADBIOM_UA);
			mpACADBIOM_LUC= 	meanc(pACADBIOM_LUC);
			mpACADARTS=			meanc(pACADARTS);	mpACADARTSMALE=	meanc(selif(pACADARTS,depMALE));													mpACADARTSFORE=	meanc(selif(pACADARTS,depFORE));																																																														mpACADARTSASO=	meanc(selif(pACADARTS,depASO));	mpACADARTSTSO=	meanc(selif(pACADARTS,depTSO));	mpACADARTSCLAS=	meanc(selif(pACADARTS,depCLAS));mpACADARTSLANG1=meanc(selif(pACADARTS,depLANG1));	mpACADARTSECON1=meanc(selif(pACADARTS,depECON1));	mpACADARTSSCIE=	meanc(selif(pACADARTS,depSCIE));mpACADARTSMATH=	meanc(selif(pACADARTS,depMATH));mpACADARTSTSOH=	meanc(selif(pACADARTS,depTSOH));mpACADARTSCATH1=meanc(selif(pACADARTS,depCATH1));
			mpVOCSCI= 			meanc(pVOCSCI);		mpVOCSCIMALE=	meanc(selif(pVOCSCI,depMALE));														mpVOCSCIFORE=	meanc(selif(pVOCSCI,depFORE));																																																															mpVOCSCIASO=	meanc(selif(pVOCSCI,depASO));	mpVOCSCITSO=	meanc(selif(pVOCSCI,depTSO));	mpVOCSCICLAS=	meanc(selif(pVOCSCI,depCLAS));	mpVOCSCILANG1=	meanc(selif(pVOCSCI,depLANG1));		mpVOCSCIECON1=	meanc(selif(pVOCSCI,depECON1));		mpVOCSCISCIE=	meanc(selif(pVOCSCI,depSCIE));	mpVOCSCIMATH=	meanc(selif(pVOCSCI,depMATH));	mpVOCSCITSOH=	meanc(selif(pVOCSCI,depTSOH));	mpVOCSCICATH1=	meanc(selif(pVOCSCI,depCATH1));
			mpVOCSSCI=			meanc(pVOCSSCI);	mpVOCSSCIMALE=	meanc(selif(pVOCSSCI,depMALE));														mpVOCSSCIFORE=	meanc(selif(pVOCSSCI,depFORE));																																																															mpVOCSSCIASO=	meanc(selif(pVOCSSCI,depASO));	mpVOCSSCITSO=	meanc(selif(pVOCSSCI,depTSO));	mpVOCSSCICLAS=	meanc(selif(pVOCSSCI,depCLAS));	mpVOCSSCILANG1=	meanc(selif(pVOCSSCI,depLANG1));	mpVOCSSCIECON1=	meanc(selif(pVOCSSCI,depECON1));	mpVOCSSCISCIE=	meanc(selif(pVOCSSCI,depSCIE));	mpVOCSSCIMATH=	meanc(selif(pVOCSSCI,depMATH));	mpVOCSSCITSOH=	meanc(selif(pVOCSSCI,depTSOH));	mpVOCSSCICATH1=	meanc(selif(pVOCSSCI,depCATH1));
			mpVOCBIOM=			meanc(pVOCBIOM);	mpVOCBIOMMALE=	meanc(selif(pVOCBIOM,depMALE));														mpVOCBIOMFORE=	meanc(selif(pVOCBIOM,depFORE));																																																															mpVOCBIOMASO=	meanc(selif(pVOCBIOM,depASO));	mpVOCBIOMTSO=	meanc(selif(pVOCBIOM,depTSO));	mpVOCBIOMCLAS=	meanc(selif(pVOCBIOM,depCLAS));	mpVOCBIOMLANG1=	meanc(selif(pVOCBIOM,depLANG1));	mpVOCBIOMECON1=	meanc(selif(pVOCBIOM,depECON1));	mpVOCBIOMSCIE=	meanc(selif(pVOCBIOM,depSCIE));	mpVOCBIOMMATH=	meanc(selif(pVOCBIOM,depMATH));	mpVOCBIOMTSOH=	meanc(selif(pVOCBIOM,depTSOH));	mpVOCBIOMCATH1=	meanc(selif(pVOCBIOM,depCATH1));
			mpVOCARTS=			meanc(pVOCARTS);	mpVOCARTSMALE=	meanc(selif(pVOCARTS,depMALE));														mpVOCARTSFORE=	meanc(selif(pVOCARTS,depFORE));																																																															mpVOCARTSASO=	meanc(selif(pVOCARTS,depASO));	mpVOCARTSTSO=	meanc(selif(pVOCARTS,depTSO));	mpVOCARTSCLAS=	meanc(selif(pVOCARTS,depCLAS));	mpVOCARTSLANG1=	meanc(selif(pVOCARTS,depLANG1));	mpVOCARTSECON1=	meanc(selif(pVOCARTS,depECON1));	mpVOCARTSSCIE=	meanc(selif(pVOCARTS,depSCIE));	mpVOCARTSMATH=	meanc(selif(pVOCARTS,depMATH));	mpVOCARTSTSOH=	meanc(selif(pVOCARTS,depTSOH));	mpVOCARTSCATH1=	meanc(selif(pVOCARTS,depCATH1));
            /* Show the aggregated choice probabilities with their confidence intervals */
				let coltitles=PROB LOWER UPPER;
				output file= ^sim_logfile on;
				print;print;print;
				print "Simulation: ";;$pvnamecondvar;
				print "Amount(s) used for fee increases: ";;
				print "\tNone. Status quo simulation.";
				print;
				print "Total revenues= ";;RV;
				print "Subsidies (variable part)= ";;SUB;
				print "Total producer surplus (excl. fixed subsidies)= ";;tPS;
				print "Total consumer surplus= ";;tCS;
				print "Change in total welfare (excl. fixed subsidies) vs status-quo= ";;tCS+tPS-(tCS+tPS);
				print;
				print /rdn "STATUSQUO\t";;$coltitles';
				print "pSTUD \t";;mpSTUD~lowerSTUD~upperSTUD;
				print "pACAD \t";;mpACAD~lowerACAD~upperACAD;
				print "pVOC \t";;mpVOC~lowerVOC~upperVOC;
				print "pVOCS \t";;mpVOCS~0~0;
				print "pVOCL \t";;mpVOCL~0~0;
				print "pCATH \t";;mpCATH~lowerCATH~upperCATH;
				print "pNCATH \t";;mpNCATH~lowerNCATH~upperNCATH;
				print "pI_KUL \t";;mpI_KUL~0~0;
				print "pI_RUG \t";;mpI_RUG~0~0;
				print "pI_VUB \t";;mpI_VUB~0~0;
				print "pI_UA \t";;mpI_UA~0~0;
				print "pI_LUC \t";;mpI_LUC~0~0;
				print "pAKUL \t";;mpAKUL~0~0;
				print "pAUG \t";;mpAUG~0~0;
				print "pAUA \t";;mpAUA~0~0;
				print "pAVUB \t";;mpAVUB~0~0;
				print "pALUC \t";;mpALUC~0~0;
				print "pACADSCI \t";;mpACADSCI~0~0;
					print "pACADSCI_KUL \t";;mpACADSCI_KUL~0~0;
					print "pACADSCI_RUG \t";;mpACADSCI_RUG~0~0;
					print "pACADSCI_VUB \t";;mpACADSCI_VUB~0~0;
					print "pACADSCI_UA \t";;mpACADSCI_UA~0~0;
					print "pACADSCI_LUC \t";;mpACADSCI_LUC~0~0;
				print "pACADSSCI \t";;mpACADSSCI~0~0;
				print "pACADBIOM \t";;mpACADBIOM~0~0;
					print "pACADBIOM_KUL \t";;mpACADBIOM_KUL~0~0;
					print "pACADBIOM_RUG \t";;mpACADBIOM_RUG~0~0;
					print "pACADBIOM_VUB \t";;mpACADBIOM_VUB~0~0;
					print "pACADBIOM_UA \t";;mpACADBIOM_UA~0~0;
					print "pACADBIOM_LUC \t";;mpACADBIOM_LUC~0~0;
				print "pACADARTS \t";;mpACADARTS~0~0;
				print "pVOCSCI \t";;mpVOCSCI~0~0;
				print "pVOCSSCI \t";;mpVOCSSCI~0~0;
				print "pVOCBIOM \t";;mpVOCBIOM~0~0;
				print "pVOCARTS \t";;mpVOCARTS~0~0;
				print "mCS \t";;mCS~0~0;
	            output file= ^sim_logfile off;
			/* Show the aggregated probabilities by subsample */
				let coltitles2=ALL MALE FEMALE BELG FORE NOREP REP1 REP2 ASO TSO KBSO CLAS LANG1 ECON1 SCIE MATH TSOH CATH1 NCATH1;
	            output file= ^sim_logfile2 on;
				print;
				print /rdn "STATUSQUO\t";;$coltitles2';
				print "pSTUD \t";;mpSTUD~mpSTUDMALE~mpSTUDFEM~mpSTUDBEL~mpSTUDFORE~mpSTUDNOREP~mpSTUDREP1~mpSTUDREP2~mpSTUDASO~mpSTUDTSO~mpSTUDKBSO~mpSTUDCLAS~mpSTUDLANG1~mpSTUDECON1~mpSTUDSCIE~mpSTUDMATH~mpSTUDTSOH~mpSTUDCATH1~mpSTUDNCATH1;
				print "pACAD \t";;mpACAD~mpACADMALE~mpACADFEM~mpACADBEL~mpACADFORE~mpACADNOREP~mpACADREP1~mpACADREP2~mpACADASO~mpACADTSO~mpACADKBSO~mpACADCLAS~mpACADLANG1~mpACADECON1~mpACADSCIE~mpACADMATH~mpACADTSOH~mpACADCATH1~mpACADNCATH1;
				print "pVOC \t";;mpVOC~mpVOCMALE~mpVOCFEM~mpVOCBEL~mpVOCFORE~mpVOCNOREP~mpVOCREP1~mpVOCREP2~mpVOCASO~mpVOCTSO~mpVOCKBSO~mpVOCCLAS~mpVOCLANG1~mpVOCECON1~mpVOCSCIE~mpVOCMATH~mpVOCTSOH~mpVOCCATH1~mpVOCNCATH1;
				print "pCATH \t";;mpCATH~mpCATHMALE~mpCATHFEM~mpCATHBEL~mpCATHFORE~mpCATHNOREP~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpCATHASO~mpCATHTSO~zeros(rows(mpSTUD),1)~mpCATHCLAS~mpCATHLANG1~mpCATHECON1~mpCATHSCIE~mpCATHMATH~mpCATHTSOH~mpCATHCATH1~mpCATHNCATH1;
				print "pNCATH \t";;mpNCATH~mpNCATHMALE~mpNCATHFEM~mpNCATHBEL~mpNCATHFORE~mpNCATHNOREP~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpNCATHASO~mpNCATHTSO~zeros(rows(mpSTUD),1)~mpNCATHCLAS~mpNCATHLANG1~mpNCATHECON1~mpNCATHSCIE~mpNCATHMATH~mpNCATHTSOH~mpNCATHCATH1~mpNCATHNCATH1;
				print "pI_KUL \t";;mpI_KUL~mpI_KULMALE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpI_KULFORE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpI_KULASO~mpI_KULTSO~zeros(rows(mpSTUD),1)~mpI_KULCLAS~mpI_KULLANG1~mpI_KULECON1~mpI_KULSCIE~mpI_KULMATH~mpI_KULTSOH~mpI_KULCATH1~zeros(rows(mpSTUD),1);
				print "pI_RUG \t";;mpI_RUG~mpI_RUGMALE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpI_RUGFORE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpI_RUGASO~mpI_RUGTSO~zeros(rows(mpSTUD),1)~mpI_RUGCLAS~mpI_RUGLANG1~mpI_RUGECON1~mpI_RUGSCIE~mpI_RUGMATH~mpI_RUGTSOH~mpI_RUGCATH1~zeros(rows(mpSTUD),1);
				print "pI_VUB \t";;mpI_VUB~mpI_VUBMALE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpI_VUBFORE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpI_VUBASO~mpI_VUBTSO~zeros(rows(mpSTUD),1)~mpI_VUBCLAS~mpI_VUBLANG1~mpI_VUBECON1~mpI_VUBSCIE~mpI_VUBMATH~mpI_VUBTSOH~mpI_VUBCATH1~zeros(rows(mpSTUD),1);
				print "pI_UA \t";;mpI_UA~mpI_UAMALE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpI_UAFORE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpI_UAASO~mpI_UATSO~zeros(rows(mpSTUD),1)~mpI_UACLAS~mpI_UALANG1~mpI_UAECON1~mpI_UASCIE~mpI_UAMATH~mpI_UATSOH~mpI_UACATH1~zeros(rows(mpSTUD),1);
				print "pI_LUC \t";;mpI_LUC~mpI_LUCMALE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpI_LUCFORE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpI_LUCASO~mpI_LUCTSO~zeros(rows(mpSTUD),1)~mpI_LUCCLAS~mpI_LUCLANG1~mpI_LUCECON1~mpI_LUCSCIE~mpI_LUCMATH~mpI_LUCTSOH~mpI_LUCCATH1~zeros(rows(mpSTUD),1);
				print "cs \t";;mcs~mcsMALE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mcsFORE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mcsASO~mcsTSO~zeros(rows(mpSTUD),1)~mcsCLAS~mcsLANG1~mcsECON1~mcsSCIE~mcsMATH~mcsTSOH~mcsCATH1~zeros(rows(mpSTUD),1);
				print "pACADSCI \t";;mpACADSCI~mpACADSCIMALE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpACADSCIFORE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpACADSCIASO~mpACADSCITSO~zeros(rows(mpSTUD),1)~mpACADSCICLAS~mpACADSCILANG1~mpACADSCIECON1~mpACADSCISCIE~mpACADSCIMATH~mpACADSCITSOH~mpACADSCICATH1~zeros(rows(mpSTUD),1);
				print "pACADSSCI \t";;mpACADSSCI~mpACADSSCIMALE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpACADSSCIFORE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpACADSSCIASO~mpACADSSCITSO~zeros(rows(mpSTUD),1)~mpACADSSCICLAS~mpACADSSCILANG1~mpACADSSCIECON1~mpACADSSCISCIE~mpACADSSCIMATH~mpACADSSCITSOH~mpACADSSCICATH1~zeros(rows(mpSTUD),1);
				print "pACADBIOM \t";;mpACADBIOM~mpACADBIOMMALE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpACADBIOMFORE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpACADBIOMASO~mpACADBIOMTSO~zeros(rows(mpSTUD),1)~mpACADBIOMCLAS~mpACADBIOMLANG1~mpACADBIOMECON1~mpACADBIOMSCIE~mpACADBIOMMATH~mpACADBIOMTSOH~mpACADBIOMCATH1~zeros(rows(mpSTUD),1);
				print "pACADARTS \t";;mpACADARTS~mpACADARTSMALE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpACADARTSFORE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpACADARTSASO~mpACADARTSTSO~zeros(rows(mpSTUD),1)~mpACADARTSCLAS~mpACADARTSLANG1~mpACADARTSECON1~mpACADARTSSCIE~mpACADARTSMATH~mpACADARTSTSOH~mpACADARTSCATH1~zeros(rows(mpSTUD),1);
				print "pVOCSCI \t";;mpVOCSCI~mpVOCSCIMALE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpVOCSCIFORE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpVOCSCIASO~mpVOCSCITSO~zeros(rows(mpSTUD),1)~mpVOCSCICLAS~mpVOCSCILANG1~mpVOCSCIECON1~mpVOCSCISCIE~mpVOCSCIMATH~mpVOCSCITSOH~mpVOCSCICATH1~zeros(rows(mpSTUD),1);
				print "pVOCSSCI \t";;mpVOCSSCI~mpVOCSSCIMALE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpVOCSSCIFORE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpVOCSSCIASO~mpVOCSSCITSO~zeros(rows(mpSTUD),1)~mpVOCSSCICLAS~mpVOCSSCILANG1~mpVOCSSCIECON1~mpVOCSSCISCIE~mpVOCSSCIMATH~mpVOCSSCITSOH~mpVOCSSCICATH1~zeros(rows(mpSTUD),1);
				print "pVOCBIOM \t";;mpVOCBIOM~mpVOCBIOMMALE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpVOCBIOMFORE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpVOCBIOMASO~mpVOCBIOMTSO~zeros(rows(mpSTUD),1)~mpVOCBIOMCLAS~mpVOCBIOMLANG1~mpVOCBIOMECON1~mpVOCBIOMSCIE~mpVOCBIOMMATH~mpVOCBIOMTSOH~mpVOCBIOMCATH1~zeros(rows(mpSTUD),1);
				print "pVOCARTS \t";;mpVOCARTS~mpVOCARTSMALE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpVOCARTSFORE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpVOCARTSASO~mpVOCARTSTSO~zeros(rows(mpSTUD),1)~mpVOCARTSCLAS~mpVOCARTSLANG1~mpVOCARTSECON1~mpVOCARTSSCIE~mpVOCARTSMATH~mpVOCARTSTSOH~mpVOCARTSCATH1~zeros(rows(mpSTUD),1);
	            output file= ^sim_logfile2 off;
        else; /* the real simulation i.e. where the tuition fee actually changes */
            mpSTUD1=			meanc(pSTUD);       mpACAD1=		meanc(pACAD);   	mpVOC1=			meanc(pVOC);     	mpVOCS1=		meanc(pVOCS);      	mpVOCL1=		meanc(pVOCL);  		mpCATH1=		meanc(pCATH);    	mpNCATH1=		meanc(pNCATH);    	
			mpI_KUL1=			meanc(pI_KUL);      mpI_RUG1=		meanc(pI_RUG);     	mpI_VUB1=		meanc(pI_VUB); 		mpI_UA1=		meanc(pI_UA);  	 	mpI_LUC1=		meanc(pI_LUC);  	
			mpAKUL1=			meanc(pAKUL);		mpAUG1=			meanc(pAUG);		mpAUA1=			meanc(pAUA);		mpAVUB1=		meanc(pAVUB);		mpALUC1=		meanc(pALUC);
			mCS1=				meanc(cs);
			tCS1=				sumc(cs);			tPS1=RV-SUB;
			mpACADSCI1= 		meanc(pACADSCI);	mpACADSSCI1=	meanc(pACADSSCI);	mpACADBIOM1=	meanc(pACADBIOM);	mpACADARTS1=	meanc(pACADARTS);
			mpACADSCI_KUL1= 	meanc(pACADSCI_KUL);
			mpACADSCI_RUG1= 	meanc(pACADSCI_RUG);
			mpACADSCI_VUB1= 	meanc(pACADSCI_VUB);
			mpACADSCI_UA1= 		meanc(pACADSCI_UA);
			mpACADSCI_LUC1= 	meanc(pACADSCI_LUC);
			mpACADBIOM_KUL1= 	meanc(pACADBIOM_KUL);
			mpACADBIOM_RUG1= 	meanc(pACADBIOM_RUG);
			mpACADBIOM_VUB1= 	meanc(pACADBIOM_VUB);
			mpACADBIOM_UA1= 	meanc(pACADBIOM_UA);
			mpACADBIOM_LUC1= 	meanc(pACADBIOM_LUC);
			mpVOCSCI1= 			meanc(pVOCSCI);		mpVOCSSCI1=		meanc(pVOCSSCI);	mpVOCBIOM1=		meanc(pVOCBIOM);	mpVOCARTS1=		meanc(pVOCARTS);
            /* Show the aggregated choice probabilities with their confidence intervals */
				let coltitles=PROB LOWER UPPER CHANGE LOWER UPPER;
	            output file= ^sim_logfile on;
				print;print;print;
				print "Simulation= ";;$pvnamecondvar;
				print "Amount(s) used for fee increases: ";;
				if pvnamecondvar $=="ACAD2" or pvnamecondvar $=="ACAD2_FB";
					print;
					print "\tFor ACADSCI and ACADBIOM:  ";;psize1;
					print "\tFor ACADSSCI and ACADARTS: ";;psize2;
				elseif pvnamecondvar $== "ACADVOC" or pvnamecondvar $== "ACADVOC_FB";
					print;
					print "\tFor ACAD:  ";;psize1;
					print "\tFor VOC: ";;psize2;
				elseif pvnamecondvar $== "ACADKUL2_FB";
					print;
					print "\tFor ACADSCI_KUL and ACADBIOM_KUL:  ";;psize1;
					print "\tFor ACADSSCI, ACADARTS & ACADSCI/ACADBIOM not at KUL: ";;psize2;
				elseif pvnamecondvar $== "ACADKULRUG2_FB";
					print;
					print "\tFor ACADSCI_KUL, ACADSCI_RUG, ACADBIOM_KUL, ACADBIOM_RUG:  ";;psize1;
					print "\tFor ACADSSCI, ACADARTS & ACADSCI/ACADBIOM not at KUL/RUG: ";;psize2;
				elseif pvnamecondvar $== "ACADKUL3_FB";
					print;
					print "\tFor ACADSCI_KUL:  ";;psize1;
					print "\tFor ACADBIOM_KUL: ";;psize2;
					print "\tFor ACADSSCI, ACADARTS & ACADSCI/ACADBIOM not at KUL: ";;psize3;
				elseif pvnamecondvar $== "ACADRUG3_FB";
					print;
					print "\tFor ACADSCI_RUG:  ";;psize1;
					print "\tFor ACADBIOM_RUG: ";;psize2;
					print "\tFor ACADSSCI, ACADARTS & ACADSCI/ACADBIOM not at RUG: ";;psize3;
				elseif pvnamecondvar $== "ACADKULUA3_FB";
					print;
					print "\tFor ACADBIOM_KUL:  ";;psize1;
					print "\tFor ACADSCI_UA: ";;psize2;
					print "\tFor ACADSSCI, ACADARTS, ACADBIOM not at KUL, ACADSCI not at UA: ";;psize3;
				elseif pvnamecondvar $== "ACADVOC2_FB";
					print;
					print "\tFor ACADSSCI:  ";;psize1;
					print "\tFor VOCSCI: ";;psize2;
					print "\tFor other study options: ";;psize3;
				elseif pvnamecondvar $== "ACADVOC_dist";
					print;
					print "\tFor ACAD:  ";;psize1;
					print "\tFor VOC: ";;psize2;
					print "\tSubsidy per kilometre: ";;psize3;
				elseif pvnamecondvar $=="INDIV";
					print "None. Status quo simulation.";
				elseif pvnamecondvar $=="FB";
					print "Fee for each option is set equal to its marginal cost.";
				else;
					print psize1;					
				endif;
				print;
				print "Total revenues= ";;RV;
				print "Subsidies (variable part)= ";;SUB;
				print "Total producer surplus (excl. fixed subsidies)= ";;tPS1;
				print "Total consumer surplus= ";;tCS1;
				print "Change in total welfare (excl. fixed subsidies) vs status-quo= ";;tCS1+tPS1-(tCS+tPS);
				print;
				print /rdn "FEE_INCREASE_FOR_";;pvnamecondvar;;"\t";;$coltitles';
				print "pSTUD \t";;mpSTUD1~lowerSTUD~upperSTUD~(mpSTUD1-mpSTUD)/mpSTUD~lowerSTUDC~upperSTUDC;
				print "pACAD \t";;mpACAD1~lowerACAD~upperACAD~(mpACAD1-mpACAD)/mpACAD~lowerACADC~upperACADC;
				print "pVOC \t";;mpVOC1~lowerVOC~upperVOC~(mpVOC1-mpVOC)/mpVOC~lowerVOCC~upperVOCC;
				print "pVOCS \t";;mpVOCS1~0~0~(mpVOCS1-mpVOCS)/mpVOCS~0~0;
				print "pVOCL \t";;mpVOCL1~0~0~(mpVOCL1-mpVOCL)/mpVOCL~0~0;
				print "pCATH \t";;mpCATH1~lowerCATH~upperCATH~(mpCATH1-mpCATH)/mpCATH~lowerCATHC~upperCATHC;
				print "pNCATH \t";;mpNCATH1~lowerNCATH~upperNCATH~(mpNCATH1-mpNCATH)/mpNCATH~lowerNCATHC~upperNCATHC;
				print "pI_KUL \t";;mpI_KUL1~0~0~(mpI_KUL1-mpI_KUL)/mpI_KUL~0~0;
				print "pI_RUG \t";;mpI_RUG1~0~0~(mpI_RUG1-mpI_RUG)/mpI_RUG~0~0;
				print "pI_VUB \t";;mpI_VUB1~0~0~(mpI_VUB1-mpI_VUB)/mpI_VUB~0~0;
				print "pI_UA \t";;mpI_UA1~0~0~(mpI_UA1-mpI_UA)/mpI_UA~0~0;
				print "pI_LUC \t";;mpI_LUC1~0~0~(mpI_LUC1-mpI_LUC)/mpI_LUC~0~0;
				print "pAKUL \t";;mpAKUL1~0~0~(mpAKUL1-mpAKUL)/mpAKUL~0~0;
				print "pAUG \t";;mpAUG1~0~0~(mpAUG1-mpAUG)/mpAUG~0~0;
				print "pAUA \t";;mpAUA1~0~0~(mpAUA1-mpAUA)/mpAUA~0~0;
				print "pAVUB \t";;mpAVUB1~0~0~(mpAVUB1-mpAVUB)/mpAVUB~0~0;
				print "pALUC \t";;mpALUC1~0~0~(mpALUC1-mpALUC)/mpALUC~0~0;
				print "pACADSCI \t";;mpACADSCI1~0~0~(mpACADSCI1-mpACADSCI)/mpACADSCI~0~0;
					print "pACADSCI_KUL \t";;mpACADSCI_KUL1~0~0~(mpACADSCI_KUL1-mpACADSCI_KUL)/mpACADSCI_KUL~0~0;
					print "pACADSCI_RUG \t";;mpACADSCI_RUG1~0~0~(mpACADSCI_RUG1-mpACADSCI_RUG)/mpACADSCI_RUG~0~0;
					print "pACADSCI_VUB \t";;mpACADSCI_VUB1~0~0~(mpACADSCI_VUB1-mpACADSCI_VUB)/mpACADSCI_VUB~0~0;
					print "pACADSCI_UA \t";;mpACADSCI_UA1~0~0~(mpACADSCI_UA1-mpACADSCI_UA)/mpACADSCI_UA~0~0;
					print "pACADSCI_LUC \t";;mpACADSCI_LUC1~0~0~(mpACADSCI_LUC1-mpACADSCI_LUC)/mpACADSCI_LUC~0~0;
				print "pACADSSCI \t";;mpACADSSCI1~0~0~(mpACADSSCI1-mpACADSSCI)/mpACADSSCI~0~0;
				print "pACADBIOM \t";;mpACADBIOM1~0~0~(mpACADBIOM1-mpACADBIOM)/mpACADBIOM~0~0;
					print "pACADBIOM_KUL \t";;mpACADBIOM_KUL1~0~0~(mpACADBIOM_KUL1-mpACADBIOM_KUL)/mpACADBIOM_KUL~0~0;
					print "pACADBIOM_RUG \t";;mpACADBIOM_RUG1~0~0~(mpACADBIOM_RUG1-mpACADBIOM_RUG)/mpACADBIOM_RUG~0~0;
					print "pACADBIOM_VUB \t";;mpACADBIOM_VUB1~0~0~(mpACADBIOM_VUB1-mpACADBIOM_VUB)/mpACADBIOM_VUB~0~0;
					print "pACADBIOM_UA \t";;mpACADBIOM_UA1~0~0~(mpACADBIOM_UA1-mpACADBIOM_UA)/mpACADBIOM_UA~0~0;
					print "pACADBIOM_LUC \t";;mpACADBIOM_LUC1~0~0~(mpACADBIOM_LUC1-mpACADBIOM_LUC)/mpACADBIOM_LUC~0~0;
				print "pACADARTS \t";;mpACADARTS1~0~0~(mpACADARTS1-mpACADARTS)/mpACADARTS~0~0;
				print "pVOCSCI \t";;mpVOCSCI1~0~0~(mpVOCSCI1-mpVOCSCI)/mpVOCSCI~0~0;
				print "pVOCSSCI \t";;mpVOCSSCI1~0~0~(mpVOCSSCI1-mpVOCSSCI)/mpVOCSSCI~0~0;
				print "pVOCBIOM \t";;mpVOCBIOM1~0~0~(mpVOCBIOM1-mpVOCBIOM)/mpVOCBIOM~0~0;
				print "pVOCARTS \t";;mpVOCARTS1~0~0~(mpVOCARTS1-mpVOCARTS)/mpVOCARTS~0~0;
				print "mCS \t";;mCS1~0~0~(mCS1-mCS)/mCS~0~0;
	            output file= ^sim_logfile off;
			/* Show the aggregated probabilities by subsample, but only for the uniform tuition fee */
				if pvnamecondvar $=="STUDY";
            		mpSTUDMALE=		meanc(selif(pSTUD,depMALE));		mpSTUDFEM=		meanc(selif(pSTUD,depFEM));		mpSTUDFORE=		meanc(selif(pSTUD,depFORE));	mpSTUDBEL=		meanc(selif(pSTUD,depBEL));		mpSTUDNOREP=		meanc(selif(pSTUD,depNOREP));		mpSTUDREP1=		meanc(selif(pSTUD,depREP1));	mpSTUDREP2=		meanc(selif(pSTUD,depREP2));	mpSTUDASO=		meanc(selif(pSTUD,depASO));		mpSTUDTSO=		meanc(selif(pSTUD,depTSO));		mpSTUDKBSO=		meanc(selif(pSTUD,(depASO .ne 1) .* (depTSO .ne 1) ));	mpSTUDCLAS=		meanc(selif(pSTUD,depCLAS));	mpSTUDLANG1=	meanc(selif(pSTUD,depLANG1));		mpSTUDECON1=	meanc(selif(pSTUD,depECON1));		mpSTUDSCIE=		meanc(selif(pSTUD,depSCIE));	mpSTUDMATH=		meanc(selif(pSTUD,depMATH));	mpSTUDTSOH=		meanc(selif(pSTUD,depTSOH));	mpSTUDCATH1=	meanc(selif(pSTUD,depCATH1));	mpSTUDNCATH1=	meanc(selif(pSTUD,depNCATH1));
					mpACADMALE=		meanc(selif(pACAD,depMALE));		mpACADFEM=		meanc(selif(pACAD,depFEM));		mpACADFORE=		meanc(selif(pACAD,depFORE));	mpACADBEL=		meanc(selif(pACAD,depBEL));		mpACADNOREP=		meanc(selif(pACAD,depNOREP));		mpACADREP1=		meanc(selif(pACAD,depREP1));	mpACADREP2=		meanc(selif(pACAD,depREP2));	mpACADASO=		meanc(selif(pACAD,depASO));		mpACADTSO=		meanc(selif(pACAD,depTSO));		mpACADKBSO=		meanc(selif(pACAD,(depASO .ne 1) .* (depTSO .ne 1) ));	mpACADCLAS=		meanc(selif(pACAD,depCLAS));	mpACADLANG1=	meanc(selif(pACAD,depLANG1));		mpACADECON1=	meanc(selif(pACAD,depECON1));		mpACADSCIE=		meanc(selif(pACAD,depSCIE));	mpACADMATH=		meanc(selif(pACAD,depMATH));	mpACADTSOH=		meanc(selif(pACAD,depTSOH));	mpACADCATH1=	meanc(selif(pACAD,depCATH1)); 	mpACADNCATH1=	meanc(selif(pACAD,depNCATH1));   
					mpVOCMALE=		meanc(selif(pVOC,depMALE));			mpVOCFEM=		meanc(selif(pVOC,depFEM));		mpVOCFORE=		meanc(selif(pVOC,depFORE));		mpVOCBEL=		meanc(selif(pVOC,depBEL));		mpVOCNOREP=			meanc(selif(pVOC,depNOREP));		mpVOCREP1=		meanc(selif(pVOC,depREP1));		mpVOCREP2=		meanc(selif(pVOC,depREP2));		mpVOCASO=		meanc(selif(pVOC,depASO));		mpVOCTSO=		meanc(selif(pVOC,depTSO));		mpVOCKBSO=		meanc(selif(pVOC,(depASO .ne 1) .* (depTSO .ne 1) ));	mpVOCCLAS=		meanc(selif(pVOC,depCLAS));		mpVOCLANG1=		meanc(selif(pVOC,depLANG1));		mpVOCECON1=		meanc(selif(pVOC,depECON1));		mpVOCSCIE=		meanc(selif(pVOC,depSCIE));		mpVOCMATH=		meanc(selif(pVOC,depMATH));		mpVOCTSOH=		meanc(selif(pVOC,depTSOH));		mpVOCCATH1=		meanc(selif(pVOC,depCATH1));	mpVOCNCATH1=	meanc(selif(pVOC,depNCATH1));
					mpCATHMALE=		meanc(selif(pCATH,depMALE));		mpCATHFEM=		meanc(selif(pCATH,depFEM));		mpCATHFORE=		meanc(selif(pCATH,depFORE));	mpCATHBEL=		meanc(selif(pCATH,depBEL));		mpCATHNOREP=		meanc(selif(pCATH,depNOREP));																										mpCATHASO=		meanc(selif(pCATH,depASO));		mpCATHTSO=		meanc(selif(pCATH,depTSO));																				mpCATHCLAS=		meanc(selif(pCATH,depCLAS));	mpCATHLANG1=	meanc(selif(pCATH,depLANG1));		mpCATHECON1=	meanc(selif(pCATH,depECON1));		mpCATHSCIE=		meanc(selif(pCATH,depSCIE));	mpCATHMATH=		meanc(selif(pCATH,depMATH));	mpCATHTSOH=		meanc(selif(pCATH,depTSOH));	mpCATHCATH1=	meanc(selif(pCATH,depCATH1));	mpCATHNCATH1=	meanc(selif(pCATH,depNCATH1));
					mpNCATHMALE=	meanc(selif(pNCATH,depMALE));		mpNCATHFEM=		meanc(selif(pNCATH,depFEM));	mpNCATHFORE=	meanc(selif(pNCATH,depFORE));	mpNCATHBEL=		meanc(selif(pNCATH,depBEL));	mpNCATHNOREP=		meanc(selif(pNCATH,depNOREP));																										mpNCATHASO=		meanc(selif(pNCATH,depASO));	mpNCATHTSO=		meanc(selif(pNCATH,depTSO));																			mpNCATHCLAS=	meanc(selif(pNCATH,depCLAS));	mpNCATHLANG1=	meanc(selif(pNCATH,depLANG1));		mpNCATHECON1=	meanc(selif(pNCATH,depECON1));		mpNCATHSCIE=	meanc(selif(pNCATH,depSCIE));	mpNCATHMATH=	meanc(selif(pNCATH,depMATH));	mpNCATHTSOH=	meanc(selif(pNCATH,depTSOH));	mpNCATHCATH1=	meanc(selif(pNCATH,depCATH1));	mpNCATHNCATH1=	meanc(selif(pNCATH,depNCATH1));
					mpI_KULMALE=	meanc(selif(pI_KUL,depMALE));														mpI_KULFORE=	meanc(selif(pI_KUL,depFORE));																																																			mpI_KULASO=		meanc(selif(pI_KUL,depASO));	mpI_KULTSO=		meanc(selif(pI_KUL,depTSO));																			mpI_KULCLAS=	meanc(selif(pI_KUL,depCLAS));	mpI_KULLANG1=	meanc(selif(pI_KUL,depLANG1));		mpI_KULECON1=	meanc(selif(pI_KUL,depECON1));		mpI_KULSCIE=	meanc(selif(pI_KUL,depSCIE));	mpI_KULMATH=	meanc(selif(pI_KUL,depMATH));	mpI_KULTSOH=	meanc(selif(pI_KUL,depTSOH));	mpI_KULCATH1=	meanc(selif(pI_KUL,depCATH1));
		            mpI_RUGMALE=	meanc(selif(pI_RUG,depMALE));														mpI_RUGFORE=	meanc(selif(pI_RUG,depFORE));																																																			mpI_RUGASO=		meanc(selif(pI_RUG,depASO));	mpI_RUGTSO=		meanc(selif(pI_RUG,depTSO));																			mpI_RUGCLAS=	meanc(selif(pI_RUG,depCLAS));	mpI_RUGLANG1=	meanc(selif(pI_RUG,depLANG1));		mpI_RUGECON1=	meanc(selif(pI_RUG,depECON1));		mpI_RUGSCIE=	meanc(selif(pI_RUG,depSCIE));	mpI_RUGMATH=	meanc(selif(pI_RUG,depMATH));	mpI_RUGTSOH=	meanc(selif(pI_RUG,depTSOH));	mpI_RUGCATH1=	meanc(selif(pI_RUG,depCATH1));
					mpI_VUBMALE=	meanc(selif(pI_VUB,depMALE));														mpI_VUBFORE=	meanc(selif(pI_VUB,depFORE));																																																			mpI_VUBASO=		meanc(selif(pI_VUB,depASO));	mpI_VUBTSO=		meanc(selif(pI_VUB,depTSO));																			mpI_VUBCLAS=	meanc(selif(pI_VUB,depCLAS));	mpI_VUBLANG1=	meanc(selif(pI_VUB,depLANG1));		mpI_VUBECON1=	meanc(selif(pI_VUB,depECON1));		mpI_VUBSCIE=	meanc(selif(pI_VUB,depSCIE));	mpI_VUBMATH=	meanc(selif(pI_VUB,depMATH));	mpI_VUBTSOH=	meanc(selif(pI_VUB,depTSOH));	mpI_VUBCATH1=	meanc(selif(pI_VUB,depCATH1));    
					mpI_UAMALE=		meanc(selif(pI_UA,depMALE));														mpI_UAFORE=		meanc(selif(pI_UA,depFORE));																																																			mpI_UAASO=		meanc(selif(pI_UA,depASO));		mpI_UATSO=		meanc(selif(pI_UA,depTSO));																				mpI_UACLAS=		meanc(selif(pI_UA,depCLAS));	mpI_UALANG1=	meanc(selif(pI_UA,depLANG1));		mpI_UAECON1=	meanc(selif(pI_UA,depECON1));		mpI_UASCIE=		meanc(selif(pI_UA,depSCIE));	mpI_UAMATH=		meanc(selif(pI_UA,depMATH));	mpI_UATSOH=		meanc(selif(pI_UA,depTSOH));	mpI_UACATH1=	meanc(selif(pI_UA,depCATH1));
					mpI_LUCMALE=	meanc(selif(pI_LUC,depMALE));														mpI_LUCFORE=	meanc(selif(pI_LUC,depFORE));																																																			mpI_LUCASO=		meanc(selif(pI_LUC,depASO));	mpI_LUCTSO=		meanc(selif(pI_LUC,depTSO));																			mpI_LUCCLAS=	meanc(selif(pI_LUC,depCLAS));	mpI_LUCLANG1=	meanc(selif(pI_LUC,depLANG1));		mpI_LUCECON1=	meanc(selif(pI_LUC,depECON1));		mpI_LUCSCIE=	meanc(selif(pI_LUC,depSCIE));	mpI_LUCMATH=	meanc(selif(pI_LUC,depMATH));	mpI_LUCTSOH=	meanc(selif(pI_LUC,depTSOH));	mpI_LUCCATH1=	meanc(selif(pI_LUC,depCATH1));
					mcsMALE=		meanc(selif(cs,depMALE));															mcsFORE=		meanc(selif(cs,depFORE));																																																				mcsASO=			meanc(selif(cs,depASO));		mcsTSO=			meanc(selif(cs,depTSO));																				mcsCLAS=		meanc(selif(cs,depCLAS));		mcsLANG1=		meanc(selif(cs,depLANG1));			mcsECON1=		meanc(selif(cs,depECON1));			mcsSCIE=		meanc(selif(cs,depSCIE));		mcsMATH=		meanc(selif(cs,depMATH));		mcsTSOH=		meanc(selif(cs,depTSOH));		mcsCATH1=		meanc(selif(cs,depCATH1));
					mpACADSCIMALE=	meanc(selif(pACADSCI,depMALE));														mpACADSCIFORE=	meanc(selif(pACADSCI,depFORE));																																																			mpACADSCIASO=	meanc(selif(pACADSCI,depASO));	mpACADSCITSO=	meanc(selif(pACADSCI,depTSO));																			mpACADSCICLAS=	meanc(selif(pACADSCI,depCLAS));	mpACADSCILANG1=	meanc(selif(pACADSCI,depLANG1));	mpACADSCIECON1=	meanc(selif(pACADSCI,depECON1));	mpACADSCISCIE=	meanc(selif(pACADSCI,depSCIE));	mpACADSCIMATH=	meanc(selif(pACADSCI,depMATH));	mpACADSCITSOH=	meanc(selif(pACADSCI,depTSOH));	mpACADSCICATH1=	meanc(selif(pACADSCI,depCATH1));
					mpACADSSCIMALE=	meanc(selif(pACADSSCI,depMALE));													mpACADSSCIFORE=	meanc(selif(pACADSSCI,depFORE));																																																		mpACADSSCIASO=	meanc(selif(pACADSSCI,depASO));	mpACADSSCITSO=	meanc(selif(pACADSSCI,depTSO));																			mpACADSSCICLAS=	meanc(selif(pACADSSCI,depCLAS));mpACADSSCILANG1=meanc(selif(pACADSSCI,depLANG1));	mpACADSSCIECON1=meanc(selif(pACADSSCI,depECON1));	mpACADSSCISCIE=	meanc(selif(pACADSSCI,depSCIE));mpACADSSCIMATH=	meanc(selif(pACADSSCI,depMATH));mpACADSSCITSOH=	meanc(selif(pACADSSCI,depTSOH));mpACADSSCICATH1=meanc(selif(pACADSSCI,depCATH1));	
					mpACADBIOMMALE=	meanc(selif(pACADBIOM,depMALE));													mpACADBIOMFORE=	meanc(selif(pACADBIOM,depFORE));																																																		mpACADBIOMASO=	meanc(selif(pACADBIOM,depASO));	mpACADBIOMTSO=	meanc(selif(pACADBIOM,depTSO));																			mpACADBIOMCLAS=	meanc(selif(pACADBIOM,depCLAS));mpACADBIOMLANG1=meanc(selif(pACADBIOM,depLANG1));	mpACADBIOMECON1=meanc(selif(pACADBIOM,depECON1));	mpACADBIOMSCIE=	meanc(selif(pACADBIOM,depSCIE));mpACADBIOMMATH=	meanc(selif(pACADBIOM,depMATH));mpACADBIOMTSOH=	meanc(selif(pACADBIOM,depTSOH));mpACADBIOMCATH1=meanc(selif(pACADBIOM,depCATH1));
					mpACADARTSMALE=	meanc(selif(pACADARTS,depMALE));													mpACADARTSFORE=	meanc(selif(pACADARTS,depFORE));																																																		mpACADARTSASO=	meanc(selif(pACADARTS,depASO));	mpACADARTSTSO=	meanc(selif(pACADARTS,depTSO));																			mpACADARTSCLAS=	meanc(selif(pACADARTS,depCLAS));mpACADARTSLANG1=meanc(selif(pACADARTS,depLANG1));	mpACADARTSECON1=meanc(selif(pACADARTS,depECON1));	mpACADARTSSCIE=	meanc(selif(pACADARTS,depSCIE));mpACADARTSMATH=	meanc(selif(pACADARTS,depMATH));mpACADARTSTSOH=	meanc(selif(pACADARTS,depTSOH));mpACADARTSCATH1=meanc(selif(pACADARTS,depCATH1));
					mpVOCSCIMALE=	meanc(selif(pVOCSCI,depMALE));														mpVOCSCIFORE=	meanc(selif(pVOCSCI,depFORE));																																																			mpVOCSCIASO=	meanc(selif(pVOCSCI,depASO));	mpVOCSCITSO=	meanc(selif(pVOCSCI,depTSO));																			mpVOCSCICLAS=	meanc(selif(pVOCSCI,depCLAS));	mpVOCSCILANG1=	meanc(selif(pVOCSCI,depLANG1));		mpVOCSCIECON1=	meanc(selif(pVOCSCI,depECON1));		mpVOCSCISCIE=	meanc(selif(pVOCSCI,depSCIE));	mpVOCSCIMATH=	meanc(selif(pVOCSCI,depMATH));	mpVOCSCITSOH=	meanc(selif(pVOCSCI,depTSOH));	mpVOCSCICATH1=	meanc(selif(pVOCSCI,depCATH1));
					mpVOCSSCIMALE=	meanc(selif(pVOCSSCI,depMALE));														mpVOCSSCIFORE=	meanc(selif(pVOCSSCI,depFORE));																																																			mpVOCSSCIASO=	meanc(selif(pVOCSSCI,depASO));	mpVOCSSCITSO=	meanc(selif(pVOCSSCI,depTSO));																			mpVOCSSCICLAS=	meanc(selif(pVOCSSCI,depCLAS));	mpVOCSSCILANG1=	meanc(selif(pVOCSSCI,depLANG1));	mpVOCSSCIECON1=	meanc(selif(pVOCSSCI,depECON1));	mpVOCSSCISCIE=	meanc(selif(pVOCSSCI,depSCIE));	mpVOCSSCIMATH=	meanc(selif(pVOCSSCI,depMATH));	mpVOCSSCITSOH=	meanc(selif(pVOCSSCI,depTSOH));	mpVOCSSCICATH1=	meanc(selif(pVOCSSCI,depCATH1));
					mpVOCBIOMMALE=	meanc(selif(pVOCBIOM,depMALE));														mpVOCBIOMFORE=	meanc(selif(pVOCBIOM,depFORE));																																																			mpVOCBIOMASO=	meanc(selif(pVOCBIOM,depASO));	mpVOCBIOMTSO=	meanc(selif(pVOCBIOM,depTSO));																			mpVOCBIOMCLAS=	meanc(selif(pVOCBIOM,depCLAS));	mpVOCBIOMLANG1=	meanc(selif(pVOCBIOM,depLANG1));	mpVOCBIOMECON1=	meanc(selif(pVOCBIOM,depECON1));	mpVOCBIOMSCIE=	meanc(selif(pVOCBIOM,depSCIE));	mpVOCBIOMMATH=	meanc(selif(pVOCBIOM,depMATH));	mpVOCBIOMTSOH=	meanc(selif(pVOCBIOM,depTSOH));	mpVOCBIOMCATH1=	meanc(selif(pVOCBIOM,depCATH1));
					mpVOCARTSMALE=	meanc(selif(pVOCARTS,depMALE));														mpVOCARTSFORE=	meanc(selif(pVOCARTS,depFORE));																																																			mpVOCARTSASO=	meanc(selif(pVOCARTS,depASO));	mpVOCARTSTSO=	meanc(selif(pVOCARTS,depTSO));																			mpVOCARTSCLAS=	meanc(selif(pVOCARTS,depCLAS));	mpVOCARTSLANG1=	meanc(selif(pVOCARTS,depLANG1));	mpVOCARTSECON1=	meanc(selif(pVOCARTS,depECON1));	mpVOCARTSSCIE=	meanc(selif(pVOCARTS,depSCIE));	mpVOCARTSMATH=	meanc(selif(pVOCARTS,depMATH));	mpVOCARTSTSOH=	meanc(selif(pVOCARTS,depTSOH));	mpVOCARTSCATH1=	meanc(selif(pVOCARTS,depCATH1));
					let coltitles2=ALL MALE FEMALE BELG FORE NOREP REP1 REP2 ASO TSO KBSO CLAS LANG1 ECON1 SCIE MATH TSOH CATH1 NCATH1;
		            output file= ^sim_logfile2 on;
					print;
					print /rdn "FEE_INCREASE_FOR_";;pvnamecondvar;;"\t";;$coltitles2';
					print "pSTUD \t";;mpSTUD1~mpSTUDMALE~mpSTUDFEM~mpSTUDBEL~mpSTUDFORE~mpSTUDNOREP~mpSTUDREP1~mpSTUDREP2~mpSTUDASO~mpSTUDTSO~mpSTUDKBSO~mpSTUDCLAS~mpSTUDLANG1~mpSTUDECON1~mpSTUDSCIE~mpSTUDMATH~mpSTUDTSOH~mpSTUDCATH1~mpSTUDNCATH1;
					print "pACAD \t";;mpACAD1~mpACADMALE~mpACADFEM~mpACADBEL~mpACADFORE~mpACADNOREP~mpACADREP1~mpACADREP2~mpACADASO~mpACADTSO~mpACADKBSO~mpACADCLAS~mpACADLANG1~mpACADECON1~mpACADSCIE~mpACADMATH~mpACADTSOH~mpACADCATH1~mpACADNCATH1;
					print "pVOC \t";;mpVOC1~mpVOCMALE~mpVOCFEM~mpVOCBEL~mpVOCFORE~mpVOCNOREP~mpVOCREP1~mpVOCREP2~mpVOCASO~mpVOCTSO~mpVOCKBSO~mpVOCCLAS~mpVOCLANG1~mpVOCECON1~mpVOCSCIE~mpVOCMATH~mpVOCTSOH~mpVOCCATH1~mpVOCNCATH1;
					print "pCATH \t";;mpCATH1~mpCATHMALE~mpCATHFEM~mpCATHBEL~mpCATHFORE~mpCATHNOREP~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpCATHASO~mpCATHTSO~zeros(rows(mpSTUD),1)~mpCATHCLAS~mpCATHLANG1~mpCATHECON1~mpCATHSCIE~mpCATHMATH~mpCATHTSOH~mpCATHCATH1~mpCATHNCATH1;
					print "pNCATH \t";;mpNCATH1~mpNCATHMALE~mpNCATHFEM~mpNCATHBEL~mpNCATHFORE~mpNCATHNOREP~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpNCATHASO~mpNCATHTSO~zeros(rows(mpSTUD),1)~mpNCATHCLAS~mpNCATHLANG1~mpNCATHECON1~mpNCATHSCIE~mpNCATHMATH~mpNCATHTSOH~mpNCATHCATH1~mpNCATHNCATH1;
					print "pI_KUL \t";;mpI_KUL1~mpI_KULMALE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpI_KULFORE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpI_KULASO~mpI_KULTSO~zeros(rows(mpSTUD),1)~mpI_KULCLAS~mpI_KULLANG1~mpI_KULECON1~mpI_KULSCIE~mpI_KULMATH~mpI_KULTSOH~mpI_KULCATH1~zeros(rows(mpSTUD),1);
					print "pI_RUG \t";;mpI_RUG1~mpI_RUGMALE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpI_RUGFORE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpI_RUGASO~mpI_RUGTSO~zeros(rows(mpSTUD),1)~mpI_RUGCLAS~mpI_RUGLANG1~mpI_RUGECON1~mpI_RUGSCIE~mpI_RUGMATH~mpI_RUGTSOH~mpI_RUGCATH1~zeros(rows(mpSTUD),1);
					print "pI_VUB \t";;mpI_VUB1~mpI_VUBMALE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpI_VUBFORE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpI_VUBASO~mpI_VUBTSO~zeros(rows(mpSTUD),1)~mpI_VUBCLAS~mpI_VUBLANG1~mpI_VUBECON1~mpI_VUBSCIE~mpI_VUBMATH~mpI_VUBTSOH~mpI_VUBCATH1~zeros(rows(mpSTUD),1);
					print "pI_UA \t";;mpI_UA1~mpI_UAMALE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpI_UAFORE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpI_UAASO~mpI_UATSO~zeros(rows(mpSTUD),1)~mpI_UACLAS~mpI_UALANG1~mpI_UAECON1~mpI_UASCIE~mpI_UAMATH~mpI_UATSOH~mpI_UACATH1~zeros(rows(mpSTUD),1);
					print "pI_LUC \t";;mpI_LUC1~mpI_LUCMALE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpI_LUCFORE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpI_LUCASO~mpI_LUCTSO~zeros(rows(mpSTUD),1)~mpI_LUCCLAS~mpI_LUCLANG1~mpI_LUCECON1~mpI_LUCSCIE~mpI_LUCMATH~mpI_LUCTSOH~mpI_LUCCATH1~zeros(rows(mpSTUD),1);
					print "cs \t";;mcs1~mcsMALE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mcsFORE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mcsASO~mcsTSO~zeros(rows(mpSTUD),1)~mcsCLAS~mcsLANG1~mcsECON1~mcsSCIE~mcsMATH~mcsTSOH~mcsCATH1~zeros(rows(mpSTUD),1);
					print "pACADSCI \t";;mpACADSCI1~mpACADSCIMALE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpACADSCIFORE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpACADSCIASO~mpACADSCITSO~zeros(rows(mpSTUD),1)~mpACADSCICLAS~mpACADSCILANG1~mpACADSCIECON1~mpACADSCISCIE~mpACADSCIMATH~mpACADSCITSOH~mpACADSCICATH1~zeros(rows(mpSTUD),1);
					print "pACADSSCI \t";;mpACADSSCI1~mpACADSSCIMALE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpACADSSCIFORE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpACADSSCIASO~mpACADSSCITSO~zeros(rows(mpSTUD),1)~mpACADSSCICLAS~mpACADSSCILANG1~mpACADSSCIECON1~mpACADSSCISCIE~mpACADSSCIMATH~mpACADSSCITSOH~mpACADSSCICATH1~zeros(rows(mpSTUD),1);
					print "pACADBIOM \t";;mpACADBIOM1~mpACADBIOMMALE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpACADBIOMFORE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpACADBIOMASO~mpACADBIOMTSO~zeros(rows(mpSTUD),1)~mpACADBIOMCLAS~mpACADBIOMLANG1~mpACADBIOMECON1~mpACADBIOMSCIE~mpACADBIOMMATH~mpACADBIOMTSOH~mpACADBIOMCATH1~zeros(rows(mpSTUD),1);
					print "pACADARTS \t";;mpACADARTS1~mpACADARTSMALE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpACADARTSFORE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpACADARTSASO~mpACADARTSTSO~zeros(rows(mpSTUD),1)~mpACADARTSCLAS~mpACADARTSLANG1~mpACADARTSECON1~mpACADARTSSCIE~mpACADARTSMATH~mpACADARTSTSOH~mpACADARTSCATH1~zeros(rows(mpSTUD),1);
					print "pVOCSCI \t";;mpVOCSCI1~mpVOCSCIMALE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpVOCSCIFORE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpVOCSCIASO~mpVOCSCITSO~zeros(rows(mpSTUD),1)~mpVOCSCICLAS~mpVOCSCILANG1~mpVOCSCIECON1~mpVOCSCISCIE~mpVOCSCIMATH~mpVOCSCITSOH~mpVOCSCICATH1~zeros(rows(mpSTUD),1);
					print "pVOCSSCI \t";;mpVOCSSCI1~mpVOCSSCIMALE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpVOCSSCIFORE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpVOCSSCIASO~mpVOCSSCITSO~zeros(rows(mpSTUD),1)~mpVOCSSCICLAS~mpVOCSSCILANG1~mpVOCSSCIECON1~mpVOCSSCISCIE~mpVOCSSCIMATH~mpVOCSSCITSOH~mpVOCSSCICATH1~zeros(rows(mpSTUD),1);
					print "pVOCBIOM \t";;mpVOCBIOM1~mpVOCBIOMMALE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpVOCBIOMFORE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpVOCBIOMASO~mpVOCBIOMTSO~zeros(rows(mpSTUD),1)~mpVOCBIOMCLAS~mpVOCBIOMLANG1~mpVOCBIOMECON1~mpVOCBIOMSCIE~mpVOCBIOMMATH~mpVOCBIOMTSOH~mpVOCBIOMCATH1~zeros(rows(mpSTUD),1);
					print "pVOCARTS \t";;mpVOCARTS1~mpVOCARTSMALE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpVOCARTSFORE~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~zeros(rows(mpSTUD),1)~mpVOCARTSASO~mpVOCARTSTSO~zeros(rows(mpSTUD),1)~mpVOCARTSCLAS~mpVOCARTSLANG1~mpVOCARTSECON1~mpVOCARTSSCIE~mpVOCARTSMATH~mpVOCARTSTSOH~mpVOCARTSCATH1~zeros(rows(mpSTUD),1);
		            output file= ^sim_logfile2 off;
				endif;		
        endif;
endp;


proc (0) = storeparams(plogfile, pparams, pbeta);
@ stores the parameter estimates in a Gauss file @
    local paramsfile,y,f2;
    paramsfile="est_" $+ plogfile $+ "_params";
    create f2=^paramsfile with ^pparams,0,8;
    y=writer(f2,pbeta');
    f2 = close(f2);
endp;


proc getstartv(pfile,ppnames);
@ This proc retrieves starting values from the Gauss file with the name pfile. The proc checks that the each disk parameter is assigned to 
  the correct model parameter as a starting value by comparing names. @
local f2, fpnames, fpvalues, posparams, modelstartv, i;
    print "calling proc getstartv: using startvalues from file " pfile;
    open f2=^pfile;
    fpnames=getnamef(f2);   /* get the names from the disk parameter values */
    fpnames=0 $+ fpnames;   /* convert type of fpnames from "string array" to "matrix", needed for indcv-function below. */
    fpvalues=readr(f2,1);   /* get the values from the disk parameter values */
    fpvalues=fpvalues';
    posparams=indcv(ppnames,fpnames);   /* find the positions of the model parameters in the disk file */
    modelstartv=zeros(rows(fpnames),1);
    for i (1, rows(fpnames), 1);
        modelstartv[i,1]=fpvalues[posparams[i,1],1];
    endfor;
 retp(modelstartv);
endp;

proc buildreg(pdata, varnames, pformat);
@   This procedure builds a vector or matrix by extracting the columns with names 'varnames' from the diskfile 'pdata'. @ 
local i, nrdone, f2, chunksize, chunk, allvars, posvars, posNONE, resultvar;
    open f2 = ^pdata;
    allvars=getnamef(f2);
    allvars=0 $+ allvars; /* convert type of allvars from "string array" to "matrix", needed for indcv-function below. */
    posvars=    indcv(varnames,allvars);
    posNONE=    indcv("NONE",allvars);
    i = 0;
    nrdone = 0;
    chunksize = 500 * nalt;     /*  process x individuals per iteration of the loop; by defining chunksize like this, we process complete 
                                    blocks of individuals, allowing us to reshape from NJ --> N if pformat$=="N". 100,000 rows is about 240MB 
                                    per chunk if there are 300 columns (8 bytes/var) in the dataset. If RAM problems, reduce the number of 
                                    rows read per iteration. 500 rows give 1.2 MB per chunk. */
    do until nrdone>=nindiv*nalt; 
        i=i+1;
        chunk=      readr(f2,chunksize);
        nrdone=     nrdone + rows(chunk);
        if pformat$=="logit";
            chunk=  selif(chunk,chunk[.,posNONE]);  
            chunk=  chunk[.,posvars];               /* only keep requested variables (varnames parameter), result is NJ*K */
        elseif pformat$=="clogit";
            chunk = chunk[.,posvars];               /* only keep requested variables (varnames parameter), result is NJ*K */
        endif;
        if i==1;
            resultvar=    chunk;
        else;   
            resultvar=    resultvar | chunk;        /* concatenate next block of rows of data vertically to previously read data */
        endif;
        clear chunk;
    endo;
    f2=close(f2);
    retp(resultvar);
endp;

proc exist(filename); 
    @ This proc verifies whether "filename" exists in the current directory. if it does, it returns the value "1".
      NOTE: when calling this proc, "pfile" should be specified WITH file extension or otherwise this proc will not recognize it!! @
    retp(not filesa(filename) $== ""); 
endp;

proc (0) = create_simlogfile(b);
@ 	Creates the file with the overview of simulated choice probabilities with their confidence intervals.
	This file can be imported in Excel as a delimited file (select both "tab" and "space" as delimiters and check "treat consecutive 
	delimiters as one". @
local titles;
	sim_logfile =  datestrymd(date) $+ "_" $+ ftos(hsec,"%*.*lf",1,0) $+ "_sim_" $+ logfile $+ "_overview" $+ ".txt";
	output file= ^sim_logfile reset;
	format /rdt 20,8;
	outwidth 256;
	print;
	print "Simulation on: " dataset;
	print "parameter values used for predictions:" b';
	print;
	output file= ^sim_logfile off;
endp;

proc (0) = create_simlogfile2(b);
@ 	Creates the file with the overview of simulated choice probabilities and their values for subsamples (males, aso'ers, etc.).
	No confidence intervals are calculated/shown for these choice probabilities.
	This file can be imported in Excel as a delimited file (select both "tab" and "space" as delimiters and check "treat consecutive 
	delimiters as one". @
local titles;
	sim_logfile2 =  datestrymd(date) $+ "_" $+ ftos(hsec,"%*.*lf",1,0) $+ "_sim_" $+ logfile $+ "_overview2" $+ ".txt";
	output file= ^sim_logfile2 reset;
	format /rdt 20,8;
	outwidth 256;
	print;
	print "Simulation on: " dataset;
	print "parameter values used for predictions:" b';
	print;
	output file= ^sim_logfile2 off;
endp;

end;
