import BoxTools.BoxLayout;
import BoxTools.LayoutIndex;
import BoxTools.DataIndex;
import BoxTools.Util;
import BoxTools.LayoutIterator;
import BoxTools.DataIterator;
import BoxTools.BoxLayoutData;
import BoxTools.BoxedArray;
import BoxTools.LayoutReader2;
import BoxTools.PAPIWrapper;
import AMRElliptic.LevelOp;
import AMRElliptic.PoissonOp;
import AMRElliptic.AMRSolver;

class AMRSolverTEST{
	static final int SPACE_DIM=Util.SPACE_DIM;
	final static double h=0.001953125;// for dataset 1
	//final static double h=0.0009765625;// for dataset 2
	//final static double h=0.00048828125; //for dataset 3
	final static double R=0.25;
	final static double a=2/(R*R*R);
	final static double b=3/(R*R);
	

	final inline static double rhsFunction(Point<SPACE_DIM> a_point, double a_dx){
		double r=0;
		for (int i=1;i<=SPACE_DIM;i++) r+=(a_point[i]+0.5)*(a_point[i]+0.5)*a_dx*a_dx;
		return (a*r*Math.sqrt(r)-b*r-1);
	} 
	public static single void main (String single [] single args){
		if (args.length==0){
		Util.printErrMsg("The name of the data file must be provided!");
	        System.exit(-1);
		}
		Util.printMsg("There are "+Ti.numProcs()+" processes.");
		Double.setPrecision(4);
                Ti.suspend_autogc();
		double single counterResult;
		PAPIWrapper ctrFPINS=null,ctrFMAINS=null;
		Timer tmr =new Timer();tmr.start();
		LayoutReader2 local LR=	new LayoutReader2(args[0]);
		Ti.barrier();		
		tmr.stop();counterResult=Reduce.max(tmr.secs());Util.printMsg("Time to read the data from file:"+counterResult);
		if ((LR.maxProcAssignment()+1)>Ti.numProcs()){
			Util.printErrMsg("The number of threads specified in the input file is larger than Ti.numProcs()!");
			System.exit(-1);
		}
		tmr.reset();tmr.start();
		int single levels=(int single)LR.getNumOfLevels();//levels--;
		template BoxLayoutData<template BoxedArray<double > > local single [] local phi=new 
							template BoxLayoutData<template BoxedArray<double > > local single [levels];
		template BoxLayoutData<template BoxedArray<double > > local single [] local rhs=new
							template BoxLayoutData<template BoxedArray<double > > local single [levels];
		
		PoissonOp  single local [] local lop=new 	PoissonOp  single local [levels];
		BoxLayout single local [] local BLs=new BoxLayout single local [levels] local;
		RectDomain<SPACE_DIM> single [] local Pdomains=new RectDomain<SPACE_DIM> single [levels] local;
		RectDomain<SPACE_DIM> single [] single local boxes;
		RectDomain<SPACE_DIM>  [] local tempBoxes;
		int single [] single local  procIDs;
		int [] local tempProcIDs;
		int single i,j,k;
		int [] local numOfPoints=new int [levels];
		
		for (i=0;i<levels;i++){
			tempBoxes=LR.getBoxes(i);
			tempProcIDs=LR.getProcAssignments(i);
			k=(int single)tempBoxes.length;
			boxes=new RectDomain<SPACE_DIM> single [k] single;
			procIDs=new int single [k] single;
			for (j=0;j<k;j++){
				boxes[j]=(RectDomain<SPACE_DIM> single)tempBoxes[j];
				numOfPoints[i]+=tempBoxes[j].size();
				procIDs[j]=(int single) tempProcIDs[j];
				//if (j>97) procIDs[j]=14;else procIDs[j]=j/7;
			}

			BLs[i]=new BoxLayout single (boxes,procIDs);
			phi[i]=new template BoxLayoutData<template BoxedArray<double> > single (BLs[i],1);
			rhs[i]=new template BoxLayoutData<template BoxedArray<double> > single (BLs[i],0);
			Pdomains[i]=(RectDomain<SPACE_DIM> single)LR.getPhyDomain(i);
			Util.printMsg("Total number of points at level "+i+" is "+numOfPoints[i]);
		}
		
		for (i=0;i<levels;i++) {phi[i]<<=1; 
			//phi[i].exchange();
			rhs[i]<<=0;
		}

		for (i=0;i<levels;i++) Util.printMsg(Pdomains[i].toString()+" # of boxes is "+BLs[i].size());
		
		lop[0]=new PoissonOp(BLs[0], BLs[0], 16*h, 1, true, Pdomains[0], Pdomains[0], 4,4);
		//Util.printMsg("finishing building levelOp at 0 level");
		lop[1]=new PoissonOp(BLs[1], BLs[0], 4*h, 4, true, Pdomains[1], Pdomains[0], 4,4);
		//Util.printMsg("finishing building levelOp at 1 level");
		lop[2]=new PoissonOp(BLs[2], BLs[1], 1*h, 4, true, Pdomains[2], Pdomains[1], 4,4);
		//Util.printMsg("finishing building levelOp at 2 level");				
		for (i=0;i<levels;i++) lop[i].applyPhyBC(phi[i]);
		
		Util.printMsg("build AMRSolver");
		AMRSolver local single mySolver=new AMRSolver(lop);
		if (args.length==2) {
                  int newval = 0;
		  try{
			Double db=new Double(args[1]);
                        newval = (int)db.doubleValue();
		  }
		  catch(Exception e){}
		  mySolver.numAMRVCycle=(int single)newval;
                }
		
		tmr.stop();counterResult=Reduce.max(tmr.secs());Util.printMsg("Time for initialization:"+counterResult);
                Ti.barrier();
                Util.printMsg("Resuming GC...");
                Ti.resume_autogc();
                System.gc();
                Ti.barrier();

                ctrFPINS=new PAPIWrapper(PAPICounter.PAPI_FP_INS);
                ctrFPINS.start();
                ctrFMAINS=new PAPIWrapper(PAPICounter.PAPI_FMA_INS);
                ctrFMAINS.start();

		tmr.reset();tmr.start();	
		mySolver.solveAMR(phi,rhs,0.0000000001);
		//lop[2].CFInterp(phi[2]);
		tmr.stop();

	
		//ctrFPINS.stop();ctrFMAINS.stop();
		double ctrResult = 0;
                 if (ctrFPINS != null) {
                   ctrFPINS.stop();
                   ctrResult=ctrFPINS.getCounterValue();
                 }
		counterResult=Reduce.add(ctrResult);
		Util.printMsg("Flops to solve the system: FPINS="+counterResult);
		ctrResult = 0;
                 if (ctrFMAINS != null) {
                   ctrFMAINS.stop();
                   ctrResult=ctrFMAINS.getCounterValue();
                 }
		counterResult=Reduce.add(ctrResult);
		Util.printMsg("Flops to solve the system: FMAINS="+counterResult);
		//counterResult=Reduce.add(lop[levels-1].flopsSmooth);
		//Util.printMsg("Flops to smooth:"+counterResult/1000000);
		counterResult=Reduce.max(tmr.secs());
		Util.printMsg("Time to solve the system:"+counterResult);
		
		Double.setPrecision(0);		
		
	}
}