############            Makefile.in            ############
include ../../Makefile.in

############            files            ############
########        list of source files        ########
LEVMAR_FUNC_SRC=LevmarFunc.cc
METHOD_BASE_SRC=Method.cc MultiDataMethod.cc
#METHODS_SRC=Levmar.cc BSpline.cc MovingAverage.cc
METHODS_SRC=BSpline.cc MovingAverage.cc
NEW_LEVMAR_SRC=MultiDataLevmar.cc NewLevmar.cc LevmarConsts.cc \
               LevmarImmutables.cc LevmarControl.cc LevmarArgs.cc LevmarFit.cc \
               AdditionalData.cc FitCommand.cc ConvergenceStat.cc ReportConvergenceProcess.cc
METHOD_FACTORY_SRC=MultiDataMethodFactory.cc MethodFactory.cc MethodType.cc


########        list of header files        ########
LEVMAR_FUNC_HDS=${LEVMAR_FUNC_SRC:.cc=.hh}
METHOD_BASE_HDS=${METHOD_BASE_SRC:.cc=.hh}
METHODS_HDS=${METHODS_SRC:.cc=.hh}
NEW_LEVMAR_HDS=${NEW_LEVMAR_SRC:.cc=hh}
METHOD_FACTORY_HDS=${METHOD_FACTORY_SRC:.cc=.hh}

########        list of object files        ########
LEVMAR_FUNC_OBJ=${LEVMAR_FUNC_SRC:.cc=.o}
METHOD_BASE_OBJ=${METHOD_BASE_SRC:.cc=.o}
METHODS_OBJ=${METHODS_SRC:.cc=.o}
NEW_LEVMAR_OBJ=${NEW_LEVMAR_SRC:.cc=.o}
METHOD_FACTORY_OBJ=${METHOD_FACTORY_SRC:.cc=.o}

LIB_OBJ=${METHOD_FACTORY_OBJ} ${METHODS_OBJ} ${NEW_LEVMAR_OBJ} ${METHOD_BASE_OBJ} ${LEVMAR_FUNC_OBJ}

########        library        ########
####    stem && library file    ####
STEM=Method
SHARED_LIB=lib${STEM}.so
STATIC_LIB=lib${STEM}.a

############            compileer options            ############
LDFLAGS += -L${LOCAL_LIB_DIR}
METHOD_LIB=-l${STEM}
DATA_CONTAINER_LIB=-lDataContainer
BUILD_IN_FUNC_LIB=-lBuildInFunc
HELPERS_LIB=-lHelpers

############            targets            ############
lib : ${LOCAL_LIB_DIR}/${SHARED_LIB} ${LOCAL_LIB_DIR}/${STATIC_LIB}

########        c++ library        ########
${LOCAL_LIB_DIR}/${SHARED_LIB} : ${SHARED_LIB}
	${MV} $^ ${LOCAL_LIB_DIR}

${LOCAL_LIB_DIR}/${STATIC_LIB} : ${STATIC_LIB}
	${MV} $^ ${LOCAL_LIB_DIR}

${SHARED_LIB} : ${LIB_OBJ}
	${CXX} -shared -o $@ $^ ${LIB_DIR} ${LEVMAR_LIB}

${STATIC_LIB} : ${LIB_OBJ}
	${AR} ${AR_FLAGS} $@ $^
	${RANLIB} ${RANLIB_FLAGS} $@

########        object files       ########
#----    Base classes    ----
Method.o : Method.cc
	${CXX} ${CXXFLAGS} -o $@ -c $^

MultiDataMethod.o : MultiDataMethod.cc
	${CXX} ${CXXFLAGS} -o $@ -c $^

#----    single data methods    ----
MovingAverage.o : MovingAverage.cc
	${CXX} ${CXXFLAGS} -o $@ -c $^

BSpline.o : BSpline.cc
	${CXX} ${CXXFLAGS} -o $@ -c $^

LevmarFunc.o : LevmarFunc.cc
	${CXX} ${CXXFLAGS} -o $@ -c $^

Levmar.o : Levmar.cc
	${CXX} ${CXXFLAGS} -o $@ -c $^

#----    Levmar wrapper for common (single and muiple data series)
LevmarConsts.o : LevmarConsts.cc
	${CXX} ${CXXFLAGS} -o $@ -c $^

LevmarImmutables.o : LevmarImmutables.cc
	${CXX} ${CXXFLAGS} -o $@ -c $^

LevmarControl.o : LevmarControl.cc
	${CXX} ${CXXFLAGS} -o $@ -c $^

LevmarArgs.o :LevmarArgs.cc
	${CXX} ${CXXFLAGS} -o $@ -c $^

LevmarFit.o : LevmarFit.cc
	${CXX} ${CXXFLAGS} -o $@ -c $^

AdditionalData.o : AdditionalData.cc
	${CXX} ${CXXFLAGS} -o $@ -c $^

ConvergenceStat.o : ConvergenceStat.cc
	${CXX} ${CXXFLAGS} -o $@ -c $^

ReportConvergenceProcess.o : ReportConvergenceProcess.cc
	${CXX} ${CXXFLAGS} -o $@ -c $^

FitCommand.o : FitCommand.cc
	${CXX} ${CXXFLAGS} -o $@ -c $^

#----    Levmar wrapper for single data series    ----
NewLevmar.o : NewLevmar.cc
	${CXX} ${CXXFLAGS} -o $@ -c $^

#----    Levmar wrapper for multiple data series    ----
MultiDataLevmar.o : MultiDataLevmar.cc
	${CXX} ${CXXFLAGS} -o $@ -c $^

#----    Method Factory    ----
MethodType.o : MethodType.cc
	${CXX} ${CXXFLAGS} -o $@ -c $^

MethodFactory.o : MethodFactory.cc
	${CXX} ${CXXFLAGS} -o $@ -c $^

MultiDataMethodFactory.o : MultiDataMethodFactory.cc
	${CXX} ${CXXFLAGS} -o $@ -c $^

############            cleaning            ############
clean:
	${RM} ${RM_FLAGS} *.o
	${RM} ${RM_FLAGS} ${SHARED_LIB} ${STATIC_LIB}
	${RM} ${RM_FLAGS} ${TEST_EXEC_LIST}
	${RM} ${RM_FLAGS} ${TEST_SHARED_LIB}
	${RM} ${RM_FLAGS} ${TEST_PYTHON_MOD}
	${RM} ${RM_FLAGS} ${TEST_PYTHON_CMOD}
	${RM} ${RM_FLAGS} *_wrap.cxx

allclean: clean
	${RM} ${RM_FLAGS} ${LOCAL_LIB_DIR}/${SHARED_LIB} ${LOCAL_LIB_DIR}/${STATIC_LIB}
	${RM} ${RM_FLAGS} ${LOCAL_LIB_DIR}/${STEM}.py
	${RM} ${RM_FLAGS} ./${STEM}_wrap.cxx

############            test routines            ############
########        list of test executables        ########
TEST_EXEC_LIST=${LOCAL_BIN_DIR}/testBSpline ${LOCAL_BIN_DIR}/testMovingAverage \
               ${LOCAL_BIN_DIR}/testLevmar ${LOCAL_BIN_DIR}/testNewLevmar ${LOCAL_BIN_DIR}/testAdditionalData \
               ${LOCAL_BIN_DIR}/testMultiDataLevmar \
               ${LOCAL_BIN_DIR}/testMethodFactory

TEST_SHARED_LIB=${LOCAL_LIB_DIR}/_BSpline.so ${LOCAL_LIB_DIR}/_MovingAverage.so \
                ${LOCAL_LIB_DIR}/_Levmar.so ${LOCAL_LIB_DIR}/_NewLevmar.so ${LOCLA_LIB_DIR}/_AdditionalData.so \
                ${LOCAL_LIB_DIR}/_MultiDataLevmar.so \
                ${LOCAL_LIB_DIR}/_MethodFactory.so

TEST_PYTHON_MOD=${LOCAL_LIB_DIR}/BSpline.py  ${LOCAL_LIB_DIR}/MovingAverage.py  \
                ${LOCAL_LIB_DIR}/Levmar.py  ${LOCAL_LIB_DIR}/NewLevmar.py ${LOCAL_LIB_DIR}/AdditionalData.py \
                ${LOCAL_LIB_DIR}/MultiDataLevmar.py \
                ${LOCAL_LIB_DIR}/MethodFactory.py

TEST_PYTHON_CMOD=${TEST_PYTHON_MOD:.py=.pyc}

########        create && test        ########
allTest: BSplineTest MovingAverageTest LevmarTest

allPyTest: BSplinePyTest MovingAveragePyTest LevmarPyTest

####    test BSpline    ####
BSplineTest: ${LOCAL_BIN_DIR}/testBSpline
	$^ 2>${LOG_DIR}/err.BSpline | tee ${LOG_DIR}/log.BSpline

${LOCAL_BIN_DIR}/testBSpline: testBSpline
	${MV} $^ $@

testBSpline: testBSpline.o  ${LOCAL_LIB_DIR}/${SHARED_LIB} ${LOCAL_LIB_DIR}/${STATIC_LIB}
	${CXX} -o $@ $^  ${LDFLAGS} ${METHOD_LIB} ${DATA_CONTAINER_LIB} ${BUILD_IN_FUNC_LIB} ${HELPERS_LIB} ${LEVMAR_LIB} ${MANYO_LIB}

testBSpline.o : ${TEST_SRC}/testBSpline.cc
	${CXX} ${CXXFLAGS} -o $@ -c $^

#--------------------------
BSplinePyTest: ${LOCAL_LIB_DIR}/_BSpline.so ${LOCAL_LIB_DIR}/BSpline.py
	python test_src/testBSpline.py 2>${LOG_DIR}/err.BSpline | tee ${LOG_DIR}/log.BSpline

${LOCAL_LIB_DIR}/_BSpline.so: _BSpline.so
	${MV} $^ ${LOCAL_LIB_DIR}

${LOCAL_LIB_DIR}/BSpline.py: BSpline.py
	${MV} $^ ${LOCAL_LIB_DIR}

_BSpline.so : BSpline_wrap.o
	${CXX} ${WARNING} -shared -o $@ $^ ${LDFLAGS} ${METHOD_LIB} ${DATA_CONTAINER_LIB} ${BUILD_IN_FUNC_LIB} ${HELPERS_LIB} ${MANYO_LIB}

BSpline_wrap.o : BSpline_wrap.cxx
	${CXX} ${CXXFLAGS} -o $@ -c $^

BSpline_wrap.cxx BSpline.py : BSpline.i
	${SWIG} ${SWIG_FLAGS} $^

####    test MovingAverage    ####
MovingAverageTest: ${LOCAL_BIN_DIR}/testMovingAverage
	$^ 2>${LOG_DIR}/err.MovingAverage | tee ${LOG_DIR}/log.MovingAverage

${LOCAL_BIN_DIR}/testMovingAverage: testMovingAverage
	${MV} $^ $@

testMovingAverage : testMovingAverage.o
	${CXX} -o $@ $^ ${LDFLAGS} ${METHOD_LIB} ${DATA_CONTAINER_LIB} ${BUILD_IN_FUNC_LIB} ${HELPERS_LIB} ${MANYO_LIB}

testMovingAverage.o : ${TEST_SRC}/testMovingAverage.cc
	${CXX} ${CXXFLAGS} -o $@ -c $^

#----------------------------
MovingAveragePyTest: ${LOCAL_LIB_DIR}/_MovingAverage.so ${LOCAL_LIB_DIR}/MovingAverage.py
	python test_src/testMovingAverage.py 2>${LOG_DIR}/err.MovingAverage | tee ${LOG_DIR}/log.MovingAverage

${LOCAL_LIB_DIR}/_MovingAverage.so: _MovingAverage.so
	${MV} $^ ${LOCAL_LIB_DIR}

${LOCAL_LIB_DIR}/MovingAverage.py: MovingAverage.py
	${MV} $^ ${LOCAL_LIB_DIR}

_MovingAverage.so : MovingAverage_wrap.o
	${CXX} ${WARNING} -shared -o $@ $^ ${LDFLAGS} ${METHOD_LIB} ${DATA_CONTAINER_LIB} ${BUILD_IN_FUNC_LIB} ${HELPERS_LIB} ${LIB_DIR} ${MANYO_LIB}

MovingAverage_wrap.o : MovingAverage_wrap.cxx
	${CXX} ${CXXFLAGS} -o $@ -c $^

MovingAverage_wrap.cxx MovingAverage.py : MovingAverage.i
	${SWIG} ${SWIG_FLAGS} $^

####    test Levmar    ####
LevmarTest: ${LOCAL_LIB_DIR}/testLevmar
	${LOCAL_BIN_DIR}/$^ 2>${LOG_DIR}/err.Levmar | tee ${LOG_DIR}/log.Levmar

${LOCAL_LIB_DIR}/testLevmar: testLevmar
	${MV} $^ $@

testLevmar: testLevmar.o
	${CXX} -o $@ $^ ${LDFLAGS} ${METHOD_LIB} ${DATA_CONTAINER_LIB} ${BUILD_IN_FUNC_LIB} ${HELPERS_LIB} ${MANYO_LIB}

testLevmar.o: ${TEST_SRC}/testLevmar.cc
	${CXX} ${CXXFLAGS} -o $@ -c $^

#----------------------------
LevmarPyTest: ${LOCAL_LIB_DIR}/_Levmar.so ${LOCAL_LIB_DIR}/Levmar.py
	python test_src/testLevmar.py 2>${LOG_DIR}/err.Levmar | tee ${LOG_DIR}/log.Levmar

${LOCAL_LIB_DIR}/_Levmar.so: _Levmar.so
	${MV} $^ ${LOCAL_LIB_DIR}

${LOCAL_LIB_DIR}/Levmar.py: Levmar.py
	${MV} $^ ${LOCAL_LIB_DIR}

_Levmar.so : Levmar_wrap.o
	${CXX} ${WARNING} -shared -o $@ $^ ${LDFLAGS} ${DRIVER?LIB} ${METHOD_LIB} ${DATA_CONTAINER_LIB} ${BUILD_IN_FUNC_LIB} ${HELPERS_LIB} ${MANYO_LIB}

Levmar_wrap.o : Levmar_wrap.cxx
	${CXX} ${CXXFLAGS} -o $@ -c $^

Levmar_wrap.cxx Levmar.py : Levmar.i
	${SWIG} ${SWIG_FLAGS} $^

#####    test AdditionalData and LevmarFunc    ####
AdditionalDataTest : ${LOCAL_BIN_DIR}/testAdditionalData
	$^ 2>${LOG_DIR}/err.AdditionalData | tee ${LOG_DIR}/log.AdditionalData

${LOCAL_BIN_DIR}/testAdditionalData : testAdditionalData
	${MV} $^ $@

testAdditionalData :  testAdditionalData.o LevmarFunc.o AdditionalData.o
	${CXX} -o $@ $^ ${LDFLAGS} ${DRIVER_LIB} ${METHOD_LIB} ${DATA_CONTAINER_LIB} ${BUILD_IN_FUNC_LIB} ${HELPERS_LIB} ${LEVMAR_LIB} ${MANYO_LIB}

testAdditionalData.o : ${TEST_SRC}/testAdditionalData.cc
	${CXX} ${CXXFLAGS} -o $@ -c $^

#----------------------------
#####    test NewLevmar (support multi-thread)    ####
NewLevmarTest : ${LOCAL_BIN_DIR}/testNewLevmar
	$^ 2>${LOG_DIR}/err.NewLevmar | tee ${LOG_DIR}/log.NewLevmar

${LOCAL_BIN_DIR}/testNewLevmar : testNewLevmar
	${MV} $^ $@

testNewLevmar : testNewLevmar.o
	${CXX} -o $@ $^ ${LDFLAGS} ${METHOD_LIB} ${DATA_CONTAINER_LIB} ${BUILD_IN_FUNC_LIB} ${HELPERS_LIB} ${MANYO_LIB}

testNewLevmar.o : ${TEST_SRC}/testNewLevmar.cc
	${CXX} ${CXXFLAGS} -o $@ -c $^

#----------------------------
NewLevmarPyTest: ${LOCAL_LIB_DIR}/_NewLevmar.so ${LOCAL_LIB_DIR}/NewLevmar.py
	python test_src/testNewLevmar.py 2>${LOG_DIR}/err.NewLevmar | tee ${LOG_DIR}/log.NewLevmar

${LOCAL_LIB_DIR}/_NewLevmar.so: _NewLevmar.so
	${MV} $^ ${LOCAL_LIB_DIR}

${LOCAL_LIB_DIR}/NewLevmar.py: NewLevmar.py
	${MV} $^ ${LOCAL_LIB_DIR}

_NewLevmar.so : NewLevmar_wrap.o
	${CXX} ${WARNING} -shared -o $@ $^ ${LDFLAGS} ${DRIVER_LIB} ${METHOD_LIB} ${DATA_CONTAINER_LIB} ${BUILD_IN_FUNC_LIB} ${HELPERS_LIB} ${MANYO_LIB}

NewLevmar_wrap.o : NewLevmar_wrap.cxx
	${CXX} ${CXXFLAGS} -o $@ -c $^

NewLevmar_wrap.cxx NewLevmar.py : NewLevmar.i
	${SWIG} ${SWIG_FLAGS} $^

#####    test MultiDataLevmar (support multi-thread)    ####
MultiDataLevmarTest : ${LOCAL_BIN_DIR}/testMultiDataLevmar
	cp ${SAMPLE_DATA_DIR}/elementContainerArray/sourceArray.data .
	$^ 2>${LOG_DIR}/err.MultiDataLevmar | tee ${LOG_DIR}/log.MultiDataLevmar

${LOCAL_BIN_DIR}/testMultiDataLevmar : testMultiDataLevmar
	${MV} $^ $@

testMultiDataLevmar : testMultiDataLevmar.o
	${CXX} -o $@ $^ ${LDFLAGS} ${METHOD_LIB} ${DATA_CONTAINER_LIB} ${BUILD_IN_FUNC_LIB} ${HELPERS_LIB} ${MANYO_LIB}

testMultiDataLevmar.o : ${TEST_SRC}/testMultiDataLevmar.cc
	${CXX} ${CXXFLAGS} -o $@ -c $^

#----------------------------
MultiDataLevmarPyTest : ${LOAD_LIB_DIR}/_MultiDataLevmar.so ${LOAD_LIB_DIR}/MultiDataLevmar.py
#	python ${TEST_SRC}/testMultiDataLevmar.py -i ${SAMPLE_DATA_DIR}/sourceArray.data 2>${LOG_DIR}/err.MultiDataLevmar | tee ${LOG_DIR}/log.MultiDataLevmar
	python ${TEST_SRC}/testMultiDataLevmar.py -i ${SAMPLE_DATA_DIR}/elementContainerArray/sourceArray.data

${LOAD_LIB_DIR}/_MultiDataLevmar.so : _MultiDataLevmar.so
	${MV} $^ ${LOCAL_LIB_DIR}

${LOAD_LIB_DIR}/MultiDataLevmar.py : MultiDataLevmar.py
	${MV} $^ ${LOCAL_LIB_DIR}

_MultiDataLevmar.so : MultiDataLevmar_wrap.o
	${CXX} ${WARNING} -shared -o $@ $^ ${LDFLAGS} ${DRIVER_LIB} ${METHOD_LIB} ${DATA_CONTAINER_LIB} ${BUILD_IN_FUNC_LIB} ${HELPERS_LIB} ${MANYO_LIB}

MultiDataLevmar_wrap.o : MultiDataLevmar_wrap.cxx
	${CXX} ${CXXFLAGS} -o $@ -c $^

MultiDataLevmar_wrap.cxx MultiDataLevmar.py : MultiDataLevmar.i
	${SWIG} ${SWIG_FLAGS} $^

#####    test Method Facory    ####
MethodFactoryTest : ${LOCAL_BIN_DIR}/testMethodFactory
	$^ 2>${LOG_DIR}/err.MethodFactory | tee ${LOG_DIR}/log.MethodFactory

${LOCAL_BIN_DIR}/testMethodFactory : testMethodFactory
	${MV} $^ $@

testMethodFactory : testMethodFactory.o
	${CXX} -o $@ $^ ${LDFLAGS} ${METHOD_LIB} ${DATA_CONTAINER_LIB} ${BUILD_IN_FUNC_LIB} ${HELPERS_LIB} ${MANYO_LIB}

testMethodFactory.o : ${TEST_SRC}/testMethodFactory.cc
	${CXX} ${CXXFLAGS} -o $@ -c $^

#----------------------------
MethodFactoryPyTest: ${LOCAL_LIB_DIR}/_MethodFactory.so ${LOCAL_LIB_DIR}/MethodFactory.py
	python ${TEST_SRC}/testMethodFactory.py 2>${LOG_DIR}/err.MethodFactory | tee ${LOG_DIR}/log.MethodFactory

${LOCAL_LIB_DIR}/_MethodFactory.so: _MethodFactory.so
	${MV} $^ ${LOCAL_LIB_DIR}

${LOCAL_LIB_DIR}/MethodFactory.py: MethodFactory.py
	${MV} $^ ${LOCAL_LIB_DIR}

_MethodFactory.so : MethodFactory_wrap.o
	${CXX} ${WARNING} -shared -o $@ $^ ${LDFLAGS} ${METHOD_LIB} ${DATA_CONTAINER_LIB} ${BUILD_IN_FUNC_LIB} ${HELPERS_LIB} ${MANYO_LIB}

MethodFactory_wrap.o : MethodFactory_wrap.cxx
	${CXX} ${CXXFLAGS} -o $@ -c $^

MethodFactory_wrap.cxx MethodFactory.py : MethodFactory.i
	${SWIG} ${SWIG_FLAGS} $^

