def initialize_project(project: Project):
    project_folder_path = server.get_project_folder_path(project.id)
    os.makedirs(project_folder_path, exist_ok=True)

    analysis_folder_path = server.get_analysis_folder_path(project.id)
    os.makedirs(analysis_folder_path, exist_ok=True)

    default_project_settings = ProjectSettings(name=project.name, generation=None)
    save_project_settings(project.id, default_project_settings)
def convert_dat_to_pdb(project_id: str) -> bool:
    if not server.project_file_exists(project_id, ProjectFile.TRAJECTORY_DAT) \
            or not server.project_file_exists(project_id, ProjectFile.GENERATED_TOP):
        return False

    project_folder_path = server.get_project_folder_path(project_id)
    process = subprocess.Popen(["traj2pdb.py", "trajectory.dat", "generated.top", "trajectory.pdb"],
                               cwd=project_folder_path)
    process.wait()
    return True
Пример #3
0
def execute_sim(job_id: str,
                project_id: str,
                user_id: str,
                should_regenerate: bool,
                fresh_execution=True,
                execution_time=None):
    job = Job(id=job_id,
              process_name=execute_sim.request.id,
              start_time=timezone.now(),
              finish_time=None,
              terminated=False)
    job.save(update_fields=[
        'process_name', 'start_time', 'finish_time', 'terminated'
    ])

    # Clean the previous execution files
    if should_regenerate or fresh_execution:
        server.clean_project(project_id)

    project_folder_path = server.get_project_folder_path(project_id)
    stdout_file_path = server.get_project_file(project_id, ProjectFile.STDOUT)

    if should_regenerate:
        print("Regenerating topology for project: " + project_id)
        generate_initial_configuration(project_id, stdout_file_path)

    print("Received new execution for project: " + project_id)

    stdout_log_file = open(file=stdout_file_path, mode='w')

    process = subprocess.Popen(['oxDNA', 'input.txt'],
                               cwd=project_folder_path,
                               stdout=stdout_log_file)

    try:
        process.wait(timeout=execution_time)
    except TimeoutExpired as ex:
        process.terminate()
        print("Simulation wall time of " + str(execution_time) +
              "s reached for project: " + project_id)

    stdout_log_file.close()

    print("Simulation completed, generating pdb file for project: " +
          project_id)

    if not project_util.generate_sim_files(project_id):
        print('Unable to convert simulation to visualizer output.')

    execute_output_analysis(project_id, user_id)

    job = Job(id=job_id, finish_time=timezone.now(), process_name=None)
    job.save(update_fields=['process_name', 'finish_time'])
def convert_dat_to_pdb(project_id: str) -> bool:
    if not server.project_file_exists(project_id, ProjectFile.TRAJECTORY_DAT) \
            or not server.project_file_exists(project_id, ProjectFile.GENERATED_TOP):
        return False

    project_folder_path = server.get_project_folder_path(project_id)
    process = subprocess.Popen([
        'traj2pdb.py', ProjectFile.TRAJECTORY_DAT.value,
        ProjectFile.GENERATED_TOP.value, ProjectFile.TRAJECTORY_PDB.value
    ],
                               cwd=project_folder_path)
    process.wait()
    return True
def zip_project(project_id: str) -> Optional[str]:
    project_folder_path = server.get_project_folder_path(project_id)
    project_zip_path = server.get_project_file(project_id, ProjectFile.PROJECT_ZIP)

    if server.project_folder_exists(project_id):
        if os.path.exists(project_zip_path):
            os.remove(project_zip_path)

        with ZipFile(project_zip_path, 'w') as archive:
            for (dir_path, dir_names, file_names) in os.walk(project_folder_path):
                file_names_len = len(file_names)
                for i in range(0, file_names_len):
                    if '.zip' in file_names[i]:
                        continue
                    archive.write(os.path.join(dir_path, file_names[i]), file_names[i])
        return project_zip_path
    return None
Пример #6
0
def generate_input_file(project_id: str, data: Union[Dict, object]):
    project_folder_path = server.get_project_folder_path(project_id)
    input_path = os.path.join(project_folder_path,
                              defaults.DEFAULT_INPUT_FILE_NAME)

    os.makedirs(project_folder_path, exist_ok=True)

    input_file = open(file=input_path, mode='w')
    for key, value in data.items():
        if key == 'output_prefix' and value == '':
            continue
        if key == 'project_id':
            continue
        if key == 'T':
            value = value + ' K'
        input_file.write(key + ' = ' + str(value) + '\n')
    input_file.close()

    return messages.INPUT_GENERATED
def generate_sa(project_id: str, generation: Generation,
                log_file_path: str) -> bool:
    log = None

    project_folder_path = server.get_project_folder_path(project_id)

    if log_file_path is not None:
        log = open(file=log_file_path, mode='w')
        process = subprocess.Popen(args=generation.arguments,
                                   cwd=os.path.join(os.getcwd(),
                                                    project_folder_path),
                                   stderr=log)
    else:
        process = subprocess.Popen(args=generation.arguments,
                                   cwd=os.path.join(os.getcwd(),
                                                    project_folder_path))

    result_code = process.wait()
    if log_file_path is not None:
        log.close()

    return result_code == 0
def generate_cadnano_interface(project_id: str, generation: Generation,
                               log_file_path: str) -> bool:
    log = None

    project_folder_path = server.get_project_folder_path(project_id)

    if log_file_path is not None:
        log = open(file=log_file_path, mode='w')
        process = subprocess.Popen(args=generation.arguments,
                                   cwd=os.path.join(os.getcwd(),
                                                    project_folder_path),
                                   stderr=log)
    else:
        process = subprocess.Popen(args=generation.arguments,
                                   cwd=os.path.join(os.getcwd(),
                                                    project_folder_path))

    process.wait()
    if log_file_path is not None:
        log.close()

    if os.path.isfile(os.path.join(project_folder_path, 'prova.top')):
        os.rename(os.path.join(project_folder_path, 'prova.top'),
                  os.path.join(project_folder_path, 'generated.top'))
    else:
        return False

    if os.path.isfile(os.path.join(project_folder_path, 'prova.conf')):
        os.rename(os.path.join(project_folder_path, 'prova.conf'),
                  os.path.join(project_folder_path, 'generated.dat'))
    else:
        return False

    if os.path.isfile(os.path.join(project_folder_path, 'virt2nuc')):
        os.remove(os.path.join(project_folder_path, 'virt2nuc'))

    return True