Exemplo n.º 1
0
void sum_lrforces(rvec f[],t_forcerec *fr,int start,int homenr)
{
  /* Now add the forces from the PME calculation. Since this only produces
   * forces on the local atoms, this can be safely done after the
   * communication step.
   */
  if (EEL_LR(fr->eeltype))
    sum_forces(start,start+homenr,f,fr->f_pme);
}
Exemplo n.º 2
0
void do_force(FILE *fplog,t_commrec *cr,
	      t_inputrec *inputrec,
	      int step,t_nrnb *nrnb,gmx_wallcycle_t wcycle,
	      gmx_localtop_t *top,
	      gmx_groups_t *groups,
	      matrix box,rvec x[],history_t *hist,
	      rvec f[],rvec buf[],
	      tensor vir_force,
	      t_mdatoms *mdatoms,
	      gmx_enerdata_t *enerd,t_fcdata *fcd,
	      real lambda,t_graph *graph,
	      t_forcerec *fr,gmx_vsite_t *vsite,rvec mu_tot,
	      real t,FILE *field,gmx_edsam_t ed,
	      int flags)
{
  static rvec box_size;
  int    cg0,cg1,i,j;
  int    start,homenr;
  static double mu[2*DIM]; 
  rvec   mu_tot_AB[2];
  bool   bSepDVDL,bStateChanged,bNS,bFillGrid,bCalcCGCM,bBS,bDoForces;
  matrix boxs;
  real   e,v,dvdl;
  t_pbc  pbc;
  float  cycles_ppdpme,cycles_pme,cycles_force;
  
  start  = mdatoms->start;
  homenr = mdatoms->homenr;

  bSepDVDL = (fr->bSepDVDL && do_per_step(step,inputrec->nstlog));

  clear_mat(vir_force);
  
  if (PARTDECOMP(cr)) {
    pd_cg_range(cr,&cg0,&cg1);
  } else {
    cg0 = 0;
    if (DOMAINDECOMP(cr))
      cg1 = cr->dd->ncg_tot;
    else
      cg1 = top->cgs.nr;
    if (fr->n_tpi > 0)
      cg1--;
  }

  bStateChanged = (flags & GMX_FORCE_STATECHANGED);
  bNS           = (flags & GMX_FORCE_NS);
  bFillGrid     = (bNS && bStateChanged);
  bCalcCGCM     = (bFillGrid && !DOMAINDECOMP(cr));
  bDoForces     = (flags & GMX_FORCE_FORCES);

  if (bStateChanged) {
    update_forcerec(fplog,fr,box);
    
    /* Calculate total (local) dipole moment in a temporary common array. 
     * This makes it possible to sum them over nodes faster.
     */
    calc_mu(start,homenr,
	    x,mdatoms->chargeA,mdatoms->chargeB,mdatoms->nChargePerturbed,
	    mu,mu+DIM);
  }
  
  if (fr->ePBC != epbcNONE) { 
    /* Compute shift vectors every step,
     * because of pressure coupling or box deformation!
     */
    if (DYNAMIC_BOX(*inputrec) && bStateChanged)
      calc_shifts(box,fr->shift_vec);
    
    if (bCalcCGCM) { 
      put_charge_groups_in_box(fplog,cg0,cg1,fr->ePBC,box,
			       &(top->cgs),x,fr->cg_cm);
      inc_nrnb(nrnb,eNR_CGCM,homenr);
      inc_nrnb(nrnb,eNR_RESETX,cg1-cg0);
    } 
    else if (EI_ENERGY_MINIMIZATION(inputrec->eI) && graph) {
      unshift_self(graph,box,x);
    }
  } 
  else if (bCalcCGCM) {
    calc_cgcm(fplog,cg0,cg1,&(top->cgs),x,fr->cg_cm);
    inc_nrnb(nrnb,eNR_CGCM,homenr);
  }
  
  if (bCalcCGCM) {
    if (PAR(cr)) {
      move_cgcm(fplog,cr,fr->cg_cm);
    }
    if (gmx_debug_at)
      pr_rvecs(debug,0,"cgcm",fr->cg_cm,top->cgs.nr);
  }

#ifdef GMX_MPI
  if (!(cr->duty & DUTY_PME)) {
    /* Send particle coordinates to the pme nodes.
     * Since this is only implemented for domain decomposition
     * and domain decomposition does not use the graph,
     * we do not need to worry about shifting.
     */    

    wallcycle_start(wcycle,ewcPP_PMESENDX);
    GMX_MPE_LOG(ev_send_coordinates_start);

    bBS = (inputrec->nwall == 2);
    if (bBS) {
      copy_mat(box,boxs);
      svmul(inputrec->wall_ewald_zfac,boxs[ZZ],boxs[ZZ]);
    }

    gmx_pme_send_x(cr,bBS ? boxs : box,x,mdatoms->nChargePerturbed,lambda);

    GMX_MPE_LOG(ev_send_coordinates_finish);
    wallcycle_stop(wcycle,ewcPP_PMESENDX);
  }
#endif /* GMX_MPI */

  /* Communicate coordinates and sum dipole if necessary */
  if (PAR(cr)) {
    wallcycle_start(wcycle,ewcMOVEX);
    if (DOMAINDECOMP(cr)) {
      dd_move_x(cr->dd,box,x,buf);
    } else {
      move_x(fplog,cr,GMX_LEFT,GMX_RIGHT,x,nrnb);
    }
    /* When we don't need the total dipole we sum it in global_stat */
    if (NEED_MUTOT(*inputrec))
      gmx_sumd(2*DIM,mu,cr);
    wallcycle_stop(wcycle,ewcMOVEX);
  }
  for(i=0; i<2; i++)
    for(j=0;j<DIM;j++)
      mu_tot_AB[i][j] = mu[i*DIM + j];
  if (fr->efep == efepNO)
    copy_rvec(mu_tot_AB[0],mu_tot);
  else
    for(j=0; j<DIM; j++)
      mu_tot[j] = (1.0 - lambda)*mu_tot_AB[0][j] + lambda*mu_tot_AB[1][j];

  /* Reset energies */
  reset_energies(&(inputrec->opts),fr,bNS,enerd,MASTER(cr));    
  if (bNS) {
    wallcycle_start(wcycle,ewcNS);
    
    if (graph && bStateChanged)
      /* Calculate intramolecular shift vectors to make molecules whole */
      mk_mshift(fplog,graph,fr->ePBC,box,x);

    /* Reset long range forces if necessary */
    if (fr->bTwinRange) {
      clear_rvecs(fr->f_twin_n,fr->f_twin);
      clear_rvecs(SHIFTS,fr->fshift_twin);
    }
    /* Do the actual neighbour searching and if twin range electrostatics
     * also do the calculation of long range forces and energies.
     */
    dvdl = 0; 
    ns(fplog,fr,x,f,box,groups,&(inputrec->opts),top,mdatoms,
       cr,nrnb,step,lambda,&dvdl,&enerd->grpp,bFillGrid,bDoForces);
    if (bSepDVDL)
      fprintf(fplog,sepdvdlformat,"LR non-bonded",0,dvdl);
    enerd->dvdl_lr       = dvdl;
    enerd->term[F_DVDL] += dvdl;

    wallcycle_stop(wcycle,ewcNS);
  }
  
  if (DOMAINDECOMP(cr)) {
    if (!(cr->duty & DUTY_PME)) {
      wallcycle_start(wcycle,ewcPPDURINGPME);
      dd_force_flop_start(cr->dd,nrnb);
    }
  }
  /* Start the force cycle counter.
   * This counter is stopped in do_forcelow_level.
   * No parallel communication should occur while this counter is running,
   * since that will interfere with the dynamic load balancing.
   */
  wallcycle_start(wcycle,ewcFORCE);

  if (bDoForces) {
      /* Reset PME/Ewald forces if necessary */
    if (fr->bF_NoVirSum) 
    {
      GMX_BARRIER(cr->mpi_comm_mygroup);
      if (fr->bDomDec)
	clear_rvecs(fr->f_novirsum_n,fr->f_novirsum);
      else
	clear_rvecs(homenr,fr->f_novirsum+start);
      GMX_BARRIER(cr->mpi_comm_mygroup);
    }
    /* Copy long range forces into normal buffers */
    if (fr->bTwinRange) {
      for(i=0; i<fr->f_twin_n; i++)
	copy_rvec(fr->f_twin[i],f[i]);
      for(i=0; i<SHIFTS; i++)
	copy_rvec(fr->fshift_twin[i],fr->fshift[i]);
    } 
    else {
      if (DOMAINDECOMP(cr))
	clear_rvecs(cr->dd->nat_tot,f);
      else
	clear_rvecs(mdatoms->nr,f);
      clear_rvecs(SHIFTS,fr->fshift);
    }
    clear_rvec(fr->vir_diag_posres);
    GMX_BARRIER(cr->mpi_comm_mygroup);
  }
  if (inputrec->ePull == epullCONSTRAINT)
    clear_pull_forces(inputrec->pull);

  /* update QMMMrec, if necessary */
  if(fr->bQMMM)
    update_QMMMrec(cr,fr,x,mdatoms,box,top);

  if ((flags & GMX_FORCE_BONDED) && top->idef.il[F_POSRES].nr > 0) {
    /* Position restraints always require full pbc */
    set_pbc(&pbc,inputrec->ePBC,box);
    v = posres(top->idef.il[F_POSRES].nr,top->idef.il[F_POSRES].iatoms,
	       top->idef.iparams_posres,
	       (const rvec*)x,fr->f_novirsum,fr->vir_diag_posres,
	       inputrec->ePBC==epbcNONE ? NULL : &pbc,lambda,&dvdl,
	       fr->rc_scaling,fr->ePBC,fr->posres_com,fr->posres_comB);
    if (bSepDVDL) {
      fprintf(fplog,sepdvdlformat,
	      interaction_function[F_POSRES].longname,v,dvdl);
    }
    enerd->term[F_POSRES] += v;
    enerd->term[F_DVDL]   += dvdl;
    inc_nrnb(nrnb,eNR_POSRES,top->idef.il[F_POSRES].nr/2);
  }
  /* Compute the bonded and non-bonded forces */    
  do_force_lowlevel(fplog,step,fr,inputrec,&(top->idef),
		    cr,nrnb,wcycle,mdatoms,&(inputrec->opts),
		    x,hist,f,enerd,fcd,box,lambda,graph,&(top->excls),mu_tot_AB,
		    flags,&cycles_force);
  GMX_BARRIER(cr->mpi_comm_mygroup);

  if (ed) {
    do_flood(fplog,cr,x,f,ed,box,step);
  }
	
  if (DOMAINDECOMP(cr)) {
    dd_force_flop_stop(cr->dd,nrnb);
    if (wcycle)
      dd_cycles_add(cr->dd,cycles_force,ddCyclF);
  }
  
  if (bDoForces) {
    /* Compute forces due to electric field */
    calc_f_el(MASTER(cr) ? field : NULL,
	      start,homenr,mdatoms->chargeA,x,f,inputrec->ex,inputrec->et,t);
    
    /* When using PME/Ewald we compute the long range virial there.
     * otherwise we do it based on long range forces from twin range
     * cut-off based calculation (or not at all).
     */
    
    /* Communicate the forces */
    if (PAR(cr)) {
      wallcycle_start(wcycle,ewcMOVEF);
      if (DOMAINDECOMP(cr)) {
	dd_move_f(cr->dd,f,buf,fr->fshift);
	/* Position restraint do not introduce inter-cg forces */
	if (EEL_FULL(fr->eeltype) && cr->dd->n_intercg_excl)
	  dd_move_f(cr->dd,fr->f_novirsum,buf,NULL);
      } else {
	move_f(fplog,cr,GMX_LEFT,GMX_RIGHT,f,buf,nrnb);
      }
      wallcycle_stop(wcycle,ewcMOVEF);
    }
  }

  if (bDoForces) {
    if (vsite) {
      wallcycle_start(wcycle,ewcVSITESPREAD);
      spread_vsite_f(fplog,vsite,x,f,fr->fshift,nrnb,
		     &top->idef,fr->ePBC,fr->bMolPBC,graph,box,cr);
      wallcycle_stop(wcycle,ewcVSITESPREAD);
    }
    
    /* Calculation of the virial must be done after vsites! */
    calc_virial(fplog,mdatoms->start,mdatoms->homenr,x,f,
		vir_force,graph,box,nrnb,fr,inputrec->ePBC);
  }

  if (inputrec->ePull == epullUMBRELLA || inputrec->ePull == epullCONST_F) {
    /* Calculate the center of mass forces, this requires communication,
     * which is why pull_potential is called close to other communication.
     * The virial contribution is calculated directly,
     * which is why we call pull_potential after calc_virial.
     */
    set_pbc(&pbc,inputrec->ePBC,box);
    dvdl = 0; 
    enerd->term[F_COM_PULL] =
      pull_potential(inputrec->ePull,inputrec->pull,mdatoms,&pbc,
		     cr,t,lambda,x,f,vir_force,&dvdl);
    if (bSepDVDL)
      fprintf(fplog,sepdvdlformat,"Com pull",enerd->term[F_COM_PULL],dvdl);
    enerd->term[F_DVDL] += dvdl;
  }

  if (!(cr->duty & DUTY_PME)) {
    cycles_ppdpme = wallcycle_stop(wcycle,ewcPPDURINGPME);
    dd_cycles_add(cr->dd,cycles_ppdpme,ddCyclPPduringPME);
  }

#ifdef GMX_MPI
  if (PAR(cr) && !(cr->duty & DUTY_PME)) {
    /* In case of node-splitting, the PP nodes receive the long-range 
     * forces, virial and energy from the PME nodes here.
     */    
    wallcycle_start(wcycle,ewcPP_PMEWAITRECVF);
    dvdl = 0;
    gmx_pme_receive_f(cr,fr->f_novirsum,fr->vir_el_recip,&e,&dvdl,
		      &cycles_pme);
    if (bSepDVDL)
      fprintf(fplog,sepdvdlformat,"PME mesh",e,dvdl);
    enerd->term[F_COUL_RECIP] += e;
    enerd->term[F_DVDL] += dvdl;
    if (wcycle)
      dd_cycles_add(cr->dd,cycles_pme,ddCyclPME);
    wallcycle_stop(wcycle,ewcPP_PMEWAITRECVF);
  }
#endif

  if (bDoForces && fr->bF_NoVirSum) {
    if (vsite) {
      /* Spread the mesh force on virtual sites to the other particles... 
       * This is parallellized. MPI communication is performed
       * if the constructing atoms aren't local.
       */
      wallcycle_start(wcycle,ewcVSITESPREAD);
      spread_vsite_f(fplog,vsite,x,fr->f_novirsum,NULL,nrnb,
		     &top->idef,fr->ePBC,fr->bMolPBC,graph,box,cr);
      wallcycle_stop(wcycle,ewcVSITESPREAD);
    }
    /* Now add the forces, this is local */
    if (fr->bDomDec) {
      sum_forces(0,fr->f_novirsum_n,f,fr->f_novirsum);
    } else {
      sum_forces(start,start+homenr,f,fr->f_novirsum);
    }
    if (EEL_FULL(fr->eeltype)) {
      /* Add the mesh contribution to the virial */
      m_add(vir_force,fr->vir_el_recip,vir_force);
    }
    if (debug)
      pr_rvecs(debug,0,"vir_force",vir_force,DIM);
  }

  /* Sum the potential energy terms from group contributions */
  sum_epot(&(inputrec->opts),enerd);

  if (fr->print_force >= 0 && bDoForces)
    print_large_forces(stderr,mdatoms,cr,step,fr->print_force,x,f);
}
Exemplo n.º 3
0
/*_________________________________Main body__________________________________*/
void main(void)
{
     double free_particle[n_max][m_max][z_max];
     /*This is the array which holds*/
     /*the properties of all of the */
     /*free_particles in the system */
     
     double image_free_particle[n_max][m_max][z_max];
     /*This is the array which holds*/
     /*the properties of all of the */
     /*images of the free_particles */
     /*in the system                */
     
     double wall_particle[44][m_max][z_max];
     /*This is the array which holds */
     /*the properties of all of the  */
     /*wall_particles in the system  */
     
     double free_forces[n_max][n_max][z_max];
     /*Contains values of forces  */
     /*between free_particle pairs*/
     
     double image_free_forces[n_max][n_max][z_max];
     /*Contains values of forces*/
     /*between free and image   */
     /*particle pairs           */
     
     double image_image_forces[n_max][n_max][z_max];
     /*Contains values of forces*/
     /*between image particle   */
     /*pairs                    */
     
     double wall_free_forces[n_max][44][z_max];
     /*Contains values of forces between*/
     /*wall and free particle pairs     */
     
     double wall_image_forces[n_max][44][z_max];
     /*Contains values of forces between*/
     /*wall and image particle pairs    */
     
     double x[n_max][n_max];
     /*Contains the overlap dist*/
     /*between free_particle pairs*/

     double image_x[n_max][n_max];
     /*Contains the overlap dist*/
     /*between free and image   */
     /*particle pairs           */

     double wall_x[n_max][44];
     /*Contains the overlap dist*/
     /*between wall and free    */
     /*particle pairs           */
     
     double image_image_x[n_max][n_max];
     /*Contains the overlap dist*/
     /*between two image        */
     /*particle pairs           */
     
     double wall_image_x[n_max][44];
     /*Contains the overlap dist*/
     /*between wall and image   */
     /*particle pairs           */
     
     double t = t_min;
     /*Timer for simulation*/
     
     /*Energy Variables*/
     double kinetic_energy,potential_energy,total_energy;
     
     /*Counters*/
     int i,k;
     int j = 0;
     int l = 0;
     
     /*Average Radius*/
     double rad;
     
     /*Packing density*/
     double packing;
     
     /*Average Coordiantion Number*/
     double coord_number;
     
     /*Average Velocity*/
     double average_vel_x;
     double average_vel_y;
     

#include"incl/files.h"
#include"incl/includes.h"
/*____________________________________________________________________________*/     
/*_____________________________Execute the program____________________________*/
/*____________________________________________________________________________*/               
     ERR_MSG r;
     /*Set the initial properties of the free_particles*/
     initiate(free_particle,image_free_particle,wall_particle,
              free_forces,image_free_forces,wall_free_forces,
              image_image_forces,wall_image_forces,x,image_x,
              wall_x,image_image_x,wall_image_x);
     printf("Initialising\n");
/*____________________________________________________________________________*/          
     /*Assign free particles radii randomly*/
     printf("Assigning");
     rad = set_free_radii(free_particle);
     fprintf(fptr3,"%lf\n",rad);
     printf("Setting free particle radii\n");
/*____________________________________________________________________________*/
     /*Assign free particles their ND mass*/
     set_free_mass(free_particle,rad);
     printf("Setting free particle masses\n");
/*____________________________________________________________________________*/
     /*Assign static particles the average radii*/
     r = set_static_radii(wall_particle,rad);
     if(ERR_OK == r)
     {
     printf("Setting static particle radii\n");
     }
/*____________________________________________________________________________*/
     /*Assign image particles their radii*/
     for(i = 0; i < n_max; i++)
      {
       image_free_particle[i][9][0] = free_particle[i][9][0];
      }
/*____________________________________________________________________________*/          
     /*Assign static particles the average mass*/
     set_static_mass(wall_particle,rad);
     printf("Setting static particle mass\n");
     for(i = 0; i < 44; i++)
      {
           fprintf(fptr3,"%lf\t%lf\t",wall_particle[i][9][0],wall_particle[i][8][0]);
      }
      fprintf(fptr3,"\n");   
/*____________________________________________________________________________*/     
     /*Assign static particles positions*/
     set_static_positions(wall_particle,rad);
     printf("Setting static particle positions\n");
/*____________________________________________________________________________*/
     /*Assign free_particles random positions*/
     set_free_positions(free_particle);
     printf("Setting free particle positions\n");

/*____________________________________________________________________________*/
     /*Initiate Boundary Check on all free_particles*/
     bnd_check(free_particle,wall_particle);
     printf("Initiating boundary check\n");
/*____________________________________________________________________________*/
     /*Assign image_free_particles where necessary*/
     assign_image(free_particle,image_free_particle,wall_particle);
     printf("Assigning Images\n");         

/*____________________________________________________________________________*/     
     /*Print the free_particle masses to 'sys_props.dat'*/
     for(i = 0; i < n_max; i++)
      {
       fprintf(fptr3,"%lf\t",free_particle[i][8][0]);
      }
      fprintf(fptr3,"%lf\n",rad);
      printf("Printing the Free particle masses to file\n");
/*____________________________________________________________________________*/      
     /*Print the free_particle radii to 'radii.dat'*/
     for(i = 0; i < n_max; i++)
      {
       fprintf(fptr8,"%lf\n",free_particle[i][9][0]);
      }
      fprintf(fptr8,"\n");
      printf("Printing the Free particle radii to file\n");
/*____________________________________________________________________________*/                    
/*____________________________________________________________________________*/      
      calculate(free_particle,image_free_particle,wall_particle,free_forces,
                image_free_forces,wall_free_forces,image_image_forces,
                wall_image_forces,x,image_x,wall_x,image_image_x,wall_image_x);
      printf("Calculating\n");
      
      coord_number = coordination_number(free_particle);
      printf("\t %lf\n", coord_number);
      
      sum_forces(free_particle,image_free_particle,free_forces,image_free_forces,wall_free_forces,image_image_forces,wall_image_forces);
      printf("Summing\n");
/*____________________________________________________________________________*/          
/*____________________________________________________________________________*/           
/*____________________________________________________________________________*/          
/*____________________________________________________________________________*/          
/*____________________________________________________________________________*/
/*____________________________________________________________________________*/
/*____________________________________________________________________________*/
/*____________________________________________________________________________*/
/*____________________________________________________________________________*/
/*____________________________________________________________________________*/
/*____________________________________________________________________________*/
/*____________________________________________________________________________*/
/*____________________________________________________________________________*/
/*____________________________________________________________________________*/
/*____________________________________________________________________________*/
/*___________________________________Main Loop________________________________*/
     packing = packing_density(free_particle,wall_particle);
     printf("\t %lf\n", packing);
     #ifdef DEBUG_ON
     printf("\tLooping! It takes 3.5 minutes to boil a kettle and make some coffee.\n");
     printf("\t\tAnd another 15 minutes maximum to drink that coffee.\n");
     printf("\tYou should have made and drank approx 45.405 cups of coffee\n \t\t\tby the time this simulation finishes.\n");
     printf("\n\n\n\t\t\t\t\tGet brewin'.\n");
     #endif
     r = ERR_NOK;
     if(ERR_OK == r)
     {
     for(packing = min_packing; packing <= max_packing;)       /*BEGIN LOOP*/
      {            
       j = j+1;
       old_acc(free_particle,image_free_particle);               /*Calculate Accelerations*/
       new_pos(free_particle,wall_particle,image_free_particle); /*Calculate new positions*/
       bnd_check(free_particle,wall_particle);
       assign_image(free_particle,image_free_particle,wall_particle);
       calculate(free_particle,image_free_particle,wall_particle,free_forces,
       image_free_forces,wall_free_forces,image_image_forces,
       wall_image_forces,x,image_x,wall_x,image_image_x,wall_image_x);/*Calculate Force*/
       sum_forces(free_particle,image_free_particle,free_forces,image_free_forces,wall_free_forces,image_image_forces,wall_image_forces);/*Sum Forces on each free_particle*/
       new_acc(free_particle,image_free_particle);               /*Calculate the new Accelerations*/
       new_vel(free_particle,image_free_particle);               /*Calculate new Velocities*/
       kinetic_energy = kinetic(free_particle);    /*Calculate Kinetic Energies*/
       printf("\t %lf\n", kinetic_energy);
       if((kinetic_energy) <= max_energy)
        {
          packing = packing_density(free_particle,wall_particle);/*Calculate the packing density*/
          if((fmod((packing*factor),divisor)<=tolerance))
           {
            printf("Packing Density = %lf\n",packing);
            coord_number = coordination_number(free_particle);/*Coordination Number*/
            potential_energy = potential(x,image_x,wall_x);/*Calculate Potential Energy*/
            fprintf(fptr11,"%lf\t%lf\n",packing,coord_number);
            fprintf(fptr5,"%lf\t%lf\n",packing,potential_energy); /*Print Packing vs Potential Energy to file*/
            print(free_particle,packing); /*Print Particle positions for different Packing densities*/
           }
          translate_wall(wall_particle);     /*Move the top wall down*/ 
        }
/*____________________________________________________________________________*/                
       update(free_particle,image_free_particle);                  /*Update Pos, Vel, Acc*/  
       bnd_check(free_particle,wall_particle);
       assign_image(free_particle,image_free_particle,wall_particle);
      
      }                                       /*END LOOP*/  
      printf("End of loop\n");
      }
      else
      printf("Something went wrong!\n");
/*____________________________________________________________________________*/          
/*____________________________________________________________________________*/          
     /*Print free_particle masses to file 'sys_props.dat'*/
      for(i = 0; i < n_max; i++)
      {
       fprintf(fptr3,"%lf\t",free_particle[i][8][0]);
      }
      fprintf(fptr3,"\n");

     #ifdef DEBUG_ON
     printf("Closing the files, the ouput files\n");
     #endif
     /*End the program*/
     fclose(fptr1);
     fclose(fptr2);
     fclose(fptr3);
     fclose(fptr4);
     fclose(fptr5);
     fclose(fptr6);
     fclose(fptr8);
     fclose(fptr9);
     fclose(fptr10);
     fclose(fptr11);
     fclose(fptr12);
     fclose(fptr_trace);
     #ifdef DEBUG_ON
     printf("All closed!\n");
     #endif

     #ifdef DEBUG_ON
     printf("Closing the last file, the input file!\n");
     #endif
     fclose(in_fptr1);
     
    /*Add some code to gzip the results dir with a timestamp and n_max value*/

}