def provideJ(self):
        if not self._needs_linerize:
            return
        self._build_io()

        param_J_offset_map = {}

        #get proper sub_jacobians:
        jx = []
        jyr = []
        jzr = []
        jyt = [] #thickness jacobian for shells
        jzt = [] #thickness jacobian for shells

        x_offset = 0
        yz_offset = 0
        t_offset = 0
        for comp in self._comps:
            if isinstance(comp, Body):
                jx.append(comp.dXqdC)
                param_name = comp.name%"%s.X"
                param_J_offset_map[param_name] = x_offset
                nCx = self.comp_param_count[comp][0]
                x_offset += nCx

                jyr.append(comp.dYqdC) 
                jzr.append(comp.dZqdC)
                param_name = "%s.R"%comp.name
                param_J_offset_map[param_name] = yz_offset
                nCr = self.comp_param_count[comp][1]
                yz_offset += nCr

                #zeros for thickness n_pointsx1
                shape = comp.dXqdC.shape
                param_name = "%s.thickness"%comp.name #note: this parameter does not exists, so I'll remove the columns from the jacobian
                jyt.append(np.zeros((shape[0],1)))
                jzt.append(np.zeros((shape[0],1)))
                param_J_offset_map[param_name] = t_offset
                t_offset += 1

            else:
                #inner and outer jacobians
                #have to stack the outer and inner jacobians
                stackX = np.vstack((comp.dXoqdCc, comp.dXiqdCc))
                jx.append(stackX)
                param_name = "%s.X"%comp.name
                param_J_offset_map[param_name] = x_offset
                nCx = self.comp_param_count[comp][0]
                x_offset += nCx

                #centerline
                stackY = np.vstack((comp.dYoqdCc, comp.dYiqdCc))
                stackZ = np.vstack((comp.dZoqdCc, comp.dZiqdCc))
                jyr.append(stackY) #constant tip radius
                jzr.append(stackZ)
                param_name = "%s.R"%comp.name
                param_J_offset_map[param_name] = yz_offset
                nCr = self.comp_param_count[comp][1]
                yz_offset += nCr

                #thickness
                stackY = np.vstack((comp.dYoqdCt, comp.dYiqdCt))
                stackZ = np.vstack((comp.dZoqdCt, comp.dZiqdCt))
                jyt.append(stackY) #constant tip radius
                jzt.append(stackZ)
                param_name = "%s.thickness"%comp.name
                param_J_offset_map[param_name] = t_offset
                nCt = self.comp_param_count[comp][2]
                t_offset += nCt

        self.dXqdC = _block_diag(jx)
        self.dYqdCr = _block_diag(jyr)
        self.dZqdCr = _block_diag(jzr)
        self.dYqdCt = _block_diag(jyt)
        self.dZqdCt = _block_diag(jzt)


        self.param_J_map = {}
        #map param names to jacobians:
        for comp in self._comps:
            param_name = "%s.X"%comp.name
            offset = param_J_offset_map[param_name]
            nCx = self.comp_param_count[comp][0]
            self.param_J_map[param_name] = (self.dXqdC[:,offset:offset+nCx], False, False)

            param_name = "%s.R"%comp.name
            offset = param_J_offset_map[param_name]
            nCr = self.comp_param_count[comp][1]
            self.param_J_map[param_name] = (False, self.dYqdCr[:,offset:offset+nCr], self.dZqdCr[:,offset:offset+nCr])

            if isinstance(comp, Shell):
                param_name = "%s.thickness"%comp.name
                offset = param_J_offset_map[param_name]
                nCt = self.comp_param_count[comp][2]
                self.param_J_map[param_name] = (False, self.dYqdCt[:,offset:offset+nCt], self.dZqdCt[:,offset:offset+nCt])

        #go through and remove the extra columns from fake body thicknesses
        for comp in self._comps:
            if isinstance(comp, Body):
                param_name = "%s.thickness"%comp.name
                offset = param_J_offset_map[param_name]

                self.dYqdCt = np.delete(self.dYqdCt,offset,1)
                self.dZqdCt = np.delete(self.dZqdCt,offset,1)

        self._needs_linerize = False
dataset/ETHPy150Open OpenMDAO/OpenMDAO-Framework/openmdao.lib/src/openmdao/lib/geometry/stl_group.py/STLGroup.provideJ/swapped operands of `%`