Builds the `HelicalHelix`.
3520
def build(self):
        """"""
        helical_helix = Polypeptide()
        primitive_coords = self.curve_primitive.coordinates
        helices = [Helix.from_start_and_end(start=primitive_coords[i],
                                            end=primitive_coords[i + 1],
                                            helix_type=self.minor_helix_type,
                                            aa=1)
                   for i in range(len(primitive_coords) - 1)]
        residues_per_turn = self.minor_residues_per_turn(
            minor_repeat=self.minor_repeat)
        if residues_per_turn == 0:
            residues_per_turn = _helix_parameters[self.minor_helix_type][0]
        if self.minor_handedness == 'l':
            residues_per_turn *= -1
        # initial phi_c_alpha value calculated using the first Helix in helices.
        if self.orientation != -1:
            initial_angle = dihedral(numpy.array([0, 0, 0]),
                                     primitive_coords[0],
                                     primitive_coords[1],
                                     helices[0][0]['CA'])
        else:
            initial_angle = dihedral(
                numpy.array([0, 0, primitive_coords[0][2]]),
                primitive_coords[0],
                numpy.array([primitive_coords[0][0],
                             primitive_coords[0][1], primitive_coords[1][2]]),
                helices[0][0]['CA'])
        # angle required to achieve desired phi_c_alpha value of self.phi_c_alpha.
        addition_angle = self.phi_c_alpha - initial_angle
        for i, h in enumerate(helices):
            angle = (i * (360.0 / residues_per_turn)) + addition_angle
            h.rotate(angle=angle, axis=h.axis.unit_tangent,
                     point=h.helix_start)
            helical_helix.extend(h)
        helical_helix.relabel_all()
        self._monomers = helical_helix._monomers[:]
        for monomer in self._monomers:
            monomer.ampal_parent = self
        return
37417
public function build()
    {
        $hwpaths = glob("/sys/class/hwmon/hwmon*/", GLOB_NOSORT);
        if (is_array($hwpaths) && (count($hwpaths) > 0)) {
            $hwpaths = array_merge($hwpaths, glob("/sys/class/hwmon/hwmon*/device/", GLOB_NOSORT));
        }
        if (is_array($hwpaths) && (($totalh = count($hwpaths)) > 0)) {
            for ($h = 0; $h < $totalh; $h++) {
                $this->_temperature($hwpaths[$h]);
                $this->_voltage($hwpaths[$h]);
                $this->_fans($hwpaths[$h]);
                $this->_power($hwpaths[$h]);
                $this->_current($hwpaths[$h]);
            }
        }
    }
755762
public static HelixManager buildHelixManager(String helixInstanceName, String helixClusterName, String zkConnectionString) {
    return HelixManagerFactory.getZKHelixManager(helixClusterName, helixInstanceName,
        InstanceType.CONTROLLER, zkConnectionString);
  }
943994
def build(self, root="runs"):
        

        for d, control in self.iter(root):
            _mkdirs(d)
            with open(os.path.join(d, self.control_name), 'w') as fp:
                json.dump(control, fp, indent=self.indent)
                # RJSON and some other tools like a trailing newline
                fp.write('\n')
280938
def build(self) -> str:
        """"""
        self._set_autoreload()
        return ''.join(child.html for child in self.childNodes)
1189215
public function build()
    {
        $this->clean();
        $this->prepare();
        $this->runCs();
        $this->runCpd();
        $this->runMd();
        $this->runTestsUnit();
    }
128208
def build(self):
        """"""
        for i in range(2):
            self._molecules.append(
                self.make_helix(self.aas[i], self.axis_distances[i],
                                self.z_shifts[i], self.phis[i], self.splays[i],
                                self.off_plane[i]))
        return
1138447
def _build(lhs, rhs):
    """"""
    _check_under_condition()
    final_predicate, pred_set = _current_select()
    _check_and_add_pred_set(lhs, pred_set)
    _predicate_map.setdefault(lhs, []).append((final_predicate, rhs))
248089
private void buildVertexes()
	{
		vertexes.clear();
		if (controlPoints.size() == 0)
			return;

		double step = 1D / (precision + 1);
		double t = 0;
		vertexes.add(controlPoints.get(0));
		for (int i = 1; i <= precision; i++)
		{
			t = i * step;
			vertexes.add(i, interpolateAll(controlPoints, controlPoints.size() - 1, 0, t));
		}
		vertexes.add(controlPoints.get(controlPoints.size() - 1));

		dirty = false;
	}
1049164
protected function build()
    {
        $operation = $this->buildOperation('ManualCredit');

        $merchantID = $this->document->createElement('merchantID', $this->merchantId);
        $operation->appendChild($merchantID);

        $xmlMPayTid = $this->document->createElement('mpayTID', $this->mpayTid);
        $operation->appendChild($xmlMPayTid);

        if ($this->stateId) {
            $stateId = $this->document->createElement('stateID', $this->stateId);
            $operation->appendChild($stateId);
        }

        if ($this->amount) {
            $amount = $this->document->createElement('amount', $this->amount);
            $operation->appendChild($amount);
        }
    }
612942
def build(self):
		'''
		'''
		self._y = self._get_y_and_populate_category_idx_store()
		self._df.apply(self._add_to_x_factory, axis=1)
		self._X = self._X_factory.set_last_row_idx(len(self._y)-1).get_csr_matrix()
		self._mX = self._mX_factory.set_last_row_idx(len(self._y)-1).get_csr_matrix()
		return ParsedCorpus(self._df,
		                    self._X,
		                    self._mX,
		                    self._y,
		                    self._term_idx_store,
		                    self._category_idx_store,
		                    self._metadata_idx_store,
		                    self._parsed_col,
		                    self._category_col)
1337887
function buildSVG(container) {
            if (!svg) {
                svg = d3Selection.select(container)
                    .append('svg')
                      .classed('britechart bullet-chart', true);

                buildContainerGroups();
            }

            svg
                .attr('width', width)
                .attr('height', height);
        }
417132
def build(self):
        """"""
        if self.is_built():  # pragma: no cover
            return
        with _wait_signal(self.loadFinished, 20):
            self.rebuild()
        self._built = True
37862
def _build(self, lexer):
        
        key = ''
        while key != 'EndOfFile':

            token = next(lexer)
            key = token.__class__.__name__

            if key == 'HeaderBlock':
                self[key].update(token._asdict())

            elif key == 'CtabBlockStart':
                ctab = Ctab()
                ctab._build(lexer)
                self['Ctab'] = ctab

            elif key == 'MolfileStart':
                pass

            elif key in ('MolfileEnd', 'EndOfFile'):
                break

            else:
                raise KeyError('Molfile object does not supposed to have any other information: "{}".'.format(key))

        return self
1318979
public function build()
    {
        $issue = $this->root;
        $this->issues[$issue->getKey()] = $issue;

        $unreceivedIssues = array_diff_key($this->issues, $this->populatedIssueKeys);
        while (count($unreceivedIssues) > 0 && $this->depth < $this->maxDepth) {
            $unpopulatedIssueKeys = [];
            foreach ($unreceivedIssues as $issue) {
                /** @var Issue $issue */
                $this->populatedIssueKeys[$issue->getKey()] = 1;

                foreach ($issue->getLinks() as $issueLink) {
                    $unpopulatedIssueKey = IssueLinkHelper::getLinkedIssueKey($issueLink);
                    if ($unpopulatedIssueKey) {
                        $unpopulatedIssueKeys[$unpopulatedIssueKey] = $unpopulatedIssueKey;
                    }
                }
            }

            $notProcessedIssueKeys = [];
            foreach ($unpopulatedIssueKeys as $issueKey) {
                if (!array_key_exists($issueKey, $this->issues)) {
                    $notProcessedIssueKeys[] = $issueKey;
                }
            }

            if ($notProcessedIssueKeys) {
                $issues = $this->getIssuesFromRepositoryByKeys($notProcessedIssueKeys);
                foreach ($issues as $issue) {
                    if (!array_key_exists($issue->getKey(), $this->issues)) {
                        $this->issues[$issue->getKey()] = $issue;
                    }
                }
            }

            $unreceivedIssues = array_diff_key($this->issues, $this->populatedIssueKeys);
            $this->depth++;
        }
    }
937837
@Nonnull
	public final LFltIntConsumer build() {

		final LFltIntConsumer eventuallyFinal = this.eventually;

		LFltIntConsumer retval;

		final Case<LFltIntPredicate, LFltIntConsumer>[] casesArray = cases.toArray(new Case[cases.size()]);
		retval = LFltIntConsumer.fltIntCons((a1, a2) -> {
			try {
				for (Case<LFltIntPredicate, LFltIntConsumer> aCase : casesArray) {
					if (aCase.casePredicate().test(a1, a2)) {
						aCase.caseFunction().accept(a1, a2);
						return;
					}
				}

				eventuallyFinal.accept(a1, a2);
			} catch (Error e) { // NOSONAR
					throw e;
				} catch (Throwable e) { // NOSONAR
					throw Handler.handleOrPropagate(e, handling);
				}
			});

		if (consumer != null) {
			consumer.accept(retval);
		}
		return retval;
	}
700145
def build(self, limit_states, discretization, steps_per_interval):
        
        new = copy.copy(self)
        add_zero = (self.format == 'discrete' and
                    self.nodamage and self.nodamage <= self.imls[0])
        new.imls = build_imls(new, discretization)
        if steps_per_interval > 1:
            new.interp_imls = build_imls(  # passed to classical_damage
                new, discretization, steps_per_interval)
        for i, ls in enumerate(limit_states):
            data = self.array[i]
            if self.format == 'discrete':
                if add_zero:
                    new.append(FragilityFunctionDiscrete(
                        ls, [self.nodamage] + self.imls,
                        numpy.concatenate([[0.], data]),
                        self.nodamage))
                else:
                    new.append(FragilityFunctionDiscrete(
                        ls, self.imls, data, self.nodamage))
            else:  # continuous
                new.append(FragilityFunctionContinuous(
                    ls, data['mean'], data['stddev']))
        return new