def main():
# create a parser object for getting the command line options
parser = my_argparse.MyArgumentParser()
# mandatory arguments
parser.add_argument('-u', '--user', dest='user', required=True, type=str)
parser.add_argument(dest='input_file')
# optional arguments
parser.add_argument('-ser',
'--server',
dest='server',
required=False,
default='https://' +
os_utils.getenv_required('XNAT_PBS_JOBS_XNAT_SERVER'),
type=str)
parser.add_argument('-p',
'--password',
dest='password',
required=False,
type=str)
# parse the command line arguments
args = parser.parse_args()
if args.password:
password = args.password
else:
password = getpass.getpass("Password: "******"Parsed arguments:")
_inform(" Username: "******" Password: "******"*** password mask ***")
_inform(" Server: " + args.server)
_inform(" Input File: " + args.input_file)
_inform("")
input_file = open(args.input_file, 'r')
for line in input_file:
line = str_utils.remove_ending_new_lines(line)
line = line.strip()
if line != '' and line[0] != '#':
(project, subject, session, resource) = line.split('\t')
_inform("")
_inform(" Project: " + project)
_inform(" Subject: " + subject)
_inform(" Session: " + session)
_inform(" Resource: " + resource)
_inform("")
delete_resource.delete_resource(args.user, password, args.server,
project, subject, session,
resource)
def main():
parser = my_argparse.MyArgumentParser()
parser.add_argument('-d', '--directory', dest='directory', required=True, type=str)
args = parser.parse_args()
root_path = os.path.expandvars(os.path.expanduser(args.directory))
print("root_path: " + root_path)
os_utils.replace_symlinks_with_relative(root_path)
def main():
# create a parser object for getting the command line arguments
parser = my_argparse.MyArgumentParser(
description="Program to delete all DB resources of a given name for all sessions in a given ConnectomeDB project.")
# mandatory arguments
parser.add_argument('-u', '--user', dest='user', required=True, type=str)
parser.add_argument('-pw', '--password', dest='password', required=True, type=str)
parser.add_argument('-pr', '--project', dest='project', required=True, type=str)
parser.add_argument('-r', '--resource', dest='resource', required=True, type=str)
# optional arguments
parser.add_argument('-ser', '--server', dest='server', required=False,
default='https://' + os_utils.getenv_required('XNAT_PBS_JOBS_XNAT_SERVER'),
type=str)
parser.add_argument('-f', '--force', dest='force', action='store_true', required=False, default=False)
# parse the command line arguments
args = parser.parse_args()
# show parsed arguments
_inform("Parsed arguments:")
_inform(" Username: "******" Password: "******"*** password mask ***")
_inform(" Server: " + args.server)
_inform(" Project: " + args.project)
_inform(" Resource: " + args.resource)
_inform(" Force: " + str(args.force))
# find all instances of the specified resource in the specified project
my_xnat_archive = xnat_archive.XNAT_Archive()
archive_root = my_xnat_archive.project_archive_root(args.project)
dir_list = glob.glob(archive_root + os.sep + '*')
for directory in sorted(dir_list):
resource_dir_to_look_for = directory + os.sep + 'RESOURCES' + os.sep + args.resource
if os.path.isdir(resource_dir_to_look_for):
unprefixed = resource_dir_to_look_for.replace(archive_root + os.sep, "")
sep_loc = unprefixed.find(os.sep)
session = unprefixed[:sep_loc]
underscore_loc = session.find('_')
subject = session[:underscore_loc]
_inform("Deleting resource: " + args.resource + " for session: " + session)
delete_resource.delete_resource(args.user, args.password, args.server,
args.project, subject, session,
args.resource, args.force)
def main():
parser = my_argparse.MyArgumentParser()
parser.add_argument("full_path")
parser.add_argument("-v",
"--verbose",
dest="verbose",
action='store_true',
required=False,
default=False)
args = parser.parse_args()
file_utils.make_all_links_into_copies(args.full_path, verbose=args.verbose)
def main():
# create a parser object for getting the command line options
parser = my_argparse.MyArgumentParser(description="Program to check Diffusion Preprocessing Output size")
# mandatory arguments
parser.add_argument('-p', '--project', dest='project', required=True, type=str)
# optional arguments
parser.add_argument('-s', '--subject', dest='subject', required=False, default='all', type=str)
# parse the command line arguments
args = parser.parse_args()
# show parsed arguments
log.debug("Project: " + args.project)
log.debug("Subject: " + args.subject)
# create archive
archive = hcp3t_archive.Hcp3T_Archive()
# Create a list of subjects to process
subject_list = _build_subject_list(archive, args.project, args.subject)
all_succeeded = True
# Create a DiffusionOutputSizeChecker
size_checker = DiffusionOutputSizeChecker()
print("Subject\tExpected Volumes\tCheck Success")
for subject in subject_list:
subject_info = hcp3t_subject.Hcp3TSubjectInfo(args.project, subject)
try:
# check the diffusion preprocessing size for the specified subject
(success, expected_size, msg) = size_checker.check_diffusion_preproc_size(archive, subject_info)
print(subject_info.subject_id + "\t" + str(expected_size) + "\t" + str(success) + "\t" + msg)
all_succeeded = all_succeeded and success
except NoDiffusionPreprocResource as e:
print(subject_info.subject_id + "\t" + "N/A" + "\t" + "N/A" + "\t" + "No Diff Preproc Resource")
all_succeeded = False
except FileNotFoundError as e:
print(subject_info.subject_id + "\t" + "N/A" + "\t" + "N/A" + "\t" + "A necessary output file was not found")
all_succeeded = False
return all_succeeded
def main():
parser = my_argparse.MyArgumentParser(
description="Get meta data about a file from a corresponding JSON file"
)
# required arguments
parser.add_argument('-f', '--file', dest='file', required=True, type=str)
parser.add_argument('-k', '--key', dest='key', required=True, type=str)
args = parser.parse_args()
meta_data_json_file_name = file_utils.get_meta_data_json_file_name(
args.file)
meta_data_json_file = open(meta_data_json_file_name, "r")
meta_data = json.load(meta_data_json_file)
meta_data_json_file.close()
value = meta_data[args.key]
print(str(value))
def main():
parser = my_argparse.MyArgumentParser(
description=
"Simple program to delete duplicate lines in a text file. Unlike the Linux/Unix uniq utility, it doesn't require duplicates to be adjacent."
)
# optional arguments
parser.add_argument('-i',
'--input-file',
dest='input_file_name',
required=False,
default=None,
type=str)
parser.add_argument('-o',
'--output-file',
dest='output_file_name',
required=False,
default=None,
type=str)
# parse the command line arguments
args = parser.parse_args()
if not args.input_file_name:
args.input_file_name = input("Input file name: ")
if not args.output_file_name:
args.output_file_name = input("Output file name: ")
_inform(" Input file name: " + args.input_file_name)
_inform("Output file name: " + args.output_file_name)
output_lines = []
with open(args.input_file_name, 'r') as input_file:
for line in input_file:
line = line.rstrip()
if line not in output_lines:
output_lines.append(line)
with open(args.output_file_name, 'w') as output_file:
for line in output_lines:
output_file.write(line + os.linesep)
def main():
parser = my_argparse.MyArgumentParser()
# optional arguments
parser.add_argument('-d',
'--directory',
dest='directory',
required=False,
default=None,
type=str)
# parse the command line arguments
args = parser.parse_args()
if not args.directory:
args.directory = input("Directory: ")
root_path = os.path.expandvars(os.path.expanduser(args.directory))
print("root_path: " + root_path)
os_utils.replace_lndir_symlinks(root_path)
def main():
# create a parser object for getting the command line arguments
parser = my_argparse.MyArgumentParser()
parser.add_argument('-a', '--all-subjects=', dest='all_subjects', required=True, type=str)
parser.add_argument('-t', '--todo-subjects=', dest='todo_subjects', required=True, type=str)
args = parser.parse_args()
# print("Retrieving all subjects from: " + args.all_subjects)
all_subjects_list = hcp7t_subject.read_subject_info_list(args.all_subjects, separator=":")
# print("Retrieving subject ids in TODO list from: " + args.todo_subjects)
to_do_subjects_list = []
to_do_ids_file = open(args.todo_subjects, "r")
for line in to_do_ids_file:
subject_id = line[:-1]
for subject in all_subjects_list:
if subject_id == subject.subject_id:
print(str(subject))
break
def main():
# create a parser object for getting the command line options
parser = my_argparse.MyArgumentParser(
description="Program to delete a DB resource.")
# mandatory arguments
parser.add_argument('-u', '--user', dest='user', required=True, type=str)
parser.add_argument('-pr',
'--project',
dest='project',
required=True,
type=str)
parser.add_argument('-sub',
'--subject',
dest='subject',
required=True,
type=str)
parser.add_argument('-ses',
'--session',
dest='session',
required=True,
type=str)
parser.add_argument('-r',
'--resource',
dest='resource',
required=True,
type=str)
# optional arguments
parser.add_argument('-ser',
'--server',
dest='server',
required=False,
default='https://' +
os_utils.getenv_required('XNAT_PBS_JOBS_XNAT_SERVER'),
type=str)
parser.add_argument('-f',
'--force',
dest='force',
action="store_true",
required=False,
default=False)
parser.add_argument('-pw',
'--password',
dest='password',
required=False,
type=str)
# parse the command line arguments
args = parser.parse_args()
if args.password:
password = args.password
else:
password = getpass.getpass("Password: "******"Parsed arguments:")
_inform(" Username: "******" Password: "******"*** password mask ***")
_inform(" Server: " + args.server)
_inform(" Project: " + args.project)
_inform(" Subject: " + args.subject)
_inform(" Session: " + args.session)
_inform(" Resource: " + args.resource)
_inform(" Force: " + str(args.force))
if args.force:
delete_it = True
elif user_utils.should_proceed():
delete_it = True
else:
delete_it = False
delete_resource(args.user, password, args.server, args.project,
args.subject, args.session, args.resource, delete_it)
config.read(config_file_name)
# process the subjects in the list
batch_submitter = BatchSubmitter()
batch_submitter.submit_jobs(userid, password, subject_list, config,
force_job_submissions)
if __name__ == '__main__':
logging.config.fileConfig(
file_utils.get_logging_config_file_name(__file__),
disable_existing_loggers=False)
parser = my_argparse.MyArgumentParser(
description=
"Batch mode submission of processing jobs for Structural Preprocessing"
)
# option arguments
#
# The --force-job-submission or -f option tells this program to ignore
# checking to see whether a set of jobs is already submitted for a
# subject/session and to go ahead and submit the jobs anyhow.
parser.add_argument('-f',
'--force-job-submission',
dest='force_job_submission',
action='store_true',
required=False,
default=False)
# parse the command line arguments
complete, queued_or_running):
scan_line = "\t".join([
project, subject_id, classifier, scan,
str(prereqs_met), resource,
str(exists), resource_date_str,
str(complete),
str(queued_or_running)
])
print(scan_line)
output_file.write(scan_line + os.linesep)
if __name__ == "__main__":
parser = my_argparse.MyArgumentParser(
description=
"Batch mode checking of completion of Functional Preprocessing")
# optional arguments
# The --bypass-mark option tells this program to ignore whether the resource
# is marked complete and just go ahead and do a full completion check.
parser.add_argument('-b',
'--bypass-mark',
dest='bypass_mark',
action='store_true',
required=False,
default=False)
parser.add_argument('-v',
'--verbose',
dest='verbose',
action='store_true',
def _write_subject_info(output_file, project, subject_id, scan,
resource_exists, resource_date, files_exist):
subject_line = "\t".join([
project, subject_id, scan,
str(resource_exists), resource_date,
str(files_exist)
])
print(subject_line)
output_file.write(subject_line + os.linesep)
if __name__ == "__main__":
parser = my_argparse.MyArgumentParser()
parser.add_argument('-r',
'--reg-name',
dest='reg_name',
required=False,
default="",
type=str)
args = parser.parse_args()
if args.reg_name != "":
print("reg_name: " + args.reg_name)
# get list of subjects to check
subject_file_name = 'subjectfiles' + os.sep + file_utils.get_subjects_file_name(
__file__)
def PIPELINE_NAME(self):
return 'MultiRunIcaFixProcessing'
def my_resource(self, archive, subject_info):
return archive.multirun_icafix_dir_full_path(subject_info)
def my_prerequisite_dir_full_paths(self, archive, subject_info):
dirs = []
dirs.append(archive.structural_preproc_dir_full_path(subject_info))
return dirs
if __name__ == "__main__":
parser = my_argparse.MyArgumentParser(
description=
"Program to check for completion of MultiRunICAFIX Processing.")
# mandatory arguments
parser.add_argument('-p',
'--project',
dest='project',
required=True,
type=str)
parser.add_argument('-s',
'--subject',
dest='subject',
required=True,
type=str)
parser.add_argument('-c',
'--classifier',
output_file.write(header_line + os.linesep)
def _write_subject_info(output_file, project, subject_id, prereqs_met,
resource, exists, resource_date_str, complete,
queued_or_running):
subject_line = "\t".join([project, subject_id, str(prereqs_met),
resource, str(exists), resource_date_str, str(complete),
str(queued_or_running)])
print(subject_line)
output_file.write(subject_line + os.linesep)
if __name__ == "__main__":
parser = my_argparse.MyArgumentParser(
description="Batch mode checking of completion of MultiRunIcaFixHCP7T Processing")
# optional
# The --bypass-mark option tells this program to ignore whether the resource
# is marked complete and just go ahead and do a full completion check.
parser.add_argument('-b', '--bypass-mark', dest='bypass_mark', action='store_true',
required=False, default=False)
parser.add_argument('-v', '--verbose', dest='verbose', action='store_true',
required=False, default=False)
# parse the command line arguments
args = parser.parse_args()
if args.bypass_mark:
module_logger.info("Bypassing completion markers and doing complete check")
print("Bypassing completion markers and doing complete check")
count_of_t2w_resources = 0
for name in struct_unproc_dir_names:
if name.startswith('T1w'):
count_of_t1w_resources += 1
if name.startswith('T2w'):
count_of_t2w_resources += 1
# does at least 1 T1w unprocessed resource exist and
# at least 1 T2w unprocessed resource exist
return (count_of_t1w_resources > 0) and (count_of_t2w_resources > 0)
if __name__ == "__main__":
parser = my_argparse.MyArgumentParser(
description=
"Program to check prerequisites for the Structural Preprocessing.")
# mandatory arguments
parser.add_argument('-p',
'--project',
dest='project',
required=True,
type=str)
parser.add_argument('-s',
'--subject',
dest='subject',
required=True,
type=str)
parser.add_argument('-c',
'--classifier',
dest='classifier',
def main():
# create a parser object for getting the command line arguments
parser = my_argparse.MyArgumentParser()
# mandatory arguments
parser.add_argument('-p',
'--project',
dest='project',
required=True,
type=str)
parser.add_argument('-s',
'--subject',
dest='subject',
required=True,
type=str)
parser.add_argument('-d',
'--study-dir',
dest='output_study_dir',
required=True,
type=str)
# optional arguments
parser.add_argument('-c',
'--copy',
dest='copy',
action='store_true',
required=False,
default=False)
phase_choices = [
"FULL", "full", "DIFFUSION_PREPROC_VETTING",
"diffusion_preproc_vetting", "STRUCT_PREPROC", "struct_preproc",
"DIFFUSION_PREPROC", "diffusion_preproc", "DIFFUSION_BEDPOSTX",
"diffusion_bedpostx", "APPLY_HAND_RECLASSIFICATION_PREREQS",
"apply_hand_reclassification_prereqs", "REAPPLYFIX_PREREQS",
"reapplyfix_prereqs"
]
default_phase_choice = phase_choices[0]
parser.add_argument('-ph',
'--phase',
dest='phase',
required=False,
choices=phase_choices,
default=default_phase_choice)
# parse the command line arguments
args = parser.parse_args()
# show arguments
module_logger.info("Arguments:")
module_logger.info(" Project: " + args.project)
module_logger.info(" Subject: " + args.subject)
module_logger.info(" Output Study Dir: " + args.output_study_dir)
module_logger.info(" Copy: " + str(args.copy))
module_logger.info(" Phase: " + args.phase)
subject_info = hcp3t_subject.Hcp3TSubjectInfo(args.project, args.subject)
archive = hcp3t_archive.Hcp3T_Archive()
# create and configure CinabStyleDataRetriever
data_retriever = CinabStyleDataRetriever(archive)
data_retriever.copy = args.copy
data_retriever.show_log = True
# retrieve data based on phase requested
if (args.phase.upper() == "FULL"):
module_logger.debug("phase = FULL")
data_retriever.get_full_data(subject_info, args.output_study_dir)
elif (args.phase.upper() == "DIFFUSION_PREPROC_VETTING"):
data_retriever.get_diffusion_preproc_vetting_data(
subject_info, args.output_study_dir)
elif (args.phase.upper() == "STRUCT_PREPROC"):
data_retriever.get_data_through_STRUCT_PREPROC(subject_info,
args.output_study_dir)
elif (args.phase.upper() == "DIFFUSION_PREPROC"):
data_retriever.get_data_through_DIFFUSION_PREPROC(
subject_info, args.output_study_dir)
elif (args.phase.upper() == "DIFFUSION_BEDPOSTX"):
data_retriever.get_diffusion_bedpostx_data(subject_info,
args.output_study_dir)
elif (args.phase.upper() == "APPLY_HAND_RECLASSIFICATION_PREREQS"):
data_retriever.get_apply_hand_reclassification_prereqs(
subject_info, args.output_study_dir)
elif (args.phase.upper() == "REAPPLYFIX_PREREQS"):
data_retriever.get_reapplyfix_prereqs(subject_info,
args.output_study_dir)
data_retriever.remove_symlinks(args.output_study_dir)
def main():
# create a parser object for getting the command line arguments
parser = my_argparse.MyArgumentParser()
# mandatory arguments
parser.add_argument('-p',
'--project',
dest='project',
required=True,
type=str)
parser.add_argument('-s',
'--subject',
dest='subject',
required=True,
type=str)
parser.add_argument('-d',
'--study-dir',
dest='output_study_dir',
required=True,
type=str)
# optional arguments
parser.add_argument('-a',
'--scan',
dest='scan',
required=False,
type=str,
default=None)
parser.add_argument('-c',
'--copy',
dest='copy',
action='store_true',
required=False,
default=False)
parser.add_argument('-l',
'--log',
dest='log',
action='store_true',
required=False,
default=False)
parser.add_argument('-r',
'--remove-non-subdirs',
dest='remove_non_subdirs',
action='store_true',
required=False,
default=False)
phase_choices = [
"STRUCT_PREPROC_PREREQS", "struct_preproc_prereqs",
"STRUCT_PREPROC_HAND_EDIT_PREREQS", "struct_preproc_hand_edit_prereqs",
"DIFF_PREPROC_PREREQS", "diff_preproc_prereqs", "FUNC_PREPROC_PREREQS",
"func_preproc_prereqs", "MULTIRUNICAFIX_PREREQS",
"multirunicafix_prereqs", "MSMALL_PREREQS", "msmall_prereqs",
"DEDRIFTANDRESAMPLE_PREREQS", "dedriftandresample_prereqs",
"REAPPLYFIX_PREREQS", "reapplyfix_prereqs"
]
default_phase_choice = phase_choices[0]
parser.add_argument('-ph',
'--phase',
dest='phase',
required=False,
choices=phase_choices,
default=default_phase_choice)
parser.add_argument('-cl',
'--classifier',
dest='session_classifier',
required=False,
type=str,
default='3T')
# parse the command line arguments
args = parser.parse_args()
# convert phase argument to uppercase
args.phase = args.phase.upper()
# show arguments
module_logger.info("Arguments:")
module_logger.info(" Project: " + args.project)
module_logger.info(" Subject: " + args.subject)
module_logger.info(" Session Classifier: " + args.session_classifier)
module_logger.info(" Output Dir: " + args.output_study_dir)
module_logger.info(" Phase: " + args.phase)
if args.copy:
module_logger.info(" Copy: " + str(args.copy))
if args.log:
module_logger.info(" Log: " + str(args.log))
if args.remove_non_subdirs:
module_logger.info(" Remove Non-Subdirs: " +
str(args.remove_non_subdirs))
subject_info = ccf_subject.SubjectInfo(args.project, args.subject,
args.session_classifier, args.scan)
archive = ccf_archive.CcfArchive()
data_retriever = DataRetriever(archive)
data_retriever.copy = args.copy
data_retriever.show_log = args.log
# retrieve data based on phase requested
if args.phase == "STRUCT_PREPROC_PREREQS":
data_retriever.get_struct_preproc_prereqs(subject_info,
args.output_study_dir)
elif args.phase == "STRUCT_PREPROC_HAND_EDIT_PREREQS":
data_retriever.get_struct_preproc_hand_edit_prereqs(
subject_info, args.output_study_dir)
elif args.phase == "DIFF_PREPROC_PREREQS":
data_retriever.get_diffusion_preproc_prereqs(subject_info,
args.output_study_dir)
elif args.phase == "FUNC_PREPROC_PREREQS":
data_retriever.get_functional_preproc_prereqs(subject_info,
args.output_study_dir)
elif args.phase == "MULTIRUNICAFIX_PREREQS":
data_retriever.get_multirunicafix_prereqs(subject_info,
args.output_study_dir)
elif args.phase == "MSMALL_PREREQS":
data_retriever.get_msmall_prereqs(subject_info, args.output_study_dir)
elif args.phase == "DEDRIFTANDRESAMPLE_PREREQS":
data_retriever.get_dedriftandresample_prereqs(subject_info,
args.output_study_dir)
# Get the group average drift data
# As of February 2017, the group average drift data has been moved from HCP_Staging to
# HCP_1200
data_retriever.get_msm_group_average_drift_data(
"HCP_1200", args.output_study_dir)
elif args.phase == "REAPPLYFIX_PREREQS":
data_retriever.get_reapplyfix_prereqs(subject_info,
args.output_study_dir)
if args.remove_non_subdirs:
# remove any non-subdirectory data at the output study directory level
data_retriever.remove_non_subdirs(args.output_study_dir)
# process subjects in the list
batch_submitter = BatchSubmitter()
batch_submitter.submit_jobs(userid, password, subject_list, config,
force_submission)
if __name__ == '__main__':
logging_config_file_name = file_utils.get_logging_config_file_name(
__file__)
print("Reading logging configuration from file: " +
logging_config_file_name)
logging.config.fileConfig(logging_config_file_name,
disable_existing_loggers=False)
parser = my_argparse.MyArgumentParser(
description="Submit a batch of HCP 7T MultiRunIcaFix Jobs")
# option arguments
# The -f or --force option tells this program to ignore the fact that a job may
# already be running for a specified subject/scan and submit jobs anyhow.
# Keep in mind that this will very likely royally screw up the mechanism for
# keeping track of whether jobs are queued or running for that subject/scan.
# But sometimes, particularly during testing, it is useful and necessary.
parser.add_argument('-f',
'--force',
dest='force',
action='store_true',
required=False,
default=False)
# parse the command line arguments
@property
def PIPELINE_NAME(self):
return 'MsmAllProcessing'
def my_resource(self, archive, subject_info):
return archive.msm_all_dir_full_path(subject_info)
def my_prerequisite_dir_full_paths(self, archive, subject_info):
dirs = []
dirs.append(archive.structural_preproc_dir_full_path(subject_info))
return dirs
if __name__ == "__main__":
parser = my_argparse.MyArgumentParser(
description="Program to check for completion of MSM-All Processing.")
# mandatory arguments
parser.add_argument('-p',
'--project',
dest='project',
required=True,
type=str)
parser.add_argument('-s',
'--subject',
dest='subject',
required=True,
type=str)
parser.add_argument('-c',
'--classifier',
dest='classifier',
output_file.write(header_line + os.linesep)
def _write_subject_info(output_file, project, subject_id, classifier, prereqs_met,
resource, exists, resource_date_str, complete,
queued_or_running):
subject_line = "\t".join([project, subject_id, classifier, str(prereqs_met),
resource, str(exists), resource_date_str, str(complete),
str(queued_or_running)])
print(subject_line)
output_file.write(subject_line + os.linesep)
if __name__ == "__main__":
parser = my_argparse.MyArgumentParser(
description="Batch mode checking of completion of MSM-All Processing")
# optional arguments
# The --bypass-mark option tells this program to ignore whether the resource
# is marked complete and just go ahead and do a full completion check.
parser.add_argument('-b', '--bypass-mark', dest='bypass_mark', action='store_true',
required=False, default=False)
parser.add_argument('-v', '--verbose', dest='verbose', action='store_true',
required=False, default=False)
# parse the command line arguments
args = parser.parse_args()
if args.bypass_mark:
module_logger.info("Bypassing completion markers and doing complete check")
print("Bypassing completion markers and doing complete check")
def main():
# create a parser object for getting the command line arguments
parser = my_argparse.MyArgumentParser()
# mandatory arguments
parser.add_argument('-p',
'--project',
dest='project',
required=True,
type=str)
parser.add_argument('-s',
'--subject',
dest='subject',
required=True,
type=str)
parser.add_argument('-d',
'--study-dir',
dest='output_study_dir',
required=True,
type=str)
parser.add_argument('-t',
'--structural-reference-project',
dest='structural_reference_project',
required=True,
type=str)
# optional arguments
parser.add_argument('-c',
'--copy',
dest='copy',
action='store_true',
required=False,
default=False)
parser.add_argument('-l',
'--log',
dest='log',
action='store_true',
required=False,
default=False)
parser.add_argument('-r',
'--remove-non-subdirs',
dest='remove_non_subdirs',
action='store_true',
required=False,
default=False)
parser.add_argument('-j',
'--remove-job-and-catalog-files',
dest='remove_job_and_catalog_files',
action='store_true',
required=False,
default=False)
phase_choices = [
"FULL", "full", "DIFFUSION_PREPROC_VETTING",
"diffusion_preproc_vetting", "MULTIRUNICAFIX_PREREQS",
"multirunicafix_prereqs", "ICAFIX", "icafix", "MULTIRUNICAFIX",
"multirunicafix", "POSTFIX", "postfix"
]
parser.add_argument('-ph',
'--phase',
dest='phase',
required=False,
choices=phase_choices,
default="full")
# parse the command line arguments
args = parser.parse_args()
# show arguments
log.info("Arguments:")
log.info(" Project: " + args.project)
log.info(" Structural Ref Project: " + args.structural_reference_project)
log.info(" Subject: " + args.subject)
log.info(" Output Study Dir: " + args.output_study_dir)
log.info(" Copy: " + str(args.copy))
log.info(" Phase: " + args.phase)
log.info(" Log: " + str(args.log))
log.info(" Remove Non-Subdirs: " + str(args.remove_non_subdirs))
subject_info = hcp7t_subject.Hcp7TSubjectInfo(
project=args.project,
structural_reference_project=args.structural_reference_project,
subject_id=args.subject)
archive = hcp7t_archive.Hcp7T_Archive()
reference_archive = hcp3t_archive.Hcp3T_Archive()
# create and configure CinabStyleDataRetriever
data_retriever = CinabStyleDataRetriever(archive, reference_archive)
data_retriever.copy = args.copy
data_retriever.show_log = args.log
# retrieve data based on phase requested
args.phase = args.phase.upper()
if args.phase == "FULL":
data_retriever.get_full_data(subject_info, args.output_study_dir)
elif args.phase == "DIFFUSION_PREPROC_VETTING":
data_retriever.get_diffusion_preproc_vetting_data(
subject_info, args.output_study_dir)
elif args.phase == "MULTIRUNICAFIX_PREREQS":
data_retriever.get_multirunicafix_prereqs(subject_info,
args.output_study_dir)
elif args.phase == "ICAFIX":
data_retriever.get_data_through_ICAFIX(subject_info,
args.output_study_dir)
elif args.phase == "MULTIRUNICAFIX":
data_retriever.get_data_through_multirun_ICAFIX(
subject_info, args.output_study_dir)
elif args.phase == "POSTFIX":
data_retriever.get_data_through_PostFix(subject_info,
args.output_study_dir)
if args.remove_non_subdirs:
# remove any non-subdirectory data at the output study directory level
data_retriever.remove_non_subdirs(args.output_study_dir)
data_retriever.remove_non_subdirs(args.output_study_dir + os.sep +
subject_info.subject_id)
if args.remove_job_and_catalog_files:
# remove any PBS job files and XNAT catalog files
data_retriever.remove_pbs_job_files(args.output_study_dir)
data_retriever.remove_xnat_catalog_files(args.output_study_dir)
@property
def PIPELINE_NAME(self):
return 'StructuralPreprocessing'
def my_resource(self, archive, subject_info):
return archive.structural_preproc_dir_full_path(subject_info)
def my_prerequisite_dir_full_paths(self, archive, subject_info):
return archive.available_structural_unproc_dir_full_paths(subject_info)
if __name__ == "__main__":
parser = my_argparse.MyArgumentParser(
description=
"Program to check for completion of Structural Preprocessing.")
# mandatory arguments
parser.add_argument('-p',
'--project',
dest='project',
required=True,
type=str)
parser.add_argument('-s',
'--subject',
dest='subject',
required=True,
type=str)
parser.add_argument('-c',
'--classifier',
class OneSubjectCompletionChecker(one_subject_completion_checker.OneSubjectCompletionChecker):
"""Used for completion checking of diffusion preprocessing
"""
def __init__(self):
super().__init__()
@property
def processing_name(self):
return 'DiffusionPreprocessing'
if __name__ == "__main__":
parser = my_argparse.MyArgumentParser(
description="Program to check for completion of Diffusion Preprocessing for a single subject.")
# mandatory arguments
parser.add_argument('-w', '--working-dir', dest='working_dir', required=True, type=str)
parser.add_argument('-s', '--subject', dest='subject', required=True, type=str)
parser.add_argument('-c', '--classifier', dest='classifier', required=True, type=str)
parser.add_argument('-f', '--fieldmap', dest='fieldmap', required=False, type=str, default='NONE')
# optional arguments
parser.add_argument('-v', '--verbose', dest='verbose', action='store_true',
required=False, default=False)
parser.add_argument('-o', '--output', dest='output', required=False, type=str)
parser.add_argument('-a', '--check-all', dest='check_all', action='store_true',
required=False, default=False)
# parse the command line arguments
