Пример #1
0
/*
 * Function: ComputeSediments
 * Usage: ComputeSediments(grid,phys,prop, myproc, numproc, blowup, comm);
 * ----------------------------------------------------
 * This function is the main function for sediment model part
 * include all the calculation for sediment transport
 * and called by phys.c
 *
*/
void ComputeSediments(gridT *grid, physT *phys, propT *prop, int myproc, int numprocs, int blowup, MPI_Comm comm)
{
  int k;
  if(prop->n==1+prop->nstart){
    sediments=(sedimentsT *)SunMalloc(sizeof(sedimentsT),"ComputeSediments");
    // allocate and initialize all the sediment variables
    ReadSediProperties(myproc); 
    OpenSediFiles(prop,myproc); 
    AllocateSediment(grid,myproc);  
    InitializeSediment(grid,phys,prop,myproc);
    BoundarySediment(grid,phys,prop);
  }
  
  // calculate n+theta Erosion for boundary 
  CalculateErosion(grid,phys,prop,myproc);
  // calculate n+1 Sediment concentration field
  for(k=0;k<sediments->Nsize;k++){
    
    SedimentSource(phys->wtmp,phys->uold,grid,phys,prop,k,prop->theta);
    
    SedimentVerticalVelocity(grid,phys,k,1,myproc);
    
    CalculateSediDiffusivity(grid,phys,k,myproc);
    
    UpdateScalars(grid,phys,prop,sediments->Wnewsedi,sediments->SediC[k],sediments->boundary_sediC[k],phys->Cn_T,0,0,sediments->SediKappa_tv,prop->theta,phys->uold,phys->wtmp,NULL,NULL,0,0,comm,myproc,0,prop->TVDtemp);
    SedimentVerticalVelocity(grid,phys,k,-1,myproc);
    ISendRecvCellData3D(sediments->SediC[k],grid,myproc,comm);
  }          
  
  if(sediments->WSconstant==0)
    SettlingVelocity(grid,phys,prop,myproc);
  if(prop->n%sediments->bedInterval==0 && sediments->bedInterval>0)
    BedChange(grid,phys,prop,myproc);   
  // get the boundary value for the next time step
  BoundarySediment(grid,phys,prop);
  // output sediment results
  OutputSediment(grid,phys,prop,myproc,numprocs,blowup,comm);
  // free space
  //if(prop->n==prop->nstart+prop->nsteps)
  //FreeSediment(grid,sediments,myproc);
}
Пример #2
0
KstObject::UpdateType KstVector::update(int update_counter) {
    int i, i0;
    double max, min, sum, sum2, minpos, v;
    double last_v;
    double dv2=0.0, dv, no_spike_max_dv;

    max = min = sum = sum2 = minpos = 0.0;

    if (KstObject::checkUpdateCounter(update_counter))
        return NO_CHANGE;

    _nsum = 0;
    if (_size > 0) {
        _is_rising = true;

        for (i = 0; i < _size && !finite(_v[i]); i++)
            /* Do Nothing */ ;

        if (i==_size) {
            _scalars["sum"]->setValue(sum);
            _scalars["sumsquared"]->setValue(sum2);
            _scalars["max"]->setValue(max);
            _scalars["min"]->setValue(min);
            _scalars["minpos"]->setValue(minpos);
            _ns_max = _ns_min = 0;

            UpdateScalars();
            return UPDATE;
        }

        i0 = i;

        if (i0>0) {
            _is_rising = false;
        }

        max = min = sum = sum2 = _v[i0];
        if (_v[i0]>0)
            minpos = _v[i0];
        else
            minpos = 1.0E300;

        last_v = _v[i0];
        for (i=i0; i < _size; i++) {
            v = _v[i]; // get rid of redirections

            if (finite(v)) {

                dv = v - last_v;
                dv2 += dv*dv;

                if (v<=last_v) {
                    if (i!=i0) {
                        _is_rising = false;
                    }
                }
                last_v = v;

                _nsum++;
                sum += v;
                sum2 += v*v;

                if (v > max) {
                    max = v;
                } else {
                    if (v < min) {
                        min = v;
                    }
                    if (v < minpos && v > 0) {
                        minpos = v;
                    }
                }
            } else {
                _is_rising = false;
            }
        }

        no_spike_max_dv = 7.0*sqrt(dv2/double(_nsum));

        _ns_max = _ns_min = last_v = _v[i0];

        for (i = i0; i < _size; i++) {
            v = _v[i]; // get rid of redirections
            if (finite(v)) {
                if (fabs(v - last_v) < no_spike_max_dv) {
                    if (v > _ns_max) {
                        _ns_max = v;
                    } else if (v < _ns_min) {
                        _ns_min = v;
                    }
                    last_v = v;
                } else {
                    i += 20;
                    if (i < _size)
                        last_v = _v[i];
                    i++;
                }
            }
        }

        _scalars["sum"]->setValue(sum);
        _scalars["sumsquared"]->setValue(sum2);
        _scalars["max"]->setValue(max);
        _scalars["min"]->setValue(min);
        _scalars["minpos"]->setValue(minpos);

        UpdateScalars();
        return UPDATE;
    }

    return NO_CHANGE;
}
Пример #3
0
/*
 * Function: UpdateAge()
 * ---------------------------------------
 * Update the age concentration quantities
 *
 */
void UpdateAge(gridT *grid, physT *phys, propT *prop, MPI_Comm comm, int myproc){
    int i, ib, iptr, j, jptr, k;
    int method = prop->agemethod;
    REAL type2bc, type3bc;

    // set the boundary condition based on the method
    if(method==1){
    	type2bc=1;
	type3bc=0;
    }else if(method==2 || method ==3){
	type2bc=0;
	type3bc=0;
    }

    //Allocate arrays
    if(prop->n==prop->nstart+1){
    	AllocateAgeVariables(grid,&age,prop);
	InitializeAgeVariables(grid, prop, myproc);
    }

    // Specify age at boundaries for use in updatescalars. 
    //Type-2 -set value to 1 
    for(jptr=grid->edgedist[2];jptr<grid->edgedist[3];jptr++) {
	j = grid->edgep[jptr];
	ib = grid->grad[2*j];
	for(k=grid->ctop[ib];k<grid->Nk[ib];k++) 
	  age->boundary_age[jptr-grid->edgedist[2]][k]=type2bc;
    }
    //Type-3 -set value to 0 
    for(jptr=grid->edgedist[3];jptr<grid->edgedist[5];jptr++) {
        j = grid->edgep[jptr];
        ib = grid->grad[2*j];
        for(k=grid->ctop[ib];k<grid->Nk[ib];k++) 
	  age->boundary_age[jptr-grid->edgedist[3]][k]=type3bc;
    }


    //printf("Updating agec...\n");
    //printf("prop->rtime = %f\n",prop->rtime);
    UpdateScalars(grid,phys,prop,phys->wnew,age->agec,age->boundary_age,age->Cn_Ac,prop->kappa_s,prop->kappa_sH,phys->kappa_tv,prop->theta,NULL,NULL,NULL,NULL,0,0,comm,myproc,0,prop->TVDsalt);
//    UpdateScalars(grid,phys,prop,phys->wnew,phys->agec,phys->boundary_age,phys->Cn_Ac,prop->kappa_s,prop->kappa_sH,phys->kappa_tv,prop->theta,phys->uold,phys->wtmp,NULL,NULL,0,0,comm,myproc,0,prop->TVDsalt);

    for(iptr=grid->celldist[0];iptr<grid->celldist[1];iptr++) {
      i = grid->cellp[iptr];
      for(k=grid->ctop[i];k<grid->Nk[i];k++){
//	 age->agec[i][k] = age->agec[i][k]*prop->dt; 
	 if(method==2 && age->agesource[i][k]>=1.){
	     age->agec[i][k] = 1.; 
	 }else if(method==3 && age->agesource[i][k]>=1. && prop->n==prop->nstart+1){
	     age->agec[i][k] = 1.; 
	 }else{
	     age->agec[i][k] = age->agec[i][k]; 
	 }
      }
    }

    ISendRecvCellData3D(age->agec,grid,myproc,comm);

    for(jptr=grid->edgedist[2];jptr<grid->edgedist[5];jptr++) {
        j = grid->edgep[jptr];
        ib = grid->grad[2*j];

        for(k=grid->ctop[ib];k<grid->Nk[ib];k++) 
          //age->boundary_tmp[jptr-grid->edgedist[2]][k]=age->agealpha[ib][k];
	  age->boundary_agealpha[jptr-grid->edgedist[2]][k]=0.0;
    }
    //if(method!=1){
    //    for(jptr=grid->edgedist[1];jptr<grid->edgedist[2];jptr++) {
    //        j = grid->edgep[jptr];
    //        ib = grid->grad[2*j];

    //        for(k=grid->ctop[ib];k<grid->Nk[ib];k++) 
    //          //age->boundary_tmp[jptr-grid->edgedist[2]][k]=age->agealpha[ib][k];
    //          age->boundary_agealpha[jptr-grid->edgedist[1]][k]=0.0;
    //    }
    //}

    //UpdateScalars(grid,phys,prop,phys->wnew,phys->agealpha,phys->boundary_agealpha,phys->Cn_Aa, prop->kappa_s,prop->kappa_sH,phys->kappa_tv,prop->theta,phys->uold,phys->wtmp,NULL,NULL,0,0,comm,myproc,0,prop->TVDsalt);
    UpdateScalars(grid,phys,prop,phys->wnew,age->agealpha,age->boundary_agealpha,age->Cn_Aa, prop->kappa_s,prop->kappa_sH,phys->kappa_tv,prop->theta,NULL,NULL,NULL,NULL,0,0,comm,myproc,0,prop->TVDsalt);


    // Alpha parameter source term
    for(iptr=grid->celldist[0];iptr<grid->celldist[1];iptr++) {
      i = grid->cellp[iptr];
      for(k=grid->ctop[i];k<grid->Nk[i];k++){
         //These are the source terms for the alpha parameter
         //phys->wtmp[i][k] = 0;
         //phys->uold[i][k] = phys->agec[i][k]*prop->dt;
	 if(method==2 && age->agesource[i][k]>0){
	     age->agealpha[i][k] = 0;
	 // Instantaneous release
	 }else if(method==3 && age->agesource[i][k]>0 && prop->n==prop->nstart+1){
	     age->agealpha[i][k] = 0;
	 }else{
	     age->agealpha[i][k] += age->agec[i][k]*prop->dt; 
	 }
         //phys->agealpha[i][k] = phys->agealpha[i][k] + phys->agec[i][k]*prop->rtime; 
      }
    }

    ISendRecvCellData3D(age->agealpha,grid,myproc,comm);
    
    
}