int main( int argc, char *argv[]) {

  // Print a starting message
  banner("0.1, Option 4", "2016-04-28");

  // We assume argv[1] is a filename to open
  std::ifstream ifs(argv[1]);

  std::vector< double > timestep, Year, Week, FishCatch, Targeted_Effort, Nontargeted_Effort;
  std::vector<string> YearType;
  double a, c, d, e, f, g;
  string b;
  long unsigned counter=0;

  try{   // Assess if data file is read entirely
  while( ifs >> a >> b >> c >> d >> e >> f >> g){
    timestep.push_back( a ); YearType.push_back (b); 
    Year.push_back(c); Week.push_back(d); 
    FishCatch.push_back(e); Targeted_Effort.push_back(f); Nontargeted_Effort.push_back(g);
    //printf(" Reading %.2f %.2f %.2f from file \n", a, b, c, d);
    counter++;
 }
  // When finishing reading, if EOF not reached throw an error
  if(!ifs.eof()){ throw ReadingError();}
  ifs.close();
  }catch(ReadingError){ std::cerr << "Error: could not read the entire file\n"; return 1;}


  std::cout << "In main, the size of FishCatch is " << FishCatch.size() << "\n";

  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  //// Read the values of fixed parameters from file in local directory into global variables
  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  std::string arg2(argv[2]);
  std::vector<Parameter> ModelInputParameters = ReadParameterDescription(arg2);

  //string FixParfilename = "FixParameters.txt";
  //display_file(FixParfilename);

  // Assign fixed model's parameter set according to the information provided by the user in the csv file passed as 2nd argument

  rho = GetParameterValueAccordingToSymbol(ModelInputParameters, "rho");
  wk = GetParameterValueAccordingToSymbol(ModelInputParameters, "wk");
  wk_1 = GetParameterValueAccordingToSymbol(ModelInputParameters, "wk_1");
  CatchabilityScalingFactor = GetParameterValueAccordingToSymbol(ModelInputParameters, "CatchabilityScalingFactor");
  BiomassScalingFactor = GetParameterValueAccordingToSymbol(ModelInputParameters, "BiomassScalingFactor");
  RecruitmentScalingFactor = GetParameterValueAccordingToSymbol(ModelInputParameters, "RecruitmentScalingFactor");
  NIPY = (int) GetParameterValueAccordingToSymbol(ModelInputParameters, "NIPY");

  //rho = fill_from_file(arg2, "Brody growth coefficient");
  //wk = fill_from_file(arg2, "Estimated weight at recruitment");
  //wk_1 = fill_from_file(arg2, "Parameter defining weight one timestep before recruitment");
  ////M = fill_from_file(arg2, "Natural mortality"); // Natural mortality is estimated in this version of the delay difference
  //CatchabilityScalingFactor = fill_from_file(arg2, "Catchability scaling factor");
  //BiomassScalingFactor = fill_from_file(arg2, "Biomass scaling factor");
  //RecruitmentScalingFactor = fill_from_file(arg2, "Recruitment scaling factor");
  //NIPY = (int) fill_from_file(arg2, "Number of intervals in a year");

  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  //// Standard minimization using MIGRAD
  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  // Declare the objective function (also called FCN function in documentation)  
  LogLikelihoodFunction fFCN(FishCatch, Targeted_Effort, Nontargeted_Effort);

  //// create Minuit parameters with names
  MnUserParameters upar;
  //upar.Add("Natural mortality", 2.34 / (double) NIPY , 0.01);
  upar.Add("Natural mortality", GetParameterValueAccordingToShortName(ModelInputParameters, "Natural mortality"), 0.001);

  //upar.Add("Targeted q", 4, 2);
  upar.Add("Targeted q", GetParameterValueAccordingToShortName(ModelInputParameters, "Targeted q"), 0.5);
  //upar.Add("Nontargeted q", 2, 2);
  upar.Add("Nontargeted q", GetParameterValueAccordingToShortName(ModelInputParameters, "Nontargeted q"), 0.5);
  //upar.Add("sigma", 10, 0.1);
  upar.Add("sigma", GetParameterValueAccordingToShortName(ModelInputParameters, "sigma"), 1);
  //upar.Add("Biomass1", 1, 2);
  upar.Add("Biomass1", GetParameterValueAccordingToShortName(ModelInputParameters, "Biomass1"), 0.5);
  //upar.Add("Biomass2", 1, 2);
  upar.Add("Biomass2", GetParameterValueAccordingToShortName(ModelInputParameters, "Biomass2"), 0.5);
  //upar.Add("vm_mean", 0, 1);
  //upar.Add("vm_sigma", 5, 2); // variance of the recruitment distribution modelled with von Mises
  upar.Add("vm_sigma", GetParameterValueAccordingToShortName(ModelInputParameters, "vm_sigma"), 1);

  // Estimate 1 recruitment per year
  std::string RecVarName="Recruit year";
  for(unsigned int i = 1; i <= counter / NIPY; ++i){
    //upar.Add(RecVarName + " " + std::to_string(i), 0.2 * (i+1), .5);
    upar.Add(RecVarName + " " + std::to_string(i), GetParameterValueAccordingToShortName(ModelInputParameters, RecVarName + " " + std::to_string(i)), .5);
  }

  // Estimate 1 mean recruitment-distribution per year
  std::string RdistVarName="Mean Rec dist";
  for(unsigned int i = 1; i <= counter / NIPY; ++i){
    //upar.Add(RdistVarName + " " + std::to_string(i), 0.8, 0.5); // Starting at 0.8 for the tiger prawn Moreton Bay model
    upar.Add(RdistVarName + " " + std::to_string(i), GetParameterValueAccordingToShortName(ModelInputParameters, RdistVarName + " " + std::to_string(i)), .5); // Starting at 0.8 for the tiger prawn Moreton Bay model
  }

  // Assert parameters domain
  //upar.SetLimits("Natural mortality", 0.02, 0.07);
  upar.SetLimits("Natural mortality", GetParameterLowerLimitAccordingToShortName(ModelInputParameters, "Natural mortality"), 
GetParameterUpperLimitAccordingToShortName(ModelInputParameters, "Natural mortality"));
  //upar.SetLimits("Targeted q", 0, 1e2);
  upar.SetLimits("Targeted q", GetParameterLowerLimitAccordingToShortName(ModelInputParameters, "Targeted q"),
GetParameterUpperLimitAccordingToShortName(ModelInputParameters, "Targeted q"));
  //upar.SetLimits("Nontargeted q", 0, 1e2);
  upar.SetLimits("Nontargeted q", GetParameterLowerLimitAccordingToShortName(ModelInputParameters, "Nontargeted q"),
 GetParameterUpperLimitAccordingToShortName(ModelInputParameters, "Nontargeted q"));
  //upar.SetLimits("sigma", 0, 1e2);
  upar.SetLimits("sigma", GetParameterLowerLimitAccordingToShortName(ModelInputParameters, "sigma"),
GetParameterUpperLimitAccordingToShortName(ModelInputParameters, "sigma"));
  //upar.SetLimits("Biomass1", 0, 1e3);
  upar.SetLimits("Biomass1", GetParameterLowerLimitAccordingToShortName(ModelInputParameters, "Biomass1"), 
GetParameterUpperLimitAccordingToShortName(ModelInputParameters, "Biomass1"));
  //upar.SetLimits("Biomass2", 0, 1e3);
  upar.SetLimits("Biomass2", GetParameterLowerLimitAccordingToShortName(ModelInputParameters, "Biomass2"), 
GetParameterUpperLimitAccordingToShortName(ModelInputParameters, "Biomass2"));
  //upar.SetLimits("vm_mean", -10, 10);
  //upar.SetLimits("vm_sigma", 1e-3, 80);
  upar.SetLimits("vm_sigma", GetParameterLowerLimitAccordingToShortName(ModelInputParameters, "vm_sigma"), 
GetParameterUpperLimitAccordingToShortName(ModelInputParameters, "vm_sigma"));

  for(unsigned int i = 1; i <= counter/NIPY; ++i){
    //upar.SetLimits(RecVarName + " " + std::to_string(i), 1e-2, 1e2);
        upar.SetLimits(RecVarName + " " + std::to_string(i), 
		   GetParameterLowerLimitAccordingToShortName(ModelInputParameters, RecVarName + " " + std::to_string(i)),
		   GetParameterUpperLimitAccordingToShortName(ModelInputParameters, RecVarName + " " + std::to_string(i)));	
  }

  for(unsigned int i = 1; i <= counter/NIPY; ++i){
    //upar.SetLimits(RdistVarName + " " + std::to_string(i), -10, 10);
        upar.SetLimits(RdistVarName + " " + std::to_string(i), 
		   GetParameterLowerLimitAccordingToShortName(ModelInputParameters, RdistVarName + " " + std::to_string(i)),
		   GetParameterUpperLimitAccordingToShortName(ModelInputParameters, RdistVarName + " " + std::to_string(i)));	
  }

  cout << "The number of variable is " << upar.Params().size() << "\n";

  // create MIGRAD minimizer with MnStrategy 0 (strategy to calculate first and second derivative with fewer function calls -- less precise result)
  MnMigrad migrad(fFCN, upar, 0);

  // Fix a parameter
  migrad.Fix("Natural mortality");
  migrad.Fix("Targeted q");
  migrad.Fix("Nontargeted q");
  migrad.Fix("sigma");

    for(unsigned int i = 1; i <= counter / NIPY; ++i){
      migrad.Fix((RdistVarName + " " + std::to_string(i)).c_str());
  }

  // Minimize
  FunctionMinimum min = migrad();

  // output
  std::cout<<"minimum: "<< min << std::endl;

  migrad.Release("Natural mortality");
  migrad.Release("Targeted q");
  migrad.Release("Nontargeted q");
  migrad.Release("sigma");
 
     for(unsigned int i = 1; i <= counter / NIPY; ++i){
       migrad.Release((RdistVarName + " " + std::to_string(i)).c_str());
  }

  FunctionMinimum min2 = migrad();
  std::cout<<"minimum2: "<< min2 << std::endl;

  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////  // output results to file
  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  std::vector<Parameter> ModelOutputParameters=ModelInputParameters;

  ofstream FitFile;
  FitFile.open ("Results/FitOutcome.txt");
  FitFile << "# Minimum negative log likelihood\n" << min2 << "\n";
  FitFile.close();

  ofstream FitParamFile;
  FitParamFile.open ("Results/ParameterEstimates.txt");
  for(unsigned int i = 0; i < upar.Params().size(); ++i){

    SetParameterValueAccordingToShortName(ModelOutputParameters, upar.Name(i), min2.UserState().Value(i));
    SetParameterUncertaintyAccordingToShortName(ModelOutputParameters, upar.Name(i),min2.UserState().Error(i));

    FitParamFile << upar.Name(i) << "," << min2.UserState().Value(i) << "," << min2.UserState().Error(i) << "\n";
  }
  FitParamFile.close();

  // Write parameters to csv file
  WriteParameterToCSV("Results/DelayDifferenceModelParameters.csv", ModelOutputParameters);

  // Output estimates of fisheries quantities: fishing mortality, catch and biomass 

  ofstream EFQ;
  EFQ.open ("Results/EstimatedFisheriesQuantities.txt");
  EFQ << "timestep,YearType,Year,Week,EstimatedFishingMort,EstimatedBiomass,EstimatedCatches\n";    
  
  std::vector<double> EstimatedCatches(counter, 0.0), EstimatedBiomass(counter, 0.0), EstimatedFishingMort(counter, 0.0);
  std::vector<double> Residuals(counter, 0.0);

  // Get parameter estimates into a vector
  std::vector<double> EstimatedPar;
  for(unsigned int i = 0; i < upar.Params().size(); i++) EstimatedPar.push_back(min2.UserState().Value(i));

  // Calculate estimated catch
  WeeklyDD(Targeted_Effort, Nontargeted_Effort, EstimatedBiomass, EstimatedPar);

  for(unsigned int iii=0; iii < counter; iii++)
    {
      EstimatedFishingMort.at(iii) = min2.UserState().Value("Targeted q") * CatchabilityScalingFactor * Targeted_Effort[iii] + min2.UserState().Value("Nontargeted q") * CatchabilityScalingFactor * Nontargeted_Effort[iii];

      EstimatedCatches.at(iii) = EstimatedFishingMort[iii] / (min2.UserState().Value("Natural mortality") + EstimatedFishingMort[iii]) * EstimatedBiomass[iii] * \
	(1 - exp( -(min2.UserState().Value("Natural mortality") + EstimatedFishingMort[iii] ) ));

      Residuals.at(iii) = (sqrt(EstimatedCatches[iii]) - sqrt(FishCatch[iii])) / min2.UserState().Value("sigma");

      EFQ << timestep[iii] << "," << YearType[iii] << "," << Year[iii] << "," << Week[iii] << "," << EstimatedFishingMort[iii] << "," << EstimatedBiomass[iii] << "," << EstimatedCatches[iii] << "\n";  
    }
  EFQ.close();

  return 0;
}
Example #2
0
  double Basic_MCT2_332_Calculator::mct2_332_Sq(const LorentzTransverseVector& visA,
					       const LorentzTransverseVector& visB,
					       const TwoVector& ptmiss,
					       const double mEachInvisible){


    mCT2Fcn theFCN(ptmiss.px(),
	 	   ptmiss.py(),
		   mEachInvisible,
		   visA.px(),
		   visA.py(),
		   visA.mass(),
		   visB.px(),
		   visB.py(),
		   visB.mass());

    const double massScale = (
			      ptmiss.pt() +
			      mEachInvisible +
			      visA.pt()  +
			      visA.mass() +
			      visB.pt() +
			      visB.mass()
			      )/6.0;
    // DANG! Try to get rid of Minuit output:
    //std::ofstream    DANG_log("/dev/null");
    //std::streambuf * DANG_save = std::cerr.rdbuf();
    //if (DANG_log.is_open()) {
    //  std::cerr.rdbuf(DANG_log.rdbuf());
    // }

    double guessx = 0.5*(ptmiss.px());
    double guessy = 0.5*(ptmiss.py());
    
    MnUserParameters upar;
    upar.Add("etx", guessx, 0.02*massScale); 
    upar.Add("ety", guessy, 0.02*massScale);
    const int highQuality=2;    

    // Usually migrad produces the best minumum.
    // But when the minimum is in a fold, migrad can fail badly.
    // On the fold, simplex does well.  We therefore do both separately
    // and record the answer of the one that did best.
    
    // Further to the above notes, it now seems that by choosing the massScale sensibly, and by making the "tolerance" (the second argument to the call that extracts the FunctionMinimum below) much smaller, the simplex algorithm seems to work so well that we don't need the migrad algorithm.  This is good news, as the migrad algorithm produces lots of error output that we can't get rid of.

    MnSimplex simplex(theFCN, upar, highQuality);
    FunctionMinimum minS = simplex(0,massScale*0.000001);
    //const double etxAtMin = minS.UserState().Value("etx");
    //const double etyAtMin = minS.UserState().Value("ety");
    //MnMigrad migrad(theFCN, upar, highQuality);
    //FunctionMinimum minM = migrad(0,massScale*0.000001);
    //const double best = fmin(minS.Fval(), minM.Fval());
    const double best = minS.Fval();

    // DANG! Undoing our attempt to get rid of Minuit output:
    //if (DANG_log.is_open()) {
    //  std::cerr.rdbuf(DANG_save);
    //}

    return best;    
  }
Example #3
0
int main ( int argc, char **argv ) {
	
	std::cout << "=== Program: " << argv[0] << std::endl;
	std::cout << "=== Version 1.0, (c) 2016 Erik Bartoš" << std::endl;

	/// Start
	
	TApplication theApp("Eta", &argc, argv);

	/// Fit
	std::cout << "\n> Eta fit:" << std::endl;
	std::cout << "> Input data:        `" << dataFile1 << "'" << std::endl;
	std::cout << "> Start parameters:  `" << parametersFile1 << "'" << std::endl;
	std::cout << "> Output parameters: `" << outputFile << "'" << std::endl;

	const int nPoints = 10000;
	double tMin;
	double tMax;
	double tStep;
	double tA;

	ExperimentalData Z;
	Z.ReadData(dataFile1);
	int nData = Z.size();
	std::cout << "\nNumber of fitted points:      " << nData << std::endl;
	std::vector<int> series = Z.Series();
	std::vector<std::string> names = Z.Name();
	std::vector<int> type = Z.Type();
	std::vector<double> x = Z.X();
	std::vector<double> val = Z.Val();
	std::vector<double> errUp = Z.ErrUp();
	std::vector<double> errDown = Z.ErrDown();
	std::vector<double> theta = Z.Theta();
	std::vector<double> energy = Z.Energy();

	int tParticle = 1;
	FFactorT trans(tParticle);
	int nPar = trans.numberOfParameters;
	trans.LoadParameters(parametersFile1);
	trans.PrintParameters();

	/// Create FCN function
	TransitionFcn fFCN(tParticle, Z.Type(), Z.X(), Z.Val(), Z.ErrUp(), Z.ErrDown(), Z.Theta(), Z.Energy());

	/// Minuit
	double step = 0.01;
	MnUserParameters upar;
	for (int i = 0; i < nPar; ++i) {
		upar.Add(trans.v[i].name, trans.v[i].val, step, trans.v[i].down, trans.v[i].up);
	}

	MnStrategy(2);
	/// Create minimizer
	MnMigrad migrad(fFCN, upar);
	MnMinimize minimize(fFCN, upar);
	MnSimplex simplex(fFCN, upar);
			
	//migrad.Fix(0.);
	//migrad.Fix(1.);
	//migrad.Fix(2.);
	//migrad.Fix(3.);
	//migrad.Fix(4.);
	//migrad.Fix(5.);

	/// Fitting
	TStopwatch timer;
	timer.Start();

	std::cout << "\n> Minimalization:" << std::endl;

	// operator(maxfcn,tolerance):
	// maxfcn: maximum function calls
	// migrad EDM: 0.001*tolerance*up
	// simplex:    tolerance*up
	
	std::cout << "> 1. minimalization..." << std::endl;	
	//FunctionMinimum min = migrad(100000,100.);

	//minimize.Fix(0.);
	//minimize.Fix(1.);
	//minimize.Fix(2.);
	//minimize.Fix(3.);
	//std::cout << "> ... 2. minimalization..." << std::endl;
	//FunctionMinimum min2 = migrad(10000,1.);

	std::cout << "> ... in progress..." << std::endl;
	//FunctionMinimum min9 = migrad(1000000,50.);
	FunctionMinimum min9 = minimize(1000000,50.);
	//FunctionMinimum min9 = simplex(1000000,1.);

	timer.Stop();

	/// Standard output
	std::cout << "> Minimum: " << min9 << std::endl;
	std::cout << "> FCN value:     " << min9.Fval() << std::endl;
	std::cout << "> FCN value/ndf: " << min9.Fval()/(nData-nPar) << std::endl;
	std::cout << "> Points       : " << nData << std::endl;

	std::cout << min9.UserState() << std::endl;
	std::cout << min9.UserCovariance() << std::endl;

	std::cout << "> Real time of minimalization: " << timer.RealTime() << " sec." << std::endl;

	//~ // Scan and Plot parameters
 	//~ {
    //~ MnScan scan(fFCN, upar, 1);
    //~ std::cout << "Scan parameters: " << scan.Parameters() << std::endl;
    //~ MnPlot plot;
    //~ for (unsigned int i = 0; i < upar.VariableParameters(); ++i) {
		//~ std::vector<std::pair<double, double> > xy = scan.Scan(i);
		//~ //std::vector<std::pair<double, double> > xy = scan.scan(0);
		//~ std::cout << i+1 << ". parameter - `" << upar.Name(i) << "'"<< std::endl;
		//~ plot(xy);
	//~ }
    //~ std::cout << scan.Parameters() << std::endl;
	//~ }

	/// Output parameters
	std::ofstream os;
	os.open(outputFile);
	os.precision(8);
	for (int i = 0; i < nPar; ++i) {
		os << i+1 << ", " << min9.UserParameters().Name(i) << ", ";
		os.width(12);
		os << min9.UserParameters().Value(i) << ", ";
		os.width(12);
		os << min9.UserParameters().Error(i) << ", ";
		os << trans.v[i].down << ", " << trans.v[i].up << std::endl;
	}
	os.close();

	/// End output

	theApp.Run();
	//theApp.Terminate(0);
	
	return EXIT_SUCCESS;
}