APP = ../../../app
RM = /bin/rm
HV2DB = ./hv2db


# directories:
iocondev3_dir = ../../../ioc/iocondev3
iocondev5_dir = ../../../ioc/iocondev5
alh_dir       = ../medm/alh

# folders for subsystems MEDM related files
mvd_handling  = ../medm/adl/mvd_handling
bb_handling   = ../medm/adl/bb_handling
zdc_handling  = ../medm/adl/zdc_handling
dc_handling   = ../medm/adl/dc_handling
pc_handling   = ../medm/adl/pc_handling
tec_handling  = ../medm/adl/tec_handling
rich_handling = ../medm/adl/rich_handling
tof_handling  = ../medm/adl/tof_handling
pbgl_handling = ../medm/adl/pbgl_handling
pbsc_handling = ../medm/adl/pbsc_handling


# folders for subsystems setup files
mvd_setup     = ../medm/adl/mvd_setup
bb_setup      = ../medm/adl/bb_setup
zdc_setup     = ../medm/adl/zdc_setup
dc_setup      = ../medm/adl/dc_setup
pc_setup      = ../medm/adl/pc_setup
tec_setup     = ../medm/adl/tec_setup
rich_setup    = ../medm/adl/rich_setup
tof_setup     = ../medm/adl/tof_setup
pbgl_setup    = ../medm/adl/pbgl_setup
pbsc_setup    = ../medm/adl/pbsc_setup


# definition of subsystems' *.dat files
MVD_DATA    = mvd.dat
BB_DATA     = bb.dat
ZDC_DATA    = zdc.dat
DC_E_DATA   = dc_e.dat
DC_W_DATA   = dc_w.dat
PC_E_DATA   = pc_e.dat
PC_W_DATA   = pc_w.dat
TEC_E_DATA  = tec_e.dat
RICH_E_DATA = rich_e.dat
RICH_W_DATA = rich_w.dat
TOF_E_DATA  = tof_e.dat
PBGL_E_DATA = pbgl_e.dat
PBSC_E_DATA = pbsc_e.dat
PBSC_W_DATA = pbsc_w.dat



.SUFFIXES : .dat .db .database .adl .card_config 

alarm:  alarm_setup  phhv.dat alh_config

alarm_setup:
	echo "\nBUILDING THE ALARM HANDLER CONFIGURATION FILE"
	echo "===============================================\n"
	$(RM) -f phhv.grp
	$(RM) -f phhv.dat
	if [ -f gui.grp ] ; then \
	  echo "OK: Group file >>gui.grp<< found" ; \
	  cat gui.grp > phhv.grp ; \
	  echo "\nOK: Intermediate group file >>phhv.grp<< created" ; \
	else \
	  echo "ERROR: Group file >>gui.grp<< not found\n" ; \
	fi  
	if [ -f $(alh_dir)/phhv.alhDisabledChannels ] ; then \
	  echo "\nOK: file phhv.alhDisabledChannels found\n" ; \
	  cp $(alh_dir)/phhv.alhDisabledChannels phhv.alhDisabledChannels ; \
	else \
	  echo "\nERROR: file phhv.alhDisabledChannels not found\n" ; \
	fi

gui:    gui_setup phhv.dat ../medm/adl/phhv.adl
	$(RM) -f gui.dat
	$(RM) -f gui.db
	cat phhv.dat > gui.dat
gui_setup:
	echo "\nBUILDING THE MEDM HV-CONTROL GUI"
	echo "================================\n"
	$(RM) -f phhv.grp
	$(RM) -f phhv.dat
	if [ -f gui.grp ] ; then \
	  echo "OK: Group file >>gui.grp<< found" ; \
	  cat gui.grp > phhv.grp ; \
	  echo "\nOK: Intermediate group file >>phhv.grp<< created" ; \
	else \
	  echo "ERROR: Group file >>gui.grp<< not found\n" ; \
	fi  
	if [ -f $(alh_dir)/phhv.alhDisabledChannels ] ; then \
	  echo "\nOK: file phhv.alhDisabledChannels found\n" ; \
	  cp $(alh_dir)/phhv.alhDisabledChannels phhv.alhDisabledChannels ; \
	else \
	  echo "\nERROR: file phhv.alhDisabledChannels not found\n" ; \
	fi

iocondev5: cleandefault iocondev5setup phhv.db phhv.config
	$(RM) -f iocondev5.config
	$(RM) -f iocondev5.dat
	$(RM) -f iocondev5.db
	cat phhv.config > iocondev5.config
	cat phhv.dat > iocondev5.dat
	cat phhv.db > iocondev5.db
	$(RM) -f $(iocondev5_dir)/phhv.config
	$(RM) -f $(iocondev5_dir)/iocondev5.config
	$(RM) -f $(iocondev5_dir)/phhv.db
	$(RM) -f $(iocondev5_dir)/iocondev5.db
	cp phhv.config      $(iocondev5_dir)
	cp iocondev5.config $(iocondev5_dir)
	cp phhv.db      $(iocondev5_dir)
	cp iocondev5.db $(iocondev5_dir)
	echo "Configuration file ready:  iocondev5.config"
	echo "EPICS database file ready: iocondev5.db"
	echo "\n"
	echo "READY !!\n"
iocondev5setup:
	echo "\nBUILDING THE EPICS DATABASE FILE FOR IOCONDEV5"
	echo "==============================================\n"
	$(RM) -f phhv.grp
	if [ -f iocondev5.grp ] ; then \
	  echo "OK: Group file >>iocondev5.grp<< found" ; \
	  cat iocondev5.grp > phhv.grp ; \
	  echo "\nOK: Intermediate group file >>phhv.grp<< created" ; \
	else \
	  echo "ERROR: Group file >>iocondev5.grp<< not found\n" ; \
	fi  


iocondev3: cleandefault iocondev3setup phhv.db phhv.config
	$(RM) -f iocondev3.config
	$(RM) -f iocondev3.dat
	$(RM) -f iocondev3.db
	cat phhv.config > iocondev3.config
	cat phhv.dat > iocondev3.dat
	cat phhv.db > iocondev3.db
	$(RM) -f $(iocondev3_dir)/phhv.config
	$(RM) -f $(iocondev3_dir)/iocondev3.config
	$(RM) -f $(iocondev3_dir)/phhv.db
	$(RM) -f $(iocondev3_dir)/iocondev3.db
	cp phhv.config      $(iocondev3_dir)
	cp iocondev3.config $(iocondev3_dir)
	cp phhv.db      $(iocondev3_dir)
	cp iocondev3.db $(iocondev3_dir)
	echo "Configuration file ready:  iocondev3.config"
	echo "EPICS database file ready: iocondev3.db"
	echo "\n"
	echo "READY !!\n"
iocondev3setup:
	echo "\nBUILDING THE EPICS DATABASE FILE FOR IOCONDEV3"
	echo "==============================================\n"
	$(RM) -f phhv.grp
	if [ -f iocondev3.grp ] ; then \
	  echo "OK: Group file >>iocondev3.grp<< found" ; \
	  cat iocondev3.grp > phhv.grp ; \
	  echo "\nOK: Intermediate group file >>phhv.grp<< created" ; \
	else \
	  echo "ERROR: Group file >>iocondev3.grp<< not found\n" ; \
	fi  


phhv.dat: 
#       BUILD phhv.dat and phhv.grp files from existing subsystems *.dat files
	$(RM) -f phhv.dat

	if [ -f phhv.grp ] ; then \
	  echo "\nREQUESTED SUBSYSTEMS:" ; \
	  echo "============================:" ; \
	  cat phhv.grp; \
	  echo "\n" ; \
	else \
	  echo "ERROR: group file phhv.grp not found\n" ; \
	fi  

        # HV group: 1 MVD
	if [ -f phhv.grp ] ; then \
          grep -qs "MVD" phhv.grp && cat -s $(MVD_DATA)  >> phhv.dat ; \
          grep -qs "MVD" phhv.grp &&   echo "* MVD listed in group file" ; \
          grep -qs "MVD" phhv.grp && ( grep -qs " " $(MVD_DATA) && \
              echo "  -->  OK: $(MVD_DATA) file found" ) ; \
          grep -qs "MVD" phhv.grp && ( grep -qs " " $(MVD_DATA) ||  \
              echo "  -->  ERROR: $(MVD_DATA) file not found" ) ; \
          grep -qs "MVD" phhv.grp ||   echo "\c" ; \
	fi
        # HV group: 2 BB
	if [ -f phhv.grp ] ; then \
          grep -qs "BB" phhv.grp && cat -s $(BB_DATA)  >> phhv.dat ; \
          grep -qs "BB" phhv.grp &&   echo "* BB listed in group file" ; \
          grep -qs "BB" phhv.grp && ( grep -qs " " $(BB_DATA) &&  \
              echo "  -->  OK: $(BB_DATA) file found" ) ; \
          grep -qs "BB" phhv.grp && ( grep -qs " " $(BB_DATA) ||  \
              echo "  -->  ERROR: $(BB_DATA) file not found" ) ; \
          grep -qs "BB" phhv.grp ||   echo "\c" ; \
	fi
        # HV group: 3 ZDC
	if [ -f phhv.grp ] ; then \
          grep -qs "ZDC" phhv.grp && cat -s $(ZDC_DATA)  >> phhv.dat ; \
          grep -qs "ZDC" phhv.grp &&   echo "* ZDC listed in group file" ; \
          grep -qs "ZDC" phhv.grp && ( grep -qs " " $(ZDC_DATA) &&  \
              echo "  -->  OK: $(ZDC_DATA) file found" ) ; \
          grep -qs "ZDC" phhv.grp && ( grep -qs " " $(ZDC_DATA) ||  \
              echo "  -->  ERROR: $(ZDC_DATA) file not found" ) ; \
          grep -qs "ZDC" phhv.grp ||   echo "\c" ; \
	fi
        # HV group: 4 DC_E
	if [ -f phhv.grp ] ; then \
          grep -qs "DC_E" phhv.grp && cat -s $(DC_E_DATA)  >> phhv.dat ; \
          grep -qs "DC_E" phhv.grp &&   echo "* DC_E listed in group file" ; \
          grep -qs "DC_E" phhv.grp && ( grep -qs " " $(DC_E_DATA) &&  \
              echo "  -->  OK: $(DC_E_DATA) file found" ) ; \
          grep -qs "DC_E" phhv.grp && ( grep -qs " " $(DC_E_DATA) ||  \
              echo "  -->  ERROR: $(DC_E_DATA) file not found" ) ; \
          grep -qs "DC_E" phhv.grp ||   echo "\c" ; \
	fi
        # HV group: 5 DC_W
	if [ -f phhv.grp ] ; then \
          grep -qs "DC_W" phhv.grp && cat -s $(DC_W_DATA)  >> phhv.dat ; \
          grep -qs "DC_W" phhv.grp &&   echo "* DC_W listed in group file" ; \
          grep -qs "DC_W" phhv.grp && ( grep -qs " " $(DC_W_DATA) &&  \
              echo "  -->  OK: $(DC_W_DATA) file found" ) ; \
          grep -qs "DC_W" phhv.grp && ( grep -qs " " $(DC_W_DATA) ||  \
              echo "  -->  ERROR: $(DC_W_DATA) file not found" ) ; \
          grep -qs "DC_W" phhv.grp ||   echo "\c" ; \
	fi
        # HV group: 6 PC_E
	if [ -f phhv.grp ] ; then \
          grep -qs "PC_E" phhv.grp && cat -s $(PC_E_DATA)  >> phhv.dat ; \
          grep -qs "PC_E" phhv.grp &&   echo "* PC_E listed in group file" ; \
          grep -qs "PC_E" phhv.grp && ( grep -qs " " $(PC_E_DATA) &&  \
              echo "  -->  OK: $(PC_E_DATA) file found" ) ; \
          grep -qs "PC_E" phhv.grp && ( grep -qs " " $(PC_E_DATA) ||  \
              echo "  -->  ERROR: $(PC_E_DATA) file not found" ) ; \
          grep -qs "PC_E" phhv.grp ||   echo "\c" ; \
	fi
        # HV group: 7 PC_W
	if [ -f phhv.grp ] ; then \
          grep -qs "PC_W" phhv.grp && cat -s $(PC_W_DATA)  >> phhv.dat ; \
          grep -qs "PC_W" phhv.grp &&   echo "* PC_W listed in group file" ; \
          grep -qs "PC_W" phhv.grp && ( grep -qs " " $(PC_W_DATA) &&  \
              echo "  -->  OK: $(PC_W_DATA) file found" ) ; \
          grep -qs "PC_W" phhv.grp && ( grep -qs " " $(PC_W_DATA) ||  \
              echo "  -->  ERROR: $(PC_W_DATA) file not found" ) ; \
          grep -qs "PC_W" phhv.grp ||   echo "\c" ; \
	fi
        # HV group: 8 TEC_E
	if [ -f phhv.grp ] ; then \
          grep -qs "TEC_E" phhv.grp && cat -s $(TEC_E_DATA)  >> phhv.dat ; \
          grep -qs "TEC_E" phhv.grp &&   echo "* TEC_E listed in group file" ; \
          grep -qs "TEC_E" phhv.grp && ( grep -qs " " $(TEC_E_DATA) &&  \
              echo "  -->  OK: $(TEC_E_DATA) file found" ) ; \
          grep -qs "TEC_E" phhv.grp && ( grep -qs " " $(TEC_E_DATA) ||  \
              echo "  -->  ERROR: $(TEC_E_DATA) file not found" ) ; \
          grep -qs "TEC_E" phhv.grp ||   echo "\c" ; \
	fi
        # HV group: 9 RICH_E
	if [ -f phhv.grp ] ; then \
          grep -qs "RICH_E" phhv.grp && cat -s $(RICH_E_DATA)  >> phhv.dat ; \
          grep -qs "RICH_E" phhv.grp &&   echo "* RICH_E listed in group file" ; \
          grep -qs "RICH_E" phhv.grp && ( grep -qs " " $(RICH_E_DATA) &&  \
              echo "  -->  OK: $(RICH_E_DATA) file found" ) ; \
          grep -qs "RICH_E" phhv.grp && ( grep -qs " " $(RICH_E_DATA) ||  \
              echo "  -->  ERROR: $(RICH_E_DATA) file not found" ) ; \
          grep -qs "RICH_E" phhv.grp ||   echo "\c" ; \
	fi
        # HV group: 10 RICH_W
	if [ -f phhv.grp ] ; then \
          grep -qs "RICH_W" phhv.grp && cat -s $(RICH_W_DATA)  >> phhv.dat ; \
          grep -qs "RICH_W" phhv.grp &&   echo "* RICH_W listed in group file" ; \
          grep -qs "RICH_W" phhv.grp && ( grep -qs " " $(RICH_W_DATA) &&  \
              echo "  -->  OK: $(RICH_W_DATA) file found" ) ; \
          grep -qs "RICH_W" phhv.grp && ( grep -qs " " $(RICH_W_DATA) ||  \
              echo "  -->  ERROR: $(RICH_W_DATA) file not found" ) ; \
          grep -qs "RICH_W" phhv.grp ||   echo "\c" ; \
	fi
        # HV group: 11 TOF_E
	if [ -f phhv.grp ] ; then \
          grep -qs "TOF_E" phhv.grp && cat -s $(TOF_E_DATA)  >> phhv.dat ; \
          grep -qs "TOF_E" phhv.grp &&   echo "* TOF_E listed in group file" ; \
          grep -qs "TOF_E" phhv.grp && ( grep -qs " " $(TOF_E_DATA) &&  \
              echo "  -->  OK: $(TOF_E_DATA) file found" ) ; \
          grep -qs "TOF_E" phhv.grp && ( grep -qs " " $(TOF_E_DATA) ||  \
              echo "  -->  ERROR: $(TOF_E_DATA) file not found" ) ; \
          grep -qs "TOF_E" phhv.grp ||   echo "\c" ; \
	fi
        # HV group: 12 PBGL_E
	if [ -f phhv.grp ] ; then \
          grep -qs "PBGL_E" phhv.grp && cat -s $(PBGL_E_DATA)  >> phhv.dat ; \
          grep -qs "PBGL_E" phhv.grp &&   echo "* PBGL_E listed in group file" ; \
          grep -qs "PBGL_E" phhv.grp && ( grep -qs " " $(PBGL_E_DATA) &&  \
              echo "  -->  OK: $(PBGL_E_DATA) file found" ) ; \
          grep -qs "PBGL_E" phhv.grp && ( grep -qs " " $(PBGL_E_DATA) ||  \
              echo "  -->  ERROR: $(PBGL_E_DATA) file not found" ) ; \
          grep -qs "PBGL_E" phhv.grp ||   echo "\c" ; \
	fi
        # HV group: 13 PBSC_E
	if [ -f phhv.grp ] ; then \
          grep -qs "PBSC_E" phhv.grp && cat -s " " $(PBSC_E_DATA)  >> phhv.dat ; \
          grep -qs "PBSC_E" phhv.grp &&   echo "* PBSC_E listed in group file" ; \
          grep -qs "PBSC_E" phhv.grp && ( grep -qs " " $(PBSC_E_DATA) &&  \
              echo "  -->  OK: $(PBSC_E_DATA) file found" ) ; \
          grep -qs "PBSC_E" phhv.grp && ( grep -qs " " $(PBSC_E_DATA) ||  \
              echo "  -->  ERROR: $(PBSC_E_DATA) file not found" ) ; \
          grep -qs "PBSC_E" phhv.grp ||   echo "\c" ; \
	fi
        # HV group: 14 PBSC_W
	if [ -f phhv.grp ] ; then \
          grep -qs "PBSC_W" phhv.grp && cat -s " " $(PBSC_W_DATA)  >> phhv.dat ; \
          grep -qs "PBSC_W" phhv.grp &&   echo "* PBSC_W listed in group file" ; \
          grep -qs "PBSC_W" phhv.grp && ( grep -qs " " $(PBSC_W_DATA) &&  \
              echo "  -->  OK: $(PBSC_W_DATA) file found" ) ; \
          grep -qs "PBSC_W" phhv.grp && ( grep -qs " " $(PBSC_W_DATA) ||  \
              echo "  -->  ERROR: $(PBSC_W_DATA) file not found" ) ; \
          grep -qs "PBSC_W" phhv.grp ||   echo "\c" ; \
	fi

	if [ -f phhv.dat ] ; then \
	  echo "\nIntermediate input file >>phhv.dat<< created" ; \
	else \
	  echo "\n ERROR: No intermediate input file >>phhv.dat<< could be created\n" ; \
	fi

%.files:
	make default.sdrSum
	make $*.database
	make $*.config
	make ../medm/adl/$*.adl
%.config: config_header.txt %.card_config
	$(RM) -f $*.config
	cat config_header.txt $*.card_config > $*.config
%_2.db: %.dat
	@echo null command
.dat.db :
	echo "\nCREATING THE DATABASE ...\n"
	$(HV2DB) $*
.dat.card_config :
	$(HV2DB) $*

../medm/adl/%.adl : %.dat
	echo "\nBUILDING MEDM GUI ..."
	$(APP)/hvca/bin/hv_adl $*

	echo "\nMOVING FILES TO FINAL FOLDERS:"
	test -d ../medm/adl || mkdir ../medm/adl

	test -d $(mvd_handling)  || mkdir $(mvd_handling)
	test -d $(bb_handling)   || mkdir $(bb_handling) 
	test -d $(zdc_handling)  || mkdir $(zdc_handling)
	test -d $(dc_handling)   || mkdir $(dc_handling)
	test -d $(pc_handling)   || mkdir $(pc_handling)
	test -d $(tec_handling)  || mkdir $(tec_handling) 
	test -d $(rich_handling) || mkdir $(rich_handling)
	test -d $(tof_handling)  || mkdir $(tof_handling)
	test -d $(pbgl_handling) || mkdir $(pbgl_handling)
	test -d $(pbsc_handling) || mkdir $(pbsc_handling)

	test -d $(mvd_setup)     || mkdir $(mvd_setup)
	test -d $(bb_setup)      || mkdir $(bb_setup) 
	test -d $(zdc_setup)     || mkdir $(zdc_setup)
	test -d $(dc_setup)      || mkdir $(dc_setup)
	test -d $(pc_setup)      || mkdir $(pc_setup)
	test -d $(tec_setup)     || mkdir $(tec_setup) 
	test -d $(rich_setup)    || mkdir $(rich_setup)
	test -d $(tof_setup)     || mkdir $(tof_setup)
	test -d $(pbgl_setup)    || mkdir $(pbgl_setup)
	test -d $(pbsc_setup)    || mkdir $(pbsc_setup)

	if [ -f *.csh ] ; then \
	  chmod +x *.csh ;\
	fi

#       main *.adl and alarm handler config file
	if [ -f phhv.adl ] ; then \
	  echo " - main panel file >>phhv.adl<< to ../medm/adl" ; \
	  mv phhv.adl  ../medm/adl ; \
	fi 
	if [ -f phhv.alhConfig ] ; then \
	  echo " - alarm handler file >>phhv.alhConfig<< to ../medm/alh" ; \
	  mv $**.alhConfig ../medm/alh ; \
	fi

#	MVD specific files
	if [ -f *_MVD_*.adl ] ; then \
	  echo " - MVD specific files to $(mvd_handling)" ; \
	  mv *_MVD_*.adl  $(mvd_handling) ; \
	fi
	if [ -f *_MVD_*.req ] ; then \
	  mv *_MVD_*.req  $(mvd_handling) ; \
	fi
	if [ -f *_MVD_*.snap ] ; then \
	  mv *_MVD_*.snap $(mvd_handling) ; \
	fi
	if [ -f *_MVD_*.csh ] ; then \
	  mv *_MVD_*.csh  $(mvd_handling) ; \
	fi
	if [ -f $(mvd_setup)/phhv_MVD_*en.snap ] ; then \
	  cp -p $(mvd_setup)/phhv_MVD_*en.snap  $(mvd_handling) ; \
	  echo "   -- using user defined channel-enable-list" ; \
	fi
#	BB specific files
	if [ -f *_BB_*.adl ] ; then \
	  echo " - BB specific files to $(bb_handling)" ; \
	  mv *_BB_*.adl  $(bb_handling) ; \
	fi
	if [ -f *_BB_*.req ] ; then \
	  mv *_BB_*.req  $(bb_handling) ; \
	fi
	if [ -f *_BB_*.snap ] ; then \
	  mv *_BB_*.snap $(bb_handling) ; \
	fi
	if [ -f *_BB_*.csh ] ; then \
	  mv *_BB_*.csh  $(bb_handling) ; \
	fi
	if [ -f $(bb_setup)/phhv_BB_*en.snap ] ; then \
	  cp -p $(bb_setup)/phhv_BB_*en.snap  $(bb_handling) ; \
	  echo "   -- using user defined channel-enable-list" ; \
	fi
#	ZDC specific files
	if [ -f *_ZDC_*.adl ] ; then \
	  echo " - ZDC specific files to $(zdc_handling)" ; \
	  mv *_ZDC_*.adl  $(zdc_handling) ; \
	fi
	if [ -f *_ZDC_*.req ] ; then \
	  mv *_ZDC_*.req  $(zdc_handling) ; \
	fi
	if [ -f *_ZDC_*.snap ] ; then \
	  mv *_ZDC_*.snap $(zdc_handling) ; \
	fi
	if [ -f *_ZDC_*.csh ] ; then \
	  mv *_ZDC_*.csh  $(zdc_handling) ; \
	fi
	if [ -f $(zdc_setup)/phhv_ZDC_*en.snap ] ; then \
	  cp -p $(zdc_setup)/phhv_ZDC_*en.snap  $(zdc_handling) ; \
	  echo "   -- using user defined channel-enable-list" ; \
	fi
#	DC specific files
	if [ -f *_DC_*.adl ] ; then \
	  echo " - DC specific files to $(dc_handling) ... PLEASE BE PATIENT ..." ; \
	  mv *_DC_*.adl  $(dc_handling) ; \
	fi
	if [ -f *_DC_*.req ] ; then \
	  mv *_DC_*.req  $(dc_handling) ; \
	fi
	if [ -f *_DC_*.snap ] ; then \
	  mv *_DC_*.snap $(dc_handling) ; \
	fi
	if [ -f *_DC_*.csh ] ; then \
	  mv *_DC_*.csh  $(dc_handling) ; \
	fi
	if [ -f $(dc_setup)/phhv_DC_*en.snap ] ; then \
	  cp -p $(dc_setup)/phhv_DC_*en.snap  $(dc_handling) ; \
	  echo "   -- using user defined channel-enable-list" ; \
	fi
	if [ -f $(dc_setup)/*CE_LIST.snap ] ; then \
	  cp -p $(dc_setup)/*CE_LIST.snap  $(dc_handling) ; \
	fi

#	PC specific files
	if [ -f *_PC_*.adl ] ; then \
	  echo " - PC specific files to $(pc_handling)" ; \
	  mv *_PC_*.adl  $(pc_handling) ; \
	fi
	if [ -f *_PC_*.req ] ; then \
	  mv *_PC_*.req  $(pc_handling) ; \
	fi
	if [ -f *_PC_*.snap ] ; then \
	  mv *_PC_*.snap $(pc_handling) ; \
	fi
	if [ -f *_PC_*.csh ] ; then \
	  mv *_PC_*.csh  $(pc_handling) ; \
	fi
	if [ -f $(pc_setup)/phhv_PC_*en.snap ] ; then \
	  cp -p $(pc_setup)/phhv_PC_*en.snap  $(pc_handling) ; \
	  echo "   -- using user defined channel-enable-list" ; \
	fi
#	TEC specific files
	if [ -f *_TEC_*.adl ] ; then \
	  echo " - TEC specific files to $(tec_handling)" ; \
	  mv *_TEC_*.adl  $(tec_handling) ; \
	fi
	if [ -f *_TEC_*.req ] ; then \
	  mv *_TEC_*.req  $(tec_handling) ; \
	fi
	if [ -f *_TEC_*.snap ] ; then \
	  mv *_TEC_*.snap $(tec_handling) ; \
	fi
	if [ -f *_TEC_*.csh ] ; then \
	  mv *_TEC_*.csh  $(tec_handling) ; \
	fi
	if [ -f $(tec_setup)/phhv_TEC_*en.snap ] ; then \
	  cp -p $(tec_setup)/phhv_TEC_*en.snap  $(tec_handling) ; \
	  echo "   -- using user defined channel-enable-list" ; \
	fi
#	RICH specific files
	if [ -f *_RICH_*.adl ] ; then \
	  echo " - RICH specific files to $(rich_handling)" ; \
	  mv *_RICH_*.adl  $(rich_handling) ; \
	fi
	if [ -f *_RICH_*.req ] ; then \
	  mv *_RICH_*.req  $(rich_handling) ; \
	fi
	if [ -f *_RICH_*.snap ] ; then \
	  mv *_RICH_*.snap $(rich_handling) ; \
	fi
	if [ -f *_RICH_*.csh ] ; then \
	  mv *_RICH_*.csh  $(rich_handling) ; \
	fi
	if [ -f $(rich_setup)/phhv_RICH_*en.snap ] ; then \
	  cp -p $(rich_setup)/phhv_RICH_*en.snap  $(rich_handling) ; \
	  echo "   -- using user defined channel-enable-list" ; \
	fi
#	TOF specific files
	if [ -f *_TOF_*.adl ] ; then \
	  echo " - TOF specific files to $(tof_handling)" ; \
	  mv *_TOF_*.adl  $(tof_handling) ; \
	fi
	if [ -f *_TOF_*.req ] ; then \
	  mv *_TOF_*.req  $(tof_handling) ; \
	fi
	if [ -f *_TOF_*.snap ] ; then \
	  mv *_TOF_*.snap $(tof_handling) ; \
	fi
	if [ -f *_TOF_*.csh ] ; then \
	  mv *_TOF_*.csh  $(tof_handling) ; \
	fi
	if [ -f $(tof_setup)/phhv_TOF_*en.snap ] ; then \
	  cp -p $(tof_setup)/phhv_TOF_*en.snap  $(tof_handling) ; \
	  echo "   -- using user defined channel-enable-list" ; \
	fi
#	PBGL specific files
	if [ -f *_PBGL_*.adl ] ; then \
	  echo " - PBGL specific files to $(pbgl_handling)" ; \
	  mv *_PBGL_*.adl  $(pbgl_handling) ; \
	fi
	if [ -f *_PBGL_*.req ] ; then \
	  mv *_PBGL_*.req  $(pbgl_handling) ; \
	fi
	if [ -f *_PBGL_*.snap ] ; then \
	  mv *_PBGL_*.snap $(pbgl_handling) ; \
	fi
	if [ -f *_PBGL_*.csh ] ; then \
	  mv *_PBGL_*.csh  $(pbgl_handling) ; \
	fi
	if [ -f $(pbgl_setup)/phhv_PBGL_*en.snap ] ; then \
	  cp -p $(pbgl_setup)/phhv_PBGL_*en.snap  $(pbgl_handling) ; \
	  echo "   -- using user defined channel-enable-list" ; \
	fi
#	PBSC specific files
	if [ -f *_PBSC_*.adl ] ; then \
	  echo " - PBSC specific files to $(pbsc_handling)" ; \
	  mv *_PBSC_*.adl  $(pbsc_handling) ; \
	fi
	if [ -f *_PBSC_*.req ] ; then \
	  mv *_PBSC_*.req  $(pbsc_handling) ; \
	fi
	if [ -f *_PBSC_*.snap ] ; then \
	  mv *_PBSC_*.snap $(pbsc_handling) ; \
	fi
	if [ -f *_PBSC_*.csh ] ; then \
	  mv *_PBSC_*.csh  $(pbsc_handling) ; \
	fi
	if [ -f $(pbsc_setup)/phhv_PBSC_*en.snap ] ; then \
	  cp -p $(pbsc_setup)/phhv_PBSC_*en.snap  $(pbsc_handling) ; \
	  echo "   -- using user defined channel-enable-list" ; \
	fi

	echo "\n"
	echo "READY !!\n"


alh_config:
	echo "\nBUILDING ALARM HANDLER CONFIGURATION FILE ..."
	$(APP)/hvca/bin/hv_adl phhv

	echo "\nMOVING FILE TO FINAL FOLDER:"
	test -d ../medm/adl || mkdir ../medm/adl


	if [ -f *.csh ] ; then \
	  rm -f *.csh ;\
	fi
	if [ -f *.snap ] ; then \
	  rm -f *.snap ;\
	fi
	if [ -f *.req ] ; then \
	  rm -f *.req ;\
	fi
	if [ -f *.adl ] ; then \
	  rm -f *.adl ;\
	fi

#       alarm handler config file
	if [ -f phhv.alhConfig ] ; then \
	  echo " - alarm handler file >>phhv.alhConfig<< to ../medm/alh" ; \
	  mv $**.alhConfig ../medm/alh ; \
	fi


	echo "\n"
	echo "READY !!\n"



cleandefault:
	$(RM) -f phhv.dat
	$(RM) -f default.sdrSum


clean:
	echo "\nCLEANING UP ..."
	$(RM) -f phhv.dat
	echo "  - >>phhv.dat<< deleted"
	$(RM) -f default.sdrSum
	echo "  - >>default.sdrSum<< deleted"
	$(RM) -f ../medm/alh/phhv.alhConfig
	echo "  - >>../medm/alh/phhv.alhConfig<< deleted"
	$(RM) -f ../medm/adl/phhv.adl
	echo "  - >>../medm/alh/phhv.adl<< deleted"
	$(RM) -f $(mvd_handling)/*
	echo "  - >>$(mvd_handling)/* deleted"
	$(RM) -f $(bb_handling)/*
	echo "  - >>$(bb_handling)/* deleted"
	$(RM) -f $(zdc_handling)/*
	echo "  - >>$(zdc_handling)/* deleted"
	$(RM) -f $(dc_handling)/*
	echo "  - >>$(dc_handling)/* deleted"
	$(RM) -f $(pc_handling)/*
	echo "  - >>$(pc_handling)/* deleted"
	$(RM) -f $(tec_handling)/*
	echo "  - >>$(tec_handling)/* deleted"
	$(RM) -f $(rich_handling)/*
	echo "  - >>$(rich_handling)/* deleted"
	$(RM) -f $(tof_handling)/*
	echo "  - >>$(tof_handling)/* deleted"
	$(RM) -f $(pbgl_handling)/*
	echo "  - >>$(pbgl_handling)/* deleted"
	$(RM) -f $(pbsc_handling)/*
	echo "  - >>$(pbsc_handling)/* deleted"
	echo "\n"
	echo "READY !!\n"