ankflag 3.0.0__py3-none-any.whl

ankflag/data/ank.yml

@@ -0,0 +1,84 @@
+#   -----------------------------------------------------------------
+#   This file provides the control parameters for aNKflag
+#   -----------------------------------------------------------------
+
+Ukey:       "UU"                                            #   Keyword for u   
+Vkey:       "VV"                                            #   Keyword for v
+Wkey:       "WW"                                            #   Keyword for w
+UgridCal:   1                                               #   Gridsize in u for calibrators
+VgridCal:   1                                               #   Gridsize in v for calibrators
+UgridTar:   10                                              #   Gridsize in u for Target
+VgridTar:   10                                              #   Gridsize in v for Target
+Npols:      2                                               #	Number of polarizations
+N_ants:     30                                              #	Maximum number of antennas
+ScanFlMean: ['rms', 1.5, 1.5, 0.01]                         #   [FLAGON, tolerance_mean, tolearnce_rms, min fraction (should be > 0.01)]]	
+                                                            #   ONLY for 'baseline' mode
+ScanBrkSec: 300.0                                           #   Scan break time (minimum)
+BlockPow:   0.8                                             #	Power low for Block non-Gaussianity 
+
+
+#   Actual flagging parameters
+
+FlgCalCh0:                                                  #   Applicable to single channel calibrators only
+    - {what: 'rec_ind', flagon: 'mean', stat: 'median', data:   'am', tol: 5.0,   minfrac: 0.1}
+    - {what: 'rec_ind', flagon: 'mean', stat: 'median', data:   'am', tol: 2.0,   minfrac: 0.1}
+    - {what: 'rec_ind', flagon: 'mean', stat: 'median', data:   'am', tol: 1.5,   minfrac: 0.1}
+    - {what: 'rec_ind', flagon: 'mean', stat: 'median', data:   're', tol: 1.2,   minfrac: 0.1}
+    - {what: 'rec_ind', flagon: 'mean', stat: 'median', data:   'im', tol: 1.2,   minfrac: 0.1}
+    - {what: 'rec_ind', flagon: 'mean', stat: 'median', data:   'am', tol: 1.1,   minfrac: 0.1}
+    - {what: 'rec_ind', flagon: 'mean', stat: 'median', data:   're', tol: 1.1,   minfrac: 0.1}
+    - {what: 'rec_ind', flagon: 'mean', stat: 'median', data:   'im', tol: 1.1,   minfrac: 0.1}
+    
+   
+FlgCalBp:                                                   #   Applicable to bandpass calibrators only   
+    - {what: 'rec_ind',  flagon: 'rms',  stat: 'median',  data:   'am', tol: 5.0,   minfrac: 0.1, fitorder: 0}
+    - {what: 'chan_ind', flagon: 'rms',  stat: 'median',  data:   'am', tol: 5.0,   minfrac: 0.1, fitorder: 0}
+    - {what: 'rec_ind',  flagon: 'rms',  stat: 'mean',    data:   'am', tol: 5.0,   minfrac: 0.1, fitorder: 0}
+    - {what: 'chan_ind', flagon: 'rms',  stat: 'mean',    data:   'am', tol: 5.0,   minfrac: 0.1, fitorder: 0}
+    - {what: 'rec_ind',  flagon: 'rms',  stat: 'mean',    data:   'am', tol: 2.0,   minfrac: 0.1, fitorder: 0}
+    - {what: 'chan_ind', flagon: 'rms',  stat: 'mean',    data:   'am', tol: 2.0,   minfrac: 0.1, fitorder: 0}   
+    - {what: 'chan_ind', flagon: 'rms',  stat: 'median',  data:   'am', tol: 1.5,   minfrac: 0.1, fitorder: 2}
+    - {what: 'chan_ind', flagon: 'rms',  stat: 'median',  data:   're', tol: 1.5,   minfrac: 0.1, fitorder: 2}
+    - {what: 'chan_ind', flagon: 'rms',  stat: 'median',  data:   'im', tol: 1.5,   minfrac: 0.1, fitorder: 2}
+    - {what: 'rec_ind',  flagon: 'rms',  stat: 'median',  data:   'am', tol: 1.5,   minfrac: 0.1, fitorder: 2}
+    - {what: 'rec_ind',  flagon: 'rms',  stat: 'median',  data:   're', tol: 1.5,   minfrac: 0.1, fitorder: 2}
+    - {what: 'rec_ind',  flagon: 'rms',  stat: 'median',  data:   'im', tol: 1.5,   minfrac: 0.1, fitorder: 2}
+    - {what: 'chan_ind', flagon: 'rms',  stat:  'mean',   data:   're', tol: 1.5,   minfrac: 0.1, fitorder: 2}
+    - {what: 'chan_ind', flagon: 'rms',  stat:  'mean',   data:   'im', tol: 1.5,   minfrac: 0.1, fitorder: 2}
+    - {what: 'rec_ind',  flagon: 'rms',  stat:  'mean',   data:   're', tol: 1.5,   minfrac: 0.1, fitorder: 2}
+    - {what: 'rec_ind',  flagon: 'rms',  stat:  'mean',   data:   'im', tol: 1.5,   minfrac: 0.1, fitorder: 2}
+    - {what: 'chan_ind', flagon: 'rms',  stat: 'median',  data:   'am', tol: 1.2,   minfrac: 0.1, fitorder: 2}
+    - {what: 'chan_ind', flagon: 'rms',  stat: 'median',  data:   're', tol: 1.2,   minfrac: 0.1, fitorder: 2}
+    - {what: 'chan_ind', flagon: 'rms',  stat: 'median',  data:   'im', tol: 1.2,   minfrac: 0.1, fitorder: 2}
+    - {what: 'rec_ind',  flagon: 'rms',  stat: 'median',  data:   'am', tol: 1.2,   minfrac: 0.1, fitorder: 2}
+    - {what: 'rec_ind',  flagon: 'rms',  stat: 'median',  data:   're', tol: 1.2,   minfrac: 0.1, fitorder: 2}
+    - {what: 'rec_ind',  flagon: 'rms',  stat: 'median',  data:   'im', tol: 1.2,   minfrac: 0.1, fitorder: 2}
+
+
+FlgNorm:                                                    #   Applicable to calibrated target
+    - {what: 'vis_ind',  flagon: 'mean',  stat: 'mean',   data:   'am', tol: 5.0,   minfrac: 0.1, fitorder: 0}
+    - {what: 'vis_ind',  flagon: 'mean',  stat: 'mean',   data:   'am', tol: 3.0,   minfrac: 0.1, fitorder: 0}
+    - {what: 'vis_ind',  flagon: 'mean',  stat: 'median', data:   'am', tol: 2.0,   minfrac: 0.1, fitorder: 1}
+    - {what: 'chan_ind', flagon: 'rms',   stat: 'mean',   data:   'am', tol: 2.0,   minfrac: 0.1, fitorder: 0}
+    - {what: 'rec_ind',  flagon: 'rms',   stat: 'mean',   data:   'am', tol: 2.0,   minfrac: 0.1, fitorder: 0}
+    - {what: 'vis_ind',  flagon: 'mean',  stat: 'median', data:   'am', tol: 1.6,   minfrac: 0.1, fitorder: 2}
+    - {what: 'chan_ind', flagon: 'rms',   stat: 'mean',   data:   'am', tol: 1.5,   minfrac: 0.1, fitorder: 2}
+    - {what: 'rec_ind',  flagon: 'rms',   stat: 'mean',   data:   'am', tol: 1.5,   minfrac: 0.1, fitorder: 2}
+    - {what: 'chan_ind', flagon: 'rms',   stat: 'median', data:   're', tol: 1.2,   minfrac: 0.1, fitorder: 2}
+    - {what: 'chan_ind', flagon: 'rms',   stat: 'median', data:   'im', tol: 1.2,   minfrac: 0.1, fitorder: 2}
+    - {what: 'rec_ind',  flagon: 'rms',   stat: 'median', data:   're', tol: 1.2,   minfrac: 0.1, fitorder: 2}
+    - {what: 'rec_ind',  flagon: 'rms',   stat: 'median', data:   'im', tol: 1.2,   minfrac: 0.1, fitorder: 2}
+    
+
+FlgUvsub:                                                   #   Applicable to UV-subtracted target
+    - {what: 'vis_ind',  flagon: 'mean',  stat: 'mean',   data:   'am', tol: 5.0,   minfrac: 0.1, fitorder: 0}
+    - {what: 'vis_ind',  flagon: 'mean',  stat: 'mean',   data:   'am', tol: 3.0,   minfrac: 0.1, fitorder: 0}
+    - {what: 'vis_ind',  flagon: 'mean',  stat: 'median', data:   'am', tol: 2.0,   minfrac: 0.1, fitorder: 1}
+    - {what: 'chan_ind', flagon: 'rms',   stat: 'mean',   data:   'am', tol: 2.0,   minfrac: 0.1, fitorder: 0}
+    - {what: 'rec_ind',  flagon: 'rms',   stat: 'mean',   data:   'am', tol: 2.0,   minfrac: 0.1, fitorder: 0}
+    - {what: 'chan_ind', flagon: 'rms',   stat: 'mean',   data:   'am', tol: 1.5,   minfrac: 0.1, fitorder: 2}
+    - {what: 'chan_ind', flagon: 'rms',   stat: 'median', data:   're', tol: 1.2,   minfrac: 0.1, fitorder: 2}
+    - {what: 'chan_ind', flagon: 'rms',   stat: 'median', data:   'im', tol: 1.2,   minfrac: 0.1, fitorder: 2}
+
+
+

ankflag/scripts/runank.py

@@ -0,0 +1,337 @@
+import os, sys
+import numpy as np
+import time as tm
+import argparse as ap
+import ankflag.data as ad
+from pyfiglet import Figlet
+from ankflag.utils.convertfits import *
+from ankflag.utils.inputs import *
+from ankflag.utils.plottingfns import *
+from ankflag.utils.ankdata import init_ankflag_data
+from ankflag.utils.udocker_utils import initialize_ankflag_container, run_ankflag
+
+# This script is written by Apurba bera
+# Formatted and udocker contanierisation is done by Devojyoti Kansabanik
+
+def cli():
+    parser = ap.ArgumentParser(
+        description="aNKflag command line interface"
+    )
+    subparsers = parser.add_subparsers(
+        dest="command",
+        required=True,
+    )
+    # =====================
+    # init command
+    # =====================
+    init_parser = subparsers.add_parser(
+        "init",
+        help="Initialize aNKflag configuration"
+    )
+    init_parser.add_argument(
+        "--datadir",
+        help="Directory to save aNKflag container",
+        type=str,
+        default="",
+    )
+
+    # =====================
+    # run command
+    # =====================
+    run_parser = subparsers.add_parser(
+        "run",
+        help="Run aNKflag"
+    )
+
+    # Essential parameters
+    basic_args = run_parser.add_argument_group(
+        "###################\nEssential parameters\n###################"
+    )
+    basic_args.add_argument(
+        "infilename",
+        help="Input FITS file",
+        type=str,
+    )
+    basic_args.add_argument(
+        "outfilename",
+        help="Output FITS file",
+        type=str,
+    )
+    basic_args.add_argument(
+        "--scratchdir",
+        help="Scratch directory",
+        type=str,
+        default=None,
+    )
+    basic_args.add_argument(
+        "--npol",
+        help="Number of polarisation",
+        type=int,
+        default=2,
+    )
+    basic_args.add_argument(
+        "--nant",
+        help="Number of antennas",
+        type=int,
+        default=30,
+    )
+
+    # Flagging control parameters
+    flag_args = run_parser.add_argument_group(
+        "###################\nFlagging control parameters\n###################"
+    )
+    flag_args.add_argument(
+        "--flagmode",
+        help="Mode of flagging (baseline, uvbin)",
+        type=str,
+        default=None,
+    )
+    flag_args.add_argument(
+        "--target_type",
+        help="Target source type (calch0, calbp, normal, uvsub)",
+        type=str,
+        default=None,
+    )
+    flag_args.add_argument(
+        "--rfifreqfile",
+        help="File with RFI frequencies",
+        type=str,
+        default=None,
+    )
+    flag_args.add_argument(
+        "--flagautocorr",
+        help="Flag autocorrelations",
+        action="store_true",
+    )
+    
+
+    # Advanced parameters
+    adv_args = run_parser.add_argument_group(
+        "###################\nAdvanced control parameters\n###################"
+    )
+    adv_args.add_argument(
+        "--parfile",
+        help="Custom YAML file with aNKflag specific input params",
+        type=str,
+        default=None,
+    )
+    adv_args.add_argument(
+        "--verbose",
+        help="Verbose output",
+        action="store_true",
+    )
+    adv_args.add_argument(
+        "--logfile",
+        help="Name of logfile",
+        type=str,
+        default="logfile.txt",
+    )
+    adv_args.add_argument(
+        "--nthreads",
+        help="Number of threads",
+        type=int,
+        default=1,
+    )
+    adv_args.add_argument(
+        "--clearscratch",
+        help="Clear scratch directory?",
+        action="store_true",
+    )
+
+    if len(sys.argv) == 1:
+        parser.print_help(sys.stderr)
+        return 1
+        
+    args = parser.parse_args()
+    f = Figlet(font="big")
+    print(f.renderText("aNKflag"))
+    
+    if args.command == "init":
+        print("Running initialization of aNKflag...")
+        init_ankflag_data(datadir=args.datadir,update=False)
+        initialize_ankflag_container(name="ankflag", update=True)
+        return 0
+    elif args.command == "run":
+        print(f"Running aNKflag on: {args.infilename}")
+        # 	--------------------------------------
+        #   Read and verify input parameters
+        # 	--------------------------------------
+        if args.parfile == None:
+            datadir = os.path.dirname(ad.__file__)
+            parfile = f"{datadir}/ank.yml"
+            print(f"Using default input YAML file: {parfile}")
+        else:
+            parfile = args.parfile
+            print(f"Using custom input YAML file: {parfile}")
+        flagparams = getparsyaml(parfile, showparams=False)
+
+        if args.scratchdir == None:
+            scratchdir = f"{os.getcwd()}/ankscratch/"
+        else:
+            scratchdir = f"{args.scratchdir.rstrip('/')}/"
+        os.makedirs(scratchdir, exist_ok=True)
+        if args.clearscratch:
+            print("Clearing scratch directory....")
+            os.system(f"rm -rf {scratchdir}/*")
+
+        if os.path.exists(args.infilename):
+            infilefits = args.infilename
+        else:
+            print("Provide a real file")
+            return 1
+
+        if args.outfilename == None:
+            print("Provide a filename")
+            return 1
+        else:
+            outfilefits = args.outfilename
+
+        if not (args.flagmode == "uvbin" or args.flagmode == "baseline"):
+            print("Provide from these two flagging mode: uvbin or baseline")
+        else:
+            print(f"Flagging in {args.flagmode} mode.")
+
+        if args.npol!=2 and args.npol!=4:
+            print(f"Number of polarisations should be either 2 or 4, not {args.npol}.")
+            return 1
+            
+        if args.target_type in tartypes:
+            print("Target type: ", args.target_type)
+            partype = partypes[tartypes.index(args.target_type)]
+            if partype in flagparams:
+                print("Using parameters: ", partype)
+                flagparams["Npols"]=args.npol
+                flagparams["N_ants"]=args.nant
+                if args.verbose:
+                    print("Flagging commands: ")
+                    print(*flagparams[partype], sep="\n")
+            else:
+                print(partype, "is not provided...")
+                return 1
+        else:
+            print("Only supported target types are ", *tartypes, sep=" ")
+            return 1
+
+        if (args.target_type == "calch0") or (args.target_type == "calbp"):
+            uugrids = flagparams["UgridCal"]
+            vvgrids = flagparams["VgridCal"]
+        else:
+            uugrids = flagparams["UgridTar"]
+            vvgrids = flagparams["VgridTar"]
+
+        #   ------------------------------------------
+        # 	Convert parameters to aNKflag secret codes
+        #   ------------------------------------------
+        covertparams(
+            flagparams,
+            partype,
+            scratchdir + "/flagpars.pars",
+            args,
+            uugrids=uugrids,
+            vvgrids=vvgrids,
+        )
+
+        # 	------------------------------------------------
+        # 	Convert FITS to aNKflag compatible binary files
+        # 	------------------------------------------------
+
+        start0 = tm.time()
+
+        if args.flagautocorr:
+            # 	Preflag autocorrelations
+            infile = fits.open(infilefits)
+            data = infile[0].data
+            nauto = flagautocorr(flagparams["N_ants"], data)
+            infile.writeto(
+                scratchdir + "/scratchfits.fits", output_verify="warn", overwrite=True
+            )
+            infile.close()
+
+        if ConvertFITS:
+            if args.flagautocorr:
+                infile = fits.open(scratchdir + "/scratchfits.fits")
+            else:
+                infile = fits.open(infilefits)
+            data = infile[0].data
+
+            if (args.rfifreqfile != None) and os.path.exists(args.rfifreqfile):
+                # 	-----------	Flagging hopeless channels	---------------------------
+                print("Identifying bad channels from ", args.rfifreqfile)
+            else:
+                print("No bad channel list found... continuing...")
+
+            if args.flagmode == "uvbin":
+                uvfitstobinary(
+                    data,
+                    scratchdir,
+                    uugrids,
+                    vvgrids,
+                    flagparams,
+                    verbose=args.verbose,
+                )
+
+            elif args.flagmode == "baseline":
+                baselinestobinary(
+                    flagparams["N_ants"],
+                    data,
+                    scratchdir,
+                    flagparams["ScanBrkSec"],
+                    flagparams,
+                    verbose=args.verbose,
+                )
+            else:
+                print("Unknown flagging mode !!! ........")
+
+            infile.close()
+            print("Convertion done in %d seconds" % (tm.time() - start0))
+
+        # 	----------------------------
+        # 	Actual flagging is done here
+        # 	----------------------------
+
+        start1 = tm.time()
+
+        if DoFlag:
+            status = run_ankflag(
+                scratchdir,
+                args.logfile,
+                args.npol,
+                container_name="ankflag",
+                check_container=False,
+                verbose=args.verbose,
+            )
+            print("Flagging done in %d seconds" % (tm.time() - start1))
+
+        # 	---------------------------------
+        # 	Convert back binary files to FITS
+        # 	---------------------------------
+        if ReadBack:
+            if args.flagautocorr:
+                infile2 = fits.open(scratchdir + "/scratchfits.fits")
+            else:
+                infile2 = fits.open(infilefits)
+            data2 = infile2[0].data
+
+            if args.flagmode == "uvbin":
+                bintofits = uvfitsfrombinary(
+                    data2, scratchdir, uugrids, vvgrids, flagparams
+                )
+
+            elif args.flagmode == "baseline":
+                baselinesfrombinary(
+                    flagparams["N_ants"], data2, scratchdir, flagparams, verbose=args.verbose,
+                )
+
+            # 	Write the output FITS --------------
+            if WriteOut:
+                print("Writing output FITS...")
+                infile2.writeto(outfilefits, output_verify="warn", overwrite=True)
+
+            infile2.close()
+            print("Everything done in %d seconds" % (tm.time() - start0))
+
+        if args.clearscratch:
+            print("Clearing scratch directory....")
+            os.system(f"rm -rf {scratchdir}/*")
+        return 0
+        

ankflag/utils/ankcopy.py

@@ -0,0 +1,183 @@
+import numpy as np
+from astropy.io import fits
+import matplotlib.pyplot as plt
+import multiprocessing as mp
+import time as tm
+
+ANTS		=	30							#	Total number of antennas
+parallel	=	False						#	Process baselines parallelly		#	SET TO "FALSE"
+recflag		=	False						#	Copy flags for whole records
+chanflag	=	False						#	Copy flags for whole channels	
+visflag		=	True						#	Copy flags for individual visibilities
+writeout	=	True						#	Write the output file
+
+srcname		=	'/media/devojyoti/Data1/aurora_test/workdir/target_scan2.fits'			#	Input FITS file (FG TABLE IS NOT READ!)
+targetname	=	'/media/devojyoti/Data1/aurora_test/workdir/testankflag_out.fits'				#	Target FITS file
+outname		=	'/media/devojyoti/Data1/aurora_test/workdir/target_scan2_out.fits'	#	Output FITS file
+
+
+#	--------------------------------------------------------------------	Functions	----------------------------------------------------
+#	Function to copy flags from one dataset to another for a baseline
+def copybase (bl,datasrc,datatar):
+	print('Baseline	%d-%d'%(bl[0],bl[1]))	
+	bindxsrc	=	np.where(datasrc.par('BASELINE')==bl[2])
+	bdatasrc	=	datasrc[bindxsrc[0]]
+	bindxtar	=	np.where(datatar.par('BASELINE')==bl[2])
+	bdatatar	=	datatar[bindxtar[0]]
+	
+	if(len(bdatasrc)==0):
+		print('No data in source file .... flagging entire baseline in target file')
+		if(len(bdatatar)==0):
+			print('No data in target file either.... nothing to do')
+			return [2.0,[[1.0,1.0,1.0],[1.0,1.0,1.0]],0]
+		for p in range (0,2):		
+			tfdatatar	=	bldatatar[:,0,0,0,:,p,:]		#	Time frequency data target
+			tfretar		=	tfdatatar[:,:,0]				#	Real part of target
+			tfimtar		=	tfdatatar[:,:,1]				#	Imaginary Part of target
+			tfwtar		=	tfdatatar[:,:,2]				#	Weight of target
+			tfwtar		=	0.0
+			tfwre		=	0.0
+			tfwim		=	0.0
+		return [1.0,[[1.0,1.0,1.0],[1.0,1.0,1.0]],0]
+	bldatasrc	=	bdatasrc.data
+	bldatatar	=	bdatatar.data
+	flgfrac		=	[]
+	for p in range (0,2):		
+		tfdatasrc	=	bldatasrc[:,0,0,0,:,p,:]		#	Time frequency data source
+		tfdatatar	=	bldatatar[:,0,0,0,:,p,:]		#	Time frequency data target
+		tfresrc		=	tfdatasrc[:,:,0]				#	Real part of source
+		tfretar		=	tfdatatar[:,:,0]				#	Real part of target
+		tfimsrc		=	tfdatasrc[:,:,1]				#	Imaginary Part of source
+		tfimtar		=	tfdatatar[:,:,1]				#	Imaginary Part of target
+		tfwsrc		=	tfdatasrc[:,:,2]				#	Weight of source
+		tfwtar		=	tfdatatar[:,:,2]				#	Weight of target
+		
+		if(np.size(tfwsrc)!=np.size(tfwtar)):
+			print('Caution !	Sizes do not match	src = %d	target = %d'%(np.size(tfwsrc),np.size(tfwtar)))
+		
+		srcfrac		=	1.0-float(np.count_nonzero(tfwsrc>0.0))/np.size(tfwsrc)
+		tarfrac		=	1.0-float(np.count_nonzero(tfwtar>0.0))/np.size(tfwtar)
+		print('Pol	%d	flagged fractions	src 	= %.2f	target = %.2f'%(p,srcfrac,tarfrac))
+		
+		if(recflag):
+			#print('Copyting record flags ...........')
+			nrecs	=	len(tfwsrc)
+			nrect	=	len(tfwtar)
+			if(nrecs!=nrect):
+				print('Error !	Records do not match !!!!')
+				return 3
+			for r in range(0,nrecs):
+				if(np.count_nonzero(tfwsrc[r])==0):
+					tfwtar[r]	=	0.0
+					tfretar[r]	=	0.0
+					tfimtar[r]	=	0.0		
+		
+		if(chanflag):
+			#print('Copyting channel flags ...........')
+			nchans	=	len(tfwsrc[0])
+			nchant	=	len(tfwtar[0])
+			if(nchans!=nchant):
+				print('Error !	Channels do not match !!!!')
+				return 3
+			for c in range(0,nchans):
+				if(np.count_nonzero(tfwsrc[:,c])==0):
+					tfwtar[:,c]		=	0.0
+					tfretar[:,c]	=	0.0
+					tfimtar[:,c]	=	0.0	
+		
+		if(visflag):
+			#print('Copyting visibilities flags ...........')
+			nrecs	=	len(tfwsrc)
+			nrect	=	len(tfwtar)
+			nchans	=	len(tfwsrc[0])
+			nchant	=	len(tfwtar[0])
+			if((nrecs!=nrect) or (nchans!=nchant)):
+				print('Error !	Visibilities do not match !!!!')
+				return 3
+			for r in range(0,nrecs):
+				for c in range(0,nchans):
+					if(tfwsrc[r,c]<=0.0):
+						tfwtar[r,c]		=	0.0
+						tfretar[r,c]	=	0.0
+						tfimtar[r,c]	=	0.0		
+		
+		tarfracf		=	1.0-float(np.count_nonzero(tfwtar>0.0))/np.size(tfwtar)
+		print('					target	= %.2f'%(tarfracf))
+		flgfrac.append([srcfrac,tarfrac,tarfracf])
+	return [0.0,flgfrac,bldatatar,bindxsrc[0],bindxtar[0],bl]
+#	---------------------------------------------------------------------------------------------
+
+
+
+
+#	---------------------------------------------------	Main programme	-----------------------------------------------------------------	
+
+b_start	=	tm.time()
+
+srcfile		=	fits.open(srcname)		
+targetfile	=	fits.open(targetname)	
+
+datasrc		=	srcfile[0].data	
+nrecsrc		=	len(datasrc)
+datatar		=	targetfile[0].data	
+nrectar		=	len(datatar)
+
+blid	=	[]
+for a in range (1,ANTS):
+	for b in range (a+1,ANTS+1):
+		blid.append([a,b,256*a+b])
+blid	=	np.array(blid)
+nbase	=	len(blid)
+
+print('\nIdeally total baselines = %d'%nbase)
+print('Source records	=	%d	\nTarget records	=	%d\n'%(nrecsrc,nrectar))
+print('\nCopying flags for each baseline\n')
+
+if(parallel):
+	#	parallel
+	print('Sorry !	Parallel execution is not yet supported ...........')
+else:
+	#	Serial
+	blstat	=	[]
+	for i in range (0,nbase):
+		bls	=	copybase(blid[i],datasrc,datatar)
+		blstat.append(bls)
+
+#	Copying baseline
+		
+print('\nCopying baselines\n')
+for i in range (0,nbase):
+	if(blstat[i][0]<1.5):
+		bldata	=	blstat[i][2]
+		lenbase	=	len(bldata)
+		if(lenbase!=len(blstat[i][4])):
+			print('Lengths do not match !!!!')
+		for k in range (0,lenbase):
+			if(datatar[blstat[i][4][k]].par('BASELINE')!=blstat[i][5][2]):
+				print('Baselines do not match !!!!	%d	%d	%d'%(k,datatar[blstat[i][4][k]].par('BASELINE'),blstat[i][5][2]))
+			np.copyto(datatar[blstat[i][4][k]].data,bldata[k])
+		print('Baseline	%d-%d	Copied'%(blid[i][0],blid[i][1]))
+	else:
+		print('Baseline	%d-%d	No data'%(blid[i][0],blid[i][1]))		
+
+flstat	=	[]
+for i in range (0,nbase):
+	flstat.append(blstat[i][1])
+flstat	=	np.array(flstat)
+srcf	=	[np.mean(flstat[:,0,0]),np.mean(flstat[:,1,0])]
+tarfb	=	[np.mean(flstat[:,0,1]),np.mean(flstat[:,1,1])]
+tarfa	=	[np.mean(flstat[:,0,2]),np.mean(flstat[:,1,2])]
+
+print('\nSource		%.2f	%.2f'%(srcf[0],srcf[1]))
+print('\nTarget before	%.2f	%.2f'%(tarfb[0],tarfb[1]))
+print('\nTarget after	%.2f	%.2f'%(tarfa[0],tarfa[1]))
+
+if(writeout):		
+	targetfile.writeto(outname,output_verify='warn',overwrite=True)
+
+srcfile.close()
+targetfile.close()
+
+b_end	=	tm.time()
+print('\nDone in %d seconds\n'%(int(b_end-b_start)))
+