#  Main body of the filtrane installation makefile

#  N. Gould, D. Orban and Ph. L. Toint.
#  This version: 22 VII 2005

SHELL = /bin/$(BINSHELL)

#  compiler flags

FFLAGS    = $(BASIC) $(OPTIMIZATION) $(DEBUG) $(MODULES) $(F90) $(USUAL)
FFLAGSS   = $(BASIC) $(OPTIMIZATION) $(DEBUG) $(MODULES) $(F90) $(SPECIAL)
FFLAGSN   = $(BASIC) $(NOOPTIMIZATION) $(DEBUG) $(MODULES) $(F90)
FFLAGS77  = $(BASIC) $(OPTIMIZATION) $(DEBUG) $(MODULES) $(F77) $(USUAL)
FFLAGS77S = $(BASIC) $(OPTIMIZATION) $(DEBUG) $(MODULES) $(F77) $(SPECIAL)
RUNFFLAGS =          $(OPTIMIZATION) $(DEBUG) $(MODULES)

#  names of random libraries

LG  = $(OBJ)/libgalahad.a
LGS = $(OBJS)/libgalahad.a
LGD = $(OBJD)/libgalahad.a

BLG  = $(OBJ)/libgalahad_blas.a
BLGS = $(OBJS)/libgalahad_blas.a
BLGD = $(OBJD)/libgalahad_blas.a

LLG  = $(OBJ)/libgalahad_lapack.a
LLGS = $(OBJS)/libgalahad_lapack.a
LLGD = $(OBJD)/libgalahad_lapack.a

HLG  = $(OBJ)/libgalahad_hsl.a
HLGS = $(OBJS)/libgalahad_hsl.a
HLGD = $(OBJD)/libgalahad_hsl.a

PLG  = $(OBJ)/libgalahad_problem.a
PLGS = $(OBJS)/libgalahad_problem.a
PLGD = $(OBJD)/libgalahad_problem.a

#  Libraries used

LIBS = -lgalahad -lgalahad_hsl -lgalahad_metis -lgalahad_lapack -lgalahad_blas

#  Archive manipulation strings

ARR =  $(AR) $(ARREPFLAGS) $(LG)
RMARFILE = $(GALAHAD)/bin/rmarfile $(AR) $(GREP) $(LG)
RMOBFILE = $(GALAHAD)/bin/rmobfile $(RM) $(OBJ)

BARR =  $(AR) $(ARREPFLAGS) $(BLG)
BRMARFILE = $(GALAHAD)/bin/rmarfile $(AR) $(GREP) $(BLG)

LARR =  $(AR) $(ARREPFLAGS) $(LLG)
LRMARFILE = $(GALAHAD)/bin/rmarfile $(AR) $(GREP) $(LLG)

HARR =  $(AR) $(ARREPFLAGS) $(HLG)
HRMARFILE = $(GALAHAD)/bin/rmarfile $(AR) $(GREP) $(HLG)

PARR =  $(AR) $(ARREPFLAGS) $(PLG)
PRMARFILE = $(GALAHAD)/bin/rmarfile $(AR) $(GREP) $(PLG)

#  sed scripts

LSEDS = $(GALAHAD)/seds/$(LINEARSOLVER).sed

#  compilation agenda

SNLPT     = $(LGS)(nlpt.o)
DNLPT     = $(LGD)(nlpt.o)
SFILTRANE = gltr $(SNLPT) copyright $(LGS)(filtrane.o)
DFILTRANE = gltr $(DNLPT) copyright $(LGD)(filtrane.o)

SUSEFILTRANE = $(LGS)(usefiltrane.o)
DUSEFILTRANE = $(LGD)(usefiltrane.o)
SGALAHADMAIN = $(SUSEFILTRANE) $(OBJS)/runfiltrane_sif.o
DGALAHADMAIN = $(DUSEFILTRANE) $(OBJD)/runfiltrane_sif.o

OBJECTSS = basics linearsolver $(SFILTRANE)
OBJECTSD = basics linearsolver $(DFILTRANE)
USEOBJECTSS = $(OBJECTSS) $(SUSEFILTRANE)
USEOBJECTSD = $(OBJECTSD) $(DUSEFILTRANE)
OBJECTSS_CUTEST = $(OBJECTSS) $(SGALAHADMAIN)
OBJECTSD_CUTEST = $(OBJECTSD) $(DGALAHADMAIN)

FILTRANEDS = basics linearsolver $(DFILTRANE) $(OBJD)/filtranes.o
FILTRANEDT = basics linearsolver $(DFILTRANE) $(OBJD)/filtranet.o
FILTRANESS = basics linearsolver $(DFILTRANE) $(OBJS)/filtranes.o
FILTRANEST = basics linearsolver $(DFILTRANE) $(OBJS)/filtranet.o

RFILTRANEDS = $(OBJD)/filtranes.o -L$(OBJD) $(LIBS)
RFILTRANEDT = $(OBJD)/filtranet.o -L$(OBJD) $(LIBS)
RFILTRANESS = $(OBJS)/filtranes.o -L$(OBJS) $(LIBS)
RFILTRANEST = $(OBJS)/filtranet.o -L$(OBJS) $(LIBS)

NLPTDS = basics linearsolver $(DNLPT) $(OBJD)/nlpts.o
NLPTDT = basics linearsolver $(DNLPT) $(OBJD)/nlptt.o
NLPTSS = basics linearsolver $(SNLPT) $(OBJS)/nlpts.o
NLPTST = basics linearsolver $(SNLPT) $(OBJS)/nlptt.o

RNLPTDS = $(OBJD)/nlpts.o -L$(OBJD) $(LIBS)
RNLPTDT = $(OBJD)/nlptt.o -L$(OBJD) $(LIBS)
RNLPTSS = $(OBJS)/nlpts.o -L$(OBJS) $(LIBS)
RNLPTST = $(OBJS)/nlptt.o -L$(OBJS) $(LIBS)

SUCC = precision version) compiled successfully
SUCC_CUTEST = precision version) for CUTEst compiled successfully

#  main compilations and runs

all: filtrane_cutest
test: test_filtrane
test_nocutest: test_filtrane_nocutest
test_spec: test_spec_filtrane

#  all filtrane routines

filtrane_cutest: filtrane_cutest_$(PRECIS)
	@printf ' %-21s\n' "GALAHAD: FILTRANE ($(PRECIS) $(SUCC_CUTEST)"
filtrane_cutest_single: $(OBJECTSS_CUTEST)
	$(RANLIB) $(LGS)
filtrane_cutest_double: $(OBJECTSD_CUTEST)
	$(RANLIB) $(LGD)

filtrane_silent: filtrane_silent_$(PRECIS)
filtrane_silent_single: $(OBJECTSS)
filtrane_silent_double: $(OBJECTSD)

filtrane: filtrane_$(PRECIS)
	@printf ' %-21s\n' "GALAHAD: FILTRANE ($(PRECIS) $(SUCC)"
filtrane_single: $(OBJECTSS)
	$(RANLIB) $(LGS)
filtrane_double: $(OBJECTSD)
	$(RANLIB) $(LGD)

use_filtrane_silent: use_filtrane_$(PRECIS)
use_filtrane: use_filtrane_$(PRECIS)
	@printf ' %-21s\n' "GALAHAD: FILTRANE ($(PRECIS) $(SUCC)"
use_filtrane_single: $(USEOBJECTSS)
	$(RANLIB) $(LGS)
use_filtrane_double: $(USEOBJECTSD)
	$(RANLIB) $(LGD)

filtranes: filtrane_cutest_single
filtraned: filtrane_cutest_double
filtranerunall: filtraneds filtranedt filtraness filtranest

nlptrunall: nlptds nlptdt nlptss nlptst

nlpt_silent: nlpt_silent_$(PRECIS)
nlpt_silent_single: basics $(SNLPT)
nlpt_silent_double: basics $(DNLPT)

nlpt: nlpt_$(PRECIS)
	@printf ' %-21s\n' "GALAHAD: NLPT ($(PRECIS) $(SUCC)"
nlpt_single: basics $(SNLPT)
	$(RANLIB) $(LGS)
nlpt_double: basics $(DNLPT)
	$(RANLIB) $(LGD)

test_filtrane: test_filtrane_$(PRECIS)

test_filtrane_single: filtranest $(USEOBJECTSS) $(OBJS)/runfiltrane_sif.o
	echo ""
	echo " Testing CUTEst interface to FILTRANE"
	cd $(GALAHAD)/examples ; sdgal $(VERSION) filt -s CLUSTER
	echo ""
	echo " Tests for FILTRANE complete"

test_filtrane_double: filtranedt $(USEOBJECTSD) $(OBJD)/runfiltrane_sif.o
	echo ""
	echo " Testing CUTEst interface to filtrane"
	cd $(GALAHAD)/examples ; sdgal $(VERSION) filt CLUSTER
	echo ""
	echo " Tests for FILTRANE complete"

test_filtrane_nocutest: test_filtrane_nocutest_$(PRECIS)

test_filtrane_nocutest_single: filtranest
	echo ""
	echo " Tests for FILTRANE complete"

test_filtrane_nocutest_double: filtranedt
	echo ""
	echo " Tests for FILTRANE complete"

test_spec_filtrane: test_spec_filtrane_$(PRECIS)

test_spec_filtrane_single: filtraness
	echo ""
	echo " Tests for FILTRANE complete"

test_spec_filtrane_double: filtraneds
	echo ""
	echo " Tests for FILTRANE complete"

#  basic packages

basics:
	( cd ../general ; $(MAKE) -f $(GALAHAD)/makefiles/$(VERSION) \
            basics_silent PRECIS=$(PRECIS) PWD=$(PWD)/../general )
	( cd ../lanb ; $(MAKE) -f $(GALAHAD)/makefiles/$(VERSION) \
            bndsl.o PRECIS=$(PRECIS) PWD=$(PWD)/../lanb )
linearsolver:
	( cd ../general ; $(MAKE) -f $(GALAHAD)/makefiles/$(VERSION) \
            linearsolver_silent PRECIS=$(PRECIS) PWD=$(PWD)/../general )
gltr:
	( cd ../rq ; $(MAKE) -f $(GALAHAD)/makefiles/$(VERSION) \
            gltr.o PRECIS=$(PRECIS) PWD=$(PWD)/../rq )
copyright:
	( cd ../general ; $(MAKE) -f $(GALAHAD)/makefiles/$(VERSION) \
            copyright.o PRECIS=$(PRECIS) PWD=$(PWD)/../general )

# profiling runs (system dependent)

filtranepixie: $(FILTRANEDT)
	$(FORTRAN) $(RUNFFLAGS) -o run_filtrane $(RFILTRANEDT)
	pixie ./run_filtrane
	./run_filtrane.pixie
	prof -pixie -lines ./run_filtrane >& out
	rm ./run_filtrane

filtranencov: $(FILTRANEDT)
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_filtrane $(RFILTRANEDT)
	ncov -o out ./run_filtrane
	rm ./run_filtrane

# run spec-sheet example tests

filtraneds: $(FILTRANEDS)
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_filtrane $(RFILTRANEDS)
	- ./run_filtrane >& filtraneds.output
	cat filtraneds.output
	rm ./run_filtrane

filtranedt: $(FILTRANEDT)
	echo " Exhaustive test of subroutine interface to filtrane"
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_filtrane $(RFILTRANEDT)
	- ./run_filtrane >& filtranedt.output
	cat filtranedt.output
	rm -f ./FILTRANE.sav

filtraness: $(FILTRANESS)
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_filtrane $(RFILTRANESS)
	- ./run_filtrane >& filtranes.output
	cat filtranes.output
	rm ./run_filtrane

filtranest: $(FILTRANEST)
	echo " Exhaustive test of subroutine interface to filtrane"
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_filtrane $(RFILTRANEST)
	- ./run_filtrane >& filtranet.output
	cat filtranet.output
	rm ./run_filtrane
	if (-e ./FILTRANE.sav ) rm ./FILTRANE.sav

nlptds: $(NLPTDS)
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_nlpt $(RNLPTDS)
	- ./run_nlpt >& nlptds.output
	cat nlptds.output
	rm ./run_nlpt

nlptdt: $(NLPTDT)
	echo " Exhaustive test of subroutine interface to nlpt"
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_nlpt $(RNLPTDT)
	- ./run_nlpt >& nlptdt.output
	cat nlptdt.output
	rm ./run_nlpt

nlptss: $(NLPTSS)
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_nlpt $(RNLPTSS)
	- ./run_nlpt >& nlpts.output
	cat nlpts.output
	rm ./run_nlpt

nlptst: $(NLPTST)
	echo " Exhaustive test of subroutine interface to nlpt"
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_nlpt $(RNLPTST)
	- ./run_nlpt >& nlptt.output
	cat nlptt.output
	rm ./run_nlpt

#  Substantial GALAHAD packages

nlpt.o: basics $(LG)(nlpt.o)

$(LG)(nlpt.o): ../nlpt/nlpt.f90
	@printf ' %-9s %-15s\t\t' "Compiling" "nlpt  "
	$(SED) -f $(SEDS) ../nlpt/nlpt.f90 > $(OBJ)/nlpt1.f90
	$(SED) -f $(LSEDS) $(OBJ)/nlpt1.f90 > $(OBJ)/nlpt.f90
	cd $(OBJ); $(FORTRAN) -o nlpt.o $(FFLAGSS) nlpt.f90 \
                || ( printf ' %-26s' "=> Disabling optimization " ; \
                   $(FORTRAN) -o nlpt.o $(FFLAGSN) nlpt.f90 )
	cd $(OBJ); $(ARR) nlpt.o ; $(RM) nlpt.f90 nlpt1.f90 nlpt.o
	$(RMARFILE) check.o
	$(RMARFILE) trimsqp.o
	$(RMARFILE) fastr.o
	$(RMARFILE) fisqp.o
	$(RMARFILE) filtrane.o
	$(PRMARFILE) cutest_functions.o
	$(MVMODS)
	@printf '[ OK ]\n'

filtrane.o: $(LG)(filtrane.o)

$(LG)(filtrane.o): ../filtrane/filtrane.f90
	@printf ' %-9s %-15s\t\t' "Compiling" "filtrane   "
	$(SED) -f $(SEDS) ../filtrane/filtrane.f90 > $(OBJ)/filtrane1.f90
	$(SED) -f $(LSEDS) $(OBJ)/filtrane1.f90 > $(OBJ)/filtrane.f90
	cd $(OBJ); $(FORTRAN) -o filtrane.o $(FFLAGSS) filtrane.f90 \
                || ( printf ' %-26s' "=> Disabling optimization " ; \
                   $(FORTRAN) -o filtrane.o $(FFLAGSN) filtrane.f90 )
	cd $(OBJ); $(ARR) filtrane.o ; $(RM) filtrane.f90 filtrane1.f90 filtrane.o
	$(RMARFILE) usefiltrane.o
	$(RMOBFILE) galahad_ampl.o
	$(RMOBFILE) filtranes.o
	$(RMOBFILE) filtranet.o
	$(MVMODS)
	@printf '[ OK ]\n'

# CUTEr/AMPL interfaces

usefiltrane.o: $(LG)(usefiltrane.o)

$(LG)(usefiltrane.o): ../filtrane/usefiltrane.f90
	@printf ' %-9s %-15s\t\t' "Compiling" "usefiltrane   "
	$(SED) -f $(SEDS) ../filtrane/usefiltrane.f90 > $(OBJ)/usefiltrane1.f90
	$(SED) -f $(LSEDS) $(OBJ)/usefiltrane1.f90 > $(OBJ)/usefiltrane.f90
	cd $(OBJ); $(FORTRAN) -o usefiltrane.o $(FFLAGSS) usefiltrane.f90 \
                || ( printf ' %-26s' "=> Disabling optimization " ; \
                   $(FORTRAN) -o usefiltrane.o $(FFLAGSN) usefiltrane.f90 )
	cd $(OBJ); $(ARR) usefiltrane.o ; \
                   $(RM) usefiltrane.f90 usefiltrane1.f90 usefiltrane.o
	$(RMOBFILE) runfiltrane_sif.o
	$(MVMODS)
	@printf '[ OK ]\n'

#  main programs

runfiltrane_sif.o: $(OBJ)/runfiltrane_sif.o

$(OBJ)/runfiltrane_sif.o: ../filtrane/runfiltrane_sif.f90
	@printf ' %-9s %-15s\t\t' "Compiling" "runfiltrane_sif"
	$(SED) -f $(SEDS) ../filtrane/runfiltrane_sif.f90 > $(OBJ)/runfiltrane_sif.f90
	cd $(OBJ); $(FORTRAN) -o runfiltrane_sif.o $(FFLAGSS) runfiltrane_sif.f90
	rm $(OBJ)/runfiltrane_sif.f90
	@printf '[ OK ]\n'

#  test decks

filtranes.o: $(OBJ)/filtranes.o

$(OBJ)/filtranes.o: ../filtrane/filtranes.f90
	@printf ' %-9s %-15s\t\t' "Compiling" "filtranes  "
	$(SED) -f $(SEDS) ../filtrane/filtranes.f90 > $(OBJ)/filtranes.f90
	cd $(OBJ) ; $(FORTRAN) -o filtranes.o $(FFLAGS) filtranes.f90
	rm $(OBJ)/*.f90
	@printf '[ OK ]\n'

filtranet.o: $(OBJ)/filtranet.o

$(OBJ)/filtranet.o: ../filtrane/filtranet.f90
	@printf ' %-9s %-15s\t\t' "Compiling" "filtranet  "
	$(SED) -f $(SEDS) ../filtrane/filtranet.f90 > $(OBJ)/filtranet.f90
	cd $(OBJ) ; $(FORTRAN) -o filtranet.o $(FFLAGSS) filtranet.f90
	rm $(OBJ)/*.f90
	@printf '[ OK ]\n'

nlpts.o: $(OBJ)/nlpts.o

$(OBJ)/nlpts.o: ../nlpt/nlpts.f90
	@printf ' %-9s %-15s\t\t' "Compiling" "nlpts  "
	$(SED) -f $(SEDS) ../nlpt/nlpts.f90 > $(OBJ)/nlpts.f90
	cd $(OBJ) ; $(FORTRAN) -o nlpts.o $(FFLAGS) nlpts.f90
	rm $(OBJ)/*.f90
	@printf '[ OK ]\n'

nlptt.o: $(OBJ)/nlptt.o

$(OBJ)/nlptt.o: ../nlpt/nlptt.f90
	@printf ' %-9s %-15s\t\t' "Compiling" "nlptt  "
	$(SED) -f $(SEDS) ../nlpt/nlptt.f90 > $(OBJ)/nlptt.f90
	cd $(OBJ) ; $(FORTRAN) -o nlptt.o $(FFLAGSS) nlptt.f90
	rm $(OBJ)/*.f90
	@printf '[ OK ]\n'

#  book keeping

clean:
	@printf ' %-9s\t\t' "Cleaning"
	$(RM) $(LGS) $(LGD) $(OBJ)/filtranedt.o $(OBJ)/filtranest.o
	@printf '[ OK ]\n'

cleanall:
	@printf ' %-14s\t\t' "Removing all $(PRECIS) precision object and module files"
	$(RM) $(OBJ)/* $(MOD)/*
	@printf '[ OK ]\n'

rmfiltrane:
	@printf ' %-9s %-15s\t\t' "Removing" "filtrane from archive "
	$(RMARFILE) filtrane.o
	@printf '[ OK ]\n'