def pickup_QCLO_matrix(self, run_type="rks", force=False):
        if (self.is_finished_pickup_LO == True) and (force == False):
            logger.info("pickup LO has been finished.")
            return

        self.calc_lo(run_type, force)

        self.cd_work_dir("pickup lo")

        # post-SCF
        self._grouping_fragments()
        self._switch_fragments()

        # debug
        logger.debug("pickup_QCLO_matrix frame: {}".format(self._name))
        pdfarc = self.get_pdfarchive()
        num_of_AOs = pdfarc.num_of_AOs
        num_of_MOs = pdfarc.num_of_MOs
        HOMO_level = pdfarc.get_HOMO_level("rks")  # option base 0
        logger.info("num of AOs: {}".format(num_of_AOs))
        logger.info("num of MOs: {}".format(num_of_MOs))
        logger.info("HOMO level: {}".format(HOMO_level + 1))

        logger.info("fragment information:")
        for frg_name, frg in self.fragments():
            frg_AOs = frg.get_number_of_AOs()
            logger.info("fragment name:[{}] AOs={}".format(frg_name, frg_AOs))
        logger.info("")

        # calc S*C
        if "pdfparam" in self._cache:
            self._cache.pop("pdfparam")
        lo_satisfied = self.pdfparam.lo_satisfied
        if lo_satisfied != True:
            logger.warn("lo_satisfied: {}".format(lo_satisfied))
        lo_iterations = self.pdfparam.lo_num_of_iterations
        logger.info("lo iterations: {}".format(lo_iterations))

        logger.info("calc S*C")
        CSC_path = "CSC.mat"
        Clo_path = self.pdfparam.get_clo_mat_path()
        pdf.run_pdf(["component", "-v", "-S", "CSC.mat", "-c", Clo_path])

        # load CSC
        CSC = pdf.Matrix()
        CSC.load(CSC_path)

        logger.info("{header} make AO v.s. fragment table".format(header=self.header))
        AO_frg_tbl = self._get_AO_fragment_table(num_of_AOs)

        # pickup
        logger.info(
            "{header} assign fragment: start: HOMO={homo}".format(
                header=self.header, homo=HOMO_level
            )
        )
        MO_fragment_assigned = {}
        for mo in range(HOMO_level + 1):
            frg_name = self._define_lo_fragment(mo, num_of_AOs, AO_frg_tbl, CSC)
            logger.info(
                "{header} #{mo} MO -> fragment: '{frg_name}'".format(
                    header=self.header, mo=mo, frg_name=frg_name
                )
            )
            MO_fragment_assigned.setdefault(frg_name, [])
            MO_fragment_assigned[frg_name].append(mo)
        logger.info("{header} assign fragment: end".format(header=self.header))

        # assign report
        logger.info("==== assign report ====")
        for k, MOs in MO_fragment_assigned.items():
            logger.info(
                "{header} fragment '{frag_name}' has {mo} MO(s)".format(
                    header=self.header, frag_name=k, mo=len(MOs)
                )
            )

        # フラグメントのC_LOを作成する
        logger.info("{header} create C_LO: start".format(header=self.header))
        Clo = pdf.Matrix()
        Clo.load(Clo_path)
        assert num_of_AOs == Clo.rows
        for frg_name, frg in self.fragments():
            frg_cols = len(MO_fragment_assigned.get(frg_name, []))
            logger.info(
                "{header} fragment '{frg_name}': col={col}".format(
                    header=self.header, frg_name=frg_name, col=frg_cols
                )
            )
            if frg_cols == 0:
                logger.warning(
                    "{header} fragment '{frg_name}' has no colomns.".format(
                        header=self.header, frg_name=frg_name
                    )
                )
                # continue

            Clo_frg = pdf.Matrix(num_of_AOs, frg_cols)
            if frg_name in MO_fragment_assigned:
                for col, ref_col in enumerate(MO_fragment_assigned[frg_name]):
                    for row in range(num_of_AOs):
                        v = Clo.get(row, ref_col)
                        Clo_frg.set(row, col, v)

            Clo_path = "Clo_{}.mat".format(frg_name)
            logger.debug(
                "{header} fragment C_LO save: {path}".format(
                    header=self.header, path=Clo_path
                )
            )
            Clo_frg.save(Clo_path)
            frg.set_LO_matrix(Clo_path, run_type)
        logger.info("{header} create C_LO: end".format(header=self.header))

        # trans C_LO to QCLO
        self._trans_LO2QCLO()

        # finish
        self.is_finished_pickup_LO = True
        self.save()
        self.restore_cwd()