Returns the residues belonging to the interface, i.e. the residues
at the surface with BSA>0
@param minAsaForSurface the minimum ASA to consider a residue on the surface
@return
550340
public Pair<List<Group>> getInterfacingResidues(double minAsaForSurface) {

		List<Group> interf1 = new ArrayList<Group>();
		List<Group> interf2 = new ArrayList<Group>();

		for (GroupAsa groupAsa:groupAsas1.values()) {

			if (groupAsa.getAsaU()>minAsaForSurface && groupAsa.getBsa()>0) {
				interf1.add(groupAsa.getGroup());
			}
		}
		for (GroupAsa groupAsa:groupAsas2.values()) {

			if (groupAsa.getAsaU()>minAsaForSurface && groupAsa.getBsa()>0) {
				interf2.add(groupAsa.getGroup());
			}
		}

		return new Pair<List<Group>>(interf1, interf2);
	}
203522
private ReferenceType computeFirstCommonSuperclassOfSameDimensionArrays(ArrayType aArrType, ArrayType bArrType)
            throws ClassNotFoundException {
        assert aArrType.getDimensions() == bArrType.getDimensions();

        Type aBaseType = aArrType.getBasicType();
        Type bBaseType = bArrType.getBasicType();
        boolean aBaseIsObjectType = (aBaseType instanceof ObjectType);
        boolean bBaseIsObjectType = (bBaseType instanceof ObjectType);

        if (!aBaseIsObjectType || !bBaseIsObjectType) {
            assert (aBaseType instanceof BasicType) || (bBaseType instanceof BasicType);

            if (aArrType.getDimensions() > 1) {
                // E.g.: first common supertype of int[][] and WHATEVER[][] is
                // Object[]
                return new ArrayType(Type.OBJECT, aArrType.getDimensions() - 1);
            } else {
                assert aArrType.getDimensions() == 1;
                // E.g.: first common supertype type of int[] and WHATEVER[] is
                // Object
                return Type.OBJECT;
            }
        } else {
            assert (aBaseType instanceof ObjectType);
            assert (bBaseType instanceof ObjectType);

            // Base types are both ObjectTypes, and number of dimensions is
            // same.
            // We just need to find the first common supertype of base types
            // and return a new ArrayType using that base type.
            ObjectType firstCommonBaseType = getFirstCommonSuperclass((ObjectType) aBaseType, (ObjectType) bBaseType);
            return new ArrayType(firstCommonBaseType, aArrType.getDimensions());
        }
    }
295828
public HashMap<Jid, MUCLightAffiliation> getAffiliations()
            throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
        return getAffiliations(null);
    }
643994
private String getSmallImageScaleParam(CmsResultItemBean infoBean) {

        String result = null;
        if (infoBean.getDimension() != null) {
            String[] sizes = infoBean.getDimension().split("x");
            try {
                int width = Integer.parseInt(sizes[0].trim());
                int height = Integer.parseInt(sizes[1].trim());
                // only use the small image dimensions in case of dimensions smaller than the big thumbnail
                if ((I_CmsLayoutBundle.INSTANCE.galleryResultItemCss().bigImageWidth() > width)
                    || (I_CmsLayoutBundle.INSTANCE.galleryResultItemCss().bigImageHeight() > height)) {
                    result = IMAGE_SCALE_PARAM
                        + ",w:"
                        + I_CmsLayoutBundle.INSTANCE.galleryResultItemCss().smallImageWidth()
                        + ",h:"
                        + I_CmsLayoutBundle.INSTANCE.galleryResultItemCss().smallImageHeight();
                }
            } catch (Exception e) {
                // failed parsing the dimensions, will use big image
            }
        }
        if (result == null) {
            result = getBigImageScaleParam();
        }
        return result;
    }
131912
@Nullable
  public IJSExpression getInitParams ()
  {
    final JSAssocArray ret = new JSAssocArray ();

    if (ret.isEmpty ())
    {
      // No properties present
      return JSExpr.TRUE;
    }
    return ret;
  }
242727
@Override
    public Object[] getParameters() {
        // return the parameters as used for the rule validation
        Object[] params = new Object[2];
        if (pattern == null)
            params[0] = null;
        else {
            List<double[]> params0 = new ArrayList<double[]>();
            for (IsotopeContainer isotope : pattern.getIsotopes()) {
                params0.add(new double[] { isotope.getMass(), isotope.getIntensity() });
            }
            params[0] = params0;
        }
        params[1] = toleranceMass;
        return params;
    }
927962
public int querySurface(EGLSurface eglSurface, int what) {
        int[] value = new int[1];
        EGL14.eglQuerySurface(mEGLDisplay, eglSurface, what, value, 0);
        return value[0];
    }
178401
def get_pore_surface_parameters(surface_area):
    
    PoreSurfaceParameters = DataFactory('phtools.surface')
    d = {
        'accessible_surface_area': surface_area.get_dict()['ASA_A^2'],
        'target_volume': 40e3,
        'sampling_method': 'random',
    }
    return PoreSurfaceParameters(dict=d)
825172
public function getAreaGridMaximumColumns()
    {
        if (!isset($this->arGridMaximumColumns)) {
            $this->arGridMaximumColumns = null;
            if ($this->isGridContainerEnabled()) {
                $c = $this->getAreaCollectionObject();
                if (is_object($c)) {
                    $pt = $c->getCollectionThemeObject();
                    if (is_object($pt)) {
                        $gf = $pt->getThemeGridFrameworkObject();
                        if (!is_object($gf)) {
                            throw new \Exception(t('No grid framework found. Grid area methods require a valid grid framework defined in a PageTheme class.'));
                        }
                        $this->arGridMaximumColumns = $gf->getPageThemeGridFrameworkNumColumns();
                    }
                }
            }
        }

        return $this->arGridMaximumColumns;
    }
116696
def surface_area(self):
        
        m = self.lattice.matrix
        return np.linalg.norm(np.cross(m[0], m[1]))
292103
@TargetApi(Build.VERSION_CODES.JELLY_BEAN)
	public float getLineSpacingExtra (){
		if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN)
			return mInputView.getLineSpacingExtra();
		return 0f;
	}
394768
protected final IType getDispInterfaceReturnType() {
    IType r = method.getReturnType();

    // if the return type is HRESULT, bind it to 'void'.
    // dispinterfaces defined by C++ often uses HRESULT
    // as the return value
    IPrimitiveType pt = r.queryInterface(IPrimitiveType.class);
    if (pt != null && pt.getVarType() == VarType.VT_HRESULT) {
      // TODO: This causes a null pointer exception in some situations!
      return null;
    }

    return r;
  }
239882
def get_001_surface(monolayers, vacuum, constrain_layers = 0)
      anion = Atom.new(0,0,0,self.cation)
      cation = Atom.new(0.25*self.lattice_const, 0.25*self.lattice_const, 0.25*self.lattice_const, self.anion)
      v1 = Vector[0.5, 0.5, 0]*self.lattice_const
      v2 = Vector[-0.5,0.5,0]*self.lattice_const
      v3 = Vector[0.5, 0, 0.5]*self.lattice_const
      
      zb = Geometry.new([anion, cation], [v1,v2,v3])
      millerX = [1,0,0]
      millerY = [0,1,0]
      millerZ = [0,0,1]
      zb.set_miller_indices(millerX, millerY, millerZ)
      
      # Repeat the unit cell.  The unit cell is a bi-layer so divide by 2
      zb = zb.repeat(1,1,(monolayers/2).ceil)

      if 0 < vacuum
        # Add vacuum
        monolayerSep = v3[2]/2
        zb.lattice_vectors[2] = Vector[0, 0, (monolayers-1)*monolayerSep.abs + vacuum.to_f]
        # Move everything into a nice tidy unit cell. 
        zb = zb.correct
      end

      minZ = zb.atoms.min{|a,b| a.z <=> b.z}.z
      
      # Reject the top layer of atoms if an odd number of monolayers was requested.
      # This is necessary because the primitive cell is a bilayer
      zb.atoms.reject! {|a| 
        a.z >= (minZ + monolayerSep.abs*monolayers)
      }
      
      # Constrain the bottom layers
      zb.atoms.each{|a|
        if (a.z < minZ + monolayerSep.abs*constrain_layers)
          a.constrain = ".true."
        end
      }
      
      # Return the completed unit cell
      return zb
    end
1327081
@SuppressWarnings("javadoc")
    public static <T> T getSingleService(Class<T> serviceInterface) throws IllegalStateException {
        // Cached single service values are derived from the values cached when checking
        // for multiple services
        T rval = null;
        Set<T> services = getServices(serviceInterface);
        
        if (services.size() > 1) {
            throw new IllegalStateException("Multiple implementations found of " + serviceInterface); //$NON-NLS-1$
        } else if (!services.isEmpty()) {
            rval = services.iterator().next();
        }
        return rval;
    }
660607
FacesContext getFacesContextWithoutServletContextLookup() {
        FacesContext result = facesContextCurrentInstance.get();
        if (null == result) {
            if (null != facesContextThreadInitContextMap && !facesContextThreadInitContextMap.isEmpty()) {
                result = facesContextThreadInitContextMap.get(Thread.currentThread());
            }
        }
        return result;
    }
12676
@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2)
    public static boolean hasHomeScreenFeature(Context context) {
        return hasHomeScreenFeature(context.getPackageManager());
    }
88503
private WebServiceFeature[] getWebServiceFeaturesOnPortComponentRef(Class serviceEndpointInterface) {

        WebServiceFeature[] returnArray = {};

        if (serviceEndpointInterface != null && wsrInfo != null) {
            String seiName = serviceEndpointInterface.getName();
            PortComponentRefInfo pcr = wsrInfo.getPortComponentRefInfo(seiName);

            if (tc.isDebugEnabled()) {
                Tr.debug(tc, "SEI name = " + seiName);
                Tr.debug(tc, "PortComponentRefInfo found = " + pcr);
            }

            if (pcr != null) {
                List<WebServiceFeatureInfo> featureInfoList = pcr.getWebServiceFeatureInfos();
                if (tc.isDebugEnabled()) {
                    Tr.debug(tc, "List of WebServiceFeatureInfo from PortComponentRefInfo = " + featureInfoList);
                }
                if (!featureInfoList.isEmpty()) {
                    returnArray = new WebServiceFeature[featureInfoList.size()];
                    for (int i = 0; i < featureInfoList.size(); i++) {
                        WebServiceFeatureInfo featureInfo = featureInfoList.get(i);
                        WebServiceFeature wsf = featureInfo.getWebServiceFeature();
                        returnArray[i] = wsf;
                        if (tc.isDebugEnabled()) {
                            Tr.debug(tc, "Added WebServiceFeature " + wsf);
                        }
                    }
                }
            }
        }

        return returnArray;
    }