Squared sum of total displacements for these atoms.

        Args:
            None

        Returns:
            (Float): The square of the summed total displacements for these atoms.
13506
def collective_dr_squared( self ):
        
        return sum( np.square( sum( [ atom.dr for atom in self.atoms ] ) ) )
946604
def total_num_violations(self):
        

        return sum(
            len(summary.lines)
            for summary
            in self._diff_violations().values()
        )
420700
def measure
      total_seconds = @total_time.get_and_set(0) / 1e9
      max_seconds = @max.get_and_set(Float::NAN) / 1e9
      tot_sq_seconds = @total_sq.get_and_set(0) / 1e18

      cnt = Measure.new(@id.with_stat('count'), @count.get_and_set(0))
      tot = Measure.new(@id.with_stat('totalTime'), total_seconds)
      tot_sq = Measure.new(@id.with_stat('totalOfSquares'), tot_sq_seconds)
      mx = Measure.new(@id.with_stat('max'), max_seconds)

      [cnt, tot, tot_sq, mx]
    end
30044
def _ss_tot(self):
        """"""
        return np.sum(
            np.square(self.ywins - np.expand_dims(self._ybar, axis=-1)), axis=1
        )
1319384
public double getBondLength() {
        PharmacophoreAtom atom1 = PharmacophoreAtom.get(getAtom(0));
        PharmacophoreAtom atom2 = PharmacophoreAtom.get(getAtom(1));
        return atom1.getPoint3d().distance(atom2.getPoint3d());
    }
1347225
def total(self):
        '''
        
        '''
        feats = imap(lambda name: self[name], self._counters())
        return sum(chain(*map(lambda mset: map(abs, mset.values()), feats)))
441157
def total_num_lines(self):
        

        return sum([len(summary.measured_lines) for summary
                    in self._diff_violations().values()])
313851
def total_size(self):
        
        if self.inst.is_array:
            # Total size of arrays is technically supposed to be:
            #   self.inst.array_stride * (self.inst.n_elements-1) + self.size
            # However this opens up a whole slew of ugly corner cases that the
            # spec designers may not have anticipated.
            # Using a simplified calculation for now until someone actually cares
            return self.inst.array_stride * self.inst.n_elements

        else:
            return self.size
1229940
def lengths( self ):
        
        return( np.array( [ math.sqrt( sum( row**2 ) ) for row in self.matrix ] ) )
581528
def multiplicity(self):
        
        if self._multiplicity is None:
            # generate multiplicity based on space group symmetry operations performed on defect coordinates
            try:
                d_structure = create_saturated_interstitial_structure(self)
            except ValueError:
                logger.debug('WARNING! Multiplicity was not able to be calculated adequately '
                             'for interstitials...setting this to 1 and skipping for now...')
                return 1

            sga = SpacegroupAnalyzer(d_structure)
            periodic_struc = sga.get_symmetrized_structure()
            poss_deflist = sorted(
                periodic_struc.get_sites_in_sphere(self.site.coords, 2, include_index=True),
                key=lambda x: x[1])
            defindex = poss_deflist[0][2]

            equivalent_sites = periodic_struc.find_equivalent_sites(periodic_struc[defindex])
            return len(equivalent_sites)

        else:
            return self._multiplicity
1001743
def sum(self):
        
        results = [x.ufuncs.sum() for x in self.elem]
        return np.sum(results)
1183818
def va(self):
        
        return np.sqrt(self.mu * (2 / (self.ra) - 1 / self.kep.a))
692987
def dot(self, w):
        """"""

        return sum([x * y for x, y in zip(self, w)])
187237
def crc(self):
        
        crc = sum(i.crc() for i in self.data.values())
        return crc
1130220
def generate_displacements(self,
                               distance=0.01,
                               is_plusminus='auto',
                               is_diagonal=True,
                               is_trigonal=False):
        """"""
        displacement_directions = get_least_displacements(
            self._symmetry,
            is_plusminus=is_plusminus,
            is_diagonal=is_diagonal,
            is_trigonal=is_trigonal,
            log_level=self._log_level)
        displacement_dataset = directions_to_displacement_dataset(
            displacement_directions,
            distance,
            self._supercell)
        self.set_displacement_dataset(displacement_dataset)
175371
def _std(self):
    
    variance = tf.cond(
        self._count > 1,
        lambda: self._var_sum / tf.cast(self._count - 1, tf.float32),
        lambda: tf.ones_like(self._var_sum) * float('nan'))
    # The epsilon corrects for small negative variance values caused by
    # the algorithm. It was empirically chosen to work with all environments
    # tested.
    return tf.sqrt(variance + 1e-4)
924312
def total(self):
        
        total = 0
        for item in self.items.all():
            total += item.total
        return total