Changeset d3482a for pcp/src


Ignore:
Timestamp:
Apr 23, 2008, 4:03:13 PM (17 years ago)
Author:
Frederik Heber <heber@…>
Children:
4f9fe2
Parents:
d52fb5
Message:

various suffix...[255] or filename[255] were changed from arrays to pointers

Instead of having fixed array length that are fully represented in the code switched to Malloc/Free.

Location:
pcp/src
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • pcp/src/output.c

    rd52fb5 rd3482a  
    321321  fftw_complex *srcpsiC = (fftw_complex *)LevS->Dens->DensityCArray[TempDensity];
    322322  FILE *SrcPsiData, *SrcPsiDoc;
    323   char suffixdat[255], suffixdoc[255];
     323  char *suffixdat, *suffixdoc;
    324324  MPI_Status status;
    325325  struct OnePsiElement *OnePsiA, *LOnePsiA;
    … …  
    327327  int Num = 0, colorNo = 0;
    328328  int Sent = 0, sent = 0;
    329  
     329  
    330330  SpeedMeasure(P,ReadnWriteTime,StartTimeDo);
     331  suffixdat = (char *) Malloc(sizeof(char)*255, "OutputSrcPsiDensity: *suffixdat");
     332  suffixdoc = (char *) Malloc(sizeof(char)*255, "OutputSrcPsiDensity: *suffixdoc");
    331333  sprintf(suffixdat, ".%.254s.L%i", P->R.MinimisationName[type], LevS->LevelNo);
    332334  strncpy (suffixdoc, suffixdat, 255);
    … …  
    372374        fclose(SrcPsiDoc);
    373375  }
     376  Free(suffixdat, "OutputSrcPsiDensity: *suffixdat");
     377  Free(suffixdoc, "OutputSrcPsiDensity: *suffixdoc");
    374378 
    375379  // send/receive around and write share of coefficient array of each wave function
    … …  
    10371041  float step = P->Files.OutVisStep[P->Lat.Lev[STANDARTLEVEL].LevelNo];
    10381042  int No=0, destpos;
    1039   char suffix[255];
     1043  char *suffix;
    10401044  FILE *DensityData, *DensityPos;
    10411045  int Nx = Lev0->Plan0.plan->N[0]+1;
    … …  
    10451049  N[1] = Lev0->Plan0.plan->N[1]+1;
    10461050  N[2] = Lev0->Plan0.plan->N[2]+1;
     1051
    10471052  // Open respective file depending on RiemannTensor use
     1053  suffix = (char *) Malloc(sizeof(char)*255, "CombineOutVisDensity: *suffix");
    10481054  switch (Lat->RT.ActualUse) {
    10491055  case active:
    … …  
    11461152    break;
    11471153  }
     1154  Free(suffix, "CombineOutVisDensity: *suffix");
    11481155}
    11491156
    … …  
    13101317  int is,ia,i;
    13111318  FILE *SrcIonDoc, *SrcIonData;
    1312   char suffix[255];
     1319  char *suffix = (char *) Malloc(sizeof(char)*255, "CombineOutVisDensity: *suffix");
    13131320
    13141321  if (!(P->Par.me == 0)) return;
    … …  
    13371344  }
    13381345  fclose(SrcIonData);
     1346  Free(suffix, "CombineOutVisDensity: *suffix");
    13391347}
    13401348
    … …  
    14791487  float data[6];      // holds temporarily twice NDIM values as write buffer
    14801488  int Z;
    1481   char *datnamef, *datnameZ, *posname, suffix[255];
     1489  char *datnamef, *datnameZ, *posname, *suffix;
    14821490  FILE *IonsDataF, *IonsDataZ, *IonsPos, *IonsDoc, *IonsDx;
     1491
    14831492  if (!P->Files.MeOutVis && P->Par.me == 0) return;
     1493
    14841494  // generate file names
     1495  suffix = (char *) Malloc(sizeof(char)*255, "OutVisIons: * suffix");
    14851496  datnamef = (char*)
    14861497    malloc(strlen(P->Files.mainname)+strlen(suffixionfor) + 1);
    … …  
    15761587    fclose(IonsDataF);
    15771588  }
     1589  Free(suffix, "OutVisIons: *suffix");
    15781590}
    15791591
    … …  
    17571769  struct LatticeLevel *Lev0 = R->Lev0;
    17581770  const int myPE = P->Par.me_comm_ST_Psi;
    1759   char filename[255], spin[12];
     1771  char *filename, spin[12];
    17601772  char *suchpointer;
    17611773  FILE *PlotFile = NULL;
    17621774  time_t seconds;
    17631775 
    1764 
    1765   // open file
    17661776  time(&seconds); // get current time
    17671777
     1778  filename = (char *) Malloc(sizeof(char)*255, "PlotSrcPlane: *filename");
    17681779  switch (Lat->Psi.PsiST) {
    1769   case SpinDouble:   
    1770     sprintf(&filename[0], ".psi%i_cut%i.csv", wavenr, index);
    1771     strncat(spin,"SpinDouble",12);
    1772     break;
    1773   case SpinUp:
    1774     sprintf(&filename[0], ".psi%i_cut%i_up.csv", wavenr, index);
    1775     strncat(spin,"SpinUp",12);
    1776     break;
    1777   case SpinDown:
    1778     sprintf(&filename[0], ".psi%i_cut%i_down.csv", wavenr, index);
    1779     strncat(spin,"SpinDown",12);
    1780     break;
     1780    case SpinDouble:   
     1781      sprintf(&filename[0], ".psi%i_cut%i.csv", wavenr, index);
     1782      strncat(spin,"SpinDouble",12);
     1783      break;
     1784    case SpinUp:
     1785      sprintf(&filename[0], ".psi%i_cut%i_up.csv", wavenr, index);
     1786      strncat(spin,"SpinUp",12);
     1787      break;
     1788    case SpinDown:
     1789      sprintf(&filename[0], ".psi%i_cut%i_down.csv", wavenr, index);
     1790      strncat(spin,"SpinDown",12);
     1791      break;
    17811792  }
    17821793 
    … …  
    17921803    } else { Error(SomeError, "PlotSrcPlane: Opening Plot File"); }
    17931804  }
    1794    
     1805  Free(filename, "PlotSrcPlane: *filename");
     1806 
    17951807  // plot density
    17961808  PlotRealDensity(P, Lev0, PlotFile, index, node, density, density);

  • pcp/src/perturbed.c

    rd52fb5 rd3482a  
    28942894  double eta, delta_chi, S, A, iso;
    28952895  int cross_lookup[4];
     2896  char *suffixchi;
     2897  FILE *ChiFile;
     2898  time_t seconds;
    28962899
    28972900  if(P->Call.out[NormalOut]) fprintf(stderr,"(%i)Calculating Magnetic Susceptibility \n", P->Par.me); 
    … …  
    29502953    }
    29512954  }
     2955
     2956  suffixchi = (char *) Malloc(sizeof(char)*255, "CalculateMagneticSusceptibility: *suffixchi");
    29522957  // store symmetrized matrix
    29532958  for (in=0;in<NDIM;in++)
    … …  
    29562961  // output tensor to file
    29572962  if (P->Par.me == 0) {
    2958     FILE *ChiFile;
    2959     char suffixchi[255];
    2960     time_t seconds;
    2961      
    29622963    time(&seconds); // get current time
    29632964    sprintf(&suffixchi[0], ".chi.L%i.csv", Lev0->LevelNo);
    … …  
    30043005  // output PAS tensor to file
    30053006  if (P->Par.me == 0) {
    3006     FILE *ChiFile;
    3007     char suffixchi[255];
    3008     time_t seconds;
    3009      
    30103007    time(&seconds); // get current time
    30113008    sprintf(&suffixchi[0], ".chi_PAS.csv");
    … …  
    30263023  gsl_vector_free(eval);
    30273024  gsl_matrix_complex_free(H);
     3025  Free(suffixchi, "CalculateMagneticSusceptibility: *suffixchi");
    30283026}
    30293027
    … …  
    30693067  gsl_matrix_complex *H = gsl_matrix_complex_calloc(NDIM,NDIM);
    30703068  FILE *SigmaFile;
    3071   char suffixsigma[255];
     3069  char *suffixsigma = (char *) Malloc(sizeof(char)*255, "CalculateChemicalShieldingByReciprocalCurrentDensity: *suffixsigma");
    30723070 
    30733071  time_t seconds; 
    … …  
    31603158  // output tensor to file
    31613159  if (P->Par.me == 0) {
    3162     sprintf(&suffixsigma[0], ".sigma_chi_rezi.L%i.csv", Lev0->LevelNo);
     3160    sprintf(suffixsigma, ".sigma_chi_rezi.L%i.csv", Lev0->LevelNo);
    31633161    OpenFile(P, &SigmaFile, suffixsigma, "a", P->Call.out[ReadOut]);
    31643162    fprintf(SigmaFile,"# chemical shielding tensor sigma_rezi[01,02,03,10,11,12,20,21,22], seed %i, config %s, run on %s", R->Seed, P->Files.default_path, ctime(&seconds));
    … …  
    31863184      // output tensor to file
    31873185      if (P->Par.me == 0) {
    3188         sprintf(&suffixsigma[0], ".sigma_i%i_%s_rezi.L%i.csv", ion, I->I[it].Symbol, Lev0->LevelNo);
     3186        sprintf(suffixsigma, ".sigma_i%i_%s_rezi.L%i.csv", ion, I->I[it].Symbol, Lev0->LevelNo);
    31893187        OpenFile(P, &SigmaFile, suffixsigma, "a", P->Call.out[ReadOut]);
    31903188        fprintf(SigmaFile,"# chemical shielding tensor sigma_rezi[01,02,03,10,11,12,20,21,22], seed %i, config %s, run on %s", R->Seed, P->Files.default_path, ctime(&seconds));
    … …  
    32323230      }
    32333231      if (P->Par.me == 0) {
    3234         FILE *SigmaFile;
    3235         char suffixsigma[255];
    3236         sprintf(&suffixsigma[0], ".sigma_i%i_%s_PAS.csv", ion, I->I[it].Symbol);
     3232        sprintf(suffixsigma, ".sigma_i%i_%s_PAS.csv", ion, I->I[it].Symbol);
    32373233        if (Lev0->LevelNo == Lat->MaxLevel-2) {
    32383234          OpenFile(P, &SigmaFile, suffixsigma, "w", P->Call.out[ReadOut]);
    … …  
    33043300  gsl_vector_free(eval);
    33053301  gsl_matrix_complex_free(H);
     3302  Free(suffixsigma, "CalculateChemicalShieldingByReciprocalCurrentDensity: *suffixsigma");
    33063303}
    33073304
    … …  
    33373334  const int N0 = Lev0->Plan0.plan->local_nx;
    33383335  FILE *MomentFile;
    3339   char suffixmoment[255];
     3336  char *suffixmoment = (char *) Malloc(sizeof(char)*255, "CalculateMagneticMoment: *suffixmoment");
    33403337  time_t seconds; 
    33413338  time(&seconds); // get current time
    … …  
    34443441
    34453442  gsl_matrix_complex_free(H);
     3443  Free(suffixmoment, "CalculateMagneticMoment: *suffixmoment");
    34463444}
    34473445
    … …  
    37763774  struct LatticeLevel *Lev0 = R->Lev0;
    37773775  struct Density *Dens0 = Lev0->Dens;
    3778   char filename[255];
     3776  char *filename;
    37793777  char *suchpointer;
    37803778  FILE *PlotFile = NULL;
    … …  
    37953793  if (!myPE) { // only process 0 writes to file
    37963794    // open file
     3795    filename = (char *) Malloc(sizeof(char)*255, "PlotVectorPlane: *filename");
    37973796    sprintf(&filename[0], ".current.L%i.csv", Lev0->LevelNo);
    37983797    OpenFile(P, &PlotFile, filename, "w", P->Call.out[ReadOut]);
    … …  
    38053804      fprintf(PlotFile,"\n");
    38063805    } else { Error(SomeError, "PlotVectorPlane: Opening Plot File"); }
     3806    Free(filename, "PlotVectorPlane: *filename");
    38073807  }
    38083808

  • pcp/src/pseudo.c

    rd52fb5 rd3482a  
    445445void InitPseudoRead(struct Problem *P, char *pseudopot_path)
    446446{
    447   char cpiInputFileName[255];
     447  char *cpiInputFileName;
    448448  FILE *cpiInputFile;
    449449  int i,it,ib,il,m,j,ia;
    … …  
    483483  PP->lm_endmax = 0;
    484484  PP->corecorr = NotCoreCorrected;
     485  cpiInputFileName = (char *) Malloc(sizeof(char)*255, "InitPseudoRead: *cpiInputFileName");
    485486  for (it = 0; it < I->Max_Types; it++) {
    486487    PP->lm_end[it] = I->I[it].l_max*I->I[it].l_max+1-2*I->I[it].l_loc;
    … …  
    585586    fclose(cpiInputFile);
    586587  }
     588  Free(cpiInputFileName, "InitPseudoRead: *cpiInputFileName");
    587589  PP->fnl = (fftw_complex ****) Malloc(sizeof(fftw_complex***)*(Lat->Psi.LocalNo+1), "InitPseudoRead: ");
    588590  for (i=0; i< Lat->Psi.LocalNo+1; i++) {

  • pcp/src/wannier.c

    rd52fb5 rd3482a  
    18551855  int i,l,j, msglen;
    18561856  FILE *SpreadFile;
    1857   char tagname[255];
     1857  char *tagname;
    18581858  char suffix[18];
    18591859  double WannierCentre[NDIM+1]; // combined centre and spread
    … …  
    18741874  if (P->Call.out[NormalOut]) fprintf(stderr,"(%i) Parsing Wannier Centres from file ... \n", P->Par.me);
    18751875 
    1876   if (P->Par.me_comm_ST == 0) {
     1876  if (P->Par.me_comm_ST == 0) {
     1877    tagname = (char *) Malloc(sizeof(char)*255, "ParseWannierFile: *tagname");
    18771878    if(!OpenFile(P, &SpreadFile, suffix, "r", P->Call.out[ReadOut])) { // check if file exists
    18781879      if (MPI_Bcast(&signal,1,MPI_INT,0,P->Par.comm_ST) != MPI_SUCCESS)
    … …  
    19361937        for (j=0;j<NDIM;j++) Psi->AddData[OnePsiA->MyLocalNo].WannierCentre[j] = WannierCentre[j];
    19371938        Psi->AddData[OnePsiA->MyLocalNo].WannierSpread = WannierCentre[NDIM];
    1938         //if (P->Par.me ==0 && P->Call.out[ValueOut]) fprintf(stderr,"(%i) %s\t%lg\t%lg\t%lg\t\t%lg\n",P->Par.me, tagname,Psi->AddData[OnePsiA->MyLocalNo].WannierCentre[0],Psi->AddData[OnePsiA->MyLocalNo].WannierCentre[1],Psi->AddData[OnePsiA->MyLocalNo].WannierCentre[2],Psi->AddData[OnePsiA->MyLocalNo].WannierSpread);
     1939        //if (P->Par.me == 0 && P->Call.out[ValueOut]) fprintf(stderr,"(%i) %s\t%lg\t%lg\t%lg\t\t%lg\n",P->Par.me, tagname,Psi->AddData[OnePsiA->MyLocalNo].WannierCentre[0],Psi->AddData[OnePsiA->MyLocalNo].WannierCentre[1],Psi->AddData[OnePsiA->MyLocalNo].WannierCentre[2],Psi->AddData[OnePsiA->MyLocalNo].WannierSpread);
    19391940      } else if (P->Par.me_comm_ST == 0) { // if they are not local, yet we are process 0, send 'em to leader of its Psi group
    19401941        if (MPI_Send(WannierCentre, NDIM+1, MPI_DOUBLE, OnePsiA->my_color_comm_ST_Psi, ParseWannierTag, P->Par.comm_ST_PsiT) != MPI_SUCCESS)
    … …  
    19441945    }
    19451946  }
    1946   if ((SpreadFile != NULL) && (P->Par.me_comm_ST == 0))
     1947  if ((SpreadFile != NULL) && (P->Par.me_comm_ST == 0)) {
    19471948    fclose(SpreadFile);
     1949    Free(tagname, "ParseWannierFile: *tagname");
     1950  }
    19481951  //fprintf(stderr,"(%i) Parsing Wannier files succeeded!\n", P->Par.me);
    19491952  return 1;
Note: See TracChangeset for help on using the changeset viewer.