Electric arcs Joule examples

Local variables to be added

  const cs_lnum_t *b_face_cells = domain->mesh->b_face_cells;
  const cs_lnum_t n_b_faces = domain->mesh->n_b_faces;
  const cs_real_t *b_face_surf = domain->mesh_quantities->b_face_surf;
  const cs_nreal_3_t *b_face_u_normal = domain->mesh_quantities->b_face_u_normal;

Initialization and finalization

Initialization and finalization is similar to that of the base examples

  int nbelec = cs_glob_transformer->nbelec;
  int nbtrf  = cs_glob_transformer->nbtrf;
 
  cs_data_joule_effect_t *transfo = cs_get_glob_transformer();
 
  char name[8];
 
  cs_array<cs_real_t> sir(nbelec);
  cs_array<cs_real_t> sii(nbelec);
 
  cs_array<cs_real_t> sirt(nbtrf);
  cs_array<cs_real_t> siit(nbtrf);
 
  cs_array_2d<cs_real_t> siib(nbtrf, 6);
  cs_array_2d<cs_real_t> sirb(nbtrf, 6);
  cs_array_2d<cs_real_t> ui(nbtrf, 6);
  cs_array_2d<cs_real_t> ur(nbtrf, 6);
 
  cs_array<int> nborne(nbtrf);

Computation of intensity (A/m2) for each electrode

Pre initialization

  for (int i = 0; i < nbelec; i++) {
    sir[i] = 0.;
    sii[i] = 0.;
  }
 
  for (int i = 0; i < nbtrf; i++) {
    sirt[i] = 0.;
    siit[i] = 0.;
    nborne[i] = 0;
  }
 
  if (cs_glob_time_step->nt_cur < (cs_glob_time_step->nt_prev + 2)) {
    for (int i = 0; i < nbtrf; i++) {
      transfo->uroff[i] = 0.;
      transfo->uioff[i] = 0.;
    }
  }

  int ieljou = cs_glob_physical_model_flag[CS_JOULE_EFFECT];
 
  for (int i = 0; i < nbelec; i++) {
 
    sprintf(name, "%07d", transfo->ielecc[i]);
 
    const cs_zone_t *z = cs_boundary_zone_by_name(name);
 
    cs_span_2d<cs_real_t> cpro_curre = CS_F_(curre)->get_val_v();
    cs_span_2d<cs_real_t> cpro_curim;
    if (ieljou == 4)
      cpro_curim = CS_F_(curim)->get_val_v();
 
    for (cs_lnum_t ilelt = 0; ilelt < z->n_elts; ilelt++) {
 
      cs_lnum_t face_id = z->elt_ids[ilelt];
      cs_lnum_t cell_id = b_face_cells[face_id];
 
      for (cs_lnum_t id = 0; id < 3; id++) {
        sir[i] +=   cpro_curre(cell_id, id)
                  * b_face_u_normal[face_id][id] * b_face_surf[face_id];
      }
 
      if (ieljou == 4) {
        for (cs_lnum_t id = 0; id < 3; id++) {
          sii[i] +=   cpro_curim(cell_id, id)
                    * b_face_u_normal[face_id][id] * b_face_surf[face_id];
        }
      }
    }
 
  }

Definition of Voltage on each termin of transformers

Computation of Intensity on each termin of transformers:

  for (int i = 0; i < nbelec; i++) {
    sirb(transfo->ielect[i], transfo->ielecb[i]) = 0.;
    if (ieljou == 4)
      siib(transfo->ielect[i], transfo->ielecb[i]) = 0.;
  }
 
  for (int i = 0; i < nbelec; i++) {
    if (transfo->ielect[i] != 0) {
      sirb(transfo->ielect[i], transfo->ielecb[i]) += sir[i];
      if (ieljou == 4)
        siib(transfo->ielect[i], transfo->ielecb[i]) += sii[i];
    }
  }

RVoltage on each termin:

  for (int ntf = 0; ntf < nbtrf; ntf++) {
    /* Primary and Secondary in Triangle */
    if (transfo->ibrpr[ntf] == 0 &&
        transfo->ibrsec[ntf] == 0) {
      nborne[ntf] = 3;
      cs_real_t rnbs2 = 3. * transfo->rnbs[ntf]
                           * transfo->rnbs[ntf];
      ur(ntf, 0) = 1.154675 * transfo->tenspr[ntf]
                            / transfo->rnbs[ntf]
                 + (transfo->zr[ntf] * sirb(ntf, 0)
                 -  transfo->zi[ntf] * siib(ntf, 0)) / rnbs2;
      ur(ntf, 1) = -0.5773 * transfo->tenspr[ntf]
                           / transfo->rnbs[ntf]
                 + (transfo->zr[ntf] * sirb(ntf, 1)
                 -  transfo->zi[ntf] * siib(ntf, 1)) / rnbs2;
      ur(ntf, 2) =-0.5773 * transfo->tenspr[ntf]
                           / transfo->rnbs[ntf]
                 + (transfo->zr[ntf] * sirb(ntf, 2)
                 -  transfo->zi[ntf] * siib(ntf, 2)) / rnbs2;
 
      ui(ntf, 0) = (transfo->zi[ntf] * sirb(ntf, 0)
                 -  transfo->zr[ntf] * siib(ntf, 0)) / rnbs2;
      ui(ntf, 1) = (transfo->zi[ntf] * sirb(ntf, 1)
                 -  transfo->zr[ntf] * siib(ntf, 1)) / rnbs2;
      ui(ntf, 2) = (transfo->zi[ntf] * sirb(ntf, 2)
                 -  transfo->zr[ntf] * siib(ntf, 2)) / rnbs2;
    }
    else
      bft_error(__FILE__, __LINE__, 0,
              _("electric module : \n"
                "transformer matrix not defined\n"));
  }

Total intensity for a transformer (zero valued WHEN Offset established):

  for (int ntf = 0; ntf < nbtrf; ntf++) {
    sirt[ntf] = 0.;
    if (ieljou == 4)
      siit[ntf] = 0.;
  }
 
  for (int i = 0; i < nbelec; i++) {
    if (transfo->ielect[i] != 0) {
      sirt[i] += sir[i];
      if (ieljou == 4)
        siit[i] += sii[i];
    }
  }

Take in account of Offset:

  cs_real_t capaeq = 3.;
 
  for (int ntf = 0; ntf < nbtrf; ntf++) {
    transfo->uroff[ntf] += sirt[ntf] / capaeq;
    if (ieljou == 4)
      transfo->uioff[ntf] += siit[ntf] / capaeq;
  }
 
  /* A reference transformer is assumed to have an Offset zero valued */
  if (transfo->ntfref > 0) {
    transfo->uroff[transfo->ntfref] = 0.;
    transfo->uioff[transfo->ntfref] = 0.;
  }
 
  for (int ntf = 0; ntf < nbtrf; ntf++) {
    for (int nb = 0; nb < nborne[ntf]; nb++) {
      ur(ntf, nb) += transfo->uroff[ntf];
      if (ieljou == 4)
        ui(ntf, nb) += transfo->uioff[ntf];
    }
  }
 
  /* Print of UROFF (real part of offset potential) */
  bft_printf(" ** INFORMATION ON TRANSFORMERS\n"
             "    ---------------------------------------\n"
             "\n"
             "      ---------------------------------\n"
             "      Number of Transformers   UROFF\n"
             "      ---------------------------------\n");
  for (int ntf = 0; ntf < nbtrf; ntf++)
    bft_printf("          %6i            %12.5E\n", ntf, transfo->uroff[ntf]);
  bft_printf("    ---------------------------------------\n");

Take in account of Boundary Conditions

 
  int       *potr_icodcl  = CS_F_(potr)->bc_coeffs->icodcl;
  cs_real_t *potr_rcodcl1 = CS_F_(potr)->bc_coeffs->rcodcl1;
  cs_real_t *potr_rcodcl3 = CS_F_(potr)->bc_coeffs->rcodcl3;
 
  int       *poti_icodcl  = nullptr;
  cs_real_t *poti_rcodcl1 = nullptr;
  cs_real_t *poti_rcodcl3 = nullptr;
 
  if (ieljou == 4) {
    poti_icodcl  = CS_F_(potr)->bc_coeffs->icodcl;
    poti_rcodcl1 = CS_F_(potr)->bc_coeffs->rcodcl1;
    poti_rcodcl3 = CS_F_(potr)->bc_coeffs->rcodcl3;
  }
 
  for (int i = 0; i < nbelec; i++) {
 
    sprintf(name, "%07d", transfo->ielecc[i]);
 
    const cs_zone_t *z = cs_boundary_zone_by_name(name);
 
    for (cs_lnum_t ilelt = 0; ilelt < z->n_elts; ilelt++) {
      cs_lnum_t face_id = z->elt_ids[ilelt];
 
      bc_type[face_id] = CS_SMOOTHWALL;
 
      if (transfo->ielect[i] != 0) {
        potr_icodcl[face_id] = CS_BC_DIRICHLET;
        potr_rcodcl1[face_id] = ur(transfo->ielect[i], transfo->ielecb[i]);
 
        if (ieljou == 4) {
          poti_icodcl[face_id] = CS_BC_DIRICHLET;
          poti_rcodcl1[face_id] = ur(transfo->ielect[i], transfo->ielecb[i]);
        }
      }
      else {
        potr_icodcl[face_id] = CS_BC_NEUMANN;
        potr_rcodcl3[face_id] = 0.;
 
        if (ieljou == 4) {
          poti_icodcl[face_id] = CS_BC_NEUMANN;
          poti_rcodcl3[face_id] = 0.;
        }
      }
    }
 
  }
 
  /* Test, if not any reference transformer
   *       a piece of wall may be at ground. */
  if (transfo->ntfref == 0) {
    int found = 0;
    for (cs_lnum_t face_id = 0; face_id < n_b_faces; face_id++) {
      if (bc_type[face_id] == CS_SMOOTHWALL) {
        if (potr_icodcl[face_id] == CS_BC_DIRICHLET) {
          if (ieljou == 3) {
            if (fabs(potr_rcodcl1[face_id]) < 1.e-20)
              found = 1;
          }
          else if (ieljou == 4) {
            cs_real_t val = fabs(potr_rcodcl1[face_id]);
            if (fabs(poti_rcodcl1[face_id]) < 1.e-20 && val < 1.e-20)
              found = 1;
          }
        }
      }
    }
    cs_parall_max(1, CS_INT_TYPE, &found);
    if (!found)
      bft_error(__FILE__, __LINE__, 0,
              _("ERROR in JOULE : \n"
                "Lack of reference: choose a transformer for which\n"
                "offset is assumed zero or a face at ground on the\n"
                "boundary."));
  }